Rollup of 4 pull requests

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1498,7 +1498,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let ty = self.resolve_vars_with_obligations(ty);
 
  if self.next_trait_solver()
- && let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, _) = ty.kind()
+ && let ty::Alias(..) = ty.kind()
  {
  match self
  .at(&self.misc(sp), self.param_env)

compiler/rustc_smir/src/rustc_smir/convert/mir.rs

@@ -37,6 +37,7 @@ impl<'tcx> Stable<'tcx> for mir::Body<'tcx> {
  self.arg_count,
  self.var_debug_info.iter().map(|info| info.stable(tables)).collect(),
  self.spread_arg.stable(tables),
+ self.span.stable(tables),
  )
  }
 }

compiler/rustc_trait_selection/src/traits/structural_normalize.rs

@@ -3,7 +3,7 @@ use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKi
 use rustc_infer::traits::{FulfillmentError, TraitEngine};
 use rustc_middle::ty::{self, Ty};
 
-use crate::traits::{query::evaluate_obligation::InferCtxtExt, NormalizeExt, Obligation};
+use crate::traits::{NormalizeExt, Obligation};
 
 pub trait StructurallyNormalizeExt<'tcx> {
  fn structurally_normalize(
@@ -16,42 +16,43 @@ pub trait StructurallyNormalizeExt<'tcx> {
 impl<'tcx> StructurallyNormalizeExt<'tcx> for At<'_, 'tcx> {
  fn structurally_normalize(
  &self,
- mut ty: Ty<'tcx>,
+ ty: Ty<'tcx>,
  fulfill_cx: &mut dyn TraitEngine<'tcx>,
  ) -> Result<Ty<'tcx>, Vec<FulfillmentError<'tcx>>> {
  assert!(!ty.is_ty_var(), "should have resolved vars before calling");
 
  if self.infcx.next_trait_solver() {
- // FIXME(-Znext-solver): correctly handle
- // overflow here.
- for _ in 0..256 {
- let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, alias) = *ty.kind() else {
- break;
- };
-
- let new_infer_ty = self.infcx.next_ty_var(TypeVariableOrigin {
- kind: TypeVariableOriginKind::NormalizeProjectionType,
- span: self.cause.span,
- });
- let obligation = Obligation::new(
- self.infcx.tcx,
- self.cause.clone(),
- self.param_env,
- ty::NormalizesTo { alias, term: new_infer_ty.into() },
- );
- if self.infcx.predicate_may_hold(&obligation) {
- fulfill_cx.register_predicate_obligation(self.infcx, obligation);
- let errors = fulfill_cx.select_where_possible(self.infcx);
- if !errors.is_empty() {
- return Err(errors);
- }
- ty = self.infcx.resolve_vars_if_possible(new_infer_ty);
- } else {
- break;
- }
+ // FIXME(-Znext-solver): Should we resolve opaques here?
+ let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, _) = *ty.kind() else {
+ return Ok(ty);
+ };
+
+ let new_infer_ty = self.infcx.next_ty_var(TypeVariableOrigin {
+ kind: TypeVariableOriginKind::NormalizeProjectionType,
+ span: self.cause.span,
+ });
+
+ // We simply emit an `alias-eq` goal here, since that will take care of
+ // normalizing the LHS of the projection until it is a rigid projection
+ // (or a not-yet-defined opaque in scope).
+ let obligation = Obligation::new(
+ self.infcx.tcx,
+ self.cause.clone(),
+ self.param_env,
+ ty::PredicateKind::AliasRelate(
+ ty.into(),
+ new_infer_ty.into(),
+ ty::AliasRelationDirection::Equate,
+ ),
+ );
+
+ fulfill_cx.register_predicate_obligation(self.infcx, obligation);
+ let errors = fulfill_cx.select_where_possible(self.infcx);
+ if !errors.is_empty() {
+ return Err(errors);
  }
 
- Ok(ty)
+ Ok(self.infcx.resolve_vars_if_possible(new_infer_ty))
  } else {
  Ok(self.normalize(ty).into_value_registering_obligations(self.infcx, fulfill_cx))
  }

compiler/stable_mir/src/mir/body.rs

@@ -27,6 +27,9 @@ pub struct Body {
  ///
  /// This is used for the "rust-call" ABI such as closures.
  pub(super) spread_arg: Option<Local>,
+
+ /// The span that covers the entire function body.
+ pub span: Span,
 }
 
 pub type BasicBlockIdx = usize;
@@ -42,14 +45,15 @@ impl Body {
  arg_count: usize,
  var_debug_info: Vec<VarDebugInfo>,
  spread_arg: Option<Local>,
+ span: Span,
  ) -> Self {
  // If locals doesn't contain enough entries, it can lead to panics in
  // `ret_local`, `arg_locals`, and `inner_locals`.
  assert!(
  locals.len() > arg_count,
  "A Body must contain at least a local for the return value and each of the function's arguments"
  );
- Self { blocks, locals, arg_count, var_debug_info, spread_arg }
+ Self { blocks, locals, arg_count, var_debug_info, spread_arg, span }
  }
 
  /// Return local that holds this function's return value.

compiler/stable_mir/src/mir/visit.rs

@@ -133,7 +133,7 @@ pub trait MirVisitor {
  }
 
  fn super_body(&mut self, body: &Body) {
- let Body { blocks, locals: _, arg_count, var_debug_info, spread_arg: _ } = body;
+ let Body { blocks, locals: _, arg_count, var_debug_info, spread_arg: _, span } = body;
 
  for bb in blocks {
  self.visit_basic_block(bb);
@@ -153,6 +153,8 @@ pub trait MirVisitor {
  for info in var_debug_info.iter() {
  self.visit_var_debug_info(info);
  }
+
+ self.visit_span(span)
  }
 
  fn super_basic_block(&mut self, bb: &BasicBlock) {

tests/ui/issues/issue-22638.rs

@@ -1,6 +1,7 @@
 // build-fail
 // normalize-stderr-test: "<\{closure@.+`" -> "$$CLOSURE`"
 // normalize-stderr-test: ".nll/" -> "/"
+// ignore-compare-mode-next-solver (hangs)
 
 #![allow(unused)]
 

tests/ui/issues/issue-22638.stderr

@@ -1,11 +1,11 @@
 error: reached the recursion limit while instantiating `A::matches::$CLOSURE`
- --> $DIR/issue-22638.rs:56:9
+ --> $DIR/issue-22638.rs:57:9
  |
 LL | a.matches(f)
  | ^^^^^^^^^^^^
  |
 note: `A::matches` defined here
- --> $DIR/issue-22638.rs:15:5
+ --> $DIR/issue-22638.rs:16:5
  |
 LL | pub fn matches<F: Fn()>(&self, f: &F) {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/ui/issues/issue-67552.rs

@@ -1,7 +1,6 @@
 // build-fail
 // compile-flags: -Copt-level=0
 // normalize-stderr-test: ".nll/" -> "/"
-// ignore-compare-mode-next-solver (hangs)
 
 fn main() {
  rec(Empty);

tests/ui/issues/issue-67552.stderr

@@ -1,11 +1,11 @@
 error: reached the recursion limit while instantiating `rec::<&mut &mut &mut &mut &mut ...>`
- --> $DIR/issue-67552.rs:30:9
+ --> $DIR/issue-67552.rs:29:9
  |
 LL | rec(identity(&mut it))
  | ^^^^^^^^^^^^^^^^^^^^^^
  |
 note: `rec` defined here
- --> $DIR/issue-67552.rs:23:1
+ --> $DIR/issue-67552.rs:22:1
  |
 LL | / fn rec<T>(mut it: T)
 LL | | where

tests/ui/recursion/issue-95134.rs

@@ -3,7 +3,6 @@
 // compile-flags: -Copt-level=0
 // dont-check-failure-status
 // dont-check-compiler-stderr
-// ignore-compare-mode-next-solver (hangs)
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
  if n > 15 {

tests/ui/traits/next-solver/alias-bound-unsound.rs

@@ -23,7 +23,7 @@ fn main() {
  let x = String::from("hello, world");
  drop(<() as Foo>::copy_me(&x));
  //~^ ERROR overflow evaluating the requirement `<() as Foo>::Item: Sized`
- //~| ERROR overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
+ //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
  //~| ERROR overflow evaluating the requirement `<() as Foo>::Item well-formed`
  //~| ERROR overflow evaluating the requirement `String <: <() as Foo>::Item`
  //~| ERROR overflow evaluating the requirement `&<() as Foo>::Item well-formed`

tests/ui/traits/next-solver/alias-bound-unsound.stderr

@@ -19,7 +19,7 @@ LL | drop(<() as Foo>::copy_me(&x));
  |
  = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
 
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
+error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
  --> $DIR/alias-bound-unsound.rs:24:10
  |
 LL | drop(<() as Foo>::copy_me(&x));
@@ -59,7 +59,6 @@ LL | drop(<() as Foo>::copy_me(&x));
  | ^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
- = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: aborting due to 7 previous errors
 

tests/ui/traits/next-solver/coerce-ambig-alias-to-rigid-alias.rs

@@ -0,0 +1,15 @@
+// compile-flags: -Znext-solver
+// check-pass
+
+trait Trait {
+ type Assoc;
+}
+
+fn call<T: Trait>(_: <T as Trait>::Assoc, _: T) {}
+
+fn foo<T: Trait>(rigid: <T as Trait>::Assoc, t: T) {
+ // Check that we can coerce `<?0 as Trait>::Assoc` to `<T as Trait>::Assoc`.
+ call::<_ /* ?0 */>(rigid, t);
+}
+
+fn main() {}

tests/ui/traits/next-solver/object-unsafety.rs

@@ -13,7 +13,6 @@ pub fn copy_any<T>(t: &T) -> T {
  //~^ ERROR the type `&<dyn Setup<From = T> as Setup>::From` is not well-formed
  //~| ERROR the trait bound `dyn Setup<From = T>: Setup` is not satisfied
  //~| ERROR mismatched types
- //~| ERROR mismatched types
  //~| ERROR the type `<dyn Setup<From = T> as Setup>::From` is not well-formed
  //~| ERROR the size for values of type `<dyn Setup<From = T> as Setup>::From` cannot be known at compilation time
 

tests/ui/traits/next-solver/object-unsafety.stderr

@@ -36,20 +36,6 @@ note: function defined here
 LL | fn copy<U: Setup + ?Sized>(from: &U::From) -> U::From {
  | ^^^^ --------------
 
-error[E0308]: mismatched types
- --> $DIR/object-unsafety.rs:12:5
- |
-LL | pub fn copy_any<T>(t: &T) -> T {
- | - - expected `T` because of return type
- | |
- | expected this type parameter
-LL | copy::<dyn Setup<From=T>>(t)
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ
- |
- = note: expected type parameter `T`
- found associated type `<dyn Setup<From = T> as Setup>::From`
- = note: you might be missing a type parameter or trait bound
-
 error: the type `<dyn Setup<From = T> as Setup>::From` is not well-formed
  --> $DIR/object-unsafety.rs:12:5
  |
@@ -72,7 +58,7 @@ help: consider further restricting the associated type
 LL | pub fn copy_any<T>(t: &T) -> T where <dyn Setup<From = T> as Setup>::From: Sized {
  | +++++++++++++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0277, E0308.
 For more information about an error, try `rustc --explain E0277`.

tests/ui/type-alias-impl-trait/self-referential-3.rs

@@ -1,3 +1,5 @@
+// ignore-compare-mode-next-solver (hangs)
+
 #![feature(type_alias_impl_trait)]
 
 type Bar<'a, 'b> = impl PartialEq<Bar<'a, 'b>> + std::fmt::Debug;

tests/ui/type-alias-impl-trait/self-referential-3.stderr

@@ -1,5 +1,5 @@
 error[E0277]: can't compare `&i32` with `Bar<'a, 'b>`
- --> $DIR/self-referential-3.rs:5:31
+ --> $DIR/self-referential-3.rs:7:31
  |
 LL | fn bar<'a, 'b>(i: &'a i32) -> Bar<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == Bar<'a, 'b>`

tests/ui/type-alias-impl-trait/self-referential-4.rs

@@ -1,3 +1,5 @@
+// ignore-compare-mode-next-solver (hangs)
+
 #![feature(type_alias_impl_trait)]
 
 type Bar<'a, 'b> = impl PartialEq<Bar<'b, 'static>> + std::fmt::Debug;

tests/ui/type-alias-impl-trait/self-referential-4.stderr

@@ -1,5 +1,5 @@
 error[E0277]: can't compare `&i32` with `Bar<'b, 'static>`
- --> $DIR/self-referential-4.rs:5:31
+ --> $DIR/self-referential-4.rs:7:31
  |
 LL | fn bar<'a, 'b>(i: &'a i32) -> Bar<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == Bar<'b, 'static>`
@@ -10,7 +10,7 @@ LL | i
  = help: the trait `PartialEq` is implemented for `i32`
 
 error[E0277]: can't compare `&i32` with `Foo<'static, 'b>`
- --> $DIR/self-referential-4.rs:11:31
+ --> $DIR/self-referential-4.rs:13:31
  |
 LL | fn foo<'a, 'b>(i: &'a i32) -> Foo<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == Foo<'static, 'b>`
@@ -21,7 +21,7 @@ LL | i
  = help: the trait `PartialEq` is implemented for `i32`
 
 error[E0277]: can't compare `&i32` with `Moo<'static, 'a>`
- --> $DIR/self-referential-4.rs:17:31
+ --> $DIR/self-referential-4.rs:19:31
  |
 LL | fn moo<'a, 'b>(i: &'a i32) -> Moo<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == Moo<'static, 'a>`

tests/ui/type-alias-impl-trait/self-referential.rs

@@ -1,3 +1,5 @@
+// ignore-compare-mode-next-solver (hangs)
+
 #![feature(type_alias_impl_trait)]
 
 type Bar<'a, 'b> = impl PartialEq<Bar<'b, 'a>> + std::fmt::Debug;

tests/ui/type-alias-impl-trait/self-referential.stderr

@@ -1,5 +1,5 @@
 error[E0277]: can't compare `&i32` with `Bar<'b, 'a>`
- --> $DIR/self-referential.rs:5:31
+ --> $DIR/self-referential.rs:7:31
  |
 LL | fn bar<'a, 'b>(i: &'a i32) -> Bar<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == Bar<'b, 'a>`
@@ -11,7 +11,7 @@ LL | i
  = help: the trait `PartialEq` is implemented for `i32`
 
 error[E0277]: can't compare `&i32` with `(i32, Foo<'a, 'b>::{opaque#0})`
- --> $DIR/self-referential.rs:12:31
+ --> $DIR/self-referential.rs:14:31
  |
 LL | fn foo<'a, 'b>(i: &'a i32) -> Foo<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == (i32, Foo<'a, 'b>::{opaque#0})`
@@ -23,7 +23,7 @@ LL | (42, i)
  = help: the trait `PartialEq` is implemented for `i32`
 
 error[E0277]: can't compare `&i32` with `(i32, Moo<'b, 'a>::{opaque#0})`
- --> $DIR/self-referential.rs:19:31
+ --> $DIR/self-referential.rs:21:31
  |
 LL | fn moo<'a, 'b>(i: &'a i32) -> Moo<'a, 'b> {
  | ^^^^^^^^^^^ no implementation for `&i32 == (i32, Moo<'b, 'a>::{opaque#0})`