Bless tests, fix ICE with ImplTraitPlaceholder

Author: compiler-errors

compiler/rustc_ast_lowering/src/lib.rs

@@ -1960,8 +1960,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  //
  // Then, we will create `fn foo(..) -> Foo<'_, '_>`, and
  // hence the elision takes place at the fn site.
- let future_bound =
- this.lower_async_fn_output_type_to_future_bound(output, fn_def_id, span);
+ let future_bound = this.lower_async_fn_output_type_to_future_bound(
+ output,
+ span,
+ ImplTraitContext::ReturnPositionOpaqueTy {
+ origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
+ },
+ );
 
  let generic_params = this.arena.alloc_from_iter(collected_lifetimes.iter().map(
  |&(new_node_id, lifetime, _)| {
@@ -2064,17 +2069,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  fn_node_id: NodeId,
  opaque_ty_node_id: NodeId,
  ) -> hir::FnRetTy<'hir> {
- let span = output.span();
-
- let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::Async, span, None);
-
- let fn_def_id = self.local_def_id(fn_node_id);
-
  let kind = self.lower_impl_trait_in_trait(output.span(), opaque_ty_node_id, |lctx| {
- let bound =
- lctx.lower_async_fn_output_type_to_future_bound(output, fn_def_id, output.span());
+ let bound = lctx.lower_async_fn_output_type_to_future_bound(
+ output,
+ output.span(),
+ ImplTraitContext::Disallowed(ImplTraitPosition::TraitReturn),
+ );
  arena_vec![lctx; bound]
  });
+
+ let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::Async, output.span(), None);
  let opaque_ty = self.ty(opaque_ty_span, kind);
  hir::FnRetTy::Return(self.arena.alloc(opaque_ty))
  }
@@ -2083,19 +2087,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  fn lower_async_fn_output_type_to_future_bound(
  &mut self,
  output: &FnRetTy,
- fn_def_id: LocalDefId,
  span: Span,
+ mut nested_impl_trait_context: ImplTraitContext,
  ) -> hir::GenericBound<'hir> {
  // Compute the `T` in `Future<Output = T>` from the return type.
  let output_ty = match output {
  FnRetTy::Ty(ty) => {
  // Not `OpaqueTyOrigin::AsyncFn`: that's only used for the
  // `impl Future` opaque type that `async fn` implicitly
  // generates.
- let mut context = ImplTraitContext::ReturnPositionOpaqueTy {
- origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
- };
- self.lower_ty(ty, &mut context)
+ self.lower_ty(ty, &mut nested_impl_trait_context)
  }
  FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])),
  };

compiler/rustc_typeck/src/check/closure.rs

@@ -4,6 +4,7 @@ use super::{check_fn, Expectation, FnCtxt, GeneratorTypes};
 
 use crate::astconv::AstConv;
 use crate::rustc_middle::ty::subst::Subst;
+use hir::def::DefKind;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
@@ -680,9 +681,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  .map(|e| e.map_bound(|e| *e).transpose_tuple2())
  .find_map(|(p, s)| get_future_output(p.subst(self.tcx, substs), s.0))?,
  ty::Error(_) => return None,
+ ty::Projection(proj)
+ if self.tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder =>
+ {
+ self.tcx
+ .bound_explicit_item_bounds(proj.item_def_id)
+ .transpose_iter()
+ .map(|e| e.map_bound(|e| *e).transpose_tuple2())
+ .find_map(|(p, s)| get_future_output(p.subst(self.tcx, proj.substs), s.0))?
+ }
  _ => span_bug!(
  self.tcx.def_span(expr_def_id),
- "async fn generator return type not an inference variable"
+ "async fn generator return type not an inference variable: {ret_ty}"
  ),
  };
 

src/test/ui/async-await/async-trait-fn.rs

