Rollup merge of rust-lang#120057 - oli-obk:not_sure_wtf_is_going_on, …

…r=compiler-errors

Don't ICE when deducing future output if other errors already occurred

The situation can't really happen outside of erroneous code. What was interesting is that it ICEd before emitting any other diagnostics. This was because the other errors were silenced due to cycle_delay_bug cycle errors.

r? `@compiler-errors`

fixes rust-lang#119890

compiler/rustc_hir_typeck/src/closure.rs

@@ -754,16 +754,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  get_future_output(obligation.predicate, obligation.cause.span)
  })?
  }
+ ty::Alias(ty::Projection, _) => {
+ return Some(Ty::new_error_with_message(
+ self.tcx,
+ closure_span,
+ "this projection should have been projected to an opaque type",
+ ));
+ }
  ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => self
  .tcx
  .explicit_item_bounds(def_id)
  .iter_instantiated_copied(self.tcx, args)
  .find_map(|(p, s)| get_future_output(p.as_predicate(), s))?,
  ty::Error(_) => return Some(ret_ty),
- _ => span_bug!(
- closure_span,
- "async fn coroutine return type not an inference variable: {ret_ty}"
- ),
+ _ => {
+ span_bug!(closure_span, "invalid async fn coroutine return type: {ret_ty:?}")
+ }
  };
 
  let output_ty = self.normalize(closure_span, output_ty);

tests/ui/async-await/inference_var_self_argument.rs

@@ -0,0 +1,12 @@
+//! This is a regression test for an ICE.
+// edition: 2021
+
+trait Foo {
+ async fn foo(self: &dyn Foo) {
+ //~^ ERROR: `Foo` cannot be made into an object
+ //~| ERROR invalid `self` parameter type: &dyn Foo
+ todo!()
+ }
+}
+
+fn main() {}

tests/ui/async-await/inference_var_self_argument.stderr

@@ -0,0 +1,28 @@
+error[E0038]: the trait `Foo` cannot be made into an object
+ --> $DIR/inference_var_self_argument.rs:5:5
+ |
+LL | async fn foo(self: &dyn Foo) {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Foo` cannot be made into an object
+ |
+note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+ --> $DIR/inference_var_self_argument.rs:5:14
+ |
+LL | trait Foo {
+ | --- this trait cannot be made into an object...
+LL | async fn foo(self: &dyn Foo) {
+ | ^^^ ...because method `foo` is `async`
+ = help: consider moving `foo` to another trait
+
+error[E0307]: invalid `self` parameter type: &dyn Foo
+ --> $DIR/inference_var_self_argument.rs:5:24
+ |
+LL | async fn foo(self: &dyn Foo) {
+ | ^^^^^^^^
+ |
+ = note: type of `self` must be `Self` or a type that dereferences to it
+ = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0038, E0307.
+For more information about an error, try `rustc --explain E0038`.

tests/ui/object-safety/erroneous_signature.rs

@@ -0,0 +1,17 @@
+trait Foo {
+ fn err(&self) -> MissingType;
+ //~^ ERROR cannot find type `MissingType` in this scope
+}
+
+impl Foo for i32 {
+ fn err(&self) -> MissingType {
+ //~^ ERROR cannot find type `MissingType` in this scope
+ 0
+ }
+}
+
+fn coerce(x: &i32) -> &dyn Foo {
+ x
+}
+
+fn main() {}

tests/ui/object-safety/erroneous_signature.stderr

@@ -0,0 +1,15 @@
+error[E0412]: cannot find type `MissingType` in this scope
+ --> $DIR/erroneous_signature.rs:2:22
+ |
+LL | fn err(&self) -> MissingType;
+ | ^^^^^^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `MissingType` in this scope
+ --> $DIR/erroneous_signature.rs:7:22
+ |
+LL | fn err(&self) -> MissingType {
+ | ^^^^^^^^^^^ not found in this scope
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0412`.