Update syn to v2 (#113)

This should deal with all of the breakages from updating to `syn` v2 This update would also require an MSRV bump, since it looks like the current MSRV is 1.54 while `syn` bumped up to 1.56 (2021 edition)
illicitonion · Mar 28, 2023 · 9bc84b1 · 9bc84b1
1 parent e02abdc
commit 9bc84b1
Show file tree

Hide file tree

Showing 4 changed files with 51 additions and 52 deletions.
diff --git a/.github/workflows/msrv-build.yml b/.github/workflows/msrv-build.yml
@@ -15,7 +15,7 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.54.0
+          toolchain: 1.56.0
           target: thumbv6m-none-eabi
       - name: Use MSRV Cargo.lock
         run: cp Cargo.lock.msrv Cargo.lock
@@ -24,10 +24,10 @@ jobs:
         with:
           command: build
           args: --all --locked
-          toolchain: 1.54.0
+          toolchain: 1.56.0
       - name: Build no-std with MSRV
         uses: actions-rs/cargo@v1
         with:
           command: build
           args: --manifest-path=num_enum/Cargo.toml --target thumbv6m-none-eabi --no-default-features --locked
-          toolchain: 1.54.0
+          toolchain: 1.56.0
diff --git a/Cargo.lock.msrv b/Cargo.lock.msrv
diff --git a/num_enum_derive/Cargo.toml b/num_enum_derive/Cargo.toml
@@ -34,4 +34,4 @@ features = ["external_doc"]
 proc-macro2 = "1"
 proc-macro-crate = { version = "1", optional = true }
 quote = "1"
-syn = { version = "1.0.15", features = ["parsing"] }
+syn = { version = "2.0.10", features = ["parsing"] }
diff --git a/num_enum_derive/src/lib.rs b/num_enum_derive/src/lib.rs
@@ -5,14 +5,12 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use proc_macro2::Span;
-use quote::{format_ident, quote};
+use quote::{format_ident, quote, ToTokens};
 use std::collections::BTreeSet;
 use syn::{
     parse::{Parse, ParseStream},
-    parse_macro_input, parse_quote,
-    spanned::Spanned,
-    Attribute, Data, DeriveInput, Error, Expr, ExprLit, ExprUnary, Fields, Ident, Lit, LitInt,
-    Meta, Result, UnOp,
+    parse_macro_input, parse_quote, Attribute, Data, DeriveInput, Error, Expr, ExprLit, ExprUnary,
+    Fields, Ident, Lit, LitInt, Meta, Result, UnOp,
 };
 
 macro_rules! die {
@@ -86,11 +84,11 @@ fn parse_alternative_values(val_expr: &Expr) -> Result<Vec<DiscriminantValue>> {
     }
 
     if let Expr::Range(syn::ExprRange {
-        from, to, limits, ..
+        start, end, limits, ..
     }) = val_expr
     {
-        let lower = range_expr_value_to_number(val_expr, from)?;
-        let upper = range_expr_value_to_number(val_expr, to)?;
+        let lower = range_expr_value_to_number(val_expr, start)?;
+        let upper = range_expr_value_to_number(val_expr, end)?;
         // While this is technically allowed in Rust, and results in an empty range, it's almost certainly a mistake in this context.
         if lower > upper {
             die!(val_expr => "When using ranges for alternate values, upper bound must not be less than lower bound");
@@ -136,7 +134,7 @@ struct NumEnumVariantAttributes {
 impl Parse for NumEnumVariantAttributes {
     fn parse(input: ParseStream<'_>) -> Result<Self> {
         Ok(Self {
-            items: input.parse_terminated(NumEnumVariantAttributeItem::parse)?,
+            items: input.parse_terminated(NumEnumVariantAttributeItem::parse, syn::Token![,])?,
         })
     }
 }
@@ -174,12 +172,6 @@ impl Parse for VariantDefaultAttribute {
     }
 }
 
-impl Spanned for VariantDefaultAttribute {
-    fn span(&self) -> Span {
-        self.keyword.span()
-    }
-}
-
 struct VariantCatchAllAttribute {
     keyword: kw::catch_all,
 }
@@ -192,14 +184,8 @@ impl Parse for VariantCatchAllAttribute {
     }
 }
 
-impl Spanned for VariantCatchAllAttribute {
-    fn span(&self) -> Span {
-        self.keyword.span()
-    }
-}
-
 struct VariantAlternativesAttribute {
-    keyword: kw::alternatives,
+    _keyword: kw::alternatives,
     _eq_token: syn::Token![=],
     _bracket_token: syn::token::Bracket,
     expressions: syn::punctuated::Punctuated<Expr, syn::Token![,]>,
@@ -211,22 +197,16 @@ impl Parse for VariantAlternativesAttribute {
         let keyword = input.parse()?;
         let _eq_token = input.parse()?;
         let _bracket_token = syn::bracketed!(content in input);
-        let expressions = content.parse_terminated(Expr::parse)?;
+        let expressions = content.parse_terminated(Expr::parse, syn::Token![,])?;
         Ok(Self {
-            keyword,
+            _keyword: keyword,
             _eq_token,
             _bracket_token,
             expressions,
         })
     }
 }
 
-impl Spanned for VariantAlternativesAttribute {
-    fn span(&self) -> Span {
-        self.keyword.span()
-    }
-}
-
 struct VariantInfo {
     ident: Ident,
     is_default: bool,
@@ -329,16 +309,16 @@ impl Parse for EnumInfo {
                 let mut attrs = input.attrs.into_iter();
                 loop {
                     if let Some(attr) = attrs.next() {
-                        if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
+                        if let Meta::List(meta_list) = &attr.meta {
                             if let Some(ident) = meta_list.path.get_ident() {
                                 if ident == "repr" {
-                                    let mut nested = meta_list.nested.iter();
-                                    if nested.len() != 1 {
-                                        die!(attr =>
+                                    let mut nested = meta_list.tokens.clone().into_iter();
+                                    let repr = match (nested.next(), nested.next()) {
+                                        (Some(repr), None) => repr,
+                                        _ => die!(attr =>
                                             "Expected exactly one `repr` argument"
-                                        );
-                                    }
-                                    let repr = nested.next().unwrap();
+                                        ),
+                                    };
                                     let repr: Ident = parse_quote! {
                                         #repr
                                     };
@@ -385,7 +365,7 @@ impl Parse for EnumInfo {
                 let mut is_catch_all: bool = false;
 
                 for attribute in &variant.attrs {
-                    if attribute.path.is_ident("default") {
+                    if attribute.path().is_ident("default") {
                         if has_default_variant {
                             die!(attribute =>
                                 "Multiple variants marked `#[default]` or `#[num_enum(default)]` found"
@@ -399,7 +379,7 @@ impl Parse for EnumInfo {
                         has_default_variant = true;
                     }
 
-                    if attribute.path.is_ident("num_enum") {
+                    if attribute.path().is_ident("num_enum") {
                         match attribute.parse_args_with(NumEnumVariantAttributes::parse) {
                             Ok(variant_attributes) => {
                                 for variant_attribute in variant_attributes.items {
@@ -457,7 +437,9 @@ impl Parse for EnumInfo {
                             }
                             Err(err) => {
                                 if cfg!(not(feature = "complex-expressions")) {
-                                    let attribute_str = format!("{}", attribute.tokens);
+                                    let tokens = attribute.meta.to_token_stream();
+
+                                    let attribute_str = format!("{}", tokens);
                                     if attribute_str.contains("alternatives")
                                         && attribute_str.contains("..")
                                     {