From 546a11dbc1ee64214ea174c6be1d1416e7f37f2c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 22 Jan 2023 22:42:56 -0800 Subject: [PATCH] Delete GenericMethodArgument in favor of GenericArgument --- src/expr.rs | 48 ++-------------------------------------- src/gen/clone.rs | 10 --------- src/gen/debug.rs | 18 --------------- src/gen/eq.rs | 19 ---------------- src/gen/fold.rs | 26 +--------------------- src/gen/hash.rs | 19 ---------------- src/gen/visit.rs | 23 +------------------ src/gen/visit_mut.rs | 20 +---------------- src/lib.rs | 4 +--- syn.json | 22 +----------------- tests/debug/gen.rs | 21 ------------------ tests/test_precedence.rs | 21 ++---------------- 12 files changed, 9 insertions(+), 242 deletions(-) diff --git a/src/expr.rs b/src/expr.rs index e142149cea..ad8909f7a0 100644 --- a/src/expr.rs +++ b/src/expr.rs @@ -866,26 +866,11 @@ ast_struct! { pub struct MethodTurbofish { pub colon2_token: Token![::], pub lt_token: Token![<], - pub args: Punctuated, + pub args: Punctuated, pub gt_token: Token![>], } } -#[cfg(feature = "full")] -ast_enum! { - /// An individual generic argument to a method, like `T`. - #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))] - pub enum GenericMethodArgument { - /// A type argument. - Type(Type), - /// A const expression. Must be inside of a block. - /// - /// NOTE: Identity expressions are represented as Type arguments, as - /// they are indistinguishable syntactically. - Const(Expr), - } -} - #[cfg(feature = "full")] ast_struct! { /// A field-value pair in a struct literal. @@ -1961,24 +1946,6 @@ pub(crate) mod parsing { }) } - #[cfg(feature = "full")] - #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] - impl Parse for GenericMethodArgument { - fn parse(input: ParseStream) -> Result { - if input.peek(Lit) { - let lit = input.parse()?; - return Ok(GenericMethodArgument::Const(Expr::Lit(lit))); - } - - if input.peek(token::Brace) { - let block: ExprBlock = input.parse()?; - return Ok(GenericMethodArgument::Const(Expr::Block(block))); - } - - input.parse().map(GenericMethodArgument::Type) - } - } - #[cfg(feature = "full")] #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] impl Parse for MethodTurbofish { @@ -1992,7 +1959,7 @@ pub(crate) mod parsing { if input.peek(Token![>]) { break; } - let value: GenericMethodArgument = input.parse()?; + let value: GenericArgument = input.parse()?; args.push_value(value); if input.peek(Token![>]) { break; @@ -2899,17 +2866,6 @@ pub(crate) mod printing { } } - #[cfg(feature = "full")] - #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] - impl ToTokens for GenericMethodArgument { - fn to_tokens(&self, tokens: &mut TokenStream) { - match self { - GenericMethodArgument::Type(t) => t.to_tokens(tokens), - GenericMethodArgument::Const(c) => c.to_tokens(tokens), - } - } - } - #[cfg(feature = "full")] #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] impl ToTokens for ExprTuple { diff --git a/src/gen/clone.rs b/src/gen/clone.rs index 52b43a82e6..cf7f3a4191 100644 --- a/src/gen/clone.rs +++ b/src/gen/clone.rs @@ -913,16 +913,6 @@ impl Clone for GenericArgument { } } } -#[cfg(feature = "full")] -#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))] -impl Clone for GenericMethodArgument { - fn clone(&self) -> Self { - match self { - GenericMethodArgument::Type(v0) => GenericMethodArgument::Type(v0.clone()), - GenericMethodArgument::Const(v0) => GenericMethodArgument::Const(v0.clone()), - } - } -} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))] impl Clone for GenericParam { diff --git a/src/gen/debug.rs b/src/gen/debug.rs index 52e51d56a9..da7b45e156 100644 --- a/src/gen/debug.rs +++ b/src/gen/debug.rs @@ -1283,24 +1283,6 @@ impl Debug for GenericArgument { } } } -#[cfg(feature = "full")] -#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] -impl Debug for GenericMethodArgument { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - match self { - GenericMethodArgument::Type(v0) => { - let mut formatter = formatter.debug_tuple("Type"); - formatter.field(v0); - formatter.finish() - } - GenericMethodArgument::Const(v0) => { - let mut formatter = formatter.debug_tuple("Const"); - formatter.field(v0); - formatter.finish() - } - } - } -} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] impl Debug for GenericParam { diff --git a/src/gen/eq.rs b/src/gen/eq.rs index 55990ad92a..384988c269 100644 --- a/src/gen/eq.rs +++ b/src/gen/eq.rs @@ -891,25 +891,6 @@ impl PartialEq for GenericArgument { } } } -#[cfg(feature = "full")] -#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] -impl Eq for GenericMethodArgument {} -#[cfg(feature = "full")] -#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] -impl PartialEq for GenericMethodArgument { - fn eq(&self, other: &Self) -> bool { - match (self, other) { - (GenericMethodArgument::Type(self0), GenericMethodArgument::Type(other0)) => { - self0 == other0 - } - ( - GenericMethodArgument::Const(self0), - GenericMethodArgument::Const(other0), - ) => self0 == other0, - _ => false, - } - } -} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] impl Eq for GenericParam {} diff --git a/src/gen/fold.rs b/src/gen/fold.rs index 4d04f2e656..953d5461e3 100644 --- a/src/gen/fold.rs +++ b/src/gen/fold.rs @@ -314,13 +314,6 @@ pub trait Fold { fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument { fold_generic_argument(self, i) } - #[cfg(feature = "full")] - fn fold_generic_method_argument( - &mut self, - i: GenericMethodArgument, - ) -> GenericMethodArgument { - fold_generic_method_argument(self, i) - } #[cfg(any(feature = "derive", feature = "full"))] fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam { fold_generic_param(self, i) @@ -1771,23 +1764,6 @@ where } } } -#[cfg(feature = "full")] -pub fn fold_generic_method_argument( - f: &mut F, - node: GenericMethodArgument, -) -> GenericMethodArgument -where - F: Fold + ?Sized, -{ - match node { - GenericMethodArgument::Type(_binding_0) => { - GenericMethodArgument::Type(f.fold_type(_binding_0)) - } - GenericMethodArgument::Const(_binding_0) => { - GenericMethodArgument::Const(f.fold_expr(_binding_0)) - } - } -} #[cfg(any(feature = "derive", feature = "full"))] pub fn fold_generic_param(f: &mut F, node: GenericParam) -> GenericParam where @@ -2424,7 +2400,7 @@ where MethodTurbofish { colon2_token: Token![::](tokens_helper(f, &node.colon2_token.spans)), lt_token: Token![<](tokens_helper(f, &node.lt_token.spans)), - args: FoldHelper::lift(node.args, |it| f.fold_generic_method_argument(it)), + args: FoldHelper::lift(node.args, |it| f.fold_generic_argument(it)), gt_token: Token![>](tokens_helper(f, &node.gt_token.spans)), } } diff --git a/src/gen/hash.rs b/src/gen/hash.rs index 0c077b3dd4..2a4cc3b1c9 100644 --- a/src/gen/hash.rs +++ b/src/gen/hash.rs @@ -1197,25 +1197,6 @@ impl Hash for GenericArgument { } } } -#[cfg(feature = "full")] -#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] -impl Hash for GenericMethodArgument { - fn hash(&self, state: &mut H) - where - H: Hasher, - { - match self { - GenericMethodArgument::Type(v0) => { - state.write_u8(0u8); - v0.hash(state); - } - GenericMethodArgument::Const(v0) => { - state.write_u8(1u8); - v0.hash(state); - } - } - } -} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] impl Hash for GenericParam { diff --git a/src/gen/visit.rs b/src/gen/visit.rs index 8bd9ae6adc..5d6fa29628 100644 --- a/src/gen/visit.rs +++ b/src/gen/visit.rs @@ -316,10 +316,6 @@ pub trait Visit<'ast> { fn visit_generic_argument(&mut self, i: &'ast GenericArgument) { visit_generic_argument(self, i); } - #[cfg(feature = "full")] - fn visit_generic_method_argument(&mut self, i: &'ast GenericMethodArgument) { - visit_generic_method_argument(self, i); - } #[cfg(any(feature = "derive", feature = "full"))] fn visit_generic_param(&mut self, i: &'ast GenericParam) { visit_generic_param(self, i); @@ -1965,23 +1961,6 @@ where } } } -#[cfg(feature = "full")] -pub fn visit_generic_method_argument<'ast, V>( - v: &mut V, - node: &'ast GenericMethodArgument, -) -where - V: Visit<'ast> + ?Sized, -{ - match node { - GenericMethodArgument::Type(_binding_0) => { - v.visit_type(_binding_0); - } - GenericMethodArgument::Const(_binding_0) => { - v.visit_expr(_binding_0); - } - } -} #[cfg(any(feature = "derive", feature = "full"))] pub fn visit_generic_param<'ast, V>(v: &mut V, node: &'ast GenericParam) where @@ -2692,7 +2671,7 @@ where tokens_helper(v, &node.lt_token.spans); for el in Punctuated::pairs(&node.args) { let (it, p) = el.into_tuple(); - v.visit_generic_method_argument(it); + v.visit_generic_argument(it); if let Some(p) = p { tokens_helper(v, &p.spans); } diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs index abf3b5b90d..e9453b9924 100644 --- a/src/gen/visit_mut.rs +++ b/src/gen/visit_mut.rs @@ -317,10 +317,6 @@ pub trait VisitMut { fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) { visit_generic_argument_mut(self, i); } - #[cfg(feature = "full")] - fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) { - visit_generic_method_argument_mut(self, i); - } #[cfg(any(feature = "derive", feature = "full"))] fn visit_generic_param_mut(&mut self, i: &mut GenericParam) { visit_generic_param_mut(self, i); @@ -1966,20 +1962,6 @@ where } } } -#[cfg(feature = "full")] -pub fn visit_generic_method_argument_mut(v: &mut V, node: &mut GenericMethodArgument) -where - V: VisitMut + ?Sized, -{ - match node { - GenericMethodArgument::Type(_binding_0) => { - v.visit_type_mut(_binding_0); - } - GenericMethodArgument::Const(_binding_0) => { - v.visit_expr_mut(_binding_0); - } - } -} #[cfg(any(feature = "derive", feature = "full"))] pub fn visit_generic_param_mut(v: &mut V, node: &mut GenericParam) where @@ -2692,7 +2674,7 @@ where tokens_helper(v, &mut node.lt_token.spans); for el in Punctuated::pairs_mut(&mut node.args) { let (it, p) = el.into_tuple(); - v.visit_generic_method_argument_mut(it); + v.visit_generic_argument_mut(it); if let Some(p) = p { tokens_helper(v, &mut p.spans); } diff --git a/src/lib.rs b/src/lib.rs index 2f5c4d34b0..617500ac22 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -345,9 +345,7 @@ pub use crate::error::{Error, Result}; #[cfg(any(feature = "full", feature = "derive"))] mod expr; #[cfg(feature = "full")] -pub use crate::expr::{ - Arm, FieldValue, GenericMethodArgument, Label, MethodTurbofish, RangeLimits, -}; +pub use crate::expr::{Arm, FieldValue, Label, MethodTurbofish, RangeLimits}; #[cfg(any(feature = "full", feature = "derive"))] pub use crate::expr::{ Expr, ExprArray, ExprAssign, ExprAssignOp, ExprAsync, ExprAwait, ExprBinary, ExprBlock, diff --git a/syn.json b/syn.json index c749cfa566..d8b59577f8 100644 --- a/syn.json +++ b/syn.json @@ -2261,26 +2261,6 @@ ] } }, - { - "ident": "GenericMethodArgument", - "features": { - "any": [ - "full" - ] - }, - "variants": { - "Type": [ - { - "syn": "Type" - } - ], - "Const": [ - { - "syn": "Expr" - } - ] - } - }, { "ident": "GenericParam", "features": { @@ -3617,7 +3597,7 @@ "args": { "punctuated": { "element": { - "syn": "GenericMethodArgument" + "syn": "GenericArgument" }, "punct": "Comma" } diff --git a/tests/debug/gen.rs b/tests/debug/gen.rs index c03c1660e2..ecaaf01d47 100644 --- a/tests/debug/gen.rs +++ b/tests/debug/gen.rs @@ -2322,27 +2322,6 @@ impl Debug for Lite { } } } -impl Debug for Lite { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - let _val = &self.value; - match _val { - syn::GenericMethodArgument::Type(_val) => { - formatter.write_str("Type")?; - formatter.write_str("(")?; - Debug::fmt(Lite(_val), formatter)?; - formatter.write_str(")")?; - Ok(()) - } - syn::GenericMethodArgument::Const(_val) => { - formatter.write_str("Const")?; - formatter.write_str("(")?; - Debug::fmt(Lite(_val), formatter)?; - formatter.write_str(")")?; - Ok(()) - } - } - } -} impl Debug for Lite { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let _val = &self.value; diff --git a/tests/test_precedence.rs b/tests/test_precedence.rs index fd5b82a1f9..24d2b240ca 100644 --- a/tests/test_precedence.rs +++ b/tests/test_precedence.rs @@ -355,11 +355,8 @@ fn librustc_brackets(mut librustc_expr: P) -> Option> { /// reveal the precedence of the parsed expressions, and produce a stringified /// form of the resulting expression. fn syn_brackets(syn_expr: syn::Expr) -> syn::Expr { - use syn::fold::{fold_expr, fold_generic_argument, fold_generic_method_argument, Fold}; - use syn::{ - token, BinOp, Expr, ExprParen, GenericArgument, GenericMethodArgument, MetaNameValue, Pat, - Stmt, Type, - }; + use syn::fold::{fold_expr, fold_generic_argument, Fold}; + use syn::{token, BinOp, Expr, ExprParen, GenericArgument, MetaNameValue, Pat, Stmt, Type}; struct ParenthesizeEveryExpr; impl Fold for ParenthesizeEveryExpr { @@ -396,20 +393,6 @@ fn syn_brackets(syn_expr: syn::Expr) -> syn::Expr { } } - fn fold_generic_method_argument( - &mut self, - arg: GenericMethodArgument, - ) -> GenericMethodArgument { - match arg { - GenericMethodArgument::Const(arg) => GenericMethodArgument::Const(match arg { - Expr::Block(_) => fold_expr(self, arg), - // Don't wrap unbraced const generic arg as that's invalid syntax. - _ => arg, - }), - _ => fold_generic_method_argument(self, arg), - } - } - fn fold_stmt(&mut self, stmt: Stmt) -> Stmt { match stmt { // Don't wrap toplevel expressions in statements.