Rollup of 11 pull requests

Cargo.lock

@@ -4515,6 +4515,7 @@ dependencies = [
  "rustc_session",
  "rustc_span",
  "rustc_transmute",
+ "rustc_type_ir",
  "smallvec",
  "thin-vec",
  "tracing",

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -267,13 +267,13 @@ impl<'tcx> InferCtxt<'tcx> {
  return Ty::new_error(self.tcx, e);
  }
 
- if let Err(guar) = check_opaque_type_parameter_valid(
+ if let Err(err) = check_opaque_type_parameter_valid(
  self,
  opaque_type_key,
  instantiated_ty.span,
  DefiningScopeKind::MirBorrowck,
  ) {
- return Ty::new_error(self.tcx, guar);
+ return Ty::new_error(self.tcx, err.report(self));
  }
 
  let definition_ty = instantiated_ty

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -1282,7 +1282,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
  intrinsic.name,
  );
  }
- return Err(Instance::new(instance.def_id(), instance.args));
+ return Err(Instance::new_raw(instance.def_id(), instance.args));
  }
  }
 

compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

@@ -399,7 +399,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
  }
 
  // Fall back to default body
- _ => return Err(Instance::new(instance.def_id(), instance.args)),
+ _ => return Err(Instance::new_raw(instance.def_id(), instance.args)),
  };
 
  if !fn_abi.ret.is_ignore() {

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/unused.rs

@@ -157,7 +157,7 @@ fn make_dummy_instance<'tcx>(tcx: TyCtxt<'tcx>, local_def_id: LocalDefId) -> ty:
  let def_id = local_def_id.to_def_id();
 
  // Make a dummy instance that fills in all generics with placeholders.
