Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit e267a23

Browse files
KivooeoKivooeo
committed
Added checks for attribute in type case
1 parent f63685d commit e267a23

12 files changed

+389
-32
lines changed

‎compiler/rustc_parse/messages.ftl‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -71,6 +71,17 @@ parse_attr_without_generics = attribute without generic parameters
7171
parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type
7272
.label = attributes are not allowed here
7373
74+
parse_attribute_on_type = attributes cannot be applied to a type
75+
.label = attributes are not allowed here
76+
.suggestion = remove attribute from here
77+
78+
parse_attribute_on_generic_type = attributes cannot be applied to generic type arguments
79+
.label = attributes are not allowed here
80+
.suggestion = remove attribute from here
81+
82+
parse_attribute_on_empty_generic = attributes cannot be applied here
83+
.label = attributes are not allowed here
84+
7485
parse_bad_assoc_type_bounds = bounds on associated types do not belong here
7586
.label = belongs in `where` clause
7687

‎compiler/rustc_parse/src/errors.rs‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1489,6 +1489,34 @@ pub(crate) struct AttributeOnParamType {
14891489
pub span: Span,
14901490
}
14911491

1492+
#[derive(Diagnostic)]
1493+
#[diag(parse_attribute_on_type)]
1494+
pub(crate) struct AttributeOnType {
1495+
#[primary_span]
1496+
#[label]
1497+
pub span: Span,
1498+
#[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1499+
pub fix_span: Span,
1500+
}
1501+
1502+
#[derive(Diagnostic)]
1503+
#[diag(parse_attribute_on_generic_type)]
1504+
pub(crate) struct AttributeOnGenericType {
1505+
#[primary_span]
1506+
#[label]
1507+
pub span: Span,
1508+
#[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1509+
pub fix_span: Span,
1510+
}
1511+
1512+
#[derive(Diagnostic)]
1513+
#[diag(parse_attribute_on_empty_generic)]
1514+
pub(crate) struct AttributeOnEmptyGeneric {
1515+
#[primary_span]
1516+
#[label]
1517+
pub span: Span,
1518+
}
1519+
14921520
#[derive(Diagnostic)]
14931521
#[diag(parse_pattern_method_param_without_body, code = E0642)]
14941522
pub(crate) struct PatternMethodParamWithoutBody {

‎compiler/rustc_parse/src/parser/attr_wrapper.rs‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,10 @@ impl AttrWrapper {
6969
self.attrs
7070
}
7171

72+
pub(super) fn attrs(&self) -> &AttrVec {
73+
&self.attrs
74+
}
75+
7276
/// Prepend `self.attrs` to `attrs`.
7377
// FIXME: require passing an NT to prevent misuse of this method
7478
pub(super) fn prepend_to_nt_inner(mut self, attrs: &mut AttrVec) {

‎compiler/rustc_parse/src/parser/path.rs‎

Lines changed: 27 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,8 @@ use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
1717
use super::{Parser, Restrictions, TokenType};
1818
use crate::ast::{PatKind, TyKind};
1919
use crate::errors::{
20-
self, FnPathFoundNamedParams, PathFoundAttributeInParams, PathFoundCVariadicParams,
21-
PathSingleColon, PathTripleColon,
20+
self, AttributeOnEmptyGeneric, AttributeOnGenericType, FnPathFoundNamedParams,
21+
PathFoundAttributeInParams, PathFoundCVariadicParams, PathSingleColon, PathTripleColon,
2222
};
2323
use crate::exp;
2424
use crate::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
@@ -880,6 +880,15 @@ impl<'a> Parser<'a> {
880880
&mut self,
881881
ty_generics: Option<&Generics>,
882882
) -> PResult<'a, Option<GenericArg>> {
883+
let mut attr_span: Option<Span> = None;
884+
if self.token == token::Pound && self.look_ahead(1, |t| *t == token::OpenBracket) {
885+
// Parse attribute.
886+
let attrs_wrapper = self.parse_outer_attributes()?;
887+
if !attrs_wrapper.is_empty() {
888+
let raw_attrs = attrs_wrapper.attrs();
889+
attr_span = Some(raw_attrs[0].span.to(raw_attrs.last().unwrap().span));
890+
}
891+
}
883892
let start = self.token.span;
884893
let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
885894
// Parse lifetime argument.
@@ -934,6 +943,10 @@ impl<'a> Parser<'a> {
934943
}
935944
} else if self.token.is_keyword(kw::Const) {
936945
return self.recover_const_param_declaration(ty_generics);
946+
} else if let Some(attr_span) = attr_span {
947+
// Handle case where attribute is present but no valid generic argument follows.
948+
let guar = self.dcx().emit_err(AttributeOnEmptyGeneric { span: attr_span });
949+
return Ok(Some(GenericArg::Type(self.mk_ty(attr_span, TyKind::Err(guar)))));
937950
} else {
938951
// Fall back by trying to parse a const-expr expression. If we successfully do so,
939952
// then we should report an error that it needs to be wrapped in braces.
@@ -953,6 +966,18 @@ impl<'a> Parser<'a> {
953966
}
954967
}
955968
};
969+
970+
if let Some(attr_span) = attr_span
971+
&& !(arg.span().is_empty() || arg.span().is_dummy())
972+
{
973+
let guar = self.dcx().emit_err(AttributeOnGenericType {
974+
span: attr_span,
975+
fix_span: attr_span.until(arg.span()),
976+
});
977+
978+
return Ok(Some(GenericArg::Type(self.mk_ty(attr_span, TyKind::Err(guar)))));
979+
}
980+
956981
Ok(Some(arg))
957982
}
958983

