Merge pull request #1968 from dtolnay/receiver

Optimize parse_fn_arg_or_variadic for less lookahead on erroneous receiver

Author: dtolnay

src/item.rs

@@ -1607,8 +1607,9 @@ pub(crate) mod parsing {
         allow_variadic: bool,
     ) -> Result<FnArgOrVariadic> {
         let ahead = input.fork();
-        if let Ok(mut receiver) = ahead.parse::<Receiver>() {
+        if let Ok((reference, mutability, self_token)) = parse_receiver_begin(&ahead) {
             input.advance_to(&ahead);
+            let mut receiver = parse_rest_of_receiver(reference, mutability, self_token, input)?;
             receiver.attrs = attrs;
             return Ok(FnArgOrVariadic::FnArg(FnArg::Receiver(receiver)));
         }
@@ -1654,48 +1655,68 @@ pub(crate) mod parsing {
     #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
     impl Parse for Receiver {
         fn parse(input: ParseStream) -> Result<Self> {
-            let reference = if input.peek(Token![&]) {
-                let ampersand: Token![&] = input.parse()?;
-                let lifetime: Option<Lifetime> = input.parse()?;
-                Some((ampersand, lifetime))
-            } else {
-                None
-            };
-            let mutability: Option<Token![mut]> = input.parse()?;
-            let self_token: Token![self] = input.parse()?;
-            let colon_token: Option<Token![:]> = if reference.is_some() {
-                None
-            } else {
-                input.parse()?
-            };
-            let ty: Type = if colon_token.is_some() {
-                input.parse()?
-            } else {
-                let mut ty = Type::Path(TypePath {
-                    qself: None,
-                    path: Path::from(Ident::new("Self", self_token.span)),
-                });
-                if let Some((ampersand, lifetime)) = reference.as_ref() {
-                    ty = Type::Reference(TypeReference {
-                        and_token: Token![&](ampersand.span),
-                        lifetime: lifetime.clone(),
-                        mutability: mutability.as_ref().map(|m| Token![mut](m.span)),
-                        elem: Box::new(ty),
-                    });
-                }
-                ty
-            };
-            Ok(Receiver {
-                attrs: Vec::new(),
-                reference,
-                mutability,
-                self_token,
-                colon_token,
-                ty: Box::new(ty),
-            })
+            let (reference, mutability, self_token) = parse_receiver_begin(input)?;
+            parse_rest_of_receiver(reference, mutability, self_token, input)
         }
     }
 
+    fn parse_receiver_begin(
+        input: ParseStream,
+    ) -> Result<(
+        Option<(Token![&], Option<Lifetime>)>,
+        Option<Token![mut]>,
+        Token![self],
+    )> {
+        let reference = if input.peek(Token![&]) {
+            let ampersand: Token![&] = input.parse()?;
+            let lifetime: Option<Lifetime> = input.parse()?;
+            Some((ampersand, lifetime))
+        } else {
+            None
+        };
+        let mutability: Option<Token![mut]> = input.parse()?;
+        let self_token: Token![self] = input.parse()?;
+        Ok((reference, mutability, self_token))
+    }
+
+    fn parse_rest_of_receiver(
+        reference: Option<(Token![&], Option<Lifetime>)>,
+        mutability: Option<Token![mut]>,
+        self_token: Token![self],
+        input: ParseStream,
+    ) -> Result<Receiver> {
+        let colon_token: Option<Token![:]> = if reference.is_some() {
+            None
+        } else {
+            input.parse()?
+        };
+        let ty: Type = if colon_token.is_some() {
+            input.parse()?
+        } else {
+            let mut ty = Type::Path(TypePath {
+                qself: None,
+                path: Path::from(Ident::new("Self", self_token.span)),
+            });
+            if let Some((ampersand, lifetime)) = reference.as_ref() {
+                ty = Type::Reference(TypeReference {
+                    and_token: Token![&](ampersand.span),
+                    lifetime: lifetime.clone(),
+                    mutability: mutability.as_ref().map(|m| Token![mut](m.span)),
+                    elem: Box::new(ty),
+                });
+            }
+            ty
+        };
+        Ok(Receiver {
+            attrs: Vec::new(),
+            reference,
+            mutability,
+            self_token,
+            colon_token,
+            ty: Box::new(ty),
+        })
+    }
+
     fn parse_fn_args(
         input: ParseStream,
     ) -> Result<(Punctuated<FnArg, Token![,]>, Option<Variadic>)> {

tests/test_item.rs

@@ -1,3 +1,4 @@
+#![recursion_limit = "256"]
 #![allow(
     clippy::elidable_lifetime_names,
     clippy::needless_lifetimes,
@@ -314,3 +315,56 @@ fn test_impl_trait_trailing_plus() {
     }
     "#);
 }
+
+// Regression test for issue https://github.com/dtolnay/syn/issues/1967
+#[test]
+fn test_nested_receiver_classification() {
+    let tokens = quote! {
+        fn foo(
+            self: foo<{ fn foo(
+                self: foo<{ fn foo(
+                    self: foo<{ fn foo(
+                        self: foo<{ fn foo(
+                            self: foo<{ fn foo(
+                                self: foo<{ fn foo(
+                                    self: foo<{ fn foo(
+                                        self: foo<{ fn foo(
+                                            self: foo<{ fn foo(
+                                                self: foo<{ fn foo(
+                                                    self: foo<{ fn foo(
+                                                        self: foo<{ fn foo(
+                                                            self: foo<{ fn foo(
+                                                                self: foo<{ fn foo(
+                                                                    self: foo<{ fn foo(
+                                                                        self: foo<{ fn foo(
+                                                                            self: foo<{ fn foo(
+                                                                                self: foo<{ fn foo(
+                                                                                    self: foo<{ fn foo(
+                                                                                        self: foo<{ fn foo(
+                                                                                            self: foo<{ fn foo(
+                                                                                            )}>
+                                                                                        )}>
+                                                                                    )}>
+                                                                                )}>
+                                                                            )}>
+                                                                        )}>
+                                                                    )}>
+                                                                )}>
+                                                            )}>
+                                                        )}>
+                                                    )}>
+                                                )}>
+                                            )}>
+                                        )}>
+                                    )}>
+                                )}>
+                            )}>
+                        )}>
+                    )}>
+                )}>
+            )}>
+        ) {}
+    };
+
+    let _ = syn::parse2::<syn::File>(tokens);
+}