clean up

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1248,7 +1248,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         self.root.traits.decode(self).map(move |index| self.local_def_id(index))
     }
 
-    // robert-trait: this implements trait_impls_in_crate_untracked
     /// Decodes all trait impls in the crate (for rustdoc).
     fn get_trait_impls(self) -> impl Iterator<Item = (DefId, DefId, Option<SimplifiedType>)> + 'a {
         self.cdata.trait_impls.iter().flat_map(move |(&(trait_cnum_raw, trait_index), impls)| {
@@ -1262,6 +1261,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         })
     }
 
+    /// Decodes a map from trait to impls.
     fn get_trait_impl_map(self) -> FxIndexMap<DefId, Vec<(DefId, Option<SimplifiedType>)>> {
         self.cdata
             .trait_impls
@@ -1296,7 +1296,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         }
     }
 
-    // robert-trait: ultimately uses decoder.trait_impls. this is for external crates, and is used in trait_impls_of, which iterates over external crates and calls this.
     fn get_implementations_of_trait(
         self,
         tcx: TyCtxt<'tcx>,

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1813,39 +1813,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(self.tcx.traits_in_crate(LOCAL_CRATE).iter().map(|def_id| def_id.index))
     }
 
-    // robert-trait: serialize traits to meta vir HIR iteration
     /// Encodes an index, mapping each trait to its (local) implementations.
     fn encode_impls(&mut self) -> LazyArray<TraitImpls> {
         debug!("EncodeContext::encode_traits_and_impls()");
         empty_proc_macro!(self);
         let tcx = self.tcx;
-        /*
-        let mut fx_hash_map: FxHashMap<DefId, Vec<(DefIndex, Option<SimplifiedType>)>> =
-            FxHashMap::default();
-
-        for id in tcx.hir().items() {
-            if matches!(tcx.def_kind(id.def_id), DefKind::Impl) {
-                if let Some(trait_ref) = tcx.impl_trait_ref(id.def_id.to_def_id()) {
-                    let simplified_self_ty = fast_reject::simplify_type(
-                        self.tcx,
-                        trait_ref.self_ty(),
-                        TreatParams::AsInfer,
-                    );
-
-                    fx_hash_map
-                        .entry(trait_ref.def_id)
-                        .or_default()
-                        .push((id.def_id.local_def_index, simplified_self_ty));
-                }
-            }
-        }
-        */
-
         let fx_hash_map = self.tcx.impls_in_crate(LOCAL_CRATE).to_owned();
 
-        // let mut all_impls: Vec<(DefId, Vec<(DefId, Option<SimplifiedTypeGen<DefId>>)>)>
         let mut all_impls: Vec<_> = fx_hash_map.into_iter().collect();
-        //.map(|(trait_def_id, impls)| (trait_def_id, impls.iter().map(|(impl_def_, d)| (c.expect_local().local_def_index, d))));
 
         // Bring everything into deterministic order for hashing
         all_impls.sort_by_cached_key(|&(trait_def_id, _)| tcx.def_path_hash(trait_def_id));
@@ -2297,11 +2272,6 @@ fn encode_metadata_impl(tcx: TyCtxt<'_>, path: &Path) {
 pub fn provide(providers: &mut Providers) {
     *providers = Providers {
         all_local_trait_impls: |tcx, _| {
-            // with just top live, error.
-            // with just bottom live, success.
-            // with both live, fails.
-            // so although the top has no impact on the output, it causes the failure.
-
             let o: FxIndexMap<_, _> = tcx
                 .impls_in_crate(LOCAL_CRATE)
                 .iter()
@@ -2314,49 +2284,29 @@ pub fn provide(providers: &mut Providers) {
                 .collect();
 
             tcx.arena.alloc(o)
-
-            //providers.all_local_trait_impls = |tcx, ()| &tcx.resolutions(()).trait_impls;
-            //&tcx.resolutions(()).trait_impls
         },
         traits_in_crate: |tcx, cnum| {
             assert_eq!(cnum, LOCAL_CRATE);
 
             let mut traits = Vec::new();
             for id in tcx.hir().items() {
                 if matches!(tcx.def_kind(id.def_id), DefKind::Trait | DefKind::TraitAlias) {
-                    //println!("matches b");
                     traits.push(id.def_id.to_def_id())
                 }
             }
 
-            // Bring everything into deterministic order.
-            //traits.sort_by_cached_key(|&def_id| tcx.def_path_hash(def_id));
-            // This is not necessary, since the default order is source-code order.
+            // We don't need to sort, since the default order is source-code order.
             // The source code is hashed into crate_hash, so if crate_hash is stable then it must be stable too.
 
             tcx.arena.alloc_slice(&traits)
         },
         impls_in_crate: |tcx, cnum| {
             assert_eq!(cnum, LOCAL_CRATE);
-
-            /*
-            let mut impls = Vec::new();
-
-            for id in tcx.hir().items() {
-                if matches!(tcx.def_kind(id.def_id), DefKind::Impl) {
-                    impls.push(id.def_id.to_def_id());
-                }
-            }
-
-            tcx.arena.alloc_slice(&impls) // no need to sort, source-code order is fine.
-            */
             let mut fx_hash_map: FxIndexMap<DefId, Vec<(DefId, Option<SimplifiedType>)>> =
                 FxIndexMap::default();
 
             for id in tcx.hir().items() {
-                //println!("{:?}", id);
                 if matches!(tcx.def_kind(id.def_id), DefKind::Impl) {
-                    //println!("matches a");
                     if let Some(trait_ref) = tcx.impl_trait_ref(id.def_id.to_def_id()) {
                         let simplified_self_ty = fast_reject::simplify_type(
                             tcx,

compiler/rustc_middle/src/hir/map/mod.rs

@@ -513,10 +513,8 @@ impl<'hir> Map<'hir> {
         }
     }
 
-    // robert-trait: ultimately provided by resolver outputs.
     pub fn trait_impls(self, trait_did: DefId) -> &'hir [LocalDefId] {
         self.tcx.all_local_trait_impls(()).get(&trait_did).map_or(&[], |xs| &xs[..])
-        //self.tcx.impls_in_crate(LOCAL_CRATE).get(&trait_did).map_or(&[], |xs| &xs[..])
     }
 
     /// Gets the attributes on the crate. This is preferable to

compiler/rustc_middle/src/hir/mod.rs

@@ -172,8 +172,6 @@ pub fn provide(providers: &mut Providers) {
         }
     };
     providers.opt_def_kind = |tcx, def_id| tcx.hir().opt_def_kind(def_id.expect_local());
-    // robert-resolver
-    //providers.all_local_trait_impls = |tcx, ()| &tcx.resolutions(()).trait_impls;
     providers.expn_that_defined = |tcx, id| {
         let id = id.expect_local();
         tcx.resolutions(()).expn_that_defined.get(&id).copied().unwrap_or(ExpnId::root())

compiler/rustc_middle/src/ty/mod.rs

@@ -153,7 +153,6 @@ pub struct ResolverOutputs {
     /// via `extern crate` item and not `--extern` option or compiler built-in.
     pub extern_prelude: FxHashMap<Symbol, bool>,
     pub main_def: Option<MainDefinition>,
-    //pub trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>,
     /// A list of proc macro LocalDefIds, written out in the order in which
     /// they are declared in the static array generated by proc_macro_harness.
     pub proc_macros: Vec<LocalDefId>,

compiler/rustc_middle/src/ty/trait_def.rs

@@ -211,7 +211,6 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
-// robert-trait: ultimately provided by decoder.trait_impls
 // Query provider for `trait_impls_of`.
 pub(super) fn trait_impls_of_provider(tcx: TyCtxt<'_>, trait_id: DefId) -> TraitImpls {
     let mut impls = TraitImpls::default();

compiler/rustc_resolve/src/late.rs

@@ -2620,16 +2620,6 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                                 |this, trait_id| {
                                     let item_def_id = this.r.local_def_id(item_id);
 
-                                    // Register the trait definitions from here.
-                                    // robert-resolver
-                                    //if let Some(trait_id) = trait_id {
-                                    //    this.r
-                                    //        .trait_impls
-                                    //        .entry(trait_id)
-                                    //        .or_default()
-                                    //        .push(item_def_id);
-                                    //}
-
                                     let item_def_id = item_def_id.to_def_id();
                                     let res = Res::SelfTy {
                                         trait_: trait_id,

compiler/rustc_resolve/src/lib.rs

@@ -1048,7 +1048,6 @@ pub struct Resolver<'a> {
     item_generics_num_lifetimes: FxHashMap<LocalDefId, usize>,
 
     main_def: Option<MainDefinition>,
-    //trait_impls: FxIndexMap<DefId, Vec<LocalDefId>>,
     /// A list of proc macro LocalDefIds, written out in the order in which
     /// they are declared in the static array generated by proc_macro_harness.
     proc_macros: Vec<NodeId>,
@@ -1358,7 +1357,6 @@ impl<'a> Resolver<'a> {
             legacy_const_generic_args: Default::default(),
             item_generics_num_lifetimes: Default::default(),
             main_def: Default::default(),
-            //trait_impls: Default::default(),
             proc_macros: Default::default(),
             confused_type_with_std_module: Default::default(),
             access_levels: Default::default(),
@@ -1439,7 +1437,6 @@ impl<'a> Resolver<'a> {
                 .map(|(ident, entry)| (ident.name, entry.introduced_by_item))
                 .collect(),
             main_def,
-            //trait_impls: self.trait_impls,
             proc_macros,
             confused_type_with_std_module,
             registered_tools: self.registered_tools,
@@ -1483,7 +1480,6 @@ impl<'a> Resolver<'a> {
                 .map(|(ident, entry)| (ident.name, entry.introduced_by_item))
                 .collect(),
             main_def: self.main_def,
-            //trait_impls: self.trait_impls.clone(),
             proc_macros,
             confused_type_with_std_module: self.confused_type_with_std_module.clone(),
             registered_tools: self.registered_tools.clone(),