Merge frontend improvements

frontend/exporter/src/state.rs

@@ -309,6 +309,17 @@ pub trait WithItemCacheExt<'tcx>: UnderOwnerState<'tcx> {
     fn with_cache<T>(&self, f: impl FnOnce(&mut ItemCache<'tcx>) -> T) -> T {
         self.with_item_cache(self.owner_id(), f)
     }
+    fn with_predicate_searcher<T>(&self, f: impl FnOnce(&mut PredicateSearcher<'tcx>) -> T) -> T {
+        self.with_cache(|cache| {
+            f(cache.predicate_searcher.get_or_insert_with(|| {
+                PredicateSearcher::new_for_owner(
+                    self.base().tcx,
+                    self.owner_id(),
+                    self.base().options.resolve_drop_bounds,
+                )
+            }))
+        })
+    }
 }
 impl<'tcx, S: UnderOwnerState<'tcx>> WithItemCacheExt<'tcx> for S {}
 

frontend/exporter/src/traits.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 #[cfg(feature = "rustc")]
-mod resolution;
+pub mod resolution;
 #[cfg(feature = "rustc")]
 mod utils;
 #[cfg(feature = "rustc")]
@@ -52,18 +52,11 @@ impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, ImplExprPathChunk> for resolution:
             resolution::PathChunk::AssocItem {
                 item,
                 generic_args,
-                impl_exprs,
                 predicate,
                 index,
                 ..
             } => ImplExprPathChunk::AssocItem {
-                item: ItemRef::new(
-                    s,
-                    item.def_id.sinto(s),
-                    generic_args.sinto(s),
-                    impl_exprs.sinto(s),
-                    None,
-                ),
+                item: translate_item_ref(s, item.def_id, generic_args),
                 assoc_item: item.sinto(s),
                 predicate: predicate.sinto(s),
                 predicate_id: <_ as SInto<_, Clause>>::sinto(predicate, s).id,
@@ -88,14 +81,8 @@ impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, ImplExprPathChunk> for resolution:
 #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, JsonSchema)]
 pub enum ImplExprAtom {
     /// A concrete `impl Trait for Type {}` item.
-    #[custom_arm(FROM_TYPE::Concrete { def_id, generics, impl_exprs } => TO_TYPE::Concrete(
-        ItemRef::new(
-            s,
-            def_id.sinto(s),
-            generics.sinto(s),
-            impl_exprs.sinto(s),
-            None,
-        )
+    #[custom_arm(FROM_TYPE::Concrete { def_id, generics } => TO_TYPE::Concrete(
+        translate_item_ref(s, *def_id, generics),
     ),)]
     Concrete(ItemRef),
     /// A context-bound clause like `where T: Trait`.
@@ -231,18 +218,8 @@ pub fn solve_trait<'tcx, S: UnderOwnerState<'tcx>>(
     if let Some(impl_expr) = s.with_cache(|cache| cache.impl_exprs.get(&trait_ref).cloned()) {
         return impl_expr;
     }
-    let resolved = s.with_cache(|cache| {
-        cache
-            .predicate_searcher
-            .get_or_insert_with(|| {
-                PredicateSearcher::new_for_owner(
-                    s.base().tcx,
-                    s.owner_id(),
-                    s.base().options.resolve_drop_bounds,
-                )
-            })
-            .resolve(&trait_ref, &warn)
-    });
+    let resolved =
+        s.with_predicate_searcher(|pred_searcher| pred_searcher.resolve(&trait_ref, &warn));
     let impl_expr = match resolved {
         Ok(x) => x.sinto(s),
         Err(e) => crate::fatal!(s, "{}", e),
@@ -259,53 +236,7 @@ pub fn translate_item_ref<'tcx, S: UnderOwnerState<'tcx>>(
     def_id: RDefId,
     generics: ty::GenericArgsRef<'tcx>,
 ) -> ItemRef {
-    let key = (def_id, generics);
-    if let Some(item) = s.with_cache(|cache| cache.item_refs.get(&key).cloned()) {
-        return item;
-    }
-    let mut impl_exprs = solve_item_required_traits(s, def_id, generics);
-    let mut generic_args = generics.sinto(s);
-
-    // If this is an associated item, resolve the trait reference.
-    let trait_info = self_clause_for_item(s, def_id, generics);
-    // Fixup the generics.
-    if let Some(tinfo) = &trait_info {
-        // The generics are split in two: the arguments of the trait and the arguments of the
-        // method.
-        //
-        // For instance, if we have:
-        // ```
-        // trait Foo<T> {
-        //     fn baz<U>(...) { ... }
-        // }
-        //
-        // fn test<T : Foo<u32>(x: T) {
-        //     x.baz(...);
-        //     ...
-        // }
-        // ```
-        // The generics for the call to `baz` will be the concatenation: `<T, u32, U>`, which we
-        // split into `<T, u32>` and `<U>`.
-        let trait_ref = tinfo.r#trait.hax_skip_binder_ref();
-        let num_trait_generics = trait_ref.generic_args.len();
-        generic_args.drain(0..num_trait_generics);
-        let num_trait_trait_clauses = trait_ref.impl_exprs.len();
-        // Associated items take a `Self` clause as first clause, we skip that one too. Note: that
-        // clause is the same as `tinfo`.
-        impl_exprs.drain(0..num_trait_trait_clauses + 1);
-    }
-
-    let content = ItemRefContents {
-        def_id: def_id.sinto(s),
-        generic_args,
-        impl_exprs,
-        in_trait: trait_info,
-    };
-    let item = content.intern(s);
-    s.with_cache(|cache| {
-        cache.item_refs.insert(key, item.clone());
-    });
-    item
+    ItemRef::translate(s, def_id, generics)
 }
 
 /// Solve the trait obligations for a specific item use (for example, a method call, an ADT, etc.)