Merge pull request #1431 from Nadrieril/clarify-parent-impl-exprs

Consistently translate impl exprs for parent items

Author: Nadrieril

frontend/exporter/src/constant_utils/uneval.rs

@@ -114,12 +114,11 @@ pub fn translate_constant_reference<'tcx>(
         if assoc.trait_item_def_id.is_some() {
             // This must be a trait declaration constant
             let name = assoc.name.to_string();
-            let impl_expr = self_clause_for_item(s, &assoc, ucv.args).unwrap();
+            let impl_expr = self_clause_for_item(s, ucv.def, ucv.args).unwrap();
             ConstantExprKind::TraitConst { impl_expr, name }
         } else {
             // Constant appearing in an inherent impl block.
-            let parent_def_id = tcx.parent(ucv.def);
-            let trait_refs = solve_item_required_traits(s, parent_def_id, ucv.args);
+            let trait_refs = solve_item_required_traits(s, ucv.def, ucv.args);
             ConstantExprKind::GlobalName {
                 id: ucv.def.sinto(s),
                 generics: ucv.args.sinto(s),

frontend/exporter/src/traits.rs

@@ -185,25 +185,14 @@ pub fn solve_trait<'tcx, S: BaseState<'tcx> + HasOwnerId>(
 }
 
 /// Solve the trait obligations for a specific item use (for example, a method call, an ADT, etc.)
-/// in the current context.
+/// in the current context. Just like generic args include generics of parent items, this includes
+/// impl exprs for parent items.
 #[cfg(feature = "rustc")]
 #[tracing::instrument(level = "trace", skip(s), ret)]
 pub fn solve_item_required_traits<'tcx, S: UnderOwnerState<'tcx>>(
     s: &S,
     def_id: RDefId,
     generics: ty::GenericArgsRef<'tcx>,
-) -> Vec<ImplExpr> {
-    let predicates = required_predicates(s.base().tcx, def_id);
-    solve_item_traits_inner(s, generics, predicates)
-}
-
-/// Like `solve_item_required_traits`, but also includes predicates coming from the parent items.
-#[cfg(feature = "rustc")]
-#[tracing::instrument(level = "trace", skip(s), ret)]
-pub fn solve_item_and_parents_required_traits<'tcx, S: UnderOwnerState<'tcx>>(
-    s: &S,
-    def_id: RDefId,
-    generics: ty::GenericArgsRef<'tcx>,
 ) -> Vec<ImplExpr> {
     fn accumulate<'tcx, S: UnderOwnerState<'tcx>>(
         s: &S,
@@ -220,7 +209,8 @@ pub fn solve_item_and_parents_required_traits<'tcx, S: UnderOwnerState<'tcx>>(
             }
             _ => {}
         }
-        impl_exprs.extend(solve_item_required_traits(s, def_id, generics));
+        let predicates = required_predicates(tcx, def_id);
+        impl_exprs.extend(solve_item_traits_inner(s, generics, predicates));
     }
     let mut impl_exprs = vec![];
     accumulate(s, def_id, generics, &mut impl_exprs);
@@ -272,13 +262,13 @@ fn solve_item_traits_inner<'tcx, S: UnderOwnerState<'tcx>>(
 #[cfg(feature = "rustc")]
 pub fn self_clause_for_item<'tcx, S: UnderOwnerState<'tcx>>(
     s: &S,
-    assoc: &rustc_middle::ty::AssocItem,
+    def_id: RDefId,
     generics: rustc_middle::ty::GenericArgsRef<'tcx>,
 ) -> Option<ImplExpr> {
     use rustc_middle::ty::EarlyBinder;
     let tcx = s.base().tcx;
 
-    let tr_def_id = tcx.trait_of_item(assoc.def_id)?;
+    let tr_def_id = tcx.trait_of_item(def_id)?;
     // The "self" predicate in the context of the trait.
     let self_pred = self_predicate(tcx, tr_def_id);
     // Substitute to be in the context of the current item.

frontend/exporter/src/traits/utils.rs

@@ -76,9 +76,6 @@ pub fn required_predicates<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> GenericPre
         | TraitAlias
         | TyAlias
         | Union => predicates_defined_on(tcx, def_id),
-        // The tuple struct/variant constructor functions inherit the generics and predicates from
-        // their parents.
-        Variant | Ctor(..) => return required_predicates(tcx, tcx.parent(def_id)),
         // We consider all predicates on traits to be outputs
         Trait => Default::default(),
         // `predicates_defined_on` ICEs on other def kinds.

frontend/exporter/src/types/mir.rs

@@ -5,8 +5,6 @@
 use crate::prelude::*;
 #[cfg(feature = "rustc")]
 use rustc_middle::{mir, ty};
-#[cfg(feature = "rustc")]
-use tracing::trace;
 
 #[derive_group(Serializers)]
 #[derive(AdtInto, Clone, Debug, JsonSchema)]
@@ -342,58 +340,20 @@ pub struct Terminator {
 }
 
 #[cfg(feature = "rustc")]
-pub(crate) fn get_function_from_def_id_and_generics<'tcx, S: BaseState<'tcx> + HasOwnerId>(
+/// Compute the
+pub(crate) fn get_function_from_def_id_and_generics<'tcx, S: UnderOwnerState<'tcx>>(
     s: &S,
     def_id: rustc_hir::def_id::DefId,
     generics: rustc_middle::ty::GenericArgsRef<'tcx>,
 ) -> (DefId, Vec<GenericArg>, Vec<ImplExpr>, Option<ImplExpr>) {
-    let tcx = s.base().tcx;
-
-    // Retrieve the trait requirements for the **method**.
-    // For instance, if we write:
-    // ```
-    // fn foo<T : Bar>(...)
-    //            ^^^
-    // ```
-    let mut trait_refs = solve_item_required_traits(s, def_id, generics);
+    // Retrieve the trait requirements for the item.
+    let trait_refs = solve_item_required_traits(s, def_id, generics);
 
+    // If this is a trait method call, retreive the impl expr information for that trait.
     // Check if this is a trait method call: retrieve the trait source if
-    // it is the case (i.e., where does the method come from? Does it refer
-    // to a top-level implementation? Or the method of a parameter? etc.).
-    // At the same time, retrieve the trait obligations for this **trait**.
-    // Remark: the trait obligations for the method are not the same as
-    // the trait obligations for the trait. More precisely:
-    //
-    // ```
-    // trait Foo<T : Bar> {
-    //              ^^^^^
-    //      trait level trait obligation
-    //   fn baz(...) where T : ... {
-    //      ...                ^^^
-    //             method level trait obligation
-    //   }
-    // }
-    // ```
-    //
-    // Also, a function doesn't need to belong to a trait to have trait
-    // obligations:
-    // ```
-    // fn foo<T : Bar>(...)
-    //            ^^^
-    //     method level trait obligation
-    // ```
-    let (generics, source) = if let Some(assoc) = tcx.opt_associated_item(def_id) {
-        // There is an associated item.
-        use tracing::*;
-        trace!("def_id: {:?}", def_id);
-        trace!("assoc: def_id: {:?}", assoc.def_id);
-        // Retrieve the `DefId` of the trait declaration or the impl block.
-        let container_def_id = match assoc.container {
-            rustc_middle::ty::AssocItemContainer::Trait => tcx.trait_of_item(assoc.def_id).unwrap(),
-            rustc_middle::ty::AssocItemContainer::Impl => tcx.impl_of_method(assoc.def_id).unwrap(),
-        };
-        // The generics are split in two: the arguments of the container (trait decl or impl block)
-        // and the arguments of the method.
+    let (generics, trait_impl) = if let Some(tinfo) = self_clause_for_item(s, def_id, generics) {
+        // The generics are split in two: the arguments of the container (trait decl or impl
+        // block) and the arguments of the method.
         //
         // For instance, if we have:
         // ```
@@ -408,44 +368,16 @@ pub(crate) fn get_function_from_def_id_and_generics<'tcx, S: BaseState<'tcx> + H
         // ```
         // The generics for the call to `baz` will be the concatenation: `<T, u32, U>`, which we
         // split into `<T, u32>` and `<U>`.
-        //
-        // If we have:
-        // ```
-        // impl<T: Ord> Map<T> {
-        //     pub fn insert<U: Clone>(&mut self, x: U) { ... }
-        // }
-        // pub fn test(mut tree: Map<u32>) {
-        //     tree.insert(false);
-        // }
-        // ```
-        // The generics for `insert` are `<u32>` for the impl and `<bool>` for the method.
-        match assoc.container {
-            rustc_middle::ty::AssocItemContainer::Trait => {
-                let num_container_generics = tcx.generics_of(container_def_id).own_params.len();
-                // Retrieve the trait information
-                let impl_expr = self_clause_for_item(s, &assoc, generics).unwrap();
-                // Return only the method generics; the trait generics are included in `impl_expr`.
-                let method_generics = &generics[num_container_generics..];
-                (method_generics.sinto(s), Some(impl_expr))
-            }
-            rustc_middle::ty::AssocItemContainer::Impl => {
-                // Solve the trait constraints of the impl block.
-                let container_generics = tcx.generics_of(container_def_id);
-                let container_generics = generics.truncate_to(tcx, container_generics);
-                // Prepend the container trait refs.
-                let mut combined_trait_refs =
-                    solve_item_required_traits(s, container_def_id, container_generics);
-                combined_trait_refs.extend(std::mem::take(&mut trait_refs));
-                trait_refs = combined_trait_refs;
-                (generics.sinto(s), None)
-            }
-        }
+        let num_trait_generics = tinfo.r#trait.hax_skip_binder_ref().generic_args.len();
+        // Return only the method generics; the trait generics are included in `trait_impl_expr`.
+        let method_generics = &generics[num_trait_generics..];
+        (method_generics.sinto(s), Some(tinfo))
     } else {
         // Regular function call
         (generics.sinto(s), None)
     };
 
-    (def_id.sinto(s), generics, trait_refs, source)
+    (def_id.sinto(s), generics, trait_refs, trait_impl)
 }
 
 #[cfg(feature = "rustc")]
@@ -965,7 +897,8 @@ pub enum AggregateKind {
             generics.sinto(s),
             trait_refs,
             annot.sinto(s),
-            fid.sinto(s))
+            fid.sinto(s),
+        )
     })]
     Adt(
         DefId,

frontend/exporter/src/types/thir.rs

@@ -627,7 +627,7 @@ pub enum ExprKind {
                 let tcx = gstate.base().tcx;
                 r#trait = (|| {
                     let assoc_item = tcx.opt_associated_item(*def_id)?;
-                    let impl_expr = self_clause_for_item(gstate, &assoc_item, generics)?;
+                    let impl_expr = self_clause_for_item(gstate, assoc_item.def_id, generics)?;
                     let assoc_generics = tcx.generics_of(assoc_item.def_id);
                     let assoc_generics = translated_generics.drain(0..assoc_generics.parent_count).collect();
                     Some((impl_expr, assoc_generics))
@@ -881,12 +881,7 @@ pub enum ExprKind {
         args: Vec<GenericArg>,
         user_ty: Option<CanonicalUserType>,
         #[not_in_source]
-        #[value({
-            let tcx = gstate.base().tcx;
-            tcx.opt_associated_item(*def_id).as_ref().and_then(|assoc| {
-                self_clause_for_item(gstate, assoc, args)
-            })
-        })]
+        #[value(self_clause_for_item(gstate, *def_id, args))]
         r#impl: Option<ImplExpr>,
     },
     ConstParam {

frontend/exporter/src/types/ty.rs

@@ -1327,7 +1327,7 @@ impl ClosureArgs {
             parent_trait_refs: {
                 let parent = tcx.generics_of(def_id).parent.unwrap();
                 let parent_generics_ref = tcx.mk_args(from.parent_args());
-                solve_item_and_parents_required_traits(s, parent, parent_generics_ref)
+                solve_item_required_traits(s, parent, parent_generics_ref)
             },
             tupled_sig: sig.sinto(s),
             untupled_sig: tcx