Add warnings from Block::parse

scouten · Sep 16, 2024 · fbb65de · fbb65de
1 parent 439cfab
commit fbb65de
Show file tree

Hide file tree

Showing 6 changed files with 138 additions and 49 deletions.
diff --git a/src/blocks/block.rs b/src/blocks/block.rs
@@ -4,6 +4,7 @@ use crate::{
     blocks::{ContentModel, IsBlock, MacroBlock, SectionBlock, SimpleBlock},
     span::MatchedItem,
     strings::CowStr,
+    warnings::{MatchAndWarnings, Warning},
     HasSpan, Span,
 };
 
@@ -40,43 +41,57 @@ impl<'src> Block<'src> {
     /// Parse a block of any type and return a `Block` that describes it.
     ///
     /// Consumes any blank lines before and after the block.
-    pub(crate) fn parse(source: Span<'src>) -> Option<MatchedItem<'src, Self>> {
+    pub(crate) fn parse(
+        source: Span<'src>,
+    ) -> MatchAndWarnings<'src, Option<MatchedItem<'src, Self>>> {
+        let mut warnings: Vec<Warning<'src>> = vec![];
         let source = source.discard_empty_lines();
 
         // Try to discern the block type by scanning the first line.
         let line = source.take_normalized_line();
         if line.item.contains("::") {
-            let macro_block_maw = MacroBlock::parse(source);
-            if let Some(macro_block) = macro_block_maw.item {
-                if !macro_block_maw.warnings.is_empty() {
-                    todo!("Propagate warnings up the chain");
-                }
+            let mut macro_block_maw = MacroBlock::parse(source);
+            if !macro_block_maw.warnings.is_empty() {
+                warnings.append(&mut macro_block_maw.warnings);
+            }
 
-                return Some(MatchedItem {
-                    item: Self::Macro(macro_block.item),
-                    after: macro_block.after,
-                });
+            if let Some(macro_block) = macro_block_maw.item {
+                return MatchAndWarnings {
+                    item: Some(MatchedItem {
+                        item: Self::Macro(macro_block.item),
+                        after: macro_block.after,
+                    }),
+                    warnings,
+                };
             }
 
             // A line containing `::` might be some other kind of block, so we
             // don't automatically error out on a parse failure.
-        } else if line.item.starts_with('=') {
+        }
+
+        if line.item.starts_with('=') {
             if let Some(section_block) = SectionBlock::parse(source) {
-                return Some(MatchedItem {
-                    item: Self::Section(section_block.item),
-                    after: section_block.after,
-                });
+                return MatchAndWarnings {
+                    item: Some(MatchedItem {
+                        item: Self::Section(section_block.item),
+                        after: section_block.after,
+                    }),
+                    warnings,
+                };
             }
 
             // A line starting with `=` might be some other kind of block, so we
             // don't automatically error out on a parse failure.
         }
 
-        // If no other block kind matches, we can always use SimpleBlock.
-        SimpleBlock::parse(source).map(|mi| MatchedItem {
-            item: Self::Simple(mi.item),
-            after: mi.after,
-        })
+        // If no other block kind matches, we can always use SimpleBlock.]
+        MatchAndWarnings {
+            item: SimpleBlock::parse(source).map(|mi| MatchedItem {
+                item: Self::Simple(mi.item),
+                after: mi.after,
+            }),
+            warnings,
+        }
     }
 }
 

diff --git a/src/blocks/parse_utils.rs b/src/blocks/parse_utils.rs
@@ -1,29 +1,51 @@
-use crate::{blocks::Block, span::MatchedItem, Span};
+use crate::{
+    blocks::Block,
+    span::MatchedItem,
+    warnings::{MatchAndWarnings, Warning},
+    Span,
+};
 
 /// Parse blocks until end of input or a pre-determined stop condition is
 /// reached.
 pub(crate) fn parse_blocks_until<'src, F>(
     mut source: Span<'src>,
     f: F,
-) -> Option<MatchedItem<'src, Vec<Block<'src>>>>
+) -> MatchAndWarnings<'src, Option<MatchedItem<'src, Vec<Block<'src>>>>>
 where
     F: Fn(&Span<'src>) -> bool,
 {
     let mut blocks: Vec<Block<'src>> = vec![];
+    let mut warnings: Vec<Warning<'src>> = vec![];
+
     source = source.discard_empty_lines();
 
     while !source.data().is_empty() {
         if f(&source) {
             break;
         }
 
-        let mi = Block::parse(source)?;
+        let mut maw = Block::parse(source);
+
+        if !maw.warnings.is_empty() {
+            warnings.append(&mut maw.warnings);
+        }
+
+        let Some(mi) = maw.item else {
+            return MatchAndWarnings {
+                item: None,
+                warnings,
+            };
+        };
+
         source = mi.after;
         blocks.push(mi.item);
     }
 
-    Some(MatchedItem {
-        item: blocks,
-        after: source,
-    })
+    MatchAndWarnings {
+        item: Some(MatchedItem {
+            item: blocks,
+            after: source,
+        }),
+        warnings,
+    }
 }
diff --git a/src/blocks/section.rs b/src/blocks/section.rs
@@ -26,8 +26,14 @@ impl<'src> SectionBlock<'src> {
     pub(crate) fn parse(source: Span<'src>) -> Option<MatchedItem<'src, Self>> {
         let source = source.discard_empty_lines();
         let level = parse_title_line(source)?;
-        let blocks =
-            parse_blocks_until(level.after, |i| peer_or_ancestor_section(*i, level.item.0))?;
+        let maw_blocks =
+            parse_blocks_until(level.after, |i| peer_or_ancestor_section(*i, level.item.0));
+
+        if !maw_blocks.warnings.is_empty() {
+            todo!("Propagate warnings up the chain");
+        }
+
+        let blocks = maw_blocks.item?;
         let source = source.trim_remainder(blocks.after);
 
         Some(MatchedItem {

diff --git a/src/document/document.rs b/src/document/document.rs
@@ -55,7 +55,13 @@ impl<'src> Document<'src> {
             (i, None)
         };
 
-        let blocks = parse_blocks_until(i, |_| false)?;
+        let maw_blocks = parse_blocks_until(i, |_| false);
+
+        if !maw_blocks.warnings.is_empty() {
+            todo!("Retain warnings");
+        }
+
+        let blocks = maw_blocks.item?;
 
         Some(Self {
             header,

diff --git a/src/tests/asciidoc_lang/blocks/index.rs b/src/tests/asciidoc_lang/blocks/index.rs
@@ -78,7 +78,10 @@ mod content_model {
         // simple:: a block that's treated as contiguous lines of paragraph text (and
         // subject to normal substitutions) (e.g., a paragraph block)
 
-        let block = Block::parse(Span::new("abc")).unwrap();
+        let block = Block::parse(Span::new("abc"))
+            .unwrap_if_no_warnings()
+            .unwrap();
+
         assert_eq!(block.item.content_model(), ContentModel::Simple);
     }
 
@@ -159,7 +162,9 @@ mod context {
         // distinguishes one kind of block from another. You can think of the context as
         // the block's type.
 
-        let mi = Block::parse(Span::new("== Section Title\n\nContent of section.")).unwrap();
+        let mi = Block::parse(Span::new("== Section Title\n\nContent of section."))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(mi.item.context().deref(), "section");
     }
@@ -195,7 +200,9 @@ mod context {
         // For example, all sections implicitly have the compound content model
         // because a section may only contain other blocks.
 
-        let mi = Block::parse(Span::new("== Section Title\n\nContent of section.")).unwrap();
+        let mi = Block::parse(Span::new("== Section Title\n\nContent of section."))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(mi.item.content_model(), ContentModel::Compound);
     }

diff --git a/src/tests/blocks/block.rs b/src/tests/blocks/block.rs
@@ -16,24 +16,33 @@ mod simple {
     #[test]
     fn impl_clone() {
         // Silly test to mark the #[derive(...)] line as covered.
-        let b1 = Block::parse(Span::new("abc")).unwrap();
+        let b1 = Block::parse(Span::new("abc"))
+            .unwrap_if_no_warnings()
+            .unwrap();
+
         let b2 = b1.item.clone();
         assert_eq!(b1.item, b2);
     }
 
     #[test]
     fn err_empty_source() {
-        assert!(Block::parse(Span::new("")).is_none());
+        assert!(Block::parse(Span::new(""))
+            .unwrap_if_no_warnings()
+            .is_none());
     }
 
     #[test]
     fn err_only_spaces() {
-        assert!(Block::parse(Span::new("    ")).is_none());
+        assert!(Block::parse(Span::new("    "))
+            .unwrap_if_no_warnings()
+            .is_none());
     }
 
     #[test]
     fn single_line() {
-        let mi = Block::parse(Span::new("abc")).unwrap();
+        let mi = Block::parse(Span::new("abc"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -72,7 +81,9 @@ mod simple {
 
     #[test]
     fn multiple_lines() {
-        let mi = Block::parse(Span::new("abc\ndef")).unwrap();
+        let mi = Block::parse(Span::new("abc\ndef"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -123,7 +134,9 @@ mod simple {
 
     #[test]
     fn consumes_blank_lines_after() {
-        let mi = Block::parse(Span::new("abc\n\ndef")).unwrap();
+        let mi = Block::parse(Span::new("abc\n\ndef"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -178,7 +191,9 @@ mod r#macro {
 
     #[test]
     fn err_inline_syntax() {
-        let mi = Block::parse(Span::new("foo:bar[]")).unwrap();
+        let mi = Block::parse(Span::new("foo:bar[]"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -228,7 +243,9 @@ mod r#macro {
 
     #[test]
     fn err_no_attr_list() {
-        let mi = Block::parse(Span::new("foo::bar")).unwrap();
+        let mi = Block::parse(Span::new("foo::bar"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -263,7 +280,9 @@ mod r#macro {
 
     #[test]
     fn err_attr_list_not_closed() {
-        let mi = Block::parse(Span::new("foo::bar[blah")).unwrap();
+        let mi = Block::parse(Span::new("foo::bar[blah"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -298,7 +317,9 @@ mod r#macro {
 
     #[test]
     fn err_unexpected_after_attr_list() {
-        let mi = Block::parse(Span::new("foo::bar[blah]bonus")).unwrap();
+        let mi = Block::parse(Span::new("foo::bar[blah]bonus"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -369,7 +390,9 @@ mod r#macro {
 
     #[test]
     fn simplest_block_macro() {
-        let mi = Block::parse(Span::new("foo::[]")).unwrap();
+        let mi = Block::parse(Span::new("foo::[]"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -426,7 +449,9 @@ mod r#macro {
 
     #[test]
     fn has_target() {
-        let mi = Block::parse(Span::new("foo::bar[]")).unwrap();
+        let mi = Block::parse(Span::new("foo::bar[]"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -484,7 +509,9 @@ mod r#macro {
 
     #[test]
     fn has_target_and_attrlist() {
-        let mi = Block::parse(Span::new("foo::bar[blah]")).unwrap();
+        let mi = Block::parse(Span::new("foo::bar[blah]"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -578,7 +605,9 @@ mod section {
 
     #[test]
     fn err_missing_space_before_title() {
-        let mi = Block::parse(Span::new("=blah blah")).unwrap();
+        let mi = Block::parse(Span::new("=blah blah"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(
             mi.item,
@@ -613,7 +642,9 @@ mod section {
 
     #[test]
     fn simplest_section_block() {
-        let mi = Block::parse(Span::new("== Section Title")).unwrap();
+        let mi = Block::parse(Span::new("== Section Title"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(mi.item.content_model(), ContentModel::Compound);
         assert_eq!(mi.item.context().deref(), "section");
@@ -653,7 +684,9 @@ mod section {
 
     #[test]
     fn has_child_block() {
-        let mi = Block::parse(Span::new("== Section Title\n\nabc")).unwrap();
+        let mi = Block::parse(Span::new("== Section Title\n\nabc"))
+            .unwrap_if_no_warnings()
+            .unwrap();
 
         assert_eq!(mi.item.content_model(), ContentModel::Compound);
         assert_eq!(mi.item.context().deref(), "section");