Make fn late-bound lifetimes part of the generics.

Author: cjgillot

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -58,7 +58,7 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
                         *self.tcx,
                         ty::ParamEnv::reveal_all(),
                         const_panic_fmt,
-                        self.tcx.intern_substs(&[]),
+                        self.tcx.intern_substs(&[self.tcx.lifetimes.re_erased.into()]),
                     )
                     .unwrap()
                     .unwrap(),

compiler/rustc_hir_analysis/src/check/check.rs

@@ -290,7 +290,7 @@ pub(super) fn check_opaque_for_inheriting_lifetimes<'tcx>(
         type BreakTy = Ty<'tcx>;
 
         fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
-            debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
+            debug!("(visit_ty) t={:?}", t);
             if t == self.opaque_identity_ty {
                 ControlFlow::CONTINUE
             } else {
@@ -328,14 +328,18 @@ pub(super) fn check_opaque_for_inheriting_lifetimes<'tcx>(
 
     if let ItemKind::OpaqueTy(hir::OpaqueTy {
         origin: hir::OpaqueTyOrigin::AsyncFn(..) | hir::OpaqueTyOrigin::FnReturn(..),
+        in_trait,
         ..
     }) = item.kind
     {
+        let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
+        let opaque_identity_ty = if in_trait {
+            tcx.mk_projection(def_id.to_def_id(), substs)
+        } else {
+            tcx.mk_opaque(def_id.to_def_id(), substs)
+        };
         let mut visitor = ProhibitOpaqueVisitor {
-            opaque_identity_ty: tcx.mk_opaque(
-                def_id.to_def_id(),
-                InternalSubsts::identity_for_item(tcx, def_id.to_def_id()),
-            ),
+            opaque_identity_ty,
             generics: tcx.generics_of(def_id),
             tcx,
             selftys: vec![],
@@ -344,10 +348,7 @@ pub(super) fn check_opaque_for_inheriting_lifetimes<'tcx>(
             .explicit_item_bounds(def_id)
             .iter()
             .try_for_each(|(predicate, _)| predicate.visit_with(&mut visitor));
-        debug!(
-            "check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}, visitor.opaque_identity_ty={:?}, visitor.generics={:?}",
-            prohibit_opaque, visitor.opaque_identity_ty, visitor.generics
-        );
+        debug!(?prohibit_opaque);
 
         if let Some(ty) = prohibit_opaque.break_value() {
             visitor.visit_item(&item);

compiler/rustc_hir_analysis/src/check/compare_method.rs

@@ -149,6 +149,7 @@ fn compare_predicate_entailment<'tcx>(
     impl_trait_ref: ty::TraitRef<'tcx>,
 ) -> Result<(), ErrorGuaranteed> {
     let trait_to_impl_substs = impl_trait_ref.substs;
+    debug!(?trait_to_impl_substs);
 
     // This node-id should be used for the `body_id` field on each
     // `ObligationCause` (and the `FnCtxt`).
@@ -173,7 +174,7 @@ fn compare_predicate_entailment<'tcx>(
     // Create mapping from trait to placeholder.
     let trait_to_placeholder_substs =
         impl_to_placeholder_substs.rebase_onto(tcx, impl_m.container_id(tcx), trait_to_impl_substs);
-    debug!("compare_impl_method: trait_to_placeholder_substs={:?}", trait_to_placeholder_substs);
+    debug!(?trait_to_placeholder_substs);
 
     let impl_m_generics = tcx.generics_of(impl_m.def_id);
     let trait_m_generics = tcx.generics_of(trait_m.def_id);
@@ -191,7 +192,7 @@ fn compare_predicate_entailment<'tcx>(
     let impl_predicates = tcx.predicates_of(impl_m_predicates.parent.unwrap());
     let mut hybrid_preds = impl_predicates.instantiate_identity(tcx);
 
-    debug!("compare_impl_method: impl_bounds={:?}", hybrid_preds);
+    debug!("impl_bounds={:?}", hybrid_preds);
 
     // This is the only tricky bit of the new way we check implementation methods
     // We need to build a set of predicates where only the method-level bounds
@@ -218,7 +219,7 @@ fn compare_predicate_entailment<'tcx>(
     let infcx = &tcx.infer_ctxt().build();
     let ocx = ObligationCtxt::new(infcx);
 
-    debug!("compare_impl_method: caller_bounds={:?}", param_env.caller_bounds());
+    debug!("caller_bounds={:?}", param_env.caller_bounds());
 
     let mut selcx = traits::SelectionContext::new(&infcx);
     let impl_m_own_bounds = impl_m_predicates.instantiate_own(tcx, impl_to_placeholder_substs);
@@ -258,18 +259,17 @@ fn compare_predicate_entailment<'tcx>(
 
     let mut wf_tys = FxHashSet::default();
 
-    let impl_sig = infcx.replace_bound_vars_with_fresh_vars(
-        impl_m_span,
-        infer::HigherRankedType,
-        tcx.fn_sig(impl_m.def_id),
-    );
+    let impl_sig = tcx.mk_fn_def(impl_m.def_id, impl_to_placeholder_substs).fn_sig(tcx);
+    let impl_sig =
+        infcx.replace_bound_vars_with_fresh_vars(impl_m_span, infer::HigherRankedType, impl_sig);
 
     let norm_cause = ObligationCause::misc(impl_m_span, impl_m_hir_id);
     let impl_sig = ocx.normalize(norm_cause.clone(), param_env, impl_sig);
     let impl_fty = tcx.mk_fn_ptr(ty::Binder::dummy(impl_sig));
-    debug!("compare_impl_method: impl_fty={:?}", impl_fty);
+    debug!(?impl_fty);
 
-    let trait_sig = tcx.bound_fn_sig(trait_m.def_id).subst(tcx, trait_to_placeholder_substs);
+    let trait_sig = tcx.type_of(trait_m.def_id).fn_sig(tcx);
+    let trait_sig = ty::EarlyBinder(trait_sig).subst(tcx, trait_to_placeholder_substs);
     let trait_sig = tcx.liberate_late_bound_regions(impl_m.def_id, trait_sig);
 
     // Next, add all inputs and output as well-formed tys. Importantly,
@@ -281,8 +281,7 @@ fn compare_predicate_entailment<'tcx>(
     // as we don't normalize during implied bounds computation.
     wf_tys.extend(trait_sig.inputs_and_output.iter());
     let trait_fty = tcx.mk_fn_ptr(ty::Binder::dummy(trait_sig));
-
-    debug!("compare_impl_method: trait_fty={:?}", trait_fty);
+    debug!(?trait_fty);
 
     // FIXME: We'd want to keep more accurate spans than "the method signature" when
     // processing the comparison between the trait and impl fn, but we sadly lose them
@@ -431,6 +430,7 @@ fn compare_predicate_entailment<'tcx>(
     Ok(())
 }
 
+#[instrument(level = "debug", skip(tcx), ret)]
 pub fn collect_trait_impl_trait_tys<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
@@ -464,25 +464,23 @@ pub fn collect_trait_impl_trait_tys<'tcx>(
     let infcx = &tcx.infer_ctxt().build();
     let ocx = ObligationCtxt::new(infcx);
 
+    let impl_sig = tcx.mk_fn_def(impl_m.def_id, impl_to_placeholder_substs).fn_sig(tcx);
+    let impl_sig =
+        infcx.replace_bound_vars_with_fresh_vars(return_span, infer::HigherRankedType, impl_sig);
+
     let norm_cause = ObligationCause::misc(return_span, impl_m_hir_id);
-    let impl_sig = ocx.normalize(
-        norm_cause.clone(),
-        param_env,
-        infcx.replace_bound_vars_with_fresh_vars(
-            return_span,
-            infer::HigherRankedType,
-            tcx.fn_sig(impl_m.def_id),
-        ),
-    );
+    let impl_sig = ocx.normalize(norm_cause.clone(), param_env, impl_sig);
     let impl_return_ty = impl_sig.output();
 
+    let unnormalized_trait_sig = tcx.type_of(trait_m.def_id).fn_sig(tcx);
+    let unnormalized_trait_sig =
+        ty::EarlyBinder(unnormalized_trait_sig).subst(tcx, trait_to_placeholder_substs);
+    let unnormalized_trait_sig =
+        tcx.liberate_late_bound_regions(impl_m.def_id, unnormalized_trait_sig);
+
     let mut collector = ImplTraitInTraitCollector::new(&ocx, return_span, param_env, impl_m_hir_id);
-    let unnormalized_trait_sig = tcx
-        .liberate_late_bound_regions(
-            impl_m.def_id,
-            tcx.bound_fn_sig(trait_m.def_id).subst(tcx, trait_to_placeholder_substs),
-        )
-        .fold_with(&mut collector);
+    let unnormalized_trait_sig = unnormalized_trait_sig.fold_with(&mut collector);
+
     let trait_sig = ocx.normalize(norm_cause.clone(), param_env, unnormalized_trait_sig);
     let trait_return_ty = trait_sig.output();
 
@@ -704,15 +702,11 @@ fn check_region_bounds_on_impl_item<'tcx>(
     trait_generics: &ty::Generics,
     impl_generics: &ty::Generics,
 ) -> Result<(), ErrorGuaranteed> {
-    let trait_params = trait_generics.own_counts().lifetimes;
-    let impl_params = impl_generics.own_counts().lifetimes;
-
-    debug!(
-        "check_region_bounds_on_impl_item: \
-            trait_generics={:?} \
-            impl_generics={:?}",
-        trait_generics, impl_generics
-    );
+    // For backwards compatibility reasons, we can only check that we have the correct amount
+    // of early-bound lifetimes.  The user is allowed to introduce as many late-bound lifetime
+    // as they want.
+    let trait_params = trait_generics.own_counts().early_lifetimes;
+    let impl_params = impl_generics.own_counts().early_lifetimes;
 
     // Must have same number of early-bound lifetime parameters.
     // Unfortunately, if the user screws up the bounds, then this

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -17,25 +17,23 @@ use rustc_target::spec::abi::Abi;
 
 use std::iter;
 
+#[instrument(level = "trace", skip(tcx))]
 fn equate_intrinsic_type<'tcx>(
     tcx: TyCtxt<'tcx>,
     it: &hir::ForeignItem<'_>,
     n_tps: usize,
     n_lts: usize,
     sig: ty::PolyFnSig<'tcx>,
 ) {
-    let (own_counts, span) = match &it.kind {
-        hir::ForeignItemKind::Fn(.., generics) => {
-            let own_counts = tcx.generics_of(it.def_id.to_def_id()).own_counts();
-            (own_counts, generics.span)
-        }
-        _ => {
-            struct_span_err!(tcx.sess, it.span, E0622, "intrinsic must be a function")
-                .span_label(it.span, "expected a function")
-                .emit();
-            return;
-        }
+    let hir::ForeignItemKind::Fn(.., generics) = &it.kind else {
+        struct_span_err!(tcx.sess, it.span, E0622, "intrinsic must be a function")
+            .span_label(it.span, "expected a function")
+            .emit();
+        return;
     };
+    let span = generics.span;
+    let generics = tcx.generics_of(it.def_id.to_def_id());
+    let own_counts = generics.own_counts();
 
     let gen_count_ok = |found: usize, expected: usize, descr: &str| -> bool {
         if found != expected {
@@ -51,13 +49,15 @@ fn equate_intrinsic_type<'tcx>(
         }
     };
 
-    if gen_count_ok(own_counts.lifetimes, n_lts, "lifetime")
+    if gen_count_ok(own_counts.early_lifetimes, n_lts, "lifetime")
         && gen_count_ok(own_counts.types, n_tps, "type")
         && gen_count_ok(own_counts.consts, 0, "const")
     {
         let fty = tcx.mk_fn_ptr(sig);
         let cause = ObligationCause::new(it.span, it.hir_id(), ObligationCauseCode::IntrinsicType);
-        require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(it.def_id)), fty);
+        let fn_def = tcx.type_of(it.def_id).fn_sig(tcx);
+        debug!(?fn_def);
+        require_same_types(tcx, &cause, tcx.mk_fn_ptr(fn_def), fty);
     }
 }
 

compiler/rustc_hir_analysis/src/collect.rs

@@ -20,15 +20,14 @@ use crate::errors;
 use rustc_ast as ast;
 use rustc_ast::{MetaItemKind, NestedMetaItem};
 use rustc_attr::{list_contains_name, InlineAttr, InstructionSetAttr, OptimizeAttr};
-use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorGuaranteed, StashKey};
 use rustc_hir as hir;
 use rustc_hir::def::CtorKind;
 use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::weak_lang_items;
