Detect errors in function and invocation names

Author: istathar

src/parsing/checks/errors.rs

@@ -239,6 +239,32 @@ making_coffee :
     );
 }
 
+#[test]
+fn invalid_function_with_space_in_name() {
+    expect_error(
+        r#"
+making_coffee :
+
+    1. Do something { re peat() }
+            "#
+        .trim_ascii(),
+        ParsingError::InvalidFunction(38, 0),
+    );
+}
+
+#[test]
+fn invalid_function_with_space_and_invocation() {
+    expect_error(
+        r#"
+making_coffee :
+
+    1. Do something { re peat <thing>() }
+            "#
+        .trim_ascii(),
+        ParsingError::InvalidFunction(38, 0),
+    );
+}
+
 #[test]
 fn invalid_invocation_in_repeat() {
     expect_error(

src/parsing/parser.rs

@@ -1396,7 +1396,20 @@ impl<'i> Parser<'i> {
             let invocation = self.read_invocation()?;
             Ok(Expression::Application(invocation))
         } else if is_function(content) {
-            let target = self.read_identifier()?;
+            // Extract the entire text before the opening parenthesis
+            self.trim_whitespace();
+            let content = self.source;
+            let paren = content
+                .find('(')
+                .unwrap(); // is_function() already checked
+            let text = &content[0..paren];
+
+            // Validate that the entire text is a valid identifier
+            let target = validate_identifier(text).ok_or(
+                ParsingError::InvalidFunction(self.offset, text.len()),
+            )?;
+
+            self.advance(text.len());
             let parameters = self.read_parameters()?;
 
             let function = Function { target, parameters };
@@ -1892,12 +1905,17 @@ impl<'i> Parser<'i> {
 
     /// Parse a target like <procedure_name> or <https://example.com/proc>
     fn read_target(&mut self) -> Result<Target<'i>, ParsingError> {
+        let start_offset = self.offset;
         self.take_block_chars("an invocation", '<', '>', true, |inner| {
-            let content = inner.source;
+            let content = inner
+                .source
+                .trim();
             if content.starts_with("https://") {
                 Ok(Target::Remote(External(content)))
             } else {
-                let identifier = inner.read_identifier()?;
+                let identifier = validate_identifier(content).ok_or_else(|| {
+                    ParsingError::InvalidInvocation(start_offset + 1, content.len())
+                })?;
                 Ok(Target::Local(identifier))
             }
         })