Auto merge of #93893 - oli-obk:sad_revert, r=oli-obk

Revert lazy TAIT PR

Revert #92306 (sorry `@Aaron1011,` will include your changes in the fix PR)
Revert #93783
Revert #92007

fixes #93788
fixes #93794
fixes #93821
fixes #93831
fixes #93841

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -2,13 +2,9 @@ use rustc_errors::DiagnosticBuilder;
 use rustc_infer::infer::canonical::Canonical;
 use rustc_infer::infer::error_reporting::nice_region_error::NiceRegionError;
 use rustc_infer::infer::region_constraints::Constraint;
-use rustc_infer::infer::region_constraints::RegionConstraintData;
-use rustc_infer::infer::RegionVariableOrigin;
 use rustc_infer::infer::{InferCtxt, RegionResolutionError, SubregionOrigin, TyCtxtInferExt as _};
 use rustc_infer::traits::{Normalized, ObligationCause, TraitEngine, TraitEngineExt};
 use rustc_middle::ty::error::TypeError;
-use rustc_middle::ty::RegionVid;
-use rustc_middle::ty::UniverseIndex;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc_span::Span;
 use rustc_trait_selection::traits::query::type_op;
@@ -82,15 +78,6 @@ crate trait ToUniverseInfo<'tcx> {
  fn to_universe_info(self, base_universe: ty::UniverseIndex) -> UniverseInfo<'tcx>;
 }
 
-impl<'tcx> ToUniverseInfo<'tcx> for crate::type_check::InstantiateOpaqueType<'tcx> {
- fn to_universe_info(self, base_universe: ty::UniverseIndex) -> UniverseInfo<'tcx> {
- UniverseInfo(UniverseInfoInner::TypeOp(Rc::new(crate::type_check::InstantiateOpaqueType {
- base_universe: Some(base_universe),
- ..self
- })))
- }
-}
-
 impl<'tcx> ToUniverseInfo<'tcx>
  for Canonical<'tcx, ty::ParamEnvAnd<'tcx, type_op::prove_predicate::ProvePredicate<'tcx>>>
 {
@@ -131,12 +118,6 @@ impl<'tcx, F, G> ToUniverseInfo<'tcx> for Canonical<'tcx, type_op::custom::Custo
  }
 }
 
-impl<'tcx> ToUniverseInfo<'tcx> for ! {
- fn to_universe_info(self, _base_universe: ty::UniverseIndex) -> UniverseInfo<'tcx> {
- self
- }
-}
-
 #[allow(unused_lifetimes)]
 trait TypeOpInfo<'tcx> {
  /// Returns an error to be reported if rerunning the type op fails to
