Improve error handling

4 files changed, 35 insertions, 45 deletions

diff --git a/src/syntax/expr.rs b/src/syntax/expr.rs
index 8562a3a4..1439cbdb 100644
--- a/src/syntax/expr.rs
+++ b/src/syntax/expr.rs
@@ -87,32 +87,24 @@ impl Expr {
 impl TypedNode for Expr {
     fn cast_from(node: RedRef) -> Option<Self> {
         match node.kind() {
-            NodeKind::Ident(_) => Some(Self::Ident(Ident::cast_from(node).unwrap())),
-            NodeKind::Array => Some(Self::Array(ArrayExpr::cast_from(node).unwrap())),
-            NodeKind::Dict => Some(Self::Dict(DictExpr::cast_from(node).unwrap())),
-            NodeKind::Template => {
-                Some(Self::Template(TemplateExpr::cast_from(node).unwrap()))
-            }
-            NodeKind::Group => Some(Self::Group(GroupExpr::cast_from(node).unwrap())),
-            NodeKind::Block => Some(Self::Block(BlockExpr::cast_from(node).unwrap())),
-            NodeKind::Unary => Some(Self::Unary(UnaryExpr::cast_from(node).unwrap())),
-            NodeKind::Binary => Some(Self::Binary(BinaryExpr::cast_from(node).unwrap())),
-            NodeKind::Call => Some(Self::Call(CallExpr::cast_from(node).unwrap())),
-            NodeKind::Closure => {
-                Some(Self::Closure(ClosureExpr::cast_from(node).unwrap()))
-            }
-            NodeKind::WithExpr => Some(Self::With(WithExpr::cast_from(node).unwrap())),
-            NodeKind::LetExpr => Some(Self::Let(LetExpr::cast_from(node).unwrap())),
-            NodeKind::IfExpr => Some(Self::If(IfExpr::cast_from(node).unwrap())),
-            NodeKind::WhileExpr => Some(Self::While(WhileExpr::cast_from(node).unwrap())),
-            NodeKind::ForExpr => Some(Self::For(ForExpr::cast_from(node).unwrap())),
-            NodeKind::ImportExpr => {
-                Some(Self::Import(ImportExpr::cast_from(node).unwrap()))
-            }
-            NodeKind::IncludeExpr => {
-                Some(Self::Include(IncludeExpr::cast_from(node).unwrap()))
-            }
-            _ => Some(Self::Lit(Lit::cast_from(node)?)),
+            NodeKind::Ident(_) => node.cast().map(Self::Ident),
+            NodeKind::Array => node.cast().map(Self::Array),
+            NodeKind::Dict => node.cast().map(Self::Dict),
+            NodeKind::Template => node.cast().map(Self::Template),
+            NodeKind::Group => node.cast().map(Self::Group),
+            NodeKind::Block => node.cast().map(Self::Block),
+            NodeKind::Unary => node.cast().map(Self::Unary),
+            NodeKind::Binary => node.cast().map(Self::Binary),
+            NodeKind::Call => node.cast().map(Self::Call),
+            NodeKind::Closure => node.cast().map(Self::Closure),
+            NodeKind::WithExpr => node.cast().map(Self::With),
+            NodeKind::LetExpr => node.cast().map(Self::Let),
+            NodeKind::IfExpr => node.cast().map(Self::If),
+            NodeKind::WhileExpr => node.cast().map(Self::While),
+            NodeKind::ForExpr => node.cast().map(Self::For),
+            NodeKind::ImportExpr => node.cast().map(Self::Import),
+            NodeKind::IncludeExpr => node.cast().map(Self::Include),
+            _ => node.cast().map(Self::Lit),
         }
     }
 }
diff --git a/src/syntax/markup.rs b/src/syntax/markup.rs
index de547f76..49b2a519 100644
--- a/src/syntax/markup.rs
+++ b/src/syntax/markup.rs
@@ -3,17 +3,14 @@ use crate::node;
 use crate::util::EcoString;
 use std::fmt::Write;
 
-/// The syntactical root capable of representing a full parsed document.
-pub type Markup = Vec<MarkupNode>;
-
-impl TypedNode for Markup {
-    fn cast_from(node: RedRef) -> Option<Self> {
-        if node.kind() != &NodeKind::Markup {
-            return None;
-        }
+node! {
+    /// The syntactical root capable of representing a full parsed document.
+    Markup
+}
 
-        let children = node.children().filter_map(TypedNode::cast_from).collect();
-        Some(children)
+impl Markup {
+    pub fn nodes<'a>(&'a self) -> impl Iterator<Item = MarkupNode> + 'a {
+        self.0.children().filter_map(RedRef::cast)
     }
 }
 
@@ -66,14 +63,12 @@ impl TypedNode for MarkupNode {
             NodeKind::NonBreakingSpace => {
                 Some(MarkupNode::Text(EcoString::from("\u{00A0}")))
             }
-            NodeKind::Raw(_) => Some(MarkupNode::Raw(RawNode::cast_from(node).unwrap())),
-            NodeKind::Heading => {
-                Some(MarkupNode::Heading(HeadingNode::cast_from(node).unwrap()))
-            }
-            NodeKind::List => Some(MarkupNode::List(ListNode::cast_from(node).unwrap())),
-            NodeKind::Enum => Some(MarkupNode::Enum(EnumNode::cast_from(node).unwrap())),
+            NodeKind::Raw(_) => node.cast().map(MarkupNode::Raw),
+            NodeKind::Heading => node.cast().map(MarkupNode::Heading),
+            NodeKind::List => node.cast().map(MarkupNode::List),
+            NodeKind::Enum => node.cast().map(MarkupNode::Enum),
             NodeKind::Error(_, _) => None,
-            _ => Some(MarkupNode::Expr(Expr::cast_from(node)?)),
+            _ => node.cast().map(MarkupNode::Expr),
         }
     }
 }
diff --git a/src/syntax/mod.rs b/src/syntax/mod.rs
index ca5b6a1b..afa0ab86 100644
--- a/src/syntax/mod.rs
+++ b/src/syntax/mod.rs
@@ -162,6 +162,8 @@ pub enum NodeKind {
     BlockComment,
     /// Tokens that appear in the wrong place.
     Error(ErrorPosition, EcoString),
+    /// Unknown character sequences.
+    Unknown(EcoString),
     /// Template markup.
     Markup,
     /// A forced line break: `\`.
@@ -375,10 +377,11 @@ impl NodeKind {
             Self::ImportExpr => "import expression",
             Self::ImportItems => "import items",
             Self::IncludeExpr => "include expression",
-            Self::Error(_, src) => match src.as_str() {
+            Self::Unknown(src) => match src.as_str() {
                 "*/" => "end of block comment",
                 _ => "invalid token",
             },
+            Self::Error(_, _) => "parse error",
         }
     }
 }
diff --git a/src/syntax/pretty.rs b/src/syntax/pretty.rs
index db364eaa..da0bdd44 100644
--- a/src/syntax/pretty.rs
+++ b/src/syntax/pretty.rs
@@ -82,7 +82,7 @@ impl Write for Printer {
 
 impl Pretty for Markup {
     fn pretty(&self, p: &mut Printer) {
-        for node in self {
+        for node in self.nodes() {
             node.pretty(p);
         }
     }