-use rustc_hir::{GenericParamKind, Node};
+use rustc_hir::Node;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::mir::mono::Linkage;
@@ -1132,7 +1131,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> {
 
     let icx = ItemCtxt::new(tcx, def_id.to_def_id());
 
-    match tcx.hir().get(hir_id) {
+    let sig = match tcx.hir().get(hir_id) {
         TraitItem(hir::TraitItem {
             kind: TraitItemKind::Fn(sig, TraitFn::Provided(_)),
             generics,
@@ -1213,7 +1212,11 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> {
         x => {
             bug!("unexpected sort of node in fn_sig(): {:?}", x);
         }
-    }
+    };
+
+    assert!(sig.no_bound_vars().is_some());
+
+    sig
 }
 
 fn infer_return_ty_for_fn_sig<'tcx>(
@@ -1335,21 +1338,6 @@ fn impl_polarity(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ImplPolarity {
     }
 }
 
-/// Returns the early-bound lifetimes declared in this generics
-/// listing. For anything other than fns/methods, this is just all
-/// the lifetimes that are declared. For fns or methods, we have to
-/// screen out those that do not appear in any where-clauses etc using
-/// `resolve_lifetime::early_bound_lifetimes`.
-fn early_bound_lifetimes_from_generics<'a, 'tcx: 'a>(
-    tcx: TyCtxt<'tcx>,
-    generics: &'a hir::Generics<'a>,
-) -> impl Iterator<Item = &'a hir::GenericParam<'a>> + Captures<'tcx> {
-    generics.params.iter().filter(move |param| match param.kind {
-        GenericParamKind::Lifetime { .. } => !tcx.is_late_bound(param.hir_id),
-        _ => false,
-    })
-}
-
 /// Returns a list of type predicates for the definition with ID `def_id`, including inferred
 /// lifetime constraints. This includes all predicates returned by `explicit_predicates_of`, plus
 /// inferred constraints concerning which regions outlive other regions.