chore(deps): Bump syn from 1.0.109 to 2.0.66 (#18792)

Signed-off-by: dependabot[bot] <[email protected]>
Signed-off-by: xxchan <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: xxchan <[email protected]>

Author: dependabot[bot]

Cargo.lock

@@ -190,11 +190,12 @@ expect-test = "1"
 fs-err = "2"
 paste = "1"
 pretty_assertions = "1"
+proc-macro2 = "1.0"
 quote = "1"
 rand = { workspace = true }
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.9"
-syn = { version = "1", features = ["full"] }
+syn = { version = "2", features = ["full"] }
 tempfile = "3"
 tracing-subscriber = "0.3"
 tracing-test = "0.2"

src/connector/Cargo.toml

@@ -17,9 +17,11 @@ use std::path::{Path, PathBuf};
 use std::{env, fs};
 
 use itertools::Itertools;
+use proc_macro2::TokenTree;
 use quote::ToTokens;
 use serde::Serialize;
-use syn::{parse_file, Attribute, Field, Item, ItemFn, Lit, Meta, MetaNameValue, NestedMeta, Type};
+use syn::{parse_file, Attribute, Field, Item, ItemFn, Lit, LitStr, Meta, Type};
+use thiserror_ext::AsReport;
 use walkdir::{DirEntry, WalkDir};
 
 fn connector_crate_path() -> PathBuf {
@@ -216,16 +218,14 @@ struct FunctionInfo {
 /// Has `#[derive(WithOptions)]`
 fn has_with_options_attribute(attrs: &[Attribute]) -> bool {
     attrs.iter().any(|attr| {
-        if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
+        if let Meta::List(meta_list) = &attr.meta {
             return meta_list.path.is_ident("derive")
-                && meta_list.nested.iter().any(|nested| match nested {
-                    syn::NestedMeta::Meta(Meta::Path(path)) => {
-                        // Check if the path contains WithOptions
-                        path.segments
-                            .iter()
-                            .any(|segment| segment.ident == "WithOptions")
+                && meta_list.tokens.clone().into_iter().any(|token| {
+                    if let TokenTree::Ident(ident) = token {
+                        ident == "WithOptions"
+                    } else {
+                        false
                     }
-                    _ => false,
                 });
         }
         false
@@ -236,9 +236,13 @@ fn extract_comments(attrs: &[Attribute]) -> String {
     attrs
         .iter()
         .filter_map(|attr| {
-            if let Ok(Meta::NameValue(mnv)) = attr.parse_meta() {
+            if let Meta::NameValue(mnv) = &attr.meta {
                 if mnv.path.is_ident("doc") {
-                    if let syn::Lit::Str(lit_str) = mnv.lit {
+                    if let syn::Expr::Lit(syn::ExprLit {
+                        lit: Lit::Str(lit_str),
+                        ..
+                    }) = &mnv.value
+                    {
                         return Some(lit_str.value().trim().to_string());
                     }
                 }
@@ -253,38 +257,43 @@ fn extract_comments(attrs: &[Attribute]) -> String {
 
 fn extract_serde_properties(field: &Field) -> SerdeProperties {
     for attr in &field.attrs {
-        if let Ok(meta) = attr.parse_meta() {
-            if meta.path().is_ident("serde") {
+        if let Meta::List(meta_list) = &attr.meta {
+            if meta_list.path.is_ident("serde") {
                 // Initialize the values to be extracted
                 let mut serde_props = SerdeProperties::default();
 
-                if let Meta::List(meta_list) = meta {
-                    // Iterate over nested meta items (e.g., rename = "abc")
-                    for nested_meta in meta_list.nested {
-                        if let NestedMeta::Meta(Meta::NameValue(MetaNameValue {
-                            path, lit, ..
-                        })) = nested_meta
-                        {
-                            if path.is_ident("rename") {
-                                if let Lit::Str(lit_str) = lit {
-                                    serde_props.rename = Some(lit_str.value());
-                                }
-                            } else if path.is_ident("alias") {
-                                if let Lit::Str(lit_str) = lit {
-                                    serde_props.alias.push(lit_str.value());
-                                }
-                            } else if path.is_ident("default") {
-                                if let Lit::Str(lit_str) = lit {
-                                    serde_props.default_func = Some(lit_str.value());
-                                }
+                // Iterate over nested meta items (e.g., rename = "abc")
+                meta_list
+                    .parse_nested_meta(|meta| {
+                        if meta.path.is_ident("rename") {
+                            if let Ok(value) = meta.value()?.parse::<LitStr>() {
+                                serde_props.rename = Some(value.value());
                             }
-                        } else if let NestedMeta::Meta(Meta::Path(path)) = nested_meta {
-                            if path.is_ident("default") {
+                        } else if meta.path.is_ident("alias") {
+                            if let Ok(value) = meta.value()?.parse::<LitStr>() {
+                                serde_props.alias.push(value.value());
+                            }
+                        } else if meta.path.is_ident("default") {
+                            if let Ok(value) = meta.value().and_then(|v| v.parse::<LitStr>()) {
+                                serde_props.default_func = Some(value.value());
+                            } else {
                                 serde_props.default_func = Some("Default::default".to_string());
                             }
                         }
-                    }
-                }
+                        // drain the remaining meta. Otherwise parse_nested_meta returns err
+                        // <https://github.com/dtolnay/syn/issues/1426>
+                        _ = meta.value();
+                        _ = meta.input.parse::<LitStr>();
+                        Ok(())
+                    })
+                    .unwrap_or_else(|err| {
+                        panic!(
+                            "Failed to parse serde properties for field: {:?}, err: {}",
+                            field.ident,
+                            err.to_report_string(),
+                        )
+                    });
+
                 // Return the extracted values
                 return serde_props;
             }