Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "syn"
-version = "2.0.72"
+version = "2.0.73"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 categories = ["development-tools::procedural-macro-helpers", "parser-implementations"]
 description = "Parser for Rust source code"

src/buffer.rs

@@ -364,6 +364,16 @@ impl<'a> Cursor<'a> {
 
         Some(unsafe { Cursor::create(self.ptr.add(len), self.scope) })
     }
+
+    pub(crate) fn scope_delimiter(self) -> Delimiter {
+        match unsafe { &*self.scope } {
+            Entry::End(_, offset) => match unsafe { &*self.scope.offset(*offset) } {
+                Entry::Group(group, _) => group.delimiter(),
+                _ => Delimiter::None,
+            },
+            _ => unreachable!(),
+        }
+    }
 }
 
 impl<'a> Copy for Cursor<'a> {}

src/data.rs

@@ -1,5 +1,5 @@
 use crate::attr::Attribute;
-use crate::expr::Expr;
+use crate::expr::{Expr, Index, Member};
 use crate::ident::Ident;
 use crate::punctuated::{self, Punctuated};
 use crate::restriction::{FieldMutability, Visibility};
@@ -104,6 +104,82 @@ impl Fields {
             Fields::Unnamed(f) => f.unnamed.is_empty(),
         }
     }
+
+    /// Get an iterator over the fields of a struct or variant as [`Member`]s.
+    /// This iterator can be used to iterate over a named or unnamed struct or
+    /// variant's fields uniformly.
+    ///
+    /// # Example
+    ///
+    /// The following is a simplistic [`Clone`] derive for structs. (A more
+    /// complete implementation would additionally want to infer trait bounds on
+    /// the generic type parameters.)
+    ///
+    /// ```
+    /// # use quote::quote;
+    /// #
+    /// fn derive_clone(input: &syn::ItemStruct) -> proc_macro2::TokenStream {
+    ///     let ident = &input.ident;
+    ///     let members = input.fields.members();
+    ///     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    ///     quote! {
+    ///         impl #impl_generics Clone for #ident #ty_generics #where_clause {
+    ///             fn clone(&self) -> Self {
+    ///                 Self {
+    ///                     #(#members: self.#members.clone()),*
+    ///                 }
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// For structs with named fields, it produces an expression like `Self { a:
+    /// self.a.clone() }`. For structs with unnamed fields, `Self { 0:
+    /// self.0.clone() }`. And for unit structs, `Self {}`.
+    pub fn members(&self) -> impl Iterator<Item = Member> + Clone + '_ {
+        struct Members<'a> {
+            fields: punctuated::Iter<'a, Field>,
+            index: u32,
+        }
+
+        impl<'a> Iterator for Members<'a> {
+            type Item = Member;
+
+            fn next(&mut self) -> Option<Self::Item> {
+                let field = self.fields.next()?;
+                let member = match &field.ident {
+                    Some(ident) => Member::Named(ident.clone()),
+                    None => {
+                        #[cfg(all(feature = "parsing", feature = "printing"))]
+                        let span = crate::spanned::Spanned::span(&field.ty);
+                        #[cfg(not(all(feature = "parsing", feature = "printing")))]
+                        let span = proc_macro2::Span::call_site();
+                        Member::Unnamed(Index {
+                            index: self.index,
+                            span,
+                        })
+                    }
+                };
+                self.index += 1;
+                Some(member)
+            }
+        }
+
+        impl<'a> Clone for Members<'a> {
+            fn clone(&self) -> Self {
+                Members {
+                    fields: self.fields.clone(),
+                    index: self.index,
+                }
+            }
+        }
+
+        Members {
+            fields: self.iter(),
+            index: 0,
+        }
+    }
 }
 
 impl IntoIterator for Fields {

src/discouraged.rs

@@ -175,8 +175,8 @@ impl<'a> Speculative for ParseBuffer<'a> {
         if !Rc::ptr_eq(&self_unexp, &fork_unexp) {
             match (fork_sp, self_sp) {
                 // Unexpected set on the fork, but not on `self`, copy it over.
-                (Some(span), None) => {
-                    self_unexp.set(Unexpected::Some(span));
+                (Some((span, delimiter)), None) => {
+                    self_unexp.set(Unexpected::Some(span, delimiter));
                 }
                 // Unexpected unset. Use chain to propagate errors from fork.
                 (None, None) => {

src/expr.rs

@@ -1741,6 +1741,8 @@ pub(crate) mod parsing {
             input.parse().map(Expr::Continue)
         } else if input.peek(Token![return]) {
             input.parse().map(Expr::Return)
+        } else if input.peek(Token![become]) {
+            expr_become(input)
         } else if input.peek(token::Bracket) {
             array_or_repeat(input)
         } else if input.peek(Token![let]) {
@@ -2393,6 +2395,16 @@ pub(crate) mod parsing {
         }
     }
 
+    #[cfg(feature = "full")]
+    fn expr_become(input: ParseStream) -> Result<Expr> {
+        let begin = input.fork();
+        input.parse::<Token![become]>()?;
+        if can_begin_expr(input) {
+            input.parse::<Expr>()?;
+        }
+        Ok(Expr::Verbatim(verbatim::between(&begin, input)))
+    }
+
     #[cfg(feature = "full")]
     #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
     impl Parse for ExprTryBlock {