Prevent quotes in descriptive text being taken as literal

Author: istathar

src/parsing/checks/errors.rs

@@ -122,6 +122,27 @@ making_coffee Ingredients -> Coffee
     );
 }
 
+// Content a section cannot hold is reported, not quietly dropped on the
+// floor as it makes its way past
+#[test]
+fn unrecognized_content_in_section() {
+    expect_error(
+        r#"
+making_coffee :
+
+    1.  Boil the water
+
+I. Second Section
+
+    # Overview notes
+
+    1.  Pour it out
+            "#
+        .trim_ascii(),
+        ParsingError::Unrecognized(Span::new(64, 0)),
+    );
+}
+
 // A malformed declaration must end the procedure before it, rather than
 // being taken as description and swallowing the procedure that follows
 #[test]

src/parsing/checks/parser.rs

@@ -3328,6 +3328,40 @@ fn test_redundant_error_removal_unclosed_interpolation() {
     }
 }
 
+// A quote in descriptive text is punctuation the author wrote, here an inch
+// mark. It opens no literal, so it must not hide the code inline after it
+#[test]
+fn quote_in_descriptive_text() {
+    let mut input = Parser::new();
+
+    let source = r#"Measure the 6" pipe { record_it() } carefully."#;
+
+    input.initialize(source);
+    let result = input.read_descriptive();
+
+    let paragraphs = result.unwrap();
+    let descriptives = &paragraphs[0].0;
+
+    match &descriptives[0] {
+        Descriptive::Text(text) => assert_eq!(*text, "Measure the 6\" pipe"),
+        _ => panic!("First element should be text"),
+    }
+
+    match &descriptives[1] {
+        Descriptive::CodeInline(exprs) => {
+            let [Expression::Execution(func, _)] = exprs.as_slice() else {
+                panic!("Second element should be code inline with function execution");
+            };
+            assert_eq!(
+                func.target
+                    .value,
+                "record_it"
+            );
+        }
+        _ => panic!("Second element should be code inline"),
+    }
+}
+
 #[test]
 fn multiline_code_inline() {
     let mut input = Parser::new();

src/parsing/parser.rs

@@ -598,7 +598,33 @@ impl<'i> Parser<'i> {
             .map(|(i, _)| i)
             .unwrap_or(content.len());
 
-        let block = &content[..end_pos];
+        self.take_upto(end_pos, function)
+    }
+
+    /// As take_until(), but for descriptive text, which holds no literals. A
+    /// quote there is punctuation the author wrote, an old-fashioned mark for
+    /// the inch unit of measurement, or a quotation; none of which indicate a
+    /// run of text that needs to be masked.
+    fn take_text_until<A, F>(&mut self, pattern: &[char], function: F) -> Result<A, ParsingError>
+    where
+        F: Fn(&mut Parser<'i>) -> Result<A, ParsingError>,
+    {
+        let end_pos = self
+            .source
+            .find(pattern)
+            .unwrap_or(
+                self.source
+                    .len(),
+            );
+
+        self.take_upto(end_pos, function)
+    }
+
+    fn take_upto<A, F>(&mut self, end_pos: usize, function: F) -> Result<A, ParsingError>
+    where
+        F: Fn(&mut Parser<'i>) -> Result<A, ParsingError>,
+    {
+        let block = &self.source[..end_pos];
         let mut parser = self.subparser(0, block);
 
         // Pass to closure for processing
@@ -1405,7 +1431,9 @@ impl<'i> Parser<'i> {
                                 .push(error),
                         }
                     } else {
-                        // Skip non-procedure content line by line
+                        outer
+                            .problems
+                            .push(ParsingError::Unrecognized(Span::new(outer.offset, 0)));
                         outer.skip_to_next_line();
                     }
                 }
@@ -1444,7 +1472,9 @@ impl<'i> Parser<'i> {
                             line.len(),
                         )));
                     } else {
-                        // Skip unrecognized content line by line
+                        outer
+                            .problems
+                            .push(ParsingError::Unrecognized(Span::new(outer.offset, 0)));
                         outer.skip_to_next_line();
                     }
                 }
@@ -2628,7 +2658,7 @@ impl<'i> Parser<'i> {
                                     parser.advance(1);
                                     content.push(Descriptive::Text("$"));
                                 } else {
-                                    let text = parser.take_until(
+                                    let text = parser.take_text_until(
                                         &['{', '<', '$', '~', '\n'],
                                         |inner| {
                                             let content = inner