Add tests and error messages

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,
+}