Refactor expect_previously_only_whitespace_until_newline to return a bool

- in `parse_go` we don't have a direct way to find what that previous non-whitespace token was, so the error message is adjusted accordingly

Author: aharpervc

src/dialect/mssql.rs

@@ -130,11 +130,7 @@ impl Dialect for MsSqlDialect {
     fn is_select_item_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
         // if we find maybe whitespace then a newline looking backward, then `GO` ISN'T a column alias
         // if we can't find a newline then we assume that `GO` IS a column alias
-        if kw == &Keyword::GO
-            && parser
-                .expect_previously_only_whitespace_until_newline()
-                .is_ok()
-        {
+        if kw == &Keyword::GO && parser.prev_only_whitespace_until_newline() {
             return false;
         }
 

src/parser/mod.rs

@@ -4591,35 +4591,26 @@ impl<'a> Parser<'a> {
     }
 
     /// Look backwards in the token stream and expect that there was only whitespace tokens until the previous newline or beginning of string
-    pub(crate) fn expect_previously_only_whitespace_until_newline(
-        &mut self,
-    ) -> Result<(), ParserError> {
+    pub(crate) fn prev_only_whitespace_until_newline(&mut self) -> bool {
         let mut look_back_count = 1;
         loop {
             let prev_token = self.peek_prev_nth_token_no_skip_ref(look_back_count);
             match prev_token.token {
-                Token::EOF => break,
+                Token::EOF => break true,
                 Token::Whitespace(ref w) => match w {
-                    Whitespace::Newline => break,
+                    Whitespace::Newline => break true,
                     // special consideration required for single line comments since that string includes the newline
                     Whitespace::SingleLineComment { comment, prefix: _ } => {
                         if comment.ends_with('\n') {
-                            break;
+                            break true;
                         }
                         look_back_count += 1;
                     }
                     _ => look_back_count += 1,
                 },
-                _ => self.expected(
-                    &format!(
-                        "newline before current token ({})",
-                        self.get_current_token()
-                    ),
-                    prev_token.clone(),
-                )?,
+                _ => break false,
             };
         }
-        Ok(())
     }
 
     /// If the current token is the `expected` keyword, consume it and returns
@@ -19707,7 +19698,12 @@ impl<'a> Parser<'a> {
         // select 1
         // go
         // ```
-        self.expect_previously_only_whitespace_until_newline()?;
+        if !self.prev_only_whitespace_until_newline() {
+            parser_err!(
+                "GO may only be preceded by whitespace on a line",
+                self.peek_token().span.start
+            )?;
+        }
 
         let count = loop {
             // using this peek function because we want to halt this statement parsing upon newline

tests/sqlparser_mssql.rs

@@ -2958,7 +2958,7 @@ fn parse_mssql_go_keyword() {
     let err = ms().parse_sql_statements(invalid_go_position);
     assert_eq!(
         err.unwrap_err().to_string(),
-        "sql parser error: Expected: newline before current token (GO), found: ;"
+        "sql parser error: GO may only be preceded by whitespace on a line"
     );
 
     let invalid_go_count = "SELECT 1\nGO x";