Emit an error when RTN is used with ty/ct params

Author: compiler-errors

compiler/rustc_hir_analysis/messages.ftl

@@ -195,6 +195,13 @@ hir_analysis_return_type_notation_conflicting_bound =
 hir_analysis_return_type_notation_equality_bound =
     return type notation is not allowed to use type equality
 
+hir_analysis_return_type_notation_illegal_param_const =
+    return type notation is not allowed for functions that have const parameters
+    .label = const parameter declared here
+hir_analysis_return_type_notation_illegal_param_type =
+    return type notation is not allowed for functions that have type parameters
+    .label = type parameter declared here
+
 hir_analysis_return_type_notation_missing_method =
     cannot find associated function `{$assoc_name}` for `{$ty_name}`
 

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -1215,6 +1215,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         }
 
         let projection_ty = if return_type_notation {
+            let mut emitted_bad_param_err = false;
             // If we have an method return type bound, then we need to substitute
             // the method's early bound params with suitable late-bound params.
             let mut num_bound_vars = candidate.bound_vars().len();
@@ -1230,16 +1231,35 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             },
                         )
                         .into(),
-                        GenericParamDefKind::Type { .. } => tcx
-                            .mk_bound(
+                        GenericParamDefKind::Type { .. } => {
+                            if !emitted_bad_param_err {
+                                tcx.sess.emit_err(
+                                    crate::errors::ReturnTypeNotationIllegalParam::Type {
+                                        span: path_span,
+                                        param_span: tcx.def_span(param.def_id),
+                                    },
+                                );
+                                emitted_bad_param_err = true;
+                            }
+                            tcx.mk_bound(
                                 ty::INNERMOST,
                                 ty::BoundTy {
                                     var: ty::BoundVar::from_usize(num_bound_vars),
                                     kind: ty::BoundTyKind::Param(param.def_id, param.name),
                                 },
                             )
-                            .into(),
+                            .into()
+                        }
                         GenericParamDefKind::Const { .. } => {
+                            if !emitted_bad_param_err {
+                                tcx.sess.emit_err(
+                                    crate::errors::ReturnTypeNotationIllegalParam::Const {
+                                        span: path_span,
+                                        param_span: tcx.def_span(param.def_id),
+                                    },
+                                );
+                                emitted_bad_param_err = true;
+                            }
                             let ty = tcx
                                 .type_of(param.def_id)
                                 .no_bound_vars()

compiler/rustc_hir_analysis/src/errors.rs

@@ -857,3 +857,21 @@ pub(crate) enum DropImplPolarity {
         span: Span,
     },
 }
+
+#[derive(Diagnostic)]
+pub(crate) enum ReturnTypeNotationIllegalParam {
+    #[diag(hir_analysis_return_type_notation_illegal_param_type)]
+    Type {
+        #[primary_span]
+        span: Span,
+        #[label]
+        param_span: Span,
+    },
+    #[diag(hir_analysis_return_type_notation_illegal_param_const)]
+    Const {
+        #[primary_span]
+        span: Span,
+        #[label]
+        param_span: Span,
+    },
+}

tests/ui/async-await/return-type-notation/ty-or-ct-params.rs

@@ -0,0 +1,20 @@
+// edition: 2021
+
+#![feature(async_fn_in_trait, return_type_notation)]
+//~^ WARN the feature `return_type_notation` is incomplete
+
+trait Foo {
+    async fn bar<T>() {}
+
+    async fn baz<const N: usize>() {}
+}
+
+fn test<T>()
+where
+    T: Foo<bar(): Send, baz(): Send>,
+    //~^ ERROR return type notation is not allowed for functions that have const parameters
+    //~| ERROR return type notation is not allowed for functions that have type parameters
+{
+}
+
+fn main() {}

tests/ui/async-await/return-type-notation/ty-or-ct-params.stderr

@@ -0,0 +1,29 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/ty-or-ct-params.rs:3:31
+   |
+LL | #![feature(async_fn_in_trait, return_type_notation)]
+   |                               ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+error: return type notation is not allowed for functions that have type parameters
+  --> $DIR/ty-or-ct-params.rs:14:12
+   |
+LL |     async fn bar<T>() {}
+   |                  - type parameter declared here
+...
+LL |     T: Foo<bar(): Send, baz(): Send>,
+   |            ^^^^^^^^^^^
+
+error: return type notation is not allowed for functions that have const parameters
+  --> $DIR/ty-or-ct-params.rs:14:25
+   |
+LL |     async fn baz<const N: usize>() {}
+   |                  -------------- const parameter declared here
+...
+LL |     T: Foo<bar(): Send, baz(): Send>,
+   |                         ^^^^^^^^^^^
+
+error: aborting due to 2 previous errors; 1 warning emitted
+