Added checks for attribute in type case

Author: Kivooeo

compiler/rustc_parse/messages.ftl

@@ -71,6 +71,12 @@ parse_attr_without_generics = attribute without generic parameters
 parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type
     .label = attributes are not allowed here
 
+parse_attribute_on_type = attributes cannot be applied to a type
+    .label = attributes are not allowed here
+
+parse_attribute_on_generic_type = attributes cannot be applied to generic type arguments
+    .label = attributes are not allowed here
+
 parse_bad_assoc_type_bounds = bounds on associated types do not belong here
     .label = belongs in `where` clause
 

compiler/rustc_parse/src/errors.rs

@@ -1489,6 +1489,22 @@ pub(crate) struct AttributeOnParamType {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_attribute_on_type)]
+pub(crate) struct AttributeOnType {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_attribute_on_generic_type)]
+pub(crate) struct AttributeOnGenericType {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_pattern_method_param_without_body, code = E0642)]
 pub(crate) struct PatternMethodParamWithoutBody {

compiler/rustc_parse/src/parser/path.rs

@@ -17,8 +17,8 @@ use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
 use super::{Parser, Restrictions, TokenType};
 use crate::ast::{PatKind, TyKind};
 use crate::errors::{
-    self, FnPathFoundNamedParams, PathFoundAttributeInParams, PathFoundCVariadicParams,
-    PathSingleColon, PathTripleColon,
+    self, AttributeOnGenericType, FnPathFoundNamedParams, PathFoundAttributeInParams,
+    PathFoundCVariadicParams, PathSingleColon, PathTripleColon,
 };
 use crate::exp;
 use crate::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
@@ -880,6 +880,21 @@ impl<'a> Parser<'a> {
         &mut self,
         ty_generics: Option<&Generics>,
     ) -> PResult<'a, Option<GenericArg>> {
+        let attrs_wrapper = self.parse_outer_attributes()?;
+
+        if !attrs_wrapper.is_empty() {
+            // Parse attribute.
+            let raw_attrs = attrs_wrapper.take_for_recovery(self.psess);
+
+            let attr_span = raw_attrs[0].span.to(raw_attrs.last().unwrap().span);
+
+            let ty_after_attr = self.parse_ty()?;
+            let full_span_for_err = attr_span.to(ty_after_attr.span);
+
+            let guar = self.dcx().emit_err(AttributeOnGenericType { span: attr_span });
+
+            return Ok(Some(GenericArg::Type(self.mk_ty(full_span_for_err, TyKind::Err(guar)))));
+        }
         let start = self.token.span;
         let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
             // Parse lifetime argument.

compiler/rustc_parse/src/parser/ty.rs

@@ -14,10 +14,10 @@ use thin_vec::{ThinVec, thin_vec};
 
 use super::{Parser, PathStyle, SeqSep, TokenType, Trailing};
 use crate::errors::{
-    self, DynAfterMut, ExpectedFnPathFoundFnKeyword, ExpectedMutOrConstInRawPointerType,
-    FnPtrWithGenerics, FnPtrWithGenericsSugg, HelpUseLatestEdition, InvalidDynKeyword,
-    LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime, NestedCVariadicType,
-    ReturnTypesUseThinArrow,
+    self, AttributeOnType, DynAfterMut, ExpectedFnPathFoundFnKeyword,
+    ExpectedMutOrConstInRawPointerType, FnPtrWithGenerics, FnPtrWithGenericsSugg,
+    HelpUseLatestEdition, InvalidDynKeyword, LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime,
+    NestedCVariadicType, ReturnTypesUseThinArrow,
 };
 use crate::parser::item::FrontMatterParsingMode;
 use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
@@ -254,6 +254,20 @@ impl<'a> Parser<'a> {
         let allow_qpath_recovery = recover_qpath == RecoverQPath::Yes;
         maybe_recover_from_interpolated_ty_qpath!(self, allow_qpath_recovery);
 
+        let attrs_wrapper = self.parse_outer_attributes()?;
+        if !attrs_wrapper.is_empty() {
+            let raw_attrs = attrs_wrapper.take_for_recovery(self.psess);
+
+            let attr_span = raw_attrs[0].span.to(raw_attrs.last().unwrap().span);
+
+            let ty_after_attr = self.parse_ty()?;
+            let full_span_for_err = attr_span.to(ty_after_attr.span);
+
+            let guar = self.dcx().emit_err(AttributeOnType { span: attr_span });
+
+            return Ok(self.mk_ty(full_span_for_err, TyKind::Err(guar)));
+        }
+
         if let Some(ty) = self.eat_metavar_seq_with_matcher(
             |mv_kind| matches!(mv_kind, MetaVarKind::Ty { .. }),
             |this| this.parse_ty_no_question_mark_recover(),

tests/ui/parser/attribute-on-type.rs

@@ -0,0 +1,40 @@
+//! Regression test for: <https://github.com/rust-lang/rust/issues/144132>
+//!                      <https://github.com/rust-lang/rust/issues/135017>
+
+struct Foo<T>(T);
+
+fn main() {
+    let foo: Foo<#[cfg(not(wrong))] String> = todo!();
+    //~^ ERROR attributes cannot be applied to generic type arguments
+
+    let _generic: Box<#[attr] i32> = Box::new(1);
+    //~^ ERROR attributes cannot be applied to generic type arguments
+
+    let _assignment: #[attr] i32 = Box::new(1);
+    //~^ ERROR attributes cannot be applied to a type
+
+    let _complex: Vec<#[derive(Debug)] String> = vec![];
+    //~^ ERROR attributes cannot be applied to generic type arguments
+
+    let _nested: Box<Vec<#[cfg(feature = "test")] u64>> = Box::new(vec![]);
+    //~^ ERROR attributes cannot be applied to generic type arguments
+}
+
+fn f(_param: #[attr] i32) {}
+//~^ ERROR attributes cannot be applied to a function parameter's type
+
+fn g() -> #[attr] i32 { 0 }
+//~^ ERROR attributes cannot be applied to a type
+
+struct S {
+    field: #[attr] i32,
+    //~^ ERROR attributes cannot be applied to a type
+    field1: (#[attr] i32, i32),
+    //~^ ERROR attributes cannot be applied to a type
+}
+
+type Tuple = (#[attr] i32, String);
+//~^ ERROR attributes cannot be applied to a type
+
+impl #[attr] S {}
+//~^ ERROR attributes cannot be applied to a type

tests/ui/parser/attribute-on-type.stderr

@@ -0,0 +1,68 @@
+error: attributes cannot be applied to generic type arguments
+  --> $DIR/attribute-on-type.rs:7:18
+   |
+LL |     let foo: Foo<#[cfg(not(wrong))] String> = todo!();
+   |                  ^^^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic type arguments
+  --> $DIR/attribute-on-type.rs:10:23
+   |
+LL |     let _generic: Box<#[attr] i32> = Box::new(1);
+   |                       ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a type
+  --> $DIR/attribute-on-type.rs:13:22
+   |
+LL |     let _assignment: #[attr] i32 = Box::new(1);
+   |                      ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic type arguments
+  --> $DIR/attribute-on-type.rs:16:23
+   |
+LL |     let _complex: Vec<#[derive(Debug)] String> = vec![];
+   |                       ^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic type arguments
+  --> $DIR/attribute-on-type.rs:19:26
+   |
+LL |     let _nested: Box<Vec<#[cfg(feature = "test")] u64>> = Box::new(vec![]);
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a function parameter's type
+  --> $DIR/attribute-on-type.rs:23:14
+   |
+LL | fn f(_param: #[attr] i32) {}
+   |              ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a type
+  --> $DIR/attribute-on-type.rs:26:11
+   |
+LL | fn g() -> #[attr] i32 { 0 }
+   |           ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a type
+  --> $DIR/attribute-on-type.rs:30:12
+   |
+LL |     field: #[attr] i32,
+   |            ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a type
+  --> $DIR/attribute-on-type.rs:32:14
+   |
+LL |     field1: (#[attr] i32, i32),
+   |              ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a type
+  --> $DIR/attribute-on-type.rs:36:15
+   |
+LL | type Tuple = (#[attr] i32, String);
+   |               ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to a type
+  --> $DIR/attribute-on-type.rs:39:6
+   |
+LL | impl #[attr] S {}
+   |      ^^^^^^^ attributes are not allowed here
+
+error: aborting due to 11 previous errors
+

tests/ui/parser/issues/issue-103143.rs

@@ -1,5 +1,5 @@
 fn main() {
     x::<#[a]y::<z>>
-    //~^ ERROR invalid const generic expression
+    //~^ ERROR attributes cannot be applied to generic type arguments
     //~| ERROR cannot find value `x` in this scope
 }

tests/ui/parser/issues/issue-103143.stderr

@@ -1,13 +1,8 @@
-error: invalid const generic expression
-  --> $DIR/issue-103143.rs:2:13
+error: attributes cannot be applied to generic type arguments
+  --> $DIR/issue-103143.rs:2:9
    |
 LL |     x::<#[a]y::<z>>
-   |             ^^^^^^
-   |
-help: expressions must be enclosed in braces to be used as const generic arguments
-   |
-LL |     x::<#[a]{ y::<z> }>
-   |             +        +
+   |         ^^^^ attributes are not allowed here
 
 error[E0425]: cannot find value `x` in this scope
   --> $DIR/issue-103143.rs:2:5

tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed

@@ -4,7 +4,8 @@
 pub struct Example(#[allow(dead_code)] usize)
 where
     (): Sized;
-//~^^^ ERROR where clauses are not allowed before tuple struct bodies
+//~^ ERROR attributes cannot be applied to a type
+//~^^^^ ERROR where clauses are not allowed before tuple struct bodies
 
 struct _Demo(pub usize, usize)
 where

tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs

@@ -5,7 +5,8 @@ pub struct Example
 where
     (): Sized,
 (#[allow(dead_code)] usize);
-//~^^^ ERROR where clauses are not allowed before tuple struct bodies
+//~^ ERROR attributes cannot be applied to a type
+//~^^^^ ERROR where clauses are not allowed before tuple struct bodies
 
 struct _Demo
 where