@@ -1,8 +1,11 @@
 // edition:2018
 trait T {
  async fn foo() {} //~ ERROR functions in traits cannot be declared `async`
+ //~^ ERROR mismatched types
  async fn bar(&self) {} //~ ERROR functions in traits cannot be declared `async`
+ //~^ ERROR mismatched types
  async fn baz() { //~ ERROR functions in traits cannot be declared `async`
+ //~^ ERROR mismatched types
  // Nested item must not ICE.
  fn a() {}
  }

src/test/ui/async-await/async-trait-fn.stderr

@@ -2,40 +2,89 @@ error[E0706]: functions in traits cannot be declared `async`
  --> $DIR/async-trait-fn.rs:3:5
  |
 LL | async fn foo() {}
- | -----^^^^^^^^^^^^
+ | -----^^^^^^^^^
  | |
  | `async` because of this
  |
  = note: `async` trait functions are not currently supported
  = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait
+ = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+ = help: add `#![feature(return_position_impl_trait_in_trait)]` to the crate attributes to enable
 
 error[E0706]: functions in traits cannot be declared `async`
- --> $DIR/async-trait-fn.rs:4:5
+ --> $DIR/async-trait-fn.rs:5:5
  |
 LL | async fn bar(&self) {}
- | -----^^^^^^^^^^^^^^^^^
+ | -----^^^^^^^^^^^^^^
  | |
  | `async` because of this
  |
  = note: `async` trait functions are not currently supported
  = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait
+ = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+ = help: add `#![feature(return_position_impl_trait_in_trait)]` to the crate attributes to enable
 
 error[E0706]: functions in traits cannot be declared `async`
- --> $DIR/async-trait-fn.rs:5:5
+ --> $DIR/async-trait-fn.rs:7:5
+ |
+LL | async fn baz() {
+ | -----^^^^^^^^^
+ | |
+ | `async` because of this
+ |
+ = note: `async` trait functions are not currently supported
+ = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait
+ = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+ = help: add `#![feature(return_position_impl_trait_in_trait)]` to the crate attributes to enable
+
+error[E0308]: mismatched types
+ --> $DIR/async-trait-fn.rs:3:20
+ |
+LL | async fn foo() {}
+ | ^^ expected associated type, found opaque type
+ |
+ ::: $SRC_DIR/core/src/future/mod.rs:LL:COL
+ |
+LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
+ | ------------------------------- the found opaque type
+ |
+ = note: expected associated type `<Self as T>::foo::{opaque#0}`
+ found opaque type `impl Future<Output = ()>`
+
+error[E0308]: mismatched types
+ --> $DIR/async-trait-fn.rs:5:25
+ |
+LL | async fn bar(&self) {}
+ | ^^ expected associated type, found opaque type
+ |
+ ::: $SRC_DIR/core/src/future/mod.rs:LL:COL
+ |
+LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
+ | ------------------------------- the found opaque type
+ |
+ = note: expected associated type `<Self as T>::bar::{opaque#0}`
+ found opaque type `impl Future<Output = ()>`
+
+error[E0308]: mismatched types
+ --> $DIR/async-trait-fn.rs:7:20
  |
 LL | async fn baz() {
- | ^----
- | |
- | _____`async` because of this
- | |
+ | ____________________^
+LL | |
 LL | | // Nested item must not ICE.
 LL | | fn a() {}
 LL | | }
- | |_____^
+ | |_____^ expected associated type, found opaque type
  |
- = note: `async` trait functions are not currently supported
- = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait
+ ::: $SRC_DIR/core/src/future/mod.rs:LL:COL
+ |
+LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
+ | ------------------------------- the found opaque type
+ |
+ = note: expected associated type `<Self as T>::baz::{opaque#0}`
+ found opaque type `impl Future<Output = ()>`
 
-error: aborting due to 3 previous errors
+error: aborting due to 6 previous errors
 
-For more information about this error, try `rustc --explain E0706`.
+Some errors have detailed explanations: E0308, E0706.
+For more information about an error, try `rustc --explain E0308`.

src/test/ui/async-await/edition-deny-async-fns-2015.rs

@@ -16,7 +16,8 @@ impl Foo {
 
 trait Bar {
  async fn foo() {} //~ ERROR `async fn` is not permitted in Rust 2015
- //~^ ERROR functions in traits cannot be declared `async`
+ //~^ ERROR functions in traits cannot be declared `async`
+ //~| ERROR mismatched types
 }
 
 fn main() {

src/test/ui/async-await/edition-deny-async-fns-2015.stderr

@@ -53,7 +53,7 @@ LL | async fn foo() {}
  = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
 error[E0670]: `async fn` is not permitted in Rust 2015
- --> $DIR/edition-deny-async-fns-2015.rs:36:9
+ --> $DIR/edition-deny-async-fns-2015.rs:37:9
  |
 LL | async fn bar() {}
  | ^^^^^ to use `async fn`, switch to Rust 2018 or later
@@ -62,7 +62,7 @@ LL | async fn bar() {}
  = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
 error[E0670]: `async fn` is not permitted in Rust 2015
- --> $DIR/edition-deny-async-fns-2015.rs:26:9
+ --> $DIR/edition-deny-async-fns-2015.rs:27:9
  |
 LL | async fn foo() {}
  | ^^^^^ to use `async fn`, switch to Rust 2018 or later
@@ -71,7 +71,7 @@ LL | async fn foo() {}
  = note: for more on editions, read https://doc.rust-lang.org/edition-guide
 
 error[E0670]: `async fn` is not permitted in Rust 2015
- --> $DIR/edition-deny-async-fns-2015.rs:31:13
+ --> $DIR/edition-deny-async-fns-2015.rs:32:13
  |
 LL | async fn bar() {}
  | ^^^^^ to use `async fn`, switch to Rust 2018 or later
@@ -83,14 +83,30 @@ error[E0706]: functions in traits cannot be declared `async`
  --> $DIR/edition-deny-async-fns-2015.rs:18:5
  |
 LL | async fn foo() {}
- | -----^^^^^^^^^^^^
+ | -----^^^^^^^^^
  | |
  | `async` because of this
  |
  = note: `async` trait functions are not currently supported
  = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait
+ = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+ = help: add `#![feature(return_position_impl_trait_in_trait)]` to the crate attributes to enable
 
-error: aborting due to 10 previous errors
+error[E0308]: mismatched types
+ --> $DIR/edition-deny-async-fns-2015.rs:18:20
+ |
+LL | async fn foo() {}
+ | ^^ expected associated type, found opaque type
+ |
+ ::: $SRC_DIR/core/src/future/mod.rs:LL:COL
+ |
+LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
+ | ------------------------------- the found opaque type
+ |
+ = note: expected associated type `<Self as Bar>::foo::{opaque#0}`
+ found opaque type `impl Future<Output = ()>`
+
+error: aborting due to 11 previous errors
 
-Some errors have detailed explanations: E0670, E0706.
-For more information about an error, try `rustc --explain E0670`.
+Some errors have detailed explanations: E0308, E0670, E0706.
+For more information about an error, try `rustc --explain E0308`.

src/test/ui/async-await/issues/issue-95307.stderr

@@ -8,6 +8,8 @@ LL | async fn new() -> [u8; _];
  |
  = note: `async` trait functions are not currently supported
  = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait
+ = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+ = help: add `#![feature(return_position_impl_trait_in_trait)]` to the crate attributes to enable
 
 error: in expressions, `_` can only be used on the left-hand side of an assignment
  --> $DIR/issue-95307.rs:7:28

src/test/ui/parser/fn-header-semantic-fail.rs

@@ -27,7 +27,6 @@ fn main() {
  struct Y;
  impl X for Y {
  async fn ft1() {} //~ ERROR functions in traits cannot be declared `async`
- //~^ ERROR has an incompatible type for trait
  unsafe fn ft2() {} // OK.
  const fn ft3() {} //~ ERROR functions in traits cannot be declared const
  extern "C" fn ft4() {}
@@ -36,7 +35,6 @@ fn main() {
  //~| ERROR functions in traits cannot be declared const
  //~| ERROR functions cannot be both `const` and `async`
  //~| ERROR cycle detected
- //~| ERROR has an incompatible type for trait
  }
 
  impl Y {