Delete GenericMethodArgument in favor of GenericArgument

src/expr.rs

@@ -866,26 +866,11 @@ ast_struct! {
     pub struct MethodTurbofish {
         pub colon2_token: Token![::],
         pub lt_token: Token![<],
-        pub args: Punctuated<GenericMethodArgument, Token![,]>,
+        pub args: Punctuated<GenericArgument, Token![,]>,
         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<Self> {
-            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 {

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,