Improve detection of procedure declaration mistakes

Author: istathar

src/parsing/parser.rs

@@ -283,15 +283,12 @@ impl<'i> Parser<'i> {
                             .push(error);
                     }
                 }
-            } else if self
-                .source
-                .contains(':')
-            {
+            } else if potential_procedure_declaration(self.source) {
                 // It might be that we've encountered a malformed procedure
                 // declaration, so we try parsing it anyway to get a more
                 // specific error message.
                 match self.take_block_lines(
-                    |_| true, // Accept the line regardless
+                    potential_procedure_declaration,
                     |line| is_section(line) || potential_procedure_declaration(line),
                     |inner| inner.read_procedure(),
                 ) {
@@ -2580,24 +2577,37 @@ fn is_procedure_declaration(content: &str) -> bool {
 /// reporting what turns out to be a better error.
 fn potential_procedure_declaration(content: &str) -> bool {
     match content.split_once(':') {
-        Some((before, _after)) => {
+        Some((before, after)) => {
             let before = before.trim_ascii();
-            // Check if it looks like an identifier (possibly with parameters)
-            // Accept any single token that could be an attempted identifier
-            if let Some((name, params)) = before.split_once('(') {
-                // Has parameters: check if params end with ')'
-                !name
+
+            // Empty before colon -> only a declaration if there's something after
+            if before.is_empty() {
+                return !after
                     .trim_ascii()
-                    .is_empty()
-                    && params.ends_with(')')
-            } else {
-                // No parameters: must be a single token (no spaces) that
-                // looks identifier-ish This excludes sentences like "Ask
-                // these questions: ..."
-                !before.is_empty() &&
-                !before.contains(' ') &&  // Single token only
-                before.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
+                    .is_empty();
             }
+
+            // Has parentheses -> likely trying to be a procedure with parameters
+            if before.contains('(') {
+                return true;
+            }
+
+            // Check if it looks like prose vs an identifier attempt
+            // Prose typically: starts with capital, has multiple space-separated words
+            // Identifiers: lowercase, possibly with underscores
+            let first_char = before
+                .chars()
+                .next()
+                .unwrap();
+            let has_spaces = before.contains(' ');
+
+            // If it starts with uppercase AND has spaces, it's probably prose
+            if first_char.is_uppercase() && has_spaces {
+                return false;
+            }
+
+            // Otherwise, could be a procedure declaration attempt
+            true
         }
         None => false,
     }