Remove Lexer::line_continuations

magicant · May 22, 2021 · 334732a · 334732a
1 parent 0007547
commit 334732a
Show file tree

Hide file tree

Showing 9 changed files with 4 additions and 111 deletions.
diff --git a/yash-syntax/src/parser/core.rs b/yash-syntax/src/parser/core.rs
@@ -593,7 +593,6 @@ impl Parser<'_> {
     /// peeked.
     pub async fn has_blank(&mut self) -> Result<bool> {
         assert!(self.token.is_none(), "There should be no pending token");
-        self.lexer.line_continuations().await?;
         let c = self.lexer.peek_char().await?;
         Ok(c.map_or(false, |c| is_blank(c.value)))
     }

diff --git a/yash-syntax/src/parser/lex/arith.rs b/yash-syntax/src/parser/lex/arith.rs
@@ -52,7 +52,6 @@ impl Lexer {
         if !self.skip_if(|c| c == '(').await? {
             return Ok(Err(location));
         }
-        self.line_continuations().await?;
         if !self.skip_if(|c| c == '(').await? {
             self.rewind(index);
             return Ok(Err(location));
@@ -77,7 +76,6 @@ impl Lexer {
                 return Err(Error { cause, location });
             }
         }
-        self.line_continuations().await?;
         match self.peek_char().await? {
             Some(sc) if sc.value == ')' => self.consume_char(),
             Some(_) => {

diff --git a/yash-syntax/src/parser/lex/backquote.rs b/yash-syntax/src/parser/lex/backquote.rs
@@ -29,8 +29,6 @@ impl Lexer {
         &mut self,
         double_quote_escapable: bool,
     ) -> Result<Option<BackquoteUnit>> {
-        self.line_continuations().await?;
-
         if self.skip_if(|c| c == '\\').await? {
             let is_escapable =
                 |c| matches!(c, '$' | '`' | '\\') || c == '"' && double_quote_escapable;

diff --git a/yash-syntax/src/parser/lex/braced_param.rs b/yash-syntax/src/parser/lex/braced_param.rs
@@ -39,13 +39,11 @@ pub fn is_name_char(c: char) -> bool {
 impl Lexer {
     /// Consumes a length prefix (`#`) if any.
     async fn length_prefix(&mut self) -> Result<bool> {
-        self.line_continuations().await?;
         let index = self.index();
         if !self.skip_if(|c| c == '#').await? {
             return Ok(false);
         }
 
-        self.line_continuations().await?;
         if let Some(&SourceChar { value: '}', .. }) = self.peek_char().await? {
             self.rewind(index);
             Ok(false)
@@ -54,13 +52,6 @@ impl Lexer {
         }
     }
 
-    /// Consumes a POSIXly-portable name character optionally preceded by line
-    /// continuations.
-    async fn consume_name_char(&mut self) -> Result<Option<&SourceChar>> {
-        self.line_continuations().await?;
-        self.consume_char_if(is_name_char).await
-    }
-
     /// Parses a parameter expansion that is enclosed in braces.
     ///
     /// The initial `$` must have been consumed before calling this function.
@@ -85,8 +76,6 @@ impl Lexer {
 
         let has_length_prefix = self.length_prefix().await?;
 
-        self.line_continuations().await?;
-
         let sc = self.peek_char().await?.unwrap();
         let c = sc.value;
         let name = if is_special_parameter_char(c) {
@@ -95,7 +84,7 @@ impl Lexer {
         } else if is_name_char(c) {
             self.consume_char();
             let mut name = c.to_string();
-            while let Some(c) = self.consume_name_char().await? {
+            while let Some(c) = self.consume_char_if(is_name_char).await? {
                 name.push(c.value);
             }
             name
@@ -110,8 +99,6 @@ impl Lexer {
             return Err(Error { cause, location });
         };
 
-        self.line_continuations().await?;
-
         if !self.skip_if(|c| c == '}').await? {
             let opening_location = location;
             let cause = SyntaxError::UnclosedParam { opening_location }.into();

diff --git a/yash-syntax/src/parser/lex/dollar.rs b/yash-syntax/src/parser/lex/dollar.rs
@@ -36,8 +36,6 @@ impl Lexer {
             Some(c) => c.location.clone(),
         };
 
-        self.line_continuations().await?;
-
         let location = match self.raw_param(location).await? {
             Ok(result) => return Ok(Some(result)),
             Err(location) => location,

diff --git a/yash-syntax/src/parser/lex/misc.rs b/yash-syntax/src/parser/lex/misc.rs
@@ -34,25 +34,12 @@ impl Lexer {
         Ok(self.consume_char_if(f).await?.is_some())
     }
 
-    /// Skips line continuations, if any.
-    pub async fn line_continuations(&mut self) -> Result<()> {
-        async fn line_continuation(this: &mut Lexer) -> Result<Option<()>> {
-            let ok = this.skip_if(|c| c == '\\').await? && this.skip_if(|c| c == '\n').await?;
-            Ok(if ok { Some(()) } else { None })
-        }
-        self.many(line_continuation).await.map(drop)
-    }
-
     /// Skips blank characters until reaching a non-blank.
     ///
     /// This function also skips line continuations.
     pub async fn skip_blanks(&mut self) -> Result<()> {
-        loop {
-            self.line_continuations().await?;
-            if !self.skip_if(is_blank).await? {
-                break Ok(());
-            }
-        }
+        while self.skip_if(is_blank).await? {}
+        Ok(())
     }
 
     /// Skips a comment, if any.
@@ -85,68 +72,6 @@ mod tests {
     use crate::source::Source;
     use futures::executor::block_on;
 
-    #[test]
-    fn lexer_line_continuations_success() {
-        let mut lexer = Lexer::with_source(Source::Unknown, "\\\n");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-        assert_eq!(block_on(lexer.peek_char()), Ok(None));
-
-        let mut lexer = Lexer::with_source(Source::Unknown, "\\\n\\\n\\\n");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-        assert_eq!(block_on(lexer.peek_char()), Ok(None));
-    }
-
-    #[test]
-    fn lexer_line_continuations_empty() {
-        let mut lexer = Lexer::with_source(Source::Unknown, "");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-        assert_eq!(block_on(lexer.peek_char()), Ok(None));
-    }
-
-    #[test]
-    fn lexer_line_continuations_not_backslash() {
-        let mut lexer = Lexer::with_source(Source::Unknown, "\n");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-
-        let c = block_on(lexer.peek_char()).unwrap().unwrap();
-        assert_eq!(c.value, '\n');
-        assert_eq!(c.location.line.number.get(), 1);
-        assert_eq!(c.location.column.get(), 1);
-    }
-
-    #[test]
-    fn lexer_line_continuations_only_backslash() {
-        let mut lexer = Lexer::with_source(Source::Unknown, "\\");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-
-        let c = block_on(lexer.peek_char()).unwrap().unwrap();
-        assert_eq!(c.value, '\\');
-        assert_eq!(c.location.line.number.get(), 1);
-        assert_eq!(c.location.column.get(), 1);
-    }
-
-    #[test]
-    fn lexer_line_continuations_not_newline() {
-        let mut lexer = Lexer::with_source(Source::Unknown, "\\\\");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-
-        let c = block_on(lexer.peek_char()).unwrap().unwrap();
-        assert_eq!(c.value, '\\');
-        assert_eq!(c.location.line.number.get(), 1);
-        assert_eq!(c.location.column.get(), 1);
-    }
-
-    #[test]
-    fn lexer_line_continuations_partial_match_after_success() {
-        let mut lexer = Lexer::with_source(Source::Unknown, "\\\n\\\\");
-        assert!(block_on(lexer.line_continuations()).is_ok());
-
-        let c = block_on(lexer.peek_char()).unwrap().unwrap();
-        assert_eq!(c.value, '\\');
-        assert_eq!(c.location.line.number.get(), 2);
-        assert_eq!(c.location.column.get(), 1);
-    }
-
     #[test]
     fn lexer_skip_blanks() {
         let mut lexer = Lexer::with_source(Source::Unknown, " \t w");

diff --git a/yash-syntax/src/parser/lex/op.rs b/yash-syntax/src/parser/lex/op.rs
@@ -300,8 +300,6 @@ impl Lexer {
                 return Ok(None);
             }
 
-            self.line_continuations().await?;
-
             let sc = match self.peek_char().await? {
                 None => return Ok(None),
                 Some(sc) => sc.clone(),

diff --git a/yash-syntax/src/parser/lex/raw_param.rs b/yash-syntax/src/parser/lex/raw_param.rs
@@ -19,7 +19,6 @@
 use super::core::Lexer;
 use crate::parser::core::Result;
 use crate::source::Location;
-use crate::source::SourceChar;
 use crate::syntax::TextUnit;
 
 /// Tests if a character can be part of a POSIXly-portable name.
@@ -50,13 +49,6 @@ pub fn is_single_char_name(c: char) -> bool {
 }
 
 impl Lexer {
-    /// Consumes a POSIXly-portable name character optionally preceded by line
-    /// continuations.
-    async fn consume_portable_name_char(&mut self) -> Result<Option<&SourceChar>> {
-        self.line_continuations().await?;
-        self.consume_char_if(is_portable_name_char).await
-    }
-
     /// Parses a parameter expansion that is not enclosed in braces.
     ///
     /// The initial `$` must have been consumed before calling this function.
@@ -79,7 +71,7 @@ impl Lexer {
             Ok(Ok(TextUnit::RawParam { name, location }))
         } else if let Some(c) = self.consume_char_if(is_portable_name_char).await? {
             let mut name = c.value.to_string();
-            while let Some(c) = self.consume_portable_name_char().await? {
+            while let Some(c) = self.consume_char_if(is_portable_name_char).await? {
                 name.push(c.value);
             }
             Ok(Ok(TextUnit::RawParam { name, location }))

diff --git a/yash-syntax/src/parser/lex/text.rs b/yash-syntax/src/parser/lex/text.rs
@@ -53,8 +53,6 @@ impl Lexer {
         F: FnOnce(char) -> bool,
         G: FnOnce(char) -> bool,
     {
-        self.line_continuations().await?;
-
         if self.skip_if(|c| c == '\\').await? {
             if let Some(c) = self.consume_char_if(is_escapable).await? {
                 return Ok(Some(Backslashed(c.value)));