commit e82a2b12daa709765ba3a2995e77607e579471c6
author David Tolnay <dtolnay@gmail.com> Thu Aug 30 16:31:10 2018 -0700
committer David Tolnay <dtolnay@gmail.com> Thu Aug 30 16:32:57 2018 -0700
tree 287827b023d680b5809e86b51a56edcddee176e8
parent 40c0611f5d8a25605e86dec1d40d7fec20d8358e

Update Parser trait to look like Parse

src/lib.rs

diff --git a/src/lib.rs b/src/lib.rs
index f3b13a1..51a7952 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -662,10 +662,7 @@
     feature = "parsing",
     feature = "proc-macro"
 ))]
-pub fn parse<T>(tokens: proc_macro::TokenStream) -> Result<T, Error>
-where
-    T: Synom,
-{
+pub fn parse<T: parse::Parse>(tokens: proc_macro::TokenStream) -> Result<T, Error> {
     parse2(tokens.into())
 }
 
@@ -682,10 +679,7 @@
 ///
 /// *This function is available if Syn is built with the `"parsing"` feature.*
 #[cfg(feature = "parsing")]
-pub fn parse2<T>(tokens: proc_macro2::TokenStream) -> Result<T, Error>
-where
-    T: Synom,
-{
+pub fn parse2<T: parse::Parse>(tokens: proc_macro2::TokenStream) -> Result<T, Error> {
     let parser = T::parse;
     parser.parse2(tokens).map_err(|err| match T::description() {
         Some(s) => Error::new(Span::call_site(), format!("failed to parse {}: {}", s, err)),
@@ -722,7 +716,7 @@
 /// # fn main() { run().unwrap() }
 /// ```
 #[cfg(feature = "parsing")]
-pub fn parse_str<T: Synom>(s: &str) -> Result<T, Error> {
+pub fn parse_str<T: parse::Parse>(s: &str) -> Result<T, Error> {
     match s.parse() {
         Ok(tts) => parse2(tts),
         Err(_) => Err(Error::new(

src/lit.rs

diff --git a/src/lit.rs b/src/lit.rs
index 5b2bf86..1b9efac 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -15,7 +15,7 @@
 #[cfg(feature = "parsing")]
 use proc_macro2::TokenStream;
 #[cfg(feature = "parsing")]
-use {Error, Synom};
+use Error;
 
 use proc_macro2::TokenTree;
 
@@ -24,6 +24,8 @@
 
 #[cfg(feature = "parsing")]
 use lookahead;
+#[cfg(feature = "parsing")]
+use parse::Parse;
 
 ast_enum_of_structs! {
     /// A Rust literal such as a string or integer or boolean.
@@ -125,7 +127,7 @@
     ///
     /// All spans in the syntax tree will point to the span of this `LitStr`.
     #[cfg(feature = "parsing")]
-    pub fn parse<T: Synom>(&self) -> Result<T, Error> {
+    pub fn parse<T: Parse>(&self) -> Result<T, Error> {
         use proc_macro2::Group;
 
         // Parse string literal into a token stream with every span equal to the

src/parse_quote.rs

diff --git a/src/parse_quote.rs b/src/parse_quote.rs
index 072b4f7..9d65555 100644
--- a/src/parse_quote.rs
+++ b/src/parse_quote.rs
@@ -88,8 +88,9 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Can parse any type that implements Synom.
 
-use proc_macro2::TokenStream;
 use parse::{Parse, ParseStream, Result};
+use proc_macro2::TokenStream;
+use synom::Parser;
 
 // Not public API.
 #[doc(hidden)]

src/synom.rs

diff --git a/src/synom.rs b/src/synom.rs
index 035b770..e39a534 100644
--- a/src/synom.rs
+++ b/src/synom.rs
@@ -313,21 +313,17 @@
 
 impl<F, T> Parser for F
 where
-    F: FnOnce(Cursor) -> PResult<T>,
+    F: FnOnce(ParseStream) -> Result<T>,
 {
     type Output = T;
 
     fn parse2(self, tokens: TokenStream) -> Result<T> {
         let buf = TokenBuffer::new2(tokens);
-        let (t, rest) = self(buf.begin())?;
-        if rest.eof() {
-            Ok(t)
-        } else if rest == buf.begin() {
-            // parsed nothing
-            Err(Error::new(Span::call_site(), "failed to parse anything"))
-        } else {
-            Err(Error::new(Span::call_site(), "failed to parse all tokens"))
-        }
+        let unexpected = Rc::new(Cell::new(None));
+        let state = ParseBuffer::new(Span::call_site(), buf.begin(), unexpected);
+        let node = self(&state)?;
+        state.check_unexpected()?;
+        Ok(node)
     }
 }