‎compiler/rustc_parse/src/parser/ty.rs‎

Lines changed: 22 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,10 @@ use thin_vec::{ThinVec, thin_vec};
1414

1515
use super::{Parser, PathStyle, SeqSep, TokenType, Trailing};
1616
use crate::errors::{
17-
self, DynAfterMut, ExpectedFnPathFoundFnKeyword, ExpectedMutOrConstInRawPointerType,
18-
FnPtrWithGenerics, FnPtrWithGenericsSugg, HelpUseLatestEdition, InvalidDynKeyword,
19-
LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime, NestedCVariadicType,
20-
ReturnTypesUseThinArrow,
17+
self, AttributeOnType, DynAfterMut, ExpectedFnPathFoundFnKeyword,
18+
ExpectedMutOrConstInRawPointerType, FnPtrWithGenerics, FnPtrWithGenericsSugg,
19+
HelpUseLatestEdition, InvalidDynKeyword, LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime,
20+
NestedCVariadicType, ReturnTypesUseThinArrow,
2121
};
2222
use crate::parser::item::FrontMatterParsingMode;
2323
use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
@@ -253,6 +253,24 @@ impl<'a> Parser<'a> {
253253
) -> PResult<'a, P<Ty>> {
254254
let allow_qpath_recovery = recover_qpath == RecoverQPath::Yes;
255255
maybe_recover_from_interpolated_ty_qpath!(self, allow_qpath_recovery);
256+
if self.token == token::Pound && self.look_ahead(1, |t| *t == token::OpenBracket) {
257+
let attrs_wrapper = self.parse_outer_attributes()?;
258+
if !attrs_wrapper.is_empty() {
259+
let raw_attrs = attrs_wrapper.take_for_recovery(self.psess);
260+
261+
let attr_span = raw_attrs[0].span.to(raw_attrs.last().unwrap().span);
262+
263+
let ty_after_attr = self.parse_ty()?;
264+
let full_span_for_err = attr_span.to(ty_after_attr.span);
265+
266+
let guar = self.dcx().emit_err(AttributeOnType {
267+
span: attr_span,
268+
fix_span: attr_span.until(ty_after_attr.span),
269+
});
270+
271+
return Ok(self.mk_ty(full_span_for_err, TyKind::Err(guar)));
272+
}
273+
}
256274

257275
if let Some(ty) = self.eat_metavar_seq_with_matcher(
258276
|mv_kind| matches!(mv_kind, MetaVarKind::Ty { .. }),

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

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
//! Regression test for: <https://github.com/rust-lang/rust/issues/144132>
2+
//! <https://github.com/rust-lang/rust/issues/135017>
3+
4+
struct Foo<T>(T);
5+
struct Bar<'a>(&'a i32);
6+
struct Baz<const N: usize>(i32);
7+
8+
fn main() {
9+
let foo: Foo<#[cfg(not(wrong))] String> = todo!();
10+
//~^ ERROR attributes cannot be applied to generic type arguments
11+
12+
let _: Bar<#[cfg(any())] 'static> = todo!();
13+
//~^ ERROR attributes cannot be applied to generic type arguments
14+
15+
let _: Baz<#[cfg(any())] 42> = todo!();
16+
//~^ ERROR attributes cannot be applied to generic type arguments
17+
//~| ERROR type provided when a constant was expected
18+
19+
let _: Foo<#[cfg(not(wrong))]String> = todo!();
20+
//~^ ERROR attributes cannot be applied to generic type arguments
21+
22+
let _: Bar<#[cfg(any())] 'static> = todo!();
23+
//~^ ERROR attributes cannot be applied to generic type arguments
24+
25+
let _: Baz<#[cfg(any())]> = todo!();
26+
//~^ ERROR attributes cannot be applied here
27+
//~| ERROR type provided when a constant was expected
28+
29+
let _: Foo<#[cfg(not(wrong))]> = todo!();
30+
//~^ ERROR attributes cannot be applied here
31+
32+
let _: Bar<#[cfg(any())]> = todo!();
33+
//~^ ERROR attributes cannot be applied here
34+
35+
let _generic: Box<#[attr] i32> = Box::new(1);
36+
//~^ ERROR attributes cannot be applied to generic type arguments
37+
38+
let _assignment: #[attr] i32 = Box::new(1);
39+
//~^ ERROR attributes cannot be applied to a type
40+
41+
let _complex: Vec<#[derive(Debug)] String> = vec![];
42+
//~^ ERROR attributes cannot be applied to generic type arguments
43+
44+
let _nested: Box<Vec<#[cfg(feature = "test")] u64>> = Box::new(vec![]);
45+
//~^ ERROR attributes cannot be applied to generic type arguments
46+
}
47+
48+
fn f(_param: #[attr] i32) {}
49+
//~^ ERROR attributes cannot be applied to a function parameter's type
50+
51+
fn g() -> #[attr] i32 { 0 }
52+
//~^ ERROR attributes cannot be applied to a type
53+
54+
struct S {
55+
field: #[attr] i32,
56+
//~^ ERROR attributes cannot be applied to a type
57+
field1: (#[attr] i32, i32),
58+
//~^ ERROR attributes cannot be applied to a type
59+
}
60+
61+
type Tuple = (#[attr] i32, String);
62+
//~^ ERROR attributes cannot be applied to a type
63+
64+
impl #[attr] S {}
65+
//~^ ERROR attributes cannot be applied to a type
66+

0 commit comments

Comments
 (0)