Add tests and error messages

Author: compiler-errors

compiler/rustc_ast_lowering/messages.ftl

@@ -139,3 +139,11 @@ ast_lowering_trait_fn_async =
     .label = `async` because of this
     .note = `async` trait functions are not currently supported
     .note2 = consider using the `async-trait` crate: https://crates.io/crates/async-trait
+
+ast_lowering_bad_return_type_notation_inputs =
+    argument types not allowed with return type notation
+    .suggestion = remove the input types
+
+ast_lowering_bad_return_type_notation_output =
+    return type not allowed with return type notation
+    .suggestion = remove the return type

compiler/rustc_ast_lowering/src/errors.rs

@@ -347,3 +347,19 @@ pub struct TraitFnAsync {
     #[label]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+pub enum BadReturnTypeNotation {
+    #[diag(ast_lowering_bad_return_type_notation_inputs)]
+    Inputs {
+        #[primary_span]
+        #[suggestion(code = "()", applicability = "maybe-incorrect")]
+        span: Span,
+    },
+    #[diag(ast_lowering_bad_return_type_notation_output)]
+    Output {
+        #[primary_span]
+        #[suggestion(code = "", applicability = "maybe-incorrect")]
+        span: Span,
+    },
+}

compiler/rustc_ast_lowering/src/lib.rs

@@ -987,10 +987,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 GenericArgs::AngleBracketed(data) => {
                     self.lower_angle_bracketed_parameter_data(data, ParamMode::Explicit, itctx).0
                 }
