Fix VerbatimNotSupported error spans and corner case.

In the first case, the `end()` of VerbatimNotSupported's span was
continuing to the _next_ line because `parse_ws` matches newlines.

VerbatimNotSupported was triggering in one case where spaces occur
between `%%` and a newline. It should only trigger when spaces occur
at the beginning of a line.

Author: ratmice

lrlex/src/lib/parser.rs

@@ -27,6 +27,7 @@ lazy_static! {
     static ref RE_LEADING_LINE_SEPS: Regex = Regex::new(r"^[\p{Pattern_White_Space}&&[\p{Zl}\p{Zp}\n\r\v]]*").unwrap();
     // Horizontal space separators
     static ref RE_SPACE_SEP: Regex = Regex::new(r"[\p{Pattern_White_Space}&&[\p{Zs}\t]]").unwrap();
+    static ref RE_LEADING_SPACE_SEPS: Regex = Regex::new(r"^[\p{Pattern_White_Space}&&[\p{Zs}\t]]*").unwrap();
     static ref RE_LEADING_WS: Regex = Regex::new(r"^[\p{Pattern_White_Space}]*").unwrap();
     static ref RE_WS: Regex = Regex::new(r"\p{Pattern_White_Space}").unwrap();
 }
@@ -232,7 +233,7 @@ where
                 break Err(self.mk_error(LexErrorKind::PrematureEnd, i));
             }
             if let Some(j) = self.lookahead_is("%%", i) {
-                break Ok(j);
+                break Ok(self.parse_spaces(j)?);
             }
             i = self.parse_declaration(i, errs)?;
         }
@@ -365,15 +366,15 @@ where
             let j = self.parse_ws(i)?;
             if j != i {
                 let line_len = RE_LINE_SEP
-                    .find(&self.src[j..])
+                    .find(&self.src[i..])
                     .map(|m| m.start())
                     .unwrap_or(self.src.len() - j);
                 let err = LexBuildError {
                     kind: LexErrorKind::VerbatimNotSupported,
                     spans: vec![Span::new(i, i + line_len)],
                 };
                 errs.push(err);
-                i = j + line_len;
+                i += line_len;
                 continue;
             }
             if i == self.src.len() {
@@ -632,6 +633,13 @@ where
             .unwrap_or(i))
     }
 
+    fn parse_spaces(&mut self, i: usize) -> LexInternalBuildResult<usize> {
+        Ok(RE_LEADING_SPACE_SEPS
+            .find(&self.src[i..])
+            .map(|m| m.end() + i)
+            .unwrap_or(i))
+    }
+
     fn lookahead_is(&self, s: &'static str, i: usize) -> Option<usize> {
         if self.src[i..].starts_with(s) {
             Some(i + s.len())
@@ -1638,9 +1646,25 @@ b "A"
 "#;
         LRNonStreamingLexerDef::<DefaultLexerTypes<u8>>::from_str(src).unwrap();
         let src = r#"
+        %%  
+. "SpacesAfterPercentsDontError"
+"#;
+                LRNonStreamingLexerDef::<DefaultLexerTypes<u8>>::from_str(src).unwrap();
+        let src = r#"
 %%
  // Historical practice is that in the rules section entries starting with whitespace are copied verbatim into generated code. This is not supported.
 . "InitialWhitespaceDoError"
+"#;
+        LRNonStreamingLexerDef::<DefaultLexerTypes<u8>>::from_str(src).expect_error_at_line_col(
+            src,
+            LexErrorKind::VerbatimNotSupported,
+            3,
+            1,
+        );
+        let src = r#"
+%%
+    
+. "SpacesOnlyDoError"
 "#;
         LRNonStreamingLexerDef::<DefaultLexerTypes<u8>>::from_str(src).expect_error_at_line_col(
             src,