[do not merge] CI experiments

compiler/rustc_middle/src/mir/mono.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::cmp::Ordering;
 use std::fmt;
 use std::hash::Hash;
 
@@ -527,44 +528,52 @@ impl<'tcx> CodegenUnit<'tcx> {
     ) -> Vec<(MonoItem<'tcx>, MonoItemData)> {
         // The codegen tests rely on items being process in the same order as
         // they appear in the file, so for local items, we sort by node_id first
-        #[derive(PartialEq, Eq, PartialOrd, Ord)]
-        struct ItemSortKey<'tcx>(Option<usize>, SymbolName<'tcx>);
-
-        fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> {
-            ItemSortKey(
-                match item {
-                    MonoItem::Fn(ref instance) => {
-                        match instance.def {
-                            // We only want to take HirIds of user-defined
-                            // instances into account. The others don't matter for
-                            // the codegen tests and can even make item order
-                            // unstable.
-                            InstanceKind::Item(def) => def.as_local().map(Idx::index),
-                            InstanceKind::VTableShim(..)
-                            | InstanceKind::ReifyShim(..)
-                            | InstanceKind::Intrinsic(..)
-                            | InstanceKind::FnPtrShim(..)
-                            | InstanceKind::Virtual(..)
-                            | InstanceKind::ClosureOnceShim { .. }
-                            | InstanceKind::ConstructCoroutineInClosureShim { .. }
-                            | InstanceKind::DropGlue(..)
-                            | InstanceKind::CloneShim(..)
-                            | InstanceKind::ThreadLocalShim(..)
-                            | InstanceKind::FnPtrAddrShim(..)
-                            | InstanceKind::AsyncDropGlue(..)
-                            | InstanceKind::FutureDropPollShim(..)
-                            | InstanceKind::AsyncDropGlueCtorShim(..) => None,
-                        }
+        // #[derive(PartialEq, Eq, PartialOrd, Ord)]
+        // struct ItemSortKey<'tcx>(Option<usize>, SymbolName<'tcx>);
+        //
+        // fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> {
+        //     ItemSortKey(
+        //         ,
+        //         item.symbol_name(tcx),
+        //     )
+        // }
+
+        fn foo<'tcx>(item: &MonoItem<'tcx>) -> Option<usize> {
+            match item {
+                MonoItem::Fn(instance) => {
+                    match instance.def {
+                        // We only want to take HirIds of user-defined
+                        // instances into account. The others don't matter for
+                        // the codegen tests and can even make item order
+                        // unstable.
+                        InstanceKind::Item(def) => def.as_local().map(Idx::index),
+                        InstanceKind::VTableShim(..)
+                        | InstanceKind::ReifyShim(..)
+                        | InstanceKind::Intrinsic(..)
+                        | InstanceKind::FnPtrShim(..)
+                        | InstanceKind::Virtual(..)
+                        | InstanceKind::ClosureOnceShim { .. }
+                        | InstanceKind::ConstructCoroutineInClosureShim { .. }
+                        | InstanceKind::DropGlue(..)
+                        | InstanceKind::CloneShim(..)
+                        | InstanceKind::ThreadLocalShim(..)
+                        | InstanceKind::FnPtrAddrShim(..)
+                        | InstanceKind::AsyncDropGlue(..)
+                        | InstanceKind::FutureDropPollShim(..)
+                        | InstanceKind::AsyncDropGlueCtorShim(..) => None,
                     }
-                    MonoItem::Static(def_id) => def_id.as_local().map(Idx::index),
-                    MonoItem::GlobalAsm(item_id) => Some(item_id.owner_id.def_id.index()),
-                },
-                item.symbol_name(tcx),
-            )
+                }
+                MonoItem::Static(def_id) => def_id.as_local().map(Idx::index),
+                MonoItem::GlobalAsm(item_id) => Some(item_id.owner_id.def_id.index()),
+            }
         }
 
         let mut items: Vec<_> = self.items().iter().map(|(&i, &data)| (i, data)).collect();
-        items.sort_by_cached_key(|&(i, _)| item_sort_key(tcx, i));
+        items.sort_by(|(i1, _), (i2, _)| match foo(i1).cmp(&foo(i2)) {
+            Ordering::Less => Ordering::Less,
+            Ordering::Greater => Ordering::Greater,
+            Ordering::Equal => i1.symbol_name(tcx).cmp(&i2.symbol_name(tcx)),
+        });
         items
     }
 

compiler/rustc_middle/src/query/mod.rs

@@ -1424,7 +1424,7 @@ rustc_queries! {
     /// look up the correct symbol name of instances from upstream crates.
     query symbol_name(key: ty::Instance<'tcx>) -> ty::SymbolName<'tcx> {
         desc { "computing the symbol for `{}`", key }
-        cache_on_disk_if { true }
+        cache_on_disk_if { key.def_id().is_local() }
     }
 
     query def_kind(def_id: DefId) -> DefKind {