-                GenericArgs::Parenthesized(data)
-                    if self.tcx.features().return_type_notation =>
-                {
-                    // TODO: Check the parens + no return type
+                GenericArgs::Parenthesized(data) if self.tcx.features().return_type_notation => {
+                    if !data.inputs.is_empty() {
+                        self.tcx.sess.emit_err(errors::BadReturnTypeNotation::Inputs {
+                            span: data.inputs_span,
+                        });
+                    } else if let FnRetTy::Ty(ty) = &data.output {
+                        self.tcx.sess.emit_err(errors::BadReturnTypeNotation::Output {
+                            span: data.inputs_span.shrink_to_hi().to(ty.span),
+                        });
+                    }
                     GenericArgsCtor {
                         args: Default::default(),
                         bindings: &[],
@@ -1000,7 +1006,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 }
                 GenericArgs::Parenthesized(data) => {
                     self.emit_bad_parenthesized_trait_in_assoc_ty(data);
-                    // TODO: Add a RTN feature error if the parens are shaped correctly
+                    // FIXME(return_type_notation): we could issue a feature error
+                    // if the parens are empty and there's no return type.
                     self.lower_angle_bracketed_parameter_data(
                         &data.as_angle_bracketed_args(),
                         ParamMode::Explicit,

compiler/rustc_hir_analysis/messages.ftl

@@ -178,3 +178,14 @@ hir_analysis_invalid_union_field =
 
 hir_analysis_invalid_union_field_sugg =
     wrap the field type in `ManuallyDrop<...>`
+
+hir_analysis_return_type_notation_on_non_rpitit =
+    return type notation used on function that is not `async` and does not return `impl Trait`
+    .note = function returns `{$ty}`, which is not compatible with associated type return bounds
+    .label = this function must be `async` or return `impl Trait`
+
+hir_analysis_return_type_notation_equality_bound =
+    return type notation is not allowed to use type equality
+
+hir_analysis_return_type_notation_missing_method =
+    cannot find associated function `{$assoc_name}` in trait `{$trait_name}`

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -1086,9 +1086,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         let tcx = self.tcx();
 
-        // TODO: rtn comment goes here
-        let associated_return_type_bound =
-            binding.gen_args.parenthesized && tcx.features().associated_return_type_bounds;
+        let return_type_notation =
+            binding.gen_args.parenthesized && tcx.features().return_type_notation;
 
         let candidate = if return_type_notation {
             if self.trait_defines_associated_item_named(
@@ -1098,8 +1097,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             ) {
                 trait_ref
             } else {
-                // TODO: error
-                todo!()
+                return Err(tcx.sess.emit_err(crate::errors::ReturnTypeNotationMissingMethod {
+                    span: binding.span,
+                    trait_name: tcx.item_name(trait_ref.def_id()),
+                    assoc_name: binding.item_name.name,
+                }));
             }
         } else if self.trait_defines_associated_item_named(
             trait_ref.def_id(),
@@ -1218,7 +1220,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             {
                 alias_ty
             } else {
-                todo!("found return type of {output:?}");
+                return Err(self.tcx().sess.emit_err(
+                    crate::errors::ReturnTypeNotationOnNonRpitit {
+                        span: binding.span,
+                        ty: tcx.liberate_late_bound_regions(assoc_item.def_id, output),
+                        fn_span: tcx.hir().span_if_local(assoc_item.def_id),
+                        note: (),
+                    },
+                ));
             };
 
             // Finally, move the fn return type's bound vars over to account for the early bound
@@ -1292,9 +1301,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         }
 
         match binding.kind {
-            ConvertedBindingKind::Equality(..) if associated_return_type_bound => {
-                // TODO: error
-                todo!()
+            ConvertedBindingKind::Equality(..) if return_type_notation => {
+                return Err(self.tcx().sess.emit_err(
+                    crate::errors::ReturnTypeNotationEqualityBound { span: binding.span },
+                ));
             }
             ConvertedBindingKind::Equality(mut term) => {
                 // "Desugar" a constraint like `T: Iterator<Item = u32>` this to

compiler/rustc_hir_analysis/src/errors.rs

@@ -471,6 +471,18 @@ pub(crate) struct InvalidUnionField {
     pub note: (),
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_return_type_notation_on_non_rpitit)]
+pub(crate) struct ReturnTypeNotationOnNonRpitit<'tcx> {
+    #[primary_span]
+    pub span: Span,
+    pub ty: Ty<'tcx>,
+    #[label]
+    pub fn_span: Option<Span>,
+    #[note]
+    pub note: (),
+}
+
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(hir_analysis_invalid_union_field_sugg, applicability = "machine-applicable")]
 pub(crate) struct InvalidUnionFieldSuggestion {
@@ -479,3 +491,19 @@ pub(crate) struct InvalidUnionFieldSuggestion {
     #[suggestion_part(code = ">")]
     pub hi: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_return_type_notation_equality_bound)]
+pub(crate) struct ReturnTypeNotationEqualityBound {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_return_type_notation_missing_method)]
+pub(crate) struct ReturnTypeNotationMissingMethod {
+    #[primary_span]
+    pub span: Span,
+    pub trait_name: Symbol,
+    pub assoc_name: Symbol,
+}

tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.rs

@@ -0,0 +1,17 @@
+// edition: 2021
+
+#![feature(return_type_notation, async_fn_in_trait)]
+//~^ WARN the feature `return_type_notation` is incomplete
+//~| WARN the feature `async_fn_in_trait` is incomplete
+
+trait Trait {
+    async fn method() {}
+}
+
+fn foo<T: Trait<method(i32): Send>>() {}
+//~^ ERROR argument types not allowed with return type notation
+
+fn bar<T: Trait<method() -> (): Send>>() {}
+//~^ ERROR return type not allowed with return type notation
+
+fn main() {}

tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.stderr

@@ -0,0 +1,31 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/bad-inputs-and-output.rs:3:12
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `async_fn_in_trait` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/bad-inputs-and-output.rs:3:34
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |                                  ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+
+error: argument types not allowed with return type notation
+  --> $DIR/bad-inputs-and-output.rs:11:23
+   |
+LL | fn foo<T: Trait<method(i32): Send>>() {}
+   |                       ^^^^^ help: remove the input types: `()`
+
+error: return type not allowed with return type notation
+  --> $DIR/bad-inputs-and-output.rs:14:25
+   |
+LL | fn bar<T: Trait<method() -> (): Send>>() {}
+   |                         ^^^^^^ help: remove the return type
+
+error: aborting due to 2 previous errors; 2 warnings emitted
+

tests/ui/associated-type-bounds/return-type-notation/basic.rs

@@ -0,0 +1,28 @@
+// revisions: with without
+// edition: 2021
+//[with] check-pass
+
+#![feature(return_type_notation, async_fn_in_trait)]
+//~^ WARN the feature `return_type_notation` is incomplete
+//~| WARN the feature `async_fn_in_trait` is incomplete
+
+trait Foo {
+    async fn method() -> Result<(), ()>;
+}
+
+async fn foo<T: Foo>() -> Result<(), ()> {
+    T::method().await?;
+    Ok(())
+}
+
+fn is_send(_: impl Send) {}
+
+fn test<
+    #[cfg(with)] T: Foo<method(): Send>,
+    #[cfg(without)] T: Foo,
+>() {
+    is_send(foo::<T>());
+    //[without]~^ ERROR future cannot be sent between threads safely
+}
+
+fn main() {}

tests/ui/associated-type-bounds/return-type-notation/basic.with.stderr

@@ -0,0 +1,19 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/basic.rs:5:12
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `async_fn_in_trait` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/basic.rs:5:34
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |                                  ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+
+warning: 2 warnings emitted
+

tests/ui/associated-type-bounds/return-type-notation/basic.without.stderr

@@ -0,0 +1,37 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/basic.rs:5:12
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `async_fn_in_trait` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/basic.rs:5:34
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |                                  ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+
+error: future cannot be sent between threads safely
+  --> $DIR/basic.rs:24:13
+   |
+LL |     is_send(foo::<T>());
+   |             ^^^^^^^^^^ future returned by `foo` is not `Send`
+   |
+   = help: within `impl Future<Output = Result<(), ()>>`, the trait `Send` is not implemented for `impl Future<Output = Result<(), ()>>`
+note: future is not `Send` as it awaits another future which is not `Send`
+  --> $DIR/basic.rs:14:5
+   |
+LL |     T::method().await?;
+   |     ^^^^^^^^^^^ await occurs here on type `impl Future<Output = Result<(), ()>>`, which is not `Send`
+note: required by a bound in `is_send`
+  --> $DIR/basic.rs:18:20
+   |
+LL | fn is_send(_: impl Send) {}
+   |                    ^^^^ required by this bound in `is_send`
+
+error: aborting due to previous error; 2 warnings emitted
+

tests/ui/associated-type-bounds/return-type-notation/equality.rs

@@ -0,0 +1,16 @@
+// edition: 2021
+
+#![feature(return_type_notation, async_fn_in_trait)]
+//~^ WARN the feature `return_type_notation` is incomplete
+//~| WARN the feature `async_fn_in_trait` is incomplete
+
+use std::future::Future;
+
+trait Trait {
+    async fn method() {}
+}
+
+fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
+//~^ ERROR return type notation is not allowed to use type equality
+
+fn main() {}

tests/ui/associated-type-bounds/return-type-notation/equality.stderr

@@ -0,0 +1,25 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/equality.rs:3:12
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `async_fn_in_trait` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/equality.rs:3:34
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |                                  ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+
+error: return type notation is not allowed to use type equality
+  --> $DIR/equality.rs:13:18
+   |
+LL | fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error; 2 warnings emitted
+

tests/ui/associated-type-bounds/return-type-notation/missing.rs

@@ -0,0 +1,14 @@
+// edition: 2021
+
+#![feature(return_type_notation, async_fn_in_trait)]
+//~^ WARN the feature `return_type_notation` is incomplete
+//~| WARN the feature `async_fn_in_trait` is incomplete
+
+trait Trait {
+    async fn method() {}
+}
+
+fn bar<T: Trait<methid(): Send>>() {}
+//~^ ERROR cannot find associated function `methid` in trait `Trait`
+
+fn main() {}

tests/ui/associated-type-bounds/return-type-notation/missing.stderr

@@ -0,0 +1,25 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/missing.rs:3:12
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `async_fn_in_trait` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/missing.rs:3:34
+   |
+LL | #![feature(return_type_notation, async_fn_in_trait)]
+   |                                  ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more information
+
+error: cannot find associated function `methid` in trait `Trait`
+  --> $DIR/missing.rs:11:17
+   |
+LL | fn bar<T: Trait<methid(): Send>>() {}
+   |                 ^^^^^^^^^^^^^^
+
+error: aborting due to previous error; 2 warnings emitted
+