- ty::Instance::new(
+ ty::Instance::new_raw(
  def_id,
  ty::GenericArgs::for_item(tcx, def_id, |param, _| {
  if let ty::GenericParamDefKind::Lifetime = param.kind {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -613,7 +613,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
  _ => {
  debug!("unknown intrinsic '{}' -- falling back to default body", name);
  // Call the fallback body instead of generating the intrinsic code
- return Err(ty::Instance::new(instance.def_id(), instance.args));
+ return Err(ty::Instance::new_raw(instance.def_id(), instance.args));
  }
  };
 

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -612,7 +612,7 @@ pub(crate) fn symbol_name_for_instance_in_crate<'tcx>(
  ExportedSymbol::Generic(def_id, args) => {
  rustc_symbol_mangling::symbol_name_for_instance_in_crate(
  tcx,
- Instance::new(def_id, args),
+ Instance::new_raw(def_id, args),
  instantiating_crate,
  )
  }
@@ -660,7 +660,7 @@ fn calling_convention_for_symbol<'tcx>(
  None
  }
  ExportedSymbol::NonGeneric(def_id) => Some(Instance::mono(tcx, def_id)),
- ExportedSymbol::Generic(def_id, args) => Some(Instance::new(def_id, args)),
+ ExportedSymbol::Generic(def_id, args) => Some(Instance::new_raw(def_id, args)),
  // DropGlue always use the Rust calling convention and thus follow the target's default
  // symbol decoration scheme.
  ExportedSymbol::DropGlue(..) => None,

compiler/rustc_codegen_ssa/src/base.rs

@@ -457,7 +457,13 @@ where
  rustc_hir::InlineAsmOperand::SymFn { expr } => {
  let ty = cx.tcx().typeck(item_id.owner_id).expr_ty(expr);
  let instance = match ty.kind() {
- &ty::FnDef(def_id, args) => Instance::new(def_id, args),
+ &ty::FnDef(def_id, args) => Instance::expect_resolve(
+ cx.tcx(),
+ ty::TypingEnv::fully_monomorphized(),
+ def_id,
+ args,
+ expr.span,
+ ),
  _ => span_bug!(*op_sp, "asm sym is not a function"),
  };
 

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -95,7 +95,9 @@ fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndL
  );
 
  let instance = match mono_type.kind() {
- &ty::FnDef(def_id, args) => Instance::new(def_id, args),
+ &ty::FnDef(def_id, args) => {
+ Instance::expect_resolve(cx.tcx(), cx.typing_env(), def_id, args, value.span)
+ }
  _ => bug!("asm sym is not a function"),
  };
 

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -76,6 +76,36 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
  )
  }
 
+ /// Convenience function to *deeply* normalize during wfcheck. In the old solver,
+ /// this just dispatches to [`WfCheckingCtxt::normalize`], but in the new solver
+ /// this calls `deeply_normalize` and reports errors if they are encountered.
+ ///
+ /// This function should be called in favor of `normalize` in cases where we will
+ /// then check the well-formedness of the type, since we only use the normalized
+ /// signature types for implied bounds when checking regions.
+ // FIXME(-Znext-solver): This should be removed when we compute implied outlives
+ // bounds using the unnormalized signature of the function we're checking.
+ fn deeply_normalize<T>(&self, span: Span, loc: Option<WellFormedLoc>, value: T) -> T
+ where
+ T: TypeFoldable<TyCtxt<'tcx>>,
+ {
+ if self.infcx.next_trait_solver() {
+ match self.ocx.deeply_normalize(
+ &ObligationCause::new(span, self.body_def_id, ObligationCauseCode::WellFormed(loc)),
+ self.param_env,
+ value.clone(),
+ ) {
+ Ok(value) => value,
+ Err(errors) => {
+ self.infcx.err_ctxt().report_fulfillment_errors(errors);
+ value
+ }
+ }
+ } else {
+ self.normalize(span, loc, value)
+ }
+ }
+
  fn register_wf_obligation(&self, span: Span, loc: Option<WellFormedLoc>, term: ty::Term<'tcx>) {
  let cause = traits::ObligationCause::new(
  span,
@@ -297,7 +327,8 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
  {
  let res = enter_wf_checking_ctxt(tcx, item.span, def_id, |wfcx| {
  let ty = tcx.type_of(def_id).instantiate_identity();
- let item_ty = wfcx.normalize(hir_ty.span, Some(WellFormedLoc::Ty(def_id)), ty);
+ let item_ty =
+ wfcx.deeply_normalize(hir_ty.span, Some(WellFormedLoc::Ty(def_id)), ty);
  wfcx.register_wf_obligation(
  hir_ty.span,
  Some(WellFormedLoc::Ty(def_id)),
@@ -1073,7 +1104,7 @@ fn check_associated_item(
  match item.kind {
  ty::AssocKind::Const { .. } => {
  let ty = tcx.type_of(item.def_id).instantiate_identity();
- let ty = wfcx.normalize(span, Some(WellFormedLoc::Ty(item_id)), ty);
+ let ty = wfcx.deeply_normalize(span, Some(WellFormedLoc::Ty(item_id)), ty);
  wfcx.register_wf_obligation(span, loc, ty.into());
  check_sized_if_body(
  wfcx,
@@ -1102,7 +1133,7 @@ fn check_associated_item(
  }
  if item.defaultness(tcx).has_value() {
  let ty = tcx.type_of(item.def_id).instantiate_identity();
- let ty = wfcx.normalize(span, Some(WellFormedLoc::Ty(item_id)), ty);
+ let ty = wfcx.deeply_normalize(span, Some(WellFormedLoc::Ty(item_id)), ty);
  wfcx.register_wf_obligation(span, loc, ty.into());
  }
  Ok(())
@@ -1149,7 +1180,7 @@ fn check_type_defn<'tcx>(
  let field_id = field.did.expect_local();
  let hir::FieldDef { ty: hir_ty, .. } =
  tcx.hir_node_by_def_id(field_id).expect_field();
- let ty = wfcx.normalize(
+ let ty = wfcx.deeply_normalize(
  hir_ty.span,
  None,
  tcx.type_of(field.did).instantiate_identity(),
@@ -1310,7 +1341,7 @@ fn check_item_type(
 
  enter_wf_checking_ctxt(tcx, ty_span, item_id, |wfcx| {
  let ty = tcx.type_of(item_id).instantiate_identity();
- let item_ty = wfcx.normalize(ty_span, Some(WellFormedLoc::Ty(item_id)), ty);
+ let item_ty = wfcx.deeply_normalize(ty_span, Some(WellFormedLoc::Ty(item_id)), ty);
 
  let forbid_unsized = match unsized_handling {
  UnsizedHandling::Forbid => true,
@@ -1375,7 +1406,7 @@ fn check_impl<'tcx>(
  // other `Foo` impls are incoherent.
  tcx.ensure_ok().coherent_trait(trait_ref.def_id)?;
  let trait_span = hir_trait_ref.path.span;
- let trait_ref = wfcx.normalize(
+ let trait_ref = wfcx.deeply_normalize(
  trait_span,
  Some(WellFormedLoc::Ty(item.hir_id().expect_owner().def_id)),
  trait_ref,
@@ -1435,7 +1466,7 @@ fn check_impl<'tcx>(
  }
  None => {
  let self_ty = tcx.type_of(item.owner_id).instantiate_identity();
- let self_ty = wfcx.normalize(
+ let self_ty = wfcx.deeply_normalize(
  item.span,
  Some(WellFormedLoc::Ty(item.hir_id().expect_owner().def_id)),
  self_ty,
@@ -1640,7 +1671,7 @@ fn check_fn_or_method<'tcx>(
 
  sig.inputs_and_output =
  tcx.mk_type_list_from_iter(sig.inputs_and_output.iter().enumerate().map(|(idx, ty)| {
- wfcx.normalize(
+ wfcx.deeply_normalize(
  arg_span(idx),
  Some(WellFormedLoc::Param {
  function: def_id,

compiler/rustc_hir_analysis/src/lib.rs

@@ -216,7 +216,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
  check::maybe_check_static_with_link_section(tcx, item_def_id);
  }
  DefKind::Const if tcx.generics_of(item_def_id).is_empty() => {
- let instance = ty::Instance::new(item_def_id.into(), ty::GenericArgs::empty());
+ let instance = ty::Instance::new_raw(item_def_id.into(), ty::GenericArgs::empty());
  let cid = GlobalId { instance, promoted: None };
  let typing_env = ty::TypingEnv::fully_monomorphized();
  tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));

compiler/rustc_hir_typeck/src/writeback.rs

@@ -555,15 +555,16 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
  }
  }
 
- if let Err(guar) = check_opaque_type_parameter_valid(
+ if let Err(err) = check_opaque_type_parameter_valid(
  &self.fcx,
  opaque_type_key,
  hidden_type.span,
  DefiningScopeKind::HirTypeck,
  ) {
- self.typeck_results
- .concrete_opaque_types
- .insert(opaque_type_key.def_id, ty::OpaqueHiddenType::new_error(tcx, guar));
+ self.typeck_results.concrete_opaque_types.insert(
+ opaque_type_key.def_id,
+ ty::OpaqueHiddenType::new_error(tcx, err.report(self.fcx)),
+ );
  }
 
  let hidden_type = hidden_type.remap_generic_params_to_declaration_params(

compiler/rustc_infer/src/infer/context.rs

@@ -121,28 +121,28 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
  self.enter_forall(value, f)
  }
 
- fn equate_ty_vids_raw(&self, a: rustc_type_ir::TyVid, b: rustc_type_ir::TyVid) {
+ fn equate_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
  self.inner.borrow_mut().type_variables().equate(a, b);
  }
 
- fn equate_int_vids_raw(&self, a: rustc_type_ir::IntVid, b: rustc_type_ir::IntVid) {
+ fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid) {
  self.inner.borrow_mut().int_unification_table().union(a, b);
  }
 
- fn equate_float_vids_raw(&self, a: rustc_type_ir::FloatVid, b: rustc_type_ir::FloatVid) {
+ fn equate_float_vids_raw(&self, a: ty::FloatVid, b: ty::FloatVid) {
  self.inner.borrow_mut().float_unification_table().union(a, b);
  }
 
- fn equate_const_vids_raw(&self, a: rustc_type_ir::ConstVid, b: rustc_type_ir::ConstVid) {
+ fn equate_const_vids_raw(&self, a: ty::ConstVid, b: ty::ConstVid) {
  self.inner.borrow_mut().const_unification_table().union(a, b);
  }
 
  fn instantiate_ty_var_raw<R: PredicateEmittingRelation<Self>>(
  &self,
  relation: &mut R,
  target_is_expected: bool,
- target_vid: rustc_type_ir::TyVid,
- instantiation_variance: rustc_type_ir::Variance,
+ target_vid: ty::TyVid,
+ instantiation_variance: ty::Variance,
  source_ty: Ty<'tcx>,
  ) -> RelateResult<'tcx, ()> {
  self.instantiate_ty_var(
@@ -154,27 +154,19 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
  )
  }
 
- fn instantiate_int_var_raw(
- &self,
- vid: rustc_type_ir::IntVid,
- value: rustc_type_ir::IntVarValue,
- ) {
+ fn instantiate_int_var_raw(&self, vid: ty::IntVid, value: ty::IntVarValue) {
  self.inner.borrow_mut().int_unification_table().union_value(vid, value);
  }
 
- fn instantiate_float_var_raw(
- &self,
- vid: rustc_type_ir::FloatVid,
- value: rustc_type_ir::FloatVarValue,
- ) {
+ fn instantiate_float_var_raw(&self, vid: ty::FloatVid, value: ty::FloatVarValue) {
  self.inner.borrow_mut().float_unification_table().union_value(vid, value);
  }
 
  fn instantiate_const_var_raw<R: PredicateEmittingRelation<Self>>(
  &self,
  relation: &mut R,
  target_is_expected: bool,
- target_vid: rustc_type_ir::ConstVid,
+ target_vid: ty::ConstVid,
  source_ct: ty::Const<'tcx>,
  ) -> RelateResult<'tcx, ()> {
  self.instantiate_const_var(relation, target_is_expected, target_vid, source_ct)

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -63,11 +63,11 @@ use rustc_data_structures::undo_log::UndoLogs;
 use rustc_middle::bug;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::query::NoSolution;
+use rustc_middle::ty::outlives::{Component, push_outlives_components};
 use rustc_middle::ty::{
  self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesPredicate, Region, Ty, TyCtxt,
  TypeFoldable as _, TypeVisitableExt,
 };
-use rustc_type_ir::outlives::{Component, push_outlives_components};
 use smallvec::smallvec;
 use tracing::{debug, instrument};
 

compiler/rustc_infer/src/infer/outlives/verify.rs

@@ -1,7 +1,7 @@
 use std::assert_matches::assert_matches;
 
+use rustc_middle::ty::outlives::{Component, compute_alias_components_recursive};
 use rustc_middle::ty::{self, OutlivesPredicate, Ty, TyCtxt};
-use rustc_type_ir::outlives::{Component, compute_alias_components_recursive};
 use smallvec::smallvec;
 use tracing::{debug, instrument, trace};
 

compiler/rustc_infer/src/infer/relate/mod.rs

@@ -2,9 +2,8 @@
 //! (except for some relations used for diagnostics and heuristics in the compiler).
 //! As well as the implementation of `Relate` for interned things (`Ty`/`Const`/etc).
 
-pub use rustc_middle::ty::relate::RelateResult;
-pub use rustc_type_ir::relate::combine::PredicateEmittingRelation;
-pub use rustc_type_ir::relate::*;
+pub use rustc_middle::ty::relate::combine::PredicateEmittingRelation;
+pub use rustc_middle::ty::relate::{RelateResult, *};
 
 mod generalize;
 mod higher_ranked;

compiler/rustc_infer/src/infer/relate/type_relating.rs

@@ -3,9 +3,8 @@ use rustc_middle::ty::relate::combine::{super_combine_consts, super_combine_tys}
 use rustc_middle::ty::relate::{
  Relate, RelateResult, TypeRelation, relate_args_invariantly, relate_args_with_variances,
 };
-use rustc_middle::ty::{self, Ty, TyCtxt, TyVar};
+use rustc_middle::ty::{self, DelayedSet, Ty, TyCtxt, TyVar};
 use rustc_span::Span;
-use rustc_type_ir::data_structures::DelayedSet;
 use tracing::{debug, instrument};
 
 use crate::infer::BoundRegionConversionTime::HigherRankedType;

compiler/rustc_infer/src/infer/resolve.rs

@@ -1,9 +1,8 @@
 use rustc_middle::bug;
 use rustc_middle::ty::{
- self, Const, FallibleTypeFolder, InferConst, Ty, TyCtxt, TypeFoldable, TypeFolder,
+ self, Const, DelayedMap, FallibleTypeFolder, InferConst, Ty, TyCtxt, TypeFoldable, TypeFolder,
  TypeSuperFoldable, TypeVisitableExt,
 };
-use rustc_type_ir::data_structures::DelayedMap;
 
 use super::{FixupError, FixupResult, InferCtxt};
 

compiler/rustc_infer/src/infer/snapshot/fudge.rs

@@ -3,9 +3,8 @@ use std::ops::Range;
 use rustc_data_structures::{snapshot_vec as sv, unify as ut};
 use rustc_middle::ty::{
  self, ConstVid, FloatVid, IntVid, RegionVid, Ty, TyCtxt, TyVid, TypeFoldable, TypeFolder,
- TypeSuperFoldable,
+ TypeSuperFoldable, TypeVisitableExt,
 };
-use rustc_type_ir::TypeVisitableExt;
 use tracing::instrument;
 use ut::UnifyKey;
 

compiler/rustc_infer/src/traits/util.rs

@@ -1,7 +1,7 @@
 use rustc_data_structures::fx::FxHashSet;
+pub use rustc_middle::ty::elaborate::*;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::{Ident, Span};
-pub use rustc_type_ir::elaborate::*;
 
 use crate::traits::{self, Obligation, ObligationCauseCode, PredicateObligation};
 

compiler/rustc_lint/src/foreign_modules.rs

@@ -104,7 +104,7 @@ impl ClashingExternDeclarations {
  /// for the item, return its HirId without updating the set.
  fn insert(&mut self, tcx: TyCtxt<'_>, fi: hir::ForeignItemId) -> Option<hir::OwnerId> {
  let did = fi.owner_id.to_def_id();
- let instance = Instance::new(did, ty::List::identity_for_item(tcx, did));
+ let instance = Instance::new_raw(did, ty::List::identity_for_item(tcx, did));
  let name = Symbol::intern(tcx.symbol_name(instance).name);
  if let Some(&existing_id) = self.seen_decls.get(&name) {
  // Avoid updating the map with the new entry when we do find a collision. We want to