Merge frontend improvements

engine/lib/import_thir.ml

@@ -1082,21 +1082,25 @@ end) : EXPR = struct
     | Error ->
         assertion_failure [ span ]
           "got type `Error`: Rust compilation probably failed."
-    | Dynamic (predicates, _region, Dyn) -> (
+    | Dynamic (_, predicates, _region) -> (
         let goals, non_traits =
           List.partition_map
-            ~f:(fun pred ->
-              match pred.value with
-              | Trait { args; def_id } ->
+            ~f:(fun ((clause, _span) : Types.clause * _) ->
+              match clause.kind.value with
+              | Trait { trait_ref; _ } ->
                   let goal : dyn_trait_goal =
                     {
-                      trait = Concrete_ident.of_def_id ~value:false def_id;
-                      non_self_args = List.map ~f:(c_generic_value span) args;
+                      trait =
+                        Concrete_ident.of_def_id ~value:false
+                          trait_ref.value.def_id;
+                      non_self_args =
+                        List.map ~f:(c_generic_value span)
+                          (List.tl_exn trait_ref.value.generic_args);
                     }
                   in
                   First goal
               | _ -> Second ())
-            predicates
+            predicates.predicates
         in
         match non_traits with
         | [] -> TDyn { witness = W.dyn; goals }

frontend/exporter/src/rustc_utils.rs

@@ -1,5 +1,6 @@
 use crate::prelude::*;
-use rustc_middle::ty;
+use rustc_hir::def::DefKind as RDefKind;
+use rustc_middle::{mir, ty};
 
 #[extension_traits::extension(pub trait SubstBinder)]
 impl<'tcx, T: ty::TypeFoldable<ty::TyCtxt<'tcx>>> ty::Binder<'tcx, T> {
@@ -114,3 +115,196 @@ pub fn get_closest_parent_type(
         _ => get_closest_parent_type(tcx, tcx.parent(id)),
     }
 }
+
+/// Gets the visibility (`pub` or not) of the definition. Returns `None` for defs that don't have a
+/// meaningful visibility.
+pub fn get_def_visibility<'tcx>(
+    tcx: ty::TyCtxt<'tcx>,
+    def_id: RDefId,
+    def_kind: RDefKind,
+) -> Option<bool> {
+    use RDefKind::*;
+    match def_kind {
+        AssocConst
+        | AssocFn
+        | Const
+        | Enum
+        | Field
+        | Fn
+        | ForeignTy
+        | Macro { .. }
+        | Mod
+        | Static { .. }
+        | Struct
+        | Trait
+        | TraitAlias
+        | TyAlias { .. }
+        | Union
+        | Use
+        | Variant => Some(tcx.visibility(def_id).is_public()),
+        // These kinds don't have visibility modifiers (which would cause `visibility` to panic).
+        AnonConst
+        | AssocTy
+        | Closure
+        | ConstParam
+        | Ctor { .. }
+        | ExternCrate
+        | ForeignMod
+        | GlobalAsm
+        | Impl { .. }
+        | InlineConst
+        | LifetimeParam
+        | OpaqueTy
+        | SyntheticCoroutineBody
+        | TyParam => None,
+    }
+}
+
+/// Gets the attributes of the definition.
+pub fn get_def_attrs<'tcx>(
+    tcx: ty::TyCtxt<'tcx>,
+    def_id: RDefId,
+    def_kind: RDefKind,
+) -> &'tcx [rustc_hir::Attribute] {
+    use RDefKind::*;
+    match def_kind {
+        // These kinds cause `get_attrs_unchecked` to panic.
+        ConstParam | LifetimeParam | TyParam | ForeignMod => &[],
+        _ => tcx.get_attrs_unchecked(def_id),
+    }
+}
+
+/// Gets the children of a module.
+pub fn get_mod_children<'tcx>(
+    tcx: ty::TyCtxt<'tcx>,
+    def_id: RDefId,
+) -> Vec<(Option<rustc_span::Ident>, RDefId)> {
+    match def_id.as_local() {
+        Some(ldid) => match tcx.hir_node_by_def_id(ldid) {
+            rustc_hir::Node::Crate(m)
+            | rustc_hir::Node::Item(&rustc_hir::Item {
+                kind: rustc_hir::ItemKind::Mod(_, m),
+                ..
+            }) => m
+                .item_ids
+                .iter()
+                .map(|&item_id| {
+                    let opt_ident = tcx.hir_item(item_id).kind.ident();
+                    let def_id = item_id.owner_id.to_def_id();
+                    (opt_ident, def_id)
+                })
+                .collect(),
+            node => panic!("DefKind::Module is an unexpected node: {node:?}"),
+        },
+        None => tcx
+            .module_children(def_id)
+            .iter()
+            .map(|child| (Some(child.ident), child.res.def_id()))
+            .collect(),
+    }
+}
+
+/// Gets the children of an `extern` block. Empty if the block is not defined in the current crate.
+pub fn get_foreign_mod_children<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: RDefId) -> Vec<RDefId> {
+    match def_id.as_local() {
+        Some(ldid) => tcx
+            .hir_node_by_def_id(ldid)
+            .expect_item()
+            .expect_foreign_mod()
+            .1
+            .iter()
+            .map(|foreign_item_ref| foreign_item_ref.id.owner_id.to_def_id())
+            .collect(),
+        None => vec![],
+    }
+}
+
+/// The signature of a method impl may be a subtype of the one expected from the trait decl, as in
+/// the example below. For correctness, we must be able to map from the method generics declared in
+/// the trait to the actual method generics. Because this would require type inference, we instead
+/// simply return the declared signature. This will cause issues if it is possible to use such a
+/// more-specific implementation with its more-specific type, but we have a few other issues with
+/// lifetime-generic function pointers anyway so this is unlikely to cause problems.
+///
+/// ```ignore
+/// trait MyCompare<Other>: Sized {
+///     fn compare(self, other: Other) -> bool;
+/// }
+/// impl<'a> MyCompare<&'a ()> for &'a () {
+///     // This implementation is more general because it works for non-`'a` refs. Note that only
+///     // late-bound vars may differ in this way.
+///     // `<&'a () as MyCompare<&'a ()>>::compare` has type `fn<'b>(&'a (), &'b ()) -> bool`,
+///     // but type `fn(&'a (), &'a ()) -> bool` was expected from the trait declaration.
+///     fn compare<'b>(self, _other: &'b ()) -> bool {
+///         true
+///     }
+/// }
+/// ```
+pub fn get_method_sig<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: RDefId) -> ty::PolyFnSig<'tcx> {
+    let real_sig = tcx.fn_sig(def_id).instantiate_identity();
+    let item = tcx.associated_item(def_id);
+    if !matches!(item.container, ty::AssocItemContainer::Impl) {
+        return real_sig;
+    }
+    let Some(decl_method_id) = item.trait_item_def_id else {
+        return real_sig;
+    };
+    let declared_sig = tcx.fn_sig(decl_method_id);
+
+    // TODO(Nadrieril): Temporary hack: if the signatures have the same number of bound vars, we
+    // keep the real signature. While the declared signature is more correct, it is also less
+    // normalized and we can't normalize without erasing regions but regions are crucial in
+    // function signatures. Hence we cheat here, until charon gains proper normalization
+    // capabilities.
+    if declared_sig.skip_binder().bound_vars().len() == real_sig.bound_vars().len() {
+        return real_sig;
+    }
+
+    let impl_def_id = item.container_id(tcx);
+    // The trait predicate that is implemented by the surrounding impl block.
+    let implemented_trait_ref = tcx
+        .impl_trait_ref(impl_def_id)
+        .unwrap()
+        .instantiate_identity();
+    // Construct arguments for the declared method generics in the context of the implemented
+    // method generics.
+    let impl_args = ty::GenericArgs::identity_for_item(tcx, def_id);
+    let decl_args = impl_args.rebase_onto(tcx, impl_def_id, implemented_trait_ref.args);
+    let sig = declared_sig.instantiate(tcx, decl_args);
+    // Avoids accidentally using the same lifetime name twice in the same scope
+    // (once in impl parameters, second in the method declaration late-bound vars).
+    let sig = tcx.anonymize_bound_vars(sig);
+    sig
+}
+
+pub fn closure_once_shim<'tcx>(
+    tcx: ty::TyCtxt<'tcx>,
+    closure_ty: ty::Ty<'tcx>,
+) -> Option<mir::Body<'tcx>> {
+    let ty::Closure(def_id, args) = closure_ty.kind() else {
+        unreachable!()
+    };
+    let instance = match args.as_closure().kind() {
+        ty::ClosureKind::Fn | ty::ClosureKind::FnMut => {
+            ty::Instance::fn_once_adapter_instance(tcx, *def_id, args)
+        }
+        ty::ClosureKind::FnOnce => return None,
+    };
+    let mir = tcx.instance_mir(instance.def).clone();
+    let mir = ty::EarlyBinder::bind(mir).instantiate(tcx, instance.args);
+    Some(mir)
+}
+
+pub fn drop_glue_shim<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: RDefId) -> Option<mir::Body<'tcx>> {
+    let drop_in_place =
+        tcx.require_lang_item(rustc_hir::LangItem::DropInPlace, rustc_span::DUMMY_SP);
+    if !tcx.generics_of(def_id).is_empty() {
+        // Hack: layout code panics if it can't fully normalize types, which can happen e.g. with a
+        // trait associated type. For now we only translate the glue for monomorphic types.
+        return None;
+    }
+    let ty = tcx.type_of(def_id).instantiate_identity();
+    let instance_kind = ty::InstanceKind::DropGlue(drop_in_place, Some(ty));
+    let mir = tcx.instance_mir(instance_kind).clone();
+    Some(mir)
+}