@@ -147,7 +128,7 @@ trait TypeOpInfo<'tcx> {
 
  fn nice_error(
  &self,
- mbcx: &mut MirBorrowckCtxt<'_, 'tcx>,
+ tcx: TyCtxt<'tcx>,
  cause: ObligationCause<'tcx>,
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
@@ -194,7 +175,7 @@ trait TypeOpInfo<'tcx> {
  debug!(?placeholder_region);
 
  let span = cause.span;
- let nice_error = self.nice_error(mbcx, cause, placeholder_region, error_region);
+ let nice_error = self.nice_error(tcx, cause, placeholder_region, error_region);
 
  if let Some(nice_error) = nice_error {
  nice_error.buffer(&mut mbcx.errors_buffer);
@@ -223,16 +204,16 @@ impl<'tcx> TypeOpInfo<'tcx> for PredicateQuery<'tcx> {
 
  fn nice_error(
  &self,
- mbcx: &mut MirBorrowckCtxt<'_, 'tcx>,
+ tcx: TyCtxt<'tcx>,
  cause: ObligationCause<'tcx>,
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
  ) -> Option<DiagnosticBuilder<'tcx>> {
- mbcx.infcx.tcx.infer_ctxt().enter_with_canonical(
+ tcx.infer_ctxt().enter_with_canonical(
  cause.span,
  &self.canonical_query,
  |ref infcx, key, _| {
- let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
+ let mut fulfill_cx = <dyn TraitEngine<'_>>::new(tcx);
  type_op_prove_predicate_with_cause(infcx, &mut *fulfill_cx, key, cause);
  try_extract_error_from_fulfill_cx(
  fulfill_cx,
@@ -266,16 +247,16 @@ where
 
  fn nice_error(
  &self,
- mbcx: &mut MirBorrowckCtxt<'_, 'tcx>,
+ tcx: TyCtxt<'tcx>,
  cause: ObligationCause<'tcx>,
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
  ) -> Option<DiagnosticBuilder<'tcx>> {
- mbcx.infcx.tcx.infer_ctxt().enter_with_canonical(
+ tcx.infer_ctxt().enter_with_canonical(
  cause.span,
  &self.canonical_query,
  |ref infcx, key, _| {
- let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
+ let mut fulfill_cx = <dyn TraitEngine<'_>>::new(tcx);
 
  let mut selcx = SelectionContext::new(infcx);
 
@@ -323,16 +304,16 @@ impl<'tcx> TypeOpInfo<'tcx> for AscribeUserTypeQuery<'tcx> {
 
  fn nice_error(
  &self,
- mbcx: &mut MirBorrowckCtxt<'_, 'tcx>,
+ tcx: TyCtxt<'tcx>,
  cause: ObligationCause<'tcx>,
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
  ) -> Option<DiagnosticBuilder<'tcx>> {
- mbcx.infcx.tcx.infer_ctxt().enter_with_canonical(
+ tcx.infer_ctxt().enter_with_canonical(
  cause.span,
  &self.canonical_query,
  |ref infcx, key, _| {
- let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
+ let mut fulfill_cx = <dyn TraitEngine<'_>>::new(tcx);
  type_op_ascribe_user_type_with_span(infcx, &mut *fulfill_cx, key, Some(cause.span))
  .ok()?;
  try_extract_error_from_fulfill_cx(
@@ -346,90 +327,43 @@ impl<'tcx> TypeOpInfo<'tcx> for AscribeUserTypeQuery<'tcx> {
  }
 }
 
-impl<'tcx> TypeOpInfo<'tcx> for crate::type_check::InstantiateOpaqueType<'tcx> {
- fn fallback_error(&self, tcx: TyCtxt<'tcx>, span: Span) -> DiagnosticBuilder<'tcx> {
- // FIXME: This error message isn't great, but it doesn't show up in the existing UI tests,
- // and is only the fallback when the nice error fails. Consider improving this some more.
- tcx.sess.struct_span_err(span, "higher-ranked lifetime error for opaque type!")
- }
-
- fn base_universe(&self) -> ty::UniverseIndex {
- self.base_universe.unwrap()
- }
-
- fn nice_error(
- &self,
- mbcx: &mut MirBorrowckCtxt<'_, 'tcx>,
- _cause: ObligationCause<'tcx>,
- placeholder_region: ty::Region<'tcx>,
- error_region: Option<ty::Region<'tcx>>,
- ) -> Option<DiagnosticBuilder<'tcx>> {
- try_extract_error_from_region_constraints(
- mbcx.infcx,
- placeholder_region,
- error_region,
- self.region_constraints.as_ref().unwrap(),
- // We're using the original `InferCtxt` that we
- // started MIR borrowchecking with, so the region
- // constraints have already been taken. Use the data from
- // our `mbcx` instead.
- |vid| mbcx.regioncx.var_infos[vid].origin,
- |vid| mbcx.regioncx.var_infos[vid].universe,
- )
- }
-}
-
 #[instrument(skip(fulfill_cx, infcx), level = "debug")]
 fn try_extract_error_from_fulfill_cx<'tcx>(
  mut fulfill_cx: Box<dyn TraitEngine<'tcx> + 'tcx>,
  infcx: &InferCtxt<'_, 'tcx>,
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
 ) -> Option<DiagnosticBuilder<'tcx>> {
+ let tcx = infcx.tcx;
+
  // We generally shouldn't have errors here because the query was
  // already run, but there's no point using `delay_span_bug`
  // when we're going to emit an error here anyway.
  let _errors = fulfill_cx.select_all_or_error(infcx);
- let region_constraints = infcx.with_region_constraints(|r| r.clone());
- try_extract_error_from_region_constraints(
- infcx,
- placeholder_region,
- error_region,
- &region_constraints,
- |vid| infcx.region_var_origin(vid),
- |vid| infcx.universe_of_region(infcx.tcx.mk_region(ty::ReVar(vid))),
- )
-}
 
-fn try_extract_error_from_region_constraints<'tcx>(
- infcx: &InferCtxt<'_, 'tcx>,
- placeholder_region: ty::Region<'tcx>,
- error_region: Option<ty::Region<'tcx>>,
- region_constraints: &RegionConstraintData<'tcx>,
- mut region_var_origin: impl FnMut(RegionVid) -> RegionVariableOrigin,
- mut universe_of_region: impl FnMut(RegionVid) -> UniverseIndex,
-) -> Option<DiagnosticBuilder<'tcx>> {
- let (sub_region, cause) =
+ let (sub_region, cause) = infcx.with_region_constraints(|region_constraints| {
+ debug!("{:#?}", region_constraints);
  region_constraints.constraints.iter().find_map(|(constraint, cause)| {
  match *constraint {
  Constraint::RegSubReg(sub, sup) if sup == placeholder_region && sup != sub => {
  Some((sub, cause.clone()))
  }
  // FIXME: Should this check the universe of the var?
  Constraint::VarSubReg(vid, sup) if sup == placeholder_region => {
- Some((infcx.tcx.mk_region(ty::ReVar(vid)), cause.clone()))
+ Some((tcx.mk_region(ty::ReVar(vid)), cause.clone()))
  }
  _ => None,
  }
- })?;
+ })
+ })?;
 
  debug!(?sub_region, "cause = {:#?}", cause);
  let nice_error = match (error_region, sub_region) {
  (Some(error_region), &ty::ReVar(vid)) => NiceRegionError::new(
  infcx,
  RegionResolutionError::SubSupConflict(
  vid,
- region_var_origin(vid),
+ infcx.region_var_origin(vid),
  cause.clone(),
  error_region,
  cause.clone(),
@@ -446,8 +380,8 @@ fn try_extract_error_from_region_constraints<'tcx>(
  infcx,
  RegionResolutionError::UpperBoundUniverseConflict(
  vid,
- region_var_origin(vid),
- universe_of_region(vid),
+ infcx.region_var_origin(vid),
+ infcx.universe_of_region(sub_region),
  cause.clone(),
  placeholder_region,
  ),

compiler/rustc_borrowck/src/lib.rs

@@ -5,7 +5,6 @@
 #![feature(crate_visibility_modifier)]
 #![feature(let_else)]
 #![feature(min_specialization)]
-#![feature(never_type)]
 #![feature(stmt_expr_attributes)]
 #![feature(trusted_step)]
 #![feature(try_blocks)]
@@ -125,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
@@ -142,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/mod.rs

@@ -44,7 +44,6 @@ mod reverse_sccs;
 pub mod values;
 
 pub struct RegionInferenceContext<'tcx> {
- pub var_infos: VarInfos,
  /// Contains the definition for every region variable. Region
  /// variables are identified by their index (`RegionVid`). The
  /// definition contains information about where the region came
@@ -267,7 +266,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  ) -> Self {
  // Create a RegionDefinition for each inference variable.
  let definitions: IndexVec<_, _> = var_infos
- .iter()
+ .into_iter()
  .map(|info| RegionDefinition::new(info.universe, info.origin))
  .collect();
 
@@ -292,7 +291,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  Rc::new(member_constraints_in.into_mapped(|r| constraint_sccs.scc(r)));
 
  let mut result = Self {
- var_infos,
  definitions,
  liveness_constraints,
  constraints,

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() {