change parse_Foo so that it expects to consume entire input;

later we'll make a version called `resume_Foo` or something that
lets you supply the initial state (lookbehind, lookahead, etc)
in its entirety

lalrpop-test/src/loc.rs

@@ -6,12 +6,18 @@ pub fn parse_Items<
     __TOKENS: IntoIterator<Item=(usize,Tok,usize)>,
 >(
     __tokens: __TOKENS,
-) -> Result<(Option<(usize,Tok,usize)>, Vec<(usize, usize)>), Option<(usize,Tok,usize)>>
+) -> Result<Vec<(usize, usize)>, Option<(usize,Tok,usize)>>
 {
     let mut __tokens = __tokens.into_iter();
     let __lookahead = __tokens.next();
     match try!(__parse__Items::__state0(None, __lookahead, &mut __tokens)) {
-        (_, __lookahead, __parse__Items::__Nonterminal::____Items(__nt)) => Ok((__lookahead, __nt)),
+        (_, __lookahead, __parse__Items::__Nonterminal::____Items(__nt)) => {
+            if __lookahead.is_some() {
+                Err(__lookahead)
+            } else {
+                Ok(__nt)
+            }
+        }
         _ => unreachable!(),
     }
 }
@@ -22,11 +28,11 @@ mod __parse__Items {
     use util::tok::Tok;
 
     pub enum __Nonterminal<> {
-        _40_3e(usize),
-        ____Items(Vec<(usize, usize)>),
         Items(Vec<(usize, usize)>),
+        ____Items(Vec<(usize, usize)>),
         Spanned_3c_22_2b_22_3e((usize, usize)),
         _40_3c(usize),
+        _40_3e(usize),
     }
 
     // State 0
@@ -45,11 +51,11 @@ mod __parse__Items {
     //   __Items = (*) Items [EOF]
     //
     //   EOF -> Reduce(@< =  => Lookahead;)
-    //   "-" -> Reduce(@< =  => Lookahead;)
     //   "+" -> Reduce(@< =  => Lookahead;)
+    //   "-" -> Reduce(@< =  => Lookahead;)
     //
-    //   Items -> S2
+    //   @< -> S2
-    //   @< -> S1
+    //   Items -> S1
     pub fn __state0<
         __TOKENS: Iterator<Item=(usize,Tok,usize)>,
     >(
@@ -64,11 +70,11 @@ mod __parse__Items {
                 let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                 __result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
             }
-            Some((_, Tok::Minus(..), _)) => {
+            Some((_, Tok::Plus(..), _)) => {
                 let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                 __result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
             }
-            Some((_, Tok::Plus(..), _)) => {
+            Some((_, Tok::Minus(..), _)) => {
                 let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                 __result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
             }
@@ -79,11 +85,11 @@ mod __parse__Items {
         loop {
             let (__lookbehind, __lookahead, __nt) = __result;
             match __nt {
-                __Nonterminal::Items(__nt) => {
+                __Nonterminal::_40_3c(__nt) => {
                     let __sym0 = &mut Some(__nt);
                     __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
                 }
-                __Nonterminal::_40_3c(__nt) => {
+                __Nonterminal::Items(__nt) => {
                     let __sym0 = &mut Some(__nt);
                     __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
                 }
@@ -95,6 +101,74 @@ mod __parse__Items {
     }
 
     // State 1
+    //   @< = (*) ["+"]
+    //   Items = Items (*) Spanned<"+"> [EOF]
+    //   Items = Items (*) Spanned<"+"> ["+"]
+    //   Items = Items (*) Spanned<"+"> ["-"]
+    //   Items = Items (*) "-" [EOF]
+    //   Items = Items (*) "-" ["+"]
+    //   Items = Items (*) "-" ["-"]
+    //   Spanned<"+"> = (*) @< "+" @> [EOF]
+    //   Spanned<"+"> = (*) @< "+" @> ["+"]
+    //   Spanned<"+"> = (*) @< "+" @> ["-"]
+    //   __Items = Items (*) [EOF]
+    //
+    //   "+" -> Reduce(@< =  => Lookahead;)
+    //   EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
+    //   "-" -> Shift(S3)
+    //
+    //   Spanned<"+"> -> S5
+    //   @< -> S4
+    pub fn __state1<
+        __TOKENS: Iterator<Item=(usize,Tok,usize)>,
+    >(
+        __lookbehind: Option<usize>,
+        __lookahead: Option<(usize,Tok,usize)>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<Vec<(usize, usize)>>,
+    ) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
+    {
+        let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
+        match __lookahead {
+            Some((_, __tok @ Tok::Minus(..), __loc)) => {
+                let mut __lookbehind = Some(__loc);
+                let mut __sym1 = &mut Some((__tok));
+                let __lookahead = __tokens.next();
+                __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
+            }
+            Some((_, Tok::Plus(..), _)) => {
+                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
+                __result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
+            }
+            None => {
+                let __sym0 = __sym0.take().unwrap();
+                let __nt = super::__action0(__sym0);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::____Items(__nt)));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+        while __sym0.is_some() {
+            let (__lookbehind, __lookahead, __nt) = __result;
+            match __nt {
+                __Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
+                    let __sym1 = &mut Some(__nt);
+                    __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
+                }
+                __Nonterminal::_40_3c(__nt) => {
+                    let __sym1 = &mut Some(__nt);
+                    __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym1));
+                }
+                _ => {
+                    return Ok((__lookbehind, __lookahead, __nt));
+                }
+            }
+        }
+        return Ok(__result);
+    }
+
+    // State 2
     //   @> = (*) [EOF]
     //   @> = (*) ["+"]
     //   @> = (*) ["-"]
@@ -106,8 +180,8 @@ mod __parse__Items {
     //   "+" -> Reduce(@> =  => Lookbehind;)
     //   "-" -> Reduce(@> =  => Lookbehind;)
     //
-    //   @> -> S3
+    //   @> -> S6
-    pub fn __state1<
+    pub fn __state2<
         __TOKENS: Iterator<Item=(usize,Tok,usize)>,
     >(
         __lookbehind: Option<usize>,
@@ -139,75 +213,7 @@ mod __parse__Items {
             match __nt {
                 __Nonterminal::_40_3e(__nt) => {
                     let __sym1 = &mut Some(__nt);
-                    __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
+                    __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
-                }
-                _ => {
-                    return Ok((__lookbehind, __lookahead, __nt));
-                }
-            }
-        }
-        return Ok(__result);
-    }
-
-    // State 2
-    //   @< = (*) ["+"]
-    //   Items = Items (*) Spanned<"+"> [EOF]
-    //   Items = Items (*) Spanned<"+"> ["+"]
-    //   Items = Items (*) Spanned<"+"> ["-"]
-    //   Items = Items (*) "-" [EOF]
-    //   Items = Items (*) "-" ["+"]
-    //   Items = Items (*) "-" ["-"]
-    //   Spanned<"+"> = (*) @< "+" @> [EOF]
-    //   Spanned<"+"> = (*) @< "+" @> ["+"]
-    //   Spanned<"+"> = (*) @< "+" @> ["-"]
-    //   __Items = Items (*) [EOF]
-    //
-    //   "-" -> Shift(S5)
-    //   EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
-    //   "+" -> Reduce(@< =  => Lookahead;)
-    //
-    //   @< -> S6
-    //   Spanned<"+"> -> S4
-    pub fn __state2<
-        __TOKENS: Iterator<Item=(usize,Tok,usize)>,
-    >(
-        __lookbehind: Option<usize>,
-        __lookahead: Option<(usize,Tok,usize)>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<Vec<(usize, usize)>>,
-    ) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
-    {
-        let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
-        match __lookahead {
-            Some((_, __tok @ Tok::Minus(..), __loc)) => {
-                let mut __lookbehind = Some(__loc);
-                let mut __sym1 = &mut Some((__tok));
-                let __lookahead = __tokens.next();
-                __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
-            }
-            None => {
-                let __sym0 = __sym0.take().unwrap();
-                let __nt = super::__action0(__sym0);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::____Items(__nt)));
-            }
-            Some((_, Tok::Plus(..), _)) => {
-                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
-                __result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-        while __sym0.is_some() {
-            let (__lookbehind, __lookahead, __nt) = __result;
-            match __nt {
-                __Nonterminal::_40_3c(__nt) => {
-                    let __sym1 = &mut Some(__nt);
-                    __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
-                }
-                __Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
-                    let __sym1 = &mut Some(__nt);
-                    __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
                 }
                 _ => {
                     return Ok((__lookbehind, __lookahead, __nt));
@@ -218,105 +224,15 @@ mod __parse__Items {
     }
 
     // State 3
-    //   Items = @< @> (*) [EOF]
-    //   Items = @< @> (*) ["+"]
-    //   Items = @< @> (*) ["-"]
-    //
-    //   "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
-    //   "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
-    //   EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
-    //
-    pub fn __state3<
-        __TOKENS: Iterator<Item=(usize,Tok,usize)>,
-    >(
-        __lookbehind: Option<usize>,
-        __lookahead: Option<(usize,Tok,usize)>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<usize>,
-        __sym1: &mut Option<usize>,
-    ) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
-    {
-        let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
-        match __lookahead {
-            Some((_, Tok::Plus(..), _)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __nt = super::__action1(__sym0, __sym1);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
-            }
-            Some((_, Tok::Minus(..), _)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __nt = super::__action1(__sym0, __sym1);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
-            }
-            None => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __nt = super::__action1(__sym0, __sym1);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-    }
-
-    // State 4
-    //   Items = Items Spanned<"+"> (*) [EOF]
-    //   Items = Items Spanned<"+"> (*) ["+"]
-    //   Items = Items Spanned<"+"> (*) ["-"]
-    //
-    //   "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
-    //   EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
-    //   "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
-    //
-    pub fn __state4<
-        __TOKENS: Iterator<Item=(usize,Tok,usize)>,
-    >(
-        __lookbehind: Option<usize>,
-        __lookahead: Option<(usize,Tok,usize)>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<Vec<(usize, usize)>>,
-        __sym1: &mut Option<(usize, usize)>,
-    ) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
-    {
-        let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
-        match __lookahead {
-            Some((_, Tok::Minus(..), _)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __nt = super::__action2(__sym0, __sym1);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
-            }
-            None => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __nt = super::__action2(__sym0, __sym1);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
-            }
-            Some((_, Tok::Plus(..), _)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __nt = super::__action2(__sym0, __sym1);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-    }
-
-    // State 5
     //   Items = Items "-" (*) [EOF]
     //   Items = Items "-" (*) ["+"]
     //   Items = Items "-" (*) ["-"]
     //
-    //   EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
     //   "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
+    //   EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
     //   "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
     //
-    pub fn __state5<
+    pub fn __state3<
         __TOKENS: Iterator<Item=(usize,Tok,usize)>,
     >(
         __lookbehind: Option<usize>,
@@ -328,13 +244,13 @@ mod __parse__Items {
     {
         let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
         match __lookahead {
-            None => {
+            Some((_, Tok::Minus(..), _)) => {
                 let __sym0 = __sym0.take().unwrap();
                 let __sym1 = __sym1.take().unwrap();
                 let __nt = super::__action3(__sym0, __sym1);
                 return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
             }
-            Some((_, Tok::Minus(..), _)) => {
+            None => {
                 let __sym0 = __sym0.take().unwrap();
                 let __sym1 = __sym1.take().unwrap();
                 let __nt = super::__action3(__sym0, __sym1);
@@ -352,14 +268,14 @@ mod __parse__Items {
         }
     }
 
-    // State 6
+    // State 4
     //   Spanned<"+"> = @< (*) "+" @> [EOF]
     //   Spanned<"+"> = @< (*) "+" @> ["+"]
     //   Spanned<"+"> = @< (*) "+" @> ["-"]
     //
     //   "+" -> Shift(S7)
     //
-    pub fn __state6<
+    pub fn __state4<
         __TOKENS: Iterator<Item=(usize,Tok,usize)>,
     >(
         __lookbehind: Option<usize>,
@@ -383,6 +299,96 @@ mod __parse__Items {
         return Ok(__result);
     }
 
+    // State 5
+    //   Items = Items Spanned<"+"> (*) [EOF]
+    //   Items = Items Spanned<"+"> (*) ["+"]
+    //   Items = Items Spanned<"+"> (*) ["-"]
+    //
+    //   "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
+    //   "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
+    //   EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
+    //
+    pub fn __state5<
+        __TOKENS: Iterator<Item=(usize,Tok,usize)>,
+    >(
+        __lookbehind: Option<usize>,
+        __lookahead: Option<(usize,Tok,usize)>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<Vec<(usize, usize)>>,
+        __sym1: &mut Option<(usize, usize)>,
+    ) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
+    {
+        let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
+        match __lookahead {
+            Some((_, Tok::Plus(..), _)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __nt = super::__action2(__sym0, __sym1);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
+            }
+            Some((_, Tok::Minus(..), _)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __nt = super::__action2(__sym0, __sym1);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
+            }
+            None => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __nt = super::__action2(__sym0, __sym1);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+    }
+
+    // State 6
+    //   Items = @< @> (*) [EOF]
+    //   Items = @< @> (*) ["+"]
+    //   Items = @< @> (*) ["-"]
+    //
+    //   "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
+    //   EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
+    //   "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
+    //
+    pub fn __state6<
+        __TOKENS: Iterator<Item=(usize,Tok,usize)>,
+    >(
+        __lookbehind: Option<usize>,
+        __lookahead: Option<(usize,Tok,usize)>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<usize>,
+        __sym1: &mut Option<usize>,
+    ) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
+    {
+        let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
+        match __lookahead {
+            Some((_, Tok::Minus(..), _)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __nt = super::__action1(__sym0, __sym1);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
+            }
+            None => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __nt = super::__action1(__sym0, __sym1);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
+            }
+            Some((_, Tok::Plus(..), _)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __nt = super::__action1(__sym0, __sym1);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+    }
+
     // State 7
     //   @> = (*) [EOF]
     //   @> = (*) ["+"]
@@ -391,8 +397,8 @@ mod __parse__Items {
     //   Spanned<"+"> = @< "+" (*) @> ["+"]
     //   Spanned<"+"> = @< "+" (*) @> ["-"]
     //
-    //   EOF -> Reduce(@> =  => Lookbehind;)
     //   "-" -> Reduce(@> =  => Lookbehind;)
+    //   EOF -> Reduce(@> =  => Lookbehind;)
     //   "+" -> Reduce(@> =  => Lookbehind;)
     //
     //   @> -> S8
@@ -408,11 +414,11 @@ mod __parse__Items {
     {
         let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
         match __lookahead {
-            None => {
+            Some((_, Tok::Minus(..), _)) => {
                 let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                 __result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
             }
-            Some((_, Tok::Minus(..), _)) => {
+            None => {
                 let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                 __result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
             }
@@ -445,8 +451,8 @@ mod __parse__Items {
     //   Spanned<"+"> = @< "+" @> (*) ["-"]
     //
     //   "+" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
-    //   EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
     //   "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
+    //   EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
     //
     pub fn __state8<
         __TOKENS: Iterator<Item=(usize,Tok,usize)>,
@@ -468,14 +474,14 @@ mod __parse__Items {
                 let __nt = super::__action4(__sym0, __sym1, __sym2);
                 return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
             }
-            None => {
+            Some((_, Tok::Minus(..), _)) => {
                 let __sym0 = __sym0.take().unwrap();
                 let __sym1 = __sym1.take().unwrap();
                 let __sym2 = __sym2.take().unwrap();
                 let __nt = super::__action4(__sym0, __sym1, __sym2);
                 return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
             }
-            Some((_, Tok::Minus(..), _)) => {
+            None => {
                 let __sym0 = __sym0.take().unwrap();
                 let __sym1 = __sym1.take().unwrap();
                 let __sym2 = __sym2.take().unwrap();

lalrpop-test/src/sub.rs

@@ -6,12 +6,18 @@ pub fn parse_S<
     __TOKENS: IntoIterator<Item=Tok>,
 >(
     __tokens: __TOKENS,
-) -> Result<(Option<Tok>, i32), Option<Tok>>
+) -> Result<i32, Option<Tok>>
 {
     let mut __tokens = __tokens.into_iter();
     let __lookahead = __tokens.next();
     match try!(__parse__S::__state0(None, __lookahead, &mut __tokens)) {
-        (_, __lookahead, __parse__S::__Nonterminal::____S(__nt)) => Ok((__lookahead, __nt)),
+        (_, __lookahead, __parse__S::__Nonterminal::____S(__nt)) => {
+            if __lookahead.is_some() {
+                Err(__lookahead)
+            } else {
+                Ok(__nt)
+            }
+        }
         _ => unreachable!(),
     }
 }
@@ -22,10 +28,10 @@ mod __parse__S {
     use util::tok::Tok;
 
     pub enum __Nonterminal<> {
-        ____S(i32),
-        T(i32),
         E(i32),
         S(i32),
+        ____S(i32),
+        T(i32),
     }
 
     // State 0
@@ -40,12 +46,12 @@ mod __parse__S {
     //   T = (*) "Num" ["-"]
     //   __S = (*) S [EOF]
     //
-    //   "(" -> Shift(S2)
+    //   "Num" -> Shift(S5)
-    //   "Num" -> Shift(S3)
+    //   "(" -> Shift(S3)
     //
     //   S -> S1
+    //   T -> S2
     //   E -> S4
-    //   T -> S5
     pub fn __state0<
         __TOKENS: Iterator<Item=Tok>,
     >(
@@ -56,16 +62,16 @@ mod __parse__S {
     {
         let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
         match __lookahead {
-            Some(__tok @ Tok::LParen(..)) => {
-                let mut __lookbehind = None;
-                let mut __sym0 = &mut Some((__tok));
-                let __lookahead = __tokens.next();
-                __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
-            }
             Some(Tok::Num(__tok0)) => {
                 let mut __lookbehind = None;
                 let mut __sym0 = &mut Some((__tok0));
                 let __lookahead = __tokens.next();
+                __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
+            }
+            Some(__tok @ Tok::LParen(..)) => {
+                let mut __lookbehind = None;
+                let mut __sym0 = &mut Some((__tok));
+                let __lookahead = __tokens.next();
                 __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
             }
             _ => {
@@ -79,14 +85,14 @@ mod __parse__S {
                     let __sym0 = &mut Some(__nt);
                     __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
                 }
+                __Nonterminal::T(__nt) => {
+                    let __sym0 = &mut Some(__nt);
+                    __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
+                }
                 __Nonterminal::E(__nt) => {
                     let __sym0 = &mut Some(__nt);
                     __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
                 }
-                __Nonterminal::T(__nt) => {
-                    let __sym0 = &mut Some(__nt);
-                    __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
-                }
                 _ => {
                     return Ok((__lookbehind, __lookahead, __nt));
                 }
@@ -122,77 +128,14 @@ mod __parse__S {
     }
 
     // State 2
-    //   E = (*) E "-" T [")"]
+    //   E = T (*) [EOF]
-    //   E = (*) E "-" T ["-"]
+    //   E = T (*) ["-"]
-    //   E = (*) T [")"]
-    //   E = (*) T ["-"]
-    //   T = (*) "(" E ")" [")"]
-    //   T = (*) "(" E ")" ["-"]
-    //   T = "(" (*) E ")" [EOF]
-    //   T = "(" (*) E ")" ["-"]
-    //   T = (*) "Num" [")"]
-    //   T = (*) "Num" ["-"]
     //
-    //   "Num" -> Shift(S9)
+    //   "-" -> Reduce(E = T => Call(ActionFn(3));)
-    //   "(" -> Shift(S8)
+    //   EOF -> Reduce(E = T => Call(ActionFn(3));)
     //
-    //   E -> S7
-    //   T -> S6
     pub fn __state2<
         __TOKENS: Iterator<Item=Tok>,
-    >(
-        __lookbehind: Option<()>,
-        __lookahead: Option<Tok>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<Tok>,
-    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
-    {
-        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
-        match __lookahead {
-            Some(Tok::Num(__tok0)) => {
-                let mut __lookbehind = None;
-                let mut __sym1 = &mut Some((__tok0));
-                let __lookahead = __tokens.next();
-                __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
-            }
-            Some(__tok @ Tok::LParen(..)) => {
-                let mut __lookbehind = None;
-                let mut __sym1 = &mut Some((__tok));
-                let __lookahead = __tokens.next();
-                __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-        while __sym0.is_some() {
-            let (__lookbehind, __lookahead, __nt) = __result;
-            match __nt {
-                __Nonterminal::E(__nt) => {
-                    let __sym1 = &mut Some(__nt);
-                    __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
-                }
-                __Nonterminal::T(__nt) => {
-                    let __sym1 = &mut Some(__nt);
-                    __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
-                }
-                _ => {
-                    return Ok((__lookbehind, __lookahead, __nt));
-                }
-            }
-        }
-        return Ok(__result);
-    }
-
-    // State 3
-    //   T = "Num" (*) [EOF]
-    //   T = "Num" (*) ["-"]
-    //
-    //   "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
-    //   EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
-    //
-    pub fn __state3<
-        __TOKENS: Iterator<Item=Tok>,
     >(
         __lookbehind: Option<()>,
         __lookahead: Option<Tok>,
@@ -204,13 +147,13 @@ mod __parse__S {
         match __lookahead {
             Some(Tok::Minus(..)) => {
                 let __sym0 = __sym0.take().unwrap();
-                let __nt = super::__action4(__sym0);
+                let __nt = super::__action3(__sym0);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
+                return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
             }
             None => {
                 let __sym0 = __sym0.take().unwrap();
-                let __nt = super::__action4(__sym0);
+                let __nt = super::__action3(__sym0);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
+                return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
             }
             _ => {
                 return Err(__lookahead);
@@ -218,6 +161,69 @@ mod __parse__S {
         }
     }
 
+    // State 3
+    //   E = (*) E "-" T [")"]
+    //   E = (*) E "-" T ["-"]
+    //   E = (*) T [")"]
+    //   E = (*) T ["-"]
+    //   T = (*) "(" E ")" [")"]
+    //   T = (*) "(" E ")" ["-"]
+    //   T = "(" (*) E ")" [EOF]
+    //   T = "(" (*) E ")" ["-"]
+    //   T = (*) "Num" [")"]
+    //   T = (*) "Num" ["-"]
+    //
+    //   "(" -> Shift(S7)
+    //   "Num" -> Shift(S9)
+    //
+    //   T -> S6
+    //   E -> S8
+    pub fn __state3<
+        __TOKENS: Iterator<Item=Tok>,
+    >(
+        __lookbehind: Option<()>,
+        __lookahead: Option<Tok>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<Tok>,
+    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
+    {
+        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
+        match __lookahead {
+            Some(__tok @ Tok::LParen(..)) => {
+                let mut __lookbehind = None;
+                let mut __sym1 = &mut Some((__tok));
+                let __lookahead = __tokens.next();
+                __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
+            }
+            Some(Tok::Num(__tok0)) => {
+                let mut __lookbehind = None;
+                let mut __sym1 = &mut Some((__tok0));
+                let __lookahead = __tokens.next();
+                __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+        while __sym0.is_some() {
+            let (__lookbehind, __lookahead, __nt) = __result;
+            match __nt {
+                __Nonterminal::T(__nt) => {
+                    let __sym1 = &mut Some(__nt);
+                    __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
+                }
+                __Nonterminal::E(__nt) => {
+                    let __sym1 = &mut Some(__nt);
+                    __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
+                }
+                _ => {
+                    return Ok((__lookbehind, __lookahead, __nt));
+                }
+            }
+        }
+        return Ok(__result);
+    }
+
     // State 4
     //   E = E (*) "-" T [EOF]
     //   E = E (*) "-" T ["-"]
@@ -256,11 +262,11 @@ mod __parse__S {
     }
 
     // State 5
-    //   E = T (*) [EOF]
+    //   T = "Num" (*) [EOF]
-    //   E = T (*) ["-"]
+    //   T = "Num" (*) ["-"]
     //
-    //   "-" -> Reduce(E = T => Call(ActionFn(3));)
+    //   "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
-    //   EOF -> Reduce(E = T => Call(ActionFn(3));)
+    //   EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
     //
     pub fn __state5<
         __TOKENS: Iterator<Item=Tok>,
@@ -275,13 +281,13 @@ mod __parse__S {
         match __lookahead {
             Some(Tok::Minus(..)) => {
                 let __sym0 = __sym0.take().unwrap();
-                let __nt = super::__action3(__sym0);
+                let __nt = super::__action4(__sym0);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
+                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
             }
             None => {
                 let __sym0 = __sym0.take().unwrap();
-                let __nt = super::__action3(__sym0);
+                let __nt = super::__action4(__sym0);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
+                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
             }
             _ => {
                 return Err(__lookahead);
@@ -324,46 +330,6 @@ mod __parse__S {
     }
 
     // State 7
-    //   E = E (*) "-" T [")"]
-    //   E = E (*) "-" T ["-"]
-    //   T = "(" E (*) ")" [EOF]
-    //   T = "(" E (*) ")" ["-"]
-    //
-    //   "-" -> Shift(S11)
-    //   ")" -> Shift(S12)
-    //
-    pub fn __state7<
-        __TOKENS: Iterator<Item=Tok>,
-    >(
-        __lookbehind: Option<()>,
-        __lookahead: Option<Tok>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<Tok>,
-        __sym1: &mut Option<i32>,
-    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
-    {
-        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
-        match __lookahead {
-            Some(__tok @ Tok::Minus(..)) => {
-                let mut __lookbehind = None;
-                let mut __sym2 = &mut Some((__tok));
-                let __lookahead = __tokens.next();
-                __result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
-            }
-            Some(__tok @ Tok::RParen(..)) => {
-                let mut __lookbehind = None;
-                let mut __sym2 = &mut Some((__tok));
-                let __lookahead = __tokens.next();
-                __result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-        return Ok(__result);
-    }
-
-    // State 8
     //   E = (*) E "-" T [")"]
     //   E = (*) E "-" T ["-"]
     //   E = (*) T [")"]
@@ -376,11 +342,11 @@ mod __parse__S {
     //   T = (*) "Num" ["-"]
     //
     //   "Num" -> Shift(S9)
-    //   "(" -> Shift(S8)
+    //   "(" -> Shift(S7)
     //
-    //   E -> S13
     //   T -> S6
-    pub fn __state8<
+    //   E -> S11
+    pub fn __state7<
         __TOKENS: Iterator<Item=Tok>,
     >(
         __lookbehind: Option<()>,
@@ -401,7 +367,7 @@ mod __parse__S {
                 let mut __lookbehind = None;
                 let mut __sym1 = &mut Some((__tok));
                 let __lookahead = __tokens.next();
-                __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
+                __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
             }
             _ => {
                 return Err(__lookahead);
@@ -410,14 +376,14 @@ mod __parse__S {
         while __sym0.is_some() {
             let (__lookbehind, __lookahead, __nt) = __result;
             match __nt {
-                __Nonterminal::E(__nt) => {
-                    let __sym1 = &mut Some(__nt);
-                    __result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
-                }
                 __Nonterminal::T(__nt) => {
                     let __sym1 = &mut Some(__nt);
                     __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
                 }
+                __Nonterminal::E(__nt) => {
+                    let __sym1 = &mut Some(__nt);
+                    __result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
+                }
                 _ => {
                     return Ok((__lookbehind, __lookahead, __nt));
                 }
@@ -426,6 +392,46 @@ mod __parse__S {
         return Ok(__result);
     }
 
+    // State 8
+    //   E = E (*) "-" T [")"]
+    //   E = E (*) "-" T ["-"]
+    //   T = "(" E (*) ")" [EOF]
+    //   T = "(" E (*) ")" ["-"]
+    //
+    //   "-" -> Shift(S12)
+    //   ")" -> Shift(S13)
+    //
+    pub fn __state8<
+        __TOKENS: Iterator<Item=Tok>,
+    >(
+        __lookbehind: Option<()>,
+        __lookahead: Option<Tok>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<Tok>,
+        __sym1: &mut Option<i32>,
+    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
+    {
+        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
+        match __lookahead {
+            Some(__tok @ Tok::Minus(..)) => {
+                let mut __lookbehind = None;
+                let mut __sym2 = &mut Some((__tok));
+                let __lookahead = __tokens.next();
+                __result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
+            }
+            Some(__tok @ Tok::RParen(..)) => {
+                let mut __lookbehind = None;
+                let mut __sym2 = &mut Some((__tok));
+                let __lookahead = __tokens.next();
+                __result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+        return Ok(__result);
+    }
+
     // State 9
     //   T = "Num" (*) [")"]
     //   T = "Num" (*) ["-"]
@@ -468,8 +474,8 @@ mod __parse__S {
     //   T = (*) "Num" [EOF]
     //   T = (*) "Num" ["-"]
     //
-    //   "Num" -> Shift(S3)
+    //   "(" -> Shift(S3)
-    //   "(" -> Shift(S2)
+    //   "Num" -> Shift(S5)
     //
     //   T -> S14
     pub fn __state10<
@@ -484,17 +490,17 @@ mod __parse__S {
     {
         let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
         match __lookahead {
-            Some(Tok::Num(__tok0)) => {
-                let mut __lookbehind = None;
-                let mut __sym2 = &mut Some((__tok0));
-                let __lookahead = __tokens.next();
-                __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2));
-            }
             Some(__tok @ Tok::LParen(..)) => {
                 let mut __lookbehind = None;
                 let mut __sym2 = &mut Some((__tok));
                 let __lookahead = __tokens.next();
-                __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym2));
+                __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2));
+            }
+            Some(Tok::Num(__tok0)) => {
+                let mut __lookbehind = None;
+                let mut __sym2 = &mut Some((__tok0));
+                let __lookahead = __tokens.next();
+                __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym2));
             }
             _ => {
                 return Err(__lookahead);
@@ -516,110 +522,15 @@ mod __parse__S {
     }
 
     // State 11
-    //   E = E "-" (*) T [")"]
-    //   E = E "-" (*) T ["-"]
-    //   T = (*) "(" E ")" [")"]
-    //   T = (*) "(" E ")" ["-"]
-    //   T = (*) "Num" [")"]
-    //   T = (*) "Num" ["-"]
-    //
-    //   "(" -> Shift(S8)
-    //   "Num" -> Shift(S9)
-    //
-    //   T -> S15
-    pub fn __state11<
-        __TOKENS: Iterator<Item=Tok>,
-    >(
-        __lookbehind: Option<()>,
-        __lookahead: Option<Tok>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<i32>,
-        __sym1: &mut Option<Tok>,
-    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
-    {
-        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
-        match __lookahead {
-            Some(__tok @ Tok::LParen(..)) => {
-                let mut __lookbehind = None;
-                let mut __sym2 = &mut Some((__tok));
-                let __lookahead = __tokens.next();
-                __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym2));
-            }
-            Some(Tok::Num(__tok0)) => {
-                let mut __lookbehind = None;
-                let mut __sym2 = &mut Some((__tok0));
-                let __lookahead = __tokens.next();
-                __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym2));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-        while __sym1.is_some() {
-            let (__lookbehind, __lookahead, __nt) = __result;
-            match __nt {
-                __Nonterminal::T(__nt) => {
-                    let __sym2 = &mut Some(__nt);
-                    __result = try!(__state15(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
-                }
-                _ => {
-                    return Ok((__lookbehind, __lookahead, __nt));
-                }
-            }
-        }
-        return Ok(__result);
-    }
-
-    // State 12
-    //   T = "(" E ")" (*) [EOF]
-    //   T = "(" E ")" (*) ["-"]
-    //
-    //   "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
-    //   EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
-    //
-    pub fn __state12<
-        __TOKENS: Iterator<Item=Tok>,
-    >(
-        __lookbehind: Option<()>,
-        __lookahead: Option<Tok>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<Tok>,
-        __sym1: &mut Option<i32>,
-        __sym2: &mut Option<Tok>,
-    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
-    {
-        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
-        match __lookahead {
-            Some(Tok::Minus(..)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __sym2 = __sym2.take().unwrap();
-                let __nt = super::__action5(__sym0, __sym1, __sym2);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
-            }
-            None => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __sym2 = __sym2.take().unwrap();
-                let __nt = super::__action5(__sym0, __sym1, __sym2);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-    }
-
-    // State 13
     //   E = E (*) "-" T [")"]
     //   E = E (*) "-" T ["-"]
     //   T = "(" E (*) ")" [")"]
     //   T = "(" E (*) ")" ["-"]
     //
-    //   ")" -> Shift(S16)
+    //   ")" -> Shift(S15)
-    //   "-" -> Shift(S11)
+    //   "-" -> Shift(S12)
     //
-    pub fn __state13<
+    pub fn __state11<
         __TOKENS: Iterator<Item=Tok>,
     >(
         __lookbehind: Option<()>,
@@ -635,13 +546,13 @@ mod __parse__S {
                 let mut __lookbehind = None;
                 let mut __sym2 = &mut Some((__tok));
                 let __lookahead = __tokens.next();
-                __result = try!(__state16(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
+                __result = try!(__state15(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
             }
             Some(__tok @ Tok::Minus(..)) => {
                 let mut __lookbehind = None;
                 let mut __sym2 = &mut Some((__tok));
                 let __lookahead = __tokens.next();
-                __result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
+                __result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
             }
             _ => {
                 return Err(__lookahead);
@@ -650,12 +561,107 @@ mod __parse__S {
         return Ok(__result);
     }
 
+    // State 12
+    //   E = E "-" (*) T [")"]
+    //   E = E "-" (*) T ["-"]
+    //   T = (*) "(" E ")" [")"]
+    //   T = (*) "(" E ")" ["-"]
+    //   T = (*) "Num" [")"]
+    //   T = (*) "Num" ["-"]
+    //
+    //   "Num" -> Shift(S9)
+    //   "(" -> Shift(S7)
+    //
+    //   T -> S16
+    pub fn __state12<
+        __TOKENS: Iterator<Item=Tok>,
+    >(
+        __lookbehind: Option<()>,
+        __lookahead: Option<Tok>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<i32>,
+        __sym1: &mut Option<Tok>,
+    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
+    {
+        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
+        match __lookahead {
+            Some(Tok::Num(__tok0)) => {
+                let mut __lookbehind = None;
+                let mut __sym2 = &mut Some((__tok0));
+                let __lookahead = __tokens.next();
+                __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym2));
+            }
+            Some(__tok @ Tok::LParen(..)) => {
+                let mut __lookbehind = None;
+                let mut __sym2 = &mut Some((__tok));
+                let __lookahead = __tokens.next();
+                __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym2));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+        while __sym1.is_some() {
+            let (__lookbehind, __lookahead, __nt) = __result;
+            match __nt {
+                __Nonterminal::T(__nt) => {
+                    let __sym2 = &mut Some(__nt);
+                    __result = try!(__state16(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
+                }
+                _ => {
+                    return Ok((__lookbehind, __lookahead, __nt));
+                }
+            }
+        }
+        return Ok(__result);
+    }
+
+    // State 13
+    //   T = "(" E ")" (*) [EOF]
+    //   T = "(" E ")" (*) ["-"]
+    //
+    //   EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
+    //   "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
+    //
+    pub fn __state13<
+        __TOKENS: Iterator<Item=Tok>,
+    >(
+        __lookbehind: Option<()>,
+        __lookahead: Option<Tok>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<Tok>,
+        __sym1: &mut Option<i32>,
+        __sym2: &mut Option<Tok>,
+    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
+    {
+        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
+        match __lookahead {
+            None => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __sym2 = __sym2.take().unwrap();
+                let __nt = super::__action5(__sym0, __sym1, __sym2);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
+            }
+            Some(Tok::Minus(..)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __sym2 = __sym2.take().unwrap();
+                let __nt = super::__action5(__sym0, __sym1, __sym2);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+    }
+
     // State 14
     //   E = E "-" T (*) [EOF]
     //   E = E "-" T (*) ["-"]
     //
-    //   "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
     //   EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
+    //   "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
     //
     pub fn __state14<
         __TOKENS: Iterator<Item=Tok>,
@@ -670,14 +676,14 @@ mod __parse__S {
     {
         let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
         match __lookahead {
-            Some(Tok::Minus(..)) => {
+            None => {
                 let __sym0 = __sym0.take().unwrap();
                 let __sym1 = __sym1.take().unwrap();
                 let __sym2 = __sym2.take().unwrap();
                 let __nt = super::__action2(__sym0, __sym1, __sym2);
                 return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
             }
-            None => {
+            Some(Tok::Minus(..)) => {
                 let __sym0 = __sym0.take().unwrap();
                 let __sym1 = __sym1.take().unwrap();
                 let __sym2 = __sym2.take().unwrap();
@@ -691,13 +697,53 @@ mod __parse__S {
     }
 
     // State 15
+    //   T = "(" E ")" (*) [")"]
+    //   T = "(" E ")" (*) ["-"]
+    //
+    //   "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
+    //   ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
+    //
+    pub fn __state15<
+        __TOKENS: Iterator<Item=Tok>,
+    >(
+        __lookbehind: Option<()>,
+        __lookahead: Option<Tok>,
+        __tokens: &mut __TOKENS,
+        __sym0: &mut Option<Tok>,
+        __sym1: &mut Option<i32>,
+        __sym2: &mut Option<Tok>,
+    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
+    {
+        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
+        match __lookahead {
+            Some(Tok::Minus(..)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __sym2 = __sym2.take().unwrap();
+                let __nt = super::__action5(__sym0, __sym1, __sym2);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
+            }
+            Some(Tok::RParen(..)) => {
+                let __sym0 = __sym0.take().unwrap();
+                let __sym1 = __sym1.take().unwrap();
+                let __sym2 = __sym2.take().unwrap();
+                let __nt = super::__action5(__sym0, __sym1, __sym2);
+                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
+            }
+            _ => {
+                return Err(__lookahead);
+            }
+        }
+    }
+
+    // State 16
     //   E = E "-" T (*) [")"]
     //   E = E "-" T (*) ["-"]
     //
     //   ")" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
     //   "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
     //
-    pub fn __state15<
+    pub fn __state16<
         __TOKENS: Iterator<Item=Tok>,
     >(
         __lookbehind: Option<()>,
@@ -729,46 +775,6 @@ mod __parse__S {
             }
         }
     }
-
-    // State 16
-    //   T = "(" E ")" (*) [")"]
-    //   T = "(" E ")" (*) ["-"]
-    //
-    //   ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
-    //   "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
-    //
-    pub fn __state16<
-        __TOKENS: Iterator<Item=Tok>,
-    >(
-        __lookbehind: Option<()>,
-        __lookahead: Option<Tok>,
-        __tokens: &mut __TOKENS,
-        __sym0: &mut Option<Tok>,
-        __sym1: &mut Option<i32>,
-        __sym2: &mut Option<Tok>,
-    ) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
-    {
-        let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
-        match __lookahead {
-            Some(Tok::RParen(..)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __sym2 = __sym2.take().unwrap();
-                let __nt = super::__action5(__sym0, __sym1, __sym2);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
-            }
-            Some(Tok::Minus(..)) => {
-                let __sym0 = __sym0.take().unwrap();
-                let __sym1 = __sym1.take().unwrap();
-                let __sym2 = __sym2.take().unwrap();
-                let __nt = super::__action5(__sym0, __sym1, __sym2);
-                return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
-            }
-            _ => {
-                return Err(__lookahead);
-            }
-        }
-    }
 }
 
 pub fn __action0<

lalrpop-test/src/util/mod.rs

@@ -9,7 +9,7 @@ pub mod tok;
 pub fn test<R:Debug+Eq,F>(parse_fn: F,
                           input: &str,
                           expected: R)
-    where F: FnOnce(Vec<Tok>) -> Result<(Option<Tok>,R),Option<Tok>>
+    where F: FnOnce(Vec<Tok>) -> Result<R,Option<Tok>>
 {
     // create tokens
     let tokens = tok::tokenize(input);
@@ -17,11 +17,8 @@ pub fn test<R:Debug+Eq,F>(parse_fn: F,
     // filter to tokens
     let tokens = tokens.into_iter().map(|(_, tok, _)| tok).collect();
 
-    // parse
+    // parse, expecting input to be totally consumed
-    let (lookahead, r) = parse_fn(tokens).unwrap();
+    let r = parse_fn(tokens).unwrap();
-
-    // expect input to be completely consumed
-    assert!(lookahead.is_none(), "input not completely consumed");
 
     // expect output to be correct
     assert!(r == expected, "parsing {:?}, got {:#?}, expected {:#?}", input, r, expected);
@@ -30,17 +27,13 @@ pub fn test<R:Debug+Eq,F>(parse_fn: F,
 pub fn test_loc<R:Debug+Eq,F>(parse_fn: F,
                               input: &str,
                               expected: R)
-    where F: FnOnce(Vec<(usize, Tok, usize)>) -> Result<(Option<(usize, Tok, usize)>,R),
+    where F: FnOnce(Vec<(usize, Tok, usize)>) -> Result<R, Option<(usize, Tok, usize)>>
-                                                        Option<(usize, Tok, usize)>>
 {
     // create tokens
     let tokens = tok::tokenize(input);
 
-    // parse
+    // parse, expecting input to be totally consumed
-    let (lookahead, r) = parse_fn(tokens).unwrap();
+    let r = parse_fn(tokens).unwrap();
-
-    // expect input to be completely consumed
-    assert!(lookahead.is_none(), "input not completely consumed");
 
     // expect output to be correct
     assert!(r == expected, "parsing {:?}, got {:#?}, expected {:#?}", input, r, expected);

lalrpop/src/lr1/ascent.rs

@@ -103,6 +103,9 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
         Ok(())
     }
 
+    // Generates a function `parse_Foo` that will parse an entire
+    // input as `Foo`. An error is reported if the entire input is not
+    // consumed.
     fn write_start_fn(&mut self) -> io::Result<()> {
         let item_type = self.iterator_item_type();
         rust!(self.out, "#[allow(non_snake_case)]");
@@ -111,8 +114,8 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
             format!("parse_{}", self.user_start_symbol),
             vec![format!("{}TOKENS: IntoIterator<Item={}>", self.prefix, item_type)],
             vec![format!("{}tokens: {}TOKENS", self.prefix, self.prefix)],
-            format!("Result<(Option<{}>, {}), Option<{}>>",
+            format!("Result<{}, Option<{}>>",
-                    item_type, self.types.nonterminal_type(self.start_symbol), item_type),
+                    self.types.nonterminal_type(self.start_symbol), item_type),
             vec![]));
         rust!(self.out, "{{");
         rust!(self.out, "let mut {}tokens = {}tokens.into_iter();", self.prefix, self.prefix);
@@ -120,10 +123,15 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
         rust!(self.out, "match try!({}parse{}::{}state0({}None, {}lookahead, &mut {}tokens)) {{",
               self.prefix, self.start_symbol, self.prefix,
               self.grammar.user_parameter_refs(), self.prefix, self.prefix);
-        rust!(self.out, "(_, {}lookahead, {}parse{}::{}Nonterminal::{}({}nt)) => \
+        rust!(self.out, "(_, {}lookahead, {}parse{}::{}Nonterminal::{}({}nt)) => {{",
-                         Ok(({}lookahead, {}nt)),",
               self.prefix, self.prefix, self.start_symbol, self.prefix, Escape(self.start_symbol),
-              self.prefix, self.prefix, self.prefix);
+              self.prefix);
+        rust!(self.out, "if {}lookahead.is_some() {{", self.prefix);
+        rust!(self.out, "Err({}lookahead)", self.prefix); // extra tokens
+        rust!(self.out, "}} else {{");
+        rust!(self.out, "Ok({}nt)", self.prefix);
+        rust!(self.out, "}}");
+        rust!(self.out, "}}");
         rust!(self.out, "_ => unreachable!(),");
         rust!(self.out, "}}");
         rust!(self.out, "}}");