Error message if parenthesis missing binding multiple variables

Author: istathar

src/formatting/formatter.rs

@@ -127,6 +127,12 @@ pub fn render_invocation<'i>(invocation: &'i Invocation, renderer: &dyn Render)
     render_fragments(&sub.fragments, renderer)
 }
 
+pub fn render_descriptive<'i>(descriptive: &'i Descriptive, renderer: &dyn Render) -> String {
+    let mut sub = Formatter::new(78);
+    sub.append_descriptive(descriptive);
+    render_fragments(&sub.fragments, renderer)
+}
+
 pub fn render_function<'i>(function: &'i Function, renderer: &dyn Render) -> String {
     let mut sub = Formatter::new(78);
     sub.append_function(function);
@@ -584,7 +590,16 @@ impl<'i> Formatter<'i> {
         }
     }
 
-    fn append_descriptives(&mut self, descriptives: &'i Vec<Descriptive>) {
+    // This is a helper for rendering a single descriptives in error messages.
+    // The real method is append_decriptives() below; this method simply
+    // creates a single element slice that can be passed to it.
+    fn append_descriptive(&mut self, descriptive: &'i Descriptive) {
+        use std::slice;
+        let slice = slice::from_ref(descriptive);
+        self.append_descriptives(slice);
+    }
+
+    fn append_descriptives(&mut self, descriptives: &'i [Descriptive<'i>]) {
         let syntax = self.current;
         let mut line = self.builder();
 

src/parsing/parser.rs

@@ -32,6 +32,7 @@ pub enum ParsingError {
     UnexpectedEndOfInput(usize),
     Expected(usize, &'static str),
     ExpectedMatchingChar(usize, &'static str, char, char),
+    MissingParenthesis(usize),
     // more specific errors
     InvalidCharacter(usize, char),
     InvalidHeader(usize),
@@ -68,6 +69,7 @@ impl ParsingError {
             ParsingError::Unrecognized(offset) => *offset,
             ParsingError::Expected(offset, _) => *offset,
             ParsingError::ExpectedMatchingChar(offset, _, _, _) => *offset,
+            ParsingError::MissingParenthesis(offset) => *offset,
             ParsingError::UnclosedInterpolation(offset) => *offset,
             ParsingError::InvalidHeader(offset) => *offset,
             ParsingError::InvalidCharacter(offset, _) => *offset,
@@ -1297,6 +1299,15 @@ impl<'i> Parser<'i> {
 
         if is_binding(content) {
             self.read_binding_expression()
+        } else if malformed_binding_pattern(content) {
+            if let Some(tilde_pos) = self
+                .source
+                .find('~')
+            {
+                self.advance(tilde_pos + 1); // Move past ~
+                self.trim_whitespace();
+            }
+            return Err(ParsingError::MissingParenthesis(self.offset));
         } else if is_repeat_keyword(content) {
             self.read_repeat_expression()
         } else if is_foreach_keyword(content) {
@@ -2022,7 +2033,20 @@ impl<'i> Parser<'i> {
                                     if parser.peek_next_char() == Some('~') {
                                         parser.advance(1);
                                         parser.trim_whitespace();
+                                        let start_pos = parser.offset;
                                         let variable = parser.read_identifier()?;
+
+                                        // Check for malformed tuple binding (missing parentheses)
+                                        parser.trim_whitespace();
+                                        if parser
+                                            .source
+                                            .starts_with(',')
+                                        {
+                                            return Err(ParsingError::MissingParenthesis(
+                                                start_pos,
+                                            ));
+                                        }
+
                                         content.push(Descriptive::Binding(
                                             Box::new(Descriptive::Application(invocation)),
                                             vec![variable],
@@ -2049,7 +2073,19 @@ impl<'i> Parser<'i> {
                                     } else if parser.peek_next_char() == Some('~') {
                                         parser.advance(1);
                                         parser.trim_whitespace();
+                                        let start_pos = parser.offset;
                                         let variable = parser.read_identifier()?;
+
+                                        parser.trim_whitespace();
+                                        if parser
+                                            .source
+                                            .starts_with(',')
+                                        {
+                                            return Err(ParsingError::MissingParenthesis(
+                                                start_pos,
+                                            ));
+                                        }
+
                                         content.push(Descriptive::Binding(
                                             Box::new(Descriptive::Text(text)),
                                             vec![variable],
@@ -2705,6 +2741,12 @@ fn is_binding(content: &str) -> bool {
     re.is_match(content)
 }
 
+fn malformed_binding_pattern(content: &str) -> bool {
+    // Detect ~ identifier, identifier (missing parentheses)
+    let re = regex!(r"~\s+[a-z][a-z0-9_]*\s*,\s*[a-z]");
+    re.is_match(content)
+}
+
 fn is_step_dependent(content: &str) -> bool {
     let re = regex!(r"^\s*\d+\.\s+");
     re.is_match(content)

src/problem/messages.rs

@@ -35,6 +35,30 @@ there was no more input remaining in the current scope.
             .trim_ascii()
             .to_string(),
         ),
+        ParsingError::MissingParenthesis(_) => {
+            let examples = vec![Descriptive::Binding(
+                Box::new(Descriptive::Application(Invocation {
+                    target: Target::Local(Identifier("mix_pangalactic_gargle_blaster")),
+                    parameters: None,
+                })),
+                vec![Identifier("zaphod"), Identifier("trillian")],
+            )];
+
+            (
+                "Lists of binding variables must be enclosed in parentheses".to_string(),
+                format!(
+                    r#"
+If you bind the result of an invocation to more than one variable, you must
+enclose those names in parenthesis. For example:
+
+    {}
+                    "#,
+                    examples[0].present(renderer),
+                )
+                .trim_ascii()
+                .to_string(),
+            )
+        }
         ParsingError::UnclosedInterpolation(_) => (
             "Unclosed string interpolation".to_string(),
             r#"

src/problem/present.rs

@@ -70,6 +70,12 @@ impl Present for Invocation<'_> {
     }
 }
 
+impl Present for Descriptive<'_> {
+    fn present(&self, renderer: &dyn Render) -> String {
+        formatter::render_descriptive(self, renderer)
+    }
+}
+
 impl Present for Function<'_> {
     fn present(&self, renderer: &dyn Render) -> String {
         formatter::render_function(self, renderer)