From 1da3551972ddd85295a83dbce7e9c3621dc63814 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 15 Mar 2022 16:56:20 -0700 Subject: [PATCH 1/2] Revert "Parse inner attrs on structs, enums, unions, variants" This reverts commit 8ad9561ece8ec5979f87c43cb377827693be96b8. --- src/data.rs | 16 ++-------------- src/derive.rs | 20 +++++++------------- src/item.rs | 14 ++++++-------- 3 files changed, 15 insertions(+), 35 deletions(-) diff --git a/src/data.rs b/src/data.rs index dc2138c180..3b466618f8 100644 --- a/src/data.rs +++ b/src/data.rs @@ -246,12 +246,11 @@ pub mod parsing { #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for Variant { fn parse(input: ParseStream) -> Result { - let mut attrs = input.call(Attribute::parse_outer)?; + let attrs = input.call(Attribute::parse_outer)?; let _visibility: Visibility = input.parse()?; let ident: Ident = input.parse()?; let fields = if input.peek(token::Brace) { - let fields = parse_braced(input, &mut attrs)?; - Fields::Named(fields) + Fields::Named(input.parse()?) } else if input.peek(token::Paren) { Fields::Unnamed(input.parse()?) } else { @@ -295,17 +294,6 @@ pub mod parsing { } } - pub(crate) fn parse_braced( - input: ParseStream, - attrs: &mut Vec, - ) -> Result { - let content; - let brace_token = braced!(content in input); - attr::parsing::parse_inner(&content, attrs)?; - let named = content.parse_terminated(Field::parse_named)?; - Ok(FieldsNamed { brace_token, named }) - } - impl Field { /// Parses a named (braced struct) field. #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] diff --git a/src/derive.rs b/src/derive.rs index 17387e4567..af9bb91b7a 100644 --- a/src/derive.rs +++ b/src/derive.rs @@ -95,7 +95,7 @@ pub mod parsing { #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for DeriveInput { fn parse(input: ParseStream) -> Result { - let mut attrs = input.call(Attribute::parse_outer)?; + let attrs = input.call(Attribute::parse_outer)?; let vis = input.parse::()?; let lookahead = input.lookahead1(); @@ -103,7 +103,7 @@ pub mod parsing { let struct_token = input.parse::()?; let ident = input.parse::()?; let generics = input.parse::()?; - let (where_clause, fields, semi) = data_struct(input, &mut attrs)?; + let (where_clause, fields, semi) = data_struct(input)?; Ok(DeriveInput { attrs, vis, @@ -122,7 +122,7 @@ pub mod parsing { let enum_token = input.parse::()?; let ident = input.parse::()?; let generics = input.parse::()?; - let (where_clause, brace, variants) = data_enum(input, &mut attrs)?; + let (where_clause, brace, variants) = data_enum(input)?; Ok(DeriveInput { attrs, vis, @@ -141,7 +141,7 @@ pub mod parsing { let union_token = input.parse::()?; let ident = input.parse::()?; let generics = input.parse::()?; - let (where_clause, fields) = data_union(input, &mut attrs)?; + let (where_clause, fields) = data_union(input)?; Ok(DeriveInput { attrs, vis, @@ -163,7 +163,6 @@ pub mod parsing { pub fn data_struct( input: ParseStream, - attrs: &mut Vec, ) -> Result<(Option, Fields, Option)> { let mut lookahead = input.lookahead1(); let mut where_clause = None; @@ -188,7 +187,7 @@ pub mod parsing { Err(lookahead.error()) } } else if lookahead.peek(token::Brace) { - let fields = data::parsing::parse_braced(input, attrs)?; + let fields = input.parse()?; Ok((where_clause, Fields::Named(fields), None)) } else if lookahead.peek(Token![;]) { let semi = input.parse()?; @@ -200,7 +199,6 @@ pub mod parsing { pub fn data_enum( input: ParseStream, - attrs: &mut Vec, ) -> Result<( Option, token::Brace, @@ -210,18 +208,14 @@ pub mod parsing { let content; let brace = braced!(content in input); - attr::parsing::parse_inner(&content, attrs)?; let variants = content.parse_terminated(Variant::parse)?; Ok((where_clause, brace, variants)) } - pub fn data_union( - input: ParseStream, - attrs: &mut Vec, - ) -> Result<(Option, FieldsNamed)> { + pub fn data_union(input: ParseStream) -> Result<(Option, FieldsNamed)> { let where_clause = input.parse()?; - let fields = data::parsing::parse_braced(input, attrs)?; + let fields = input.parse()?; Ok((where_clause, fields)) } } diff --git a/src/item.rs b/src/item.rs index c76805d106..b2248b9cf2 100644 --- a/src/item.rs +++ b/src/item.rs @@ -1987,13 +1987,12 @@ pub mod parsing { #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for ItemStruct { fn parse(input: ParseStream) -> Result { - let mut attrs = input.call(Attribute::parse_outer)?; + let attrs = input.call(Attribute::parse_outer)?; let vis = input.parse::()?; let struct_token = input.parse::()?; let ident = input.parse::()?; let generics = input.parse::()?; - let (where_clause, fields, semi_token) = - derive::parsing::data_struct(input, &mut attrs)?; + let (where_clause, fields, semi_token) = derive::parsing::data_struct(input)?; Ok(ItemStruct { attrs, vis, @@ -2012,13 +2011,12 @@ pub mod parsing { #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for ItemEnum { fn parse(input: ParseStream) -> Result { - let mut attrs = input.call(Attribute::parse_outer)?; + let attrs = input.call(Attribute::parse_outer)?; let vis = input.parse::()?; let enum_token = input.parse::()?; let ident = input.parse::()?; let generics = input.parse::()?; - let (where_clause, brace_token, variants) = - derive::parsing::data_enum(input, &mut attrs)?; + let (where_clause, brace_token, variants) = derive::parsing::data_enum(input)?; Ok(ItemEnum { attrs, vis, @@ -2037,12 +2035,12 @@ pub mod parsing { #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for ItemUnion { fn parse(input: ParseStream) -> Result { - let mut attrs = input.call(Attribute::parse_outer)?; + let attrs = input.call(Attribute::parse_outer)?; let vis = input.parse::()?; let union_token = input.parse::()?; let ident = input.parse::()?; let generics = input.parse::()?; - let (where_clause, fields) = derive::parsing::data_union(input, &mut attrs)?; + let (where_clause, fields) = derive::parsing::data_union(input)?; Ok(ItemUnion { attrs, vis, From fe5508b2f3bfc97e0ea934ebf755708cfeaeeacb Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 15 Mar 2022 17:04:25 -0700 Subject: [PATCH 2/2] Remove support for inner attributes on non-block expressions --- src/expr.rs | 44 +++++++++++++------------------------------- 1 file changed, 13 insertions(+), 31 deletions(-) diff --git a/src/expr.rs b/src/expr.rs index b04450ff2d..90e383f841 100644 --- a/src/expr.rs +++ b/src/expr.rs @@ -1863,8 +1863,7 @@ pub(crate) mod parsing { } if allow_struct.0 && input.peek(token::Brace) { - let outer_attrs = Vec::new(); - let expr_struct = expr_struct_helper(input, outer_attrs, expr.path)?; + let expr_struct = expr_struct_helper(input, expr.path)?; if expr.qself.is_some() { Ok(Expr::Verbatim(verbatim::between(begin, input))) } else { @@ -1890,10 +1889,9 @@ pub(crate) mod parsing { fn paren_or_tuple(input: ParseStream) -> Result { let content; let paren_token = parenthesized!(content in input); - let inner_attrs = content.call(Attribute::parse_inner)?; if content.is_empty() { return Ok(Expr::Tuple(ExprTuple { - attrs: inner_attrs, + attrs: Vec::new(), paren_token, elems: Punctuated::new(), })); @@ -1902,7 +1900,7 @@ pub(crate) mod parsing { let first: Expr = content.parse()?; if content.is_empty() { return Ok(Expr::Paren(ExprParen { - attrs: inner_attrs, + attrs: Vec::new(), paren_token, expr: Box::new(first), })); @@ -1920,7 +1918,7 @@ pub(crate) mod parsing { elems.push_value(value); } Ok(Expr::Tuple(ExprTuple { - attrs: inner_attrs, + attrs: Vec::new(), paren_token, elems, })) @@ -1930,10 +1928,9 @@ pub(crate) mod parsing { fn array_or_repeat(input: ParseStream) -> Result { let content; let bracket_token = bracketed!(content in input); - let inner_attrs = content.call(Attribute::parse_inner)?; if content.is_empty() { return Ok(Expr::Array(ExprArray { - attrs: inner_attrs, + attrs: Vec::new(), bracket_token, elems: Punctuated::new(), })); @@ -1953,7 +1950,7 @@ pub(crate) mod parsing { elems.push_value(value); } Ok(Expr::Array(ExprArray { - attrs: inner_attrs, + attrs: Vec::new(), bracket_token, elems, })) @@ -1961,7 +1958,7 @@ pub(crate) mod parsing { let semi_token: Token![;] = content.parse()?; let len: Expr = content.parse()?; Ok(Expr::Repeat(ExprRepeat { - attrs: inner_attrs, + attrs: Vec::new(), bracket_token, expr: Box::new(first), semi_token, @@ -1978,7 +1975,6 @@ pub(crate) mod parsing { fn parse(input: ParseStream) -> Result { let content; let bracket_token = bracketed!(content in input); - let inner_attrs = content.call(Attribute::parse_inner)?; let mut elems = Punctuated::new(); while !content.is_empty() { @@ -1992,7 +1988,7 @@ pub(crate) mod parsing { } Ok(ExprArray { - attrs: inner_attrs, + attrs: Vec::new(), bracket_token, elems, }) @@ -2006,7 +2002,7 @@ pub(crate) mod parsing { let content; Ok(ExprRepeat { bracket_token: bracketed!(content in input), - attrs: content.call(Attribute::parse_inner)?, + attrs: Vec::new(), expr: content.parse()?, semi_token: content.parse()?, len: content.parse()?, @@ -2648,27 +2644,21 @@ pub(crate) mod parsing { #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for ExprStruct { fn parse(input: ParseStream) -> Result { - let attrs = Vec::new(); let path: Path = input.parse()?; - expr_struct_helper(input, attrs, path) + expr_struct_helper(input, path) } } #[cfg(feature = "full")] - fn expr_struct_helper( - input: ParseStream, - mut attrs: Vec, - path: Path, - ) -> Result { + fn expr_struct_helper(input: ParseStream, path: Path) -> Result { let content; let brace_token = braced!(content in input); - attr::parsing::parse_inner(&content, &mut attrs)?; let mut fields = Punctuated::new(); while !content.is_empty() { if content.peek(Token![..]) { return Ok(ExprStruct { - attrs, + attrs: Vec::new(), brace_token, path, fields, @@ -2690,7 +2680,7 @@ pub(crate) mod parsing { } Ok(ExprStruct { - attrs, + attrs: Vec::new(), brace_token, path, fields, @@ -2957,9 +2947,6 @@ pub(crate) mod printing { #[cfg(not(feature = "full"))] pub(crate) fn outer_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {} - #[cfg(not(feature = "full"))] - fn inner_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {} - #[cfg(feature = "full")] #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] impl ToTokens for ExprBox { @@ -2976,7 +2963,6 @@ pub(crate) mod printing { fn to_tokens(&self, tokens: &mut TokenStream) { outer_attrs_to_tokens(&self.attrs, tokens); self.bracket_token.surround(tokens, |tokens| { - inner_attrs_to_tokens(&self.attrs, tokens); self.elems.to_tokens(tokens); }); } @@ -3036,7 +3022,6 @@ pub(crate) mod printing { fn to_tokens(&self, tokens: &mut TokenStream) { outer_attrs_to_tokens(&self.attrs, tokens); self.paren_token.surround(tokens, |tokens| { - inner_attrs_to_tokens(&self.attrs, tokens); self.elems.to_tokens(tokens); // If we only have one argument, we need a trailing comma to // distinguish ExprTuple from ExprParen. @@ -3433,7 +3418,6 @@ pub(crate) mod printing { outer_attrs_to_tokens(&self.attrs, tokens); self.path.to_tokens(tokens); self.brace_token.surround(tokens, |tokens| { - inner_attrs_to_tokens(&self.attrs, tokens); self.fields.to_tokens(tokens); if let Some(dot2_token) = &self.dot2_token { dot2_token.to_tokens(tokens); @@ -3451,7 +3435,6 @@ pub(crate) mod printing { fn to_tokens(&self, tokens: &mut TokenStream) { outer_attrs_to_tokens(&self.attrs, tokens); self.bracket_token.surround(tokens, |tokens| { - inner_attrs_to_tokens(&self.attrs, tokens); self.expr.to_tokens(tokens); self.semi_token.to_tokens(tokens); self.len.to_tokens(tokens); @@ -3475,7 +3458,6 @@ pub(crate) mod printing { fn to_tokens(&self, tokens: &mut TokenStream) { outer_attrs_to_tokens(&self.attrs, tokens); self.paren_token.surround(tokens, |tokens| { - inner_attrs_to_tokens(&self.attrs, tokens); self.expr.to_tokens(tokens); }); }