Revert "Auto merge of #92007 - oli-obk:lazy_tait2, r=nikomatsakis"

This reverts commit e7cc3bd, reversing
changes made to 734368a.

compiler/rustc_borrowck/src/lib.rs

@@ -124,9 +124,8 @@ fn mir_borrowck<'tcx>(
 ) -> &'tcx BorrowCheckResult<'tcx> {
     let (input_body, promoted) = tcx.mir_promoted(def);
     debug!("run query mir_borrowck: {}", tcx.def_path_str(def.did.to_def_id()));
-    let hir_owner = tcx.hir().local_def_id_to_hir_id(def.did).owner;
 
-    let opt_closure_req = tcx.infer_ctxt().with_opaque_type_inference(hir_owner).enter(|infcx| {
+    let opt_closure_req = tcx.infer_ctxt().with_opaque_type_inference(def.did).enter(|infcx| {
         let input_body: &Body<'_> = &input_body.borrow();
         let promoted: &IndexVec<_, _> = &promoted.borrow();
         do_mir_borrowck(&infcx, input_body, promoted, false).0
@@ -141,7 +140,7 @@ fn mir_borrowck<'tcx>(
 /// If `return_body_with_facts` is true, then return the body with non-erased
 /// region ids on which the borrow checking was performed together with Polonius
 /// facts.
-#[instrument(skip(infcx, input_body, input_promoted), fields(id=?input_body.source.with_opt_param().as_local().unwrap()), level = "debug")]
+#[instrument(skip(infcx, input_body, input_promoted), level = "debug")]
 fn do_mir_borrowck<'a, 'tcx>(
     infcx: &InferCtxt<'a, 'tcx>,
     input_body: &Body<'tcx>,

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -1,6 +1,7 @@
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::vec_map::VecMap;
 use rustc_hir::OpaqueTyOrigin;
+use rustc_infer::infer::opaque_types::OpaqueTypeDecl;
 use rustc_infer::infer::InferCtxt;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable};
@@ -53,44 +54,27 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     pub(crate) fn infer_opaque_types(
         &self,
         infcx: &InferCtxt<'_, 'tcx>,
-        opaque_ty_decls: VecMap<OpaqueTypeKey<'tcx>, (Ty<'tcx>, Span, OpaqueTyOrigin)>,
+        opaque_ty_decls: VecMap<OpaqueTypeKey<'tcx>, OpaqueTypeDecl<'tcx>>,
         span: Span,
     ) -> VecMap<OpaqueTypeKey<'tcx>, Ty<'tcx>> {
         opaque_ty_decls
             .into_iter()
-            .map(|(opaque_type_key, (concrete_type, decl_span, origin))| {
+            .filter_map(|(opaque_type_key, decl)| {
                 let substs = opaque_type_key.substs;
-                // FIXME: why are the spans in decl_span often DUMMY_SP?
-                let span = decl_span.substitute_dummy(span);
+                let concrete_type = decl.concrete_ty;
                 debug!(?concrete_type, ?substs);
 
                 let mut subst_regions = vec![self.universal_regions.fr_static];
                 let universal_substs = infcx.tcx.fold_regions(substs, &mut false, |region, _| {
-                    if let ty::RePlaceholder(..) = region {
-                        // Higher kinded regions don't need remapping, they don't refer to anything outside of this the substs.
-                        return region;
-                    }
-                    let vid = self.to_region_vid(region);
-                    trace!(?vid);
-                    let scc = self.constraint_sccs.scc(vid);
-                    trace!(?scc);
-                    match self.scc_values.universal_regions_outlived_by(scc).find_map(|lb| {
-                        self.eval_equal(vid, lb).then_some(self.definitions[lb].external_name?)
-                    }) {
-                        Some(region) => {
-                            let vid = self.universal_regions.to_region_vid(region);
-                            subst_regions.push(vid);
-                            region
-                        }
-                        None => {
-                            subst_regions.push(vid);
-                            infcx.tcx.sess.delay_span_bug(
-                                span,
-                                "opaque type with non-universal region substs",
-                            );
-                            infcx.tcx.lifetimes.re_static
-                        }
-                    }
+                    let vid = self.universal_regions.to_region_vid(region);
+                    subst_regions.push(vid);
+                    self.definitions[vid].external_name.unwrap_or_else(|| {
+                        infcx
+                            .tcx
+                            .sess
+                            .delay_span_bug(span, "opaque type with non-universal region substs");
+                        infcx.tcx.lifetimes.re_static
+                    })
                 });
 
                 subst_regions.sort();
@@ -116,14 +100,12 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     span,
                 );
 
-                (
+                check_opaque_type_parameter_valid(
+                    infcx.tcx,
                     opaque_type_key,
-                    if check_opaque_type_parameter_valid(infcx.tcx, opaque_type_key, origin, span) {
-                        remapped_type
-                    } else {
-                        infcx.tcx.ty_error()
-                    },
+                    OpaqueTypeDecl { concrete_ty: remapped_type, ..decl },
                 )
+                .then_some((opaque_type_key, remapped_type))
             })
             .collect()
     }
@@ -167,10 +149,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 fn check_opaque_type_parameter_valid(
     tcx: TyCtxt<'_>,
     opaque_type_key: OpaqueTypeKey<'_>,
-    origin: OpaqueTyOrigin,
-    span: Span,
+    decl: OpaqueTypeDecl<'_>,
 ) -> bool {
-    match origin {
+    match decl.origin {
         // No need to check return position impl trait (RPIT)
         // because for type and const parameters they are correct
         // by construction: we convert
@@ -196,6 +177,7 @@ fn check_opaque_type_parameter_valid(
         // Check these
         OpaqueTyOrigin::TyAlias => {}
     }
+    let span = decl.definition_span;
     let opaque_generics = tcx.generics_of(opaque_type_key.def_id);
     let mut seen_params: FxHashMap<_, Vec<_>> = FxHashMap::default();
     for (i, arg) in opaque_type_key.substs.iter().enumerate() {

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -147,9 +147,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         // Return types are a bit more complex. They may contain opaque `impl Trait` types.
         let mir_output_ty = body.local_decls[RETURN_PLACE].ty;
         let output_span = body.local_decls[RETURN_PLACE].source_info.span;
-        if let Err(terr) = self.eq_types(
-            normalized_output_ty,
+        if let Err(terr) = self.eq_opaque_type_and_type(
             mir_output_ty,
+            normalized_output_ty,
             Locations::All(output_span),
             ConstraintCategory::BoringNoLocation,
         ) {
@@ -169,9 +169,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             let user_provided_output_ty = user_provided_sig.output();
             let user_provided_output_ty =
                 self.normalize(user_provided_output_ty, Locations::All(output_span));
-            if let Err(err) = self.eq_types(
-                user_provided_output_ty,
+            if let Err(err) = self.eq_opaque_type_and_type(
                 mir_output_ty,
+                user_provided_output_ty,
                 Locations::All(output_span),
                 ConstraintCategory::BoringNoLocation,
             ) {