add error states for parsing tree and AST

This adds error states for `parse::Expression`, `ast::Expression`
`ResolvedType` and `AliasedType`.

Error recovery introduced by `chumsky` parser
require some default states to recover to, which was represented before
with
dummy values, like unit type for expression or alias with `error` name.
However, this kind of recovery is not desirable in case of further
analyzing of parse tree, because it would lead to unrecognazible errors
on analyzer.

Author: gerau

src/ast.rs

@@ -160,6 +160,13 @@ impl Expression {
     pub fn span(&self) -> &Span {
         &self.span
     }
+    pub fn error(span: Span) -> Self {
+        Self {
+            inner: ExpressionInner::Error,
+            ty: ResolvedType::error(),
+            span,
+        }
+    }
 }
 
 /// Variant of an expression.
@@ -171,6 +178,9 @@ pub enum ExpressionInner {
     /// Then, the block returns the value of its final expression.
     /// The block returns nothing (unit) if there is no final expression.
     Block(Arc<[Statement]>, Option<Arc<Expression>>),
+    /// An error expression state, which indicates that parser didn't recognize this expression or
+    /// analyzer failed to analyze this expression.
+    Error,
 }
 
 /// A single expression directly returns its value.
@@ -474,6 +484,7 @@ impl TreeLike for ExprTree<'_> {
                     Tree::Unary(Self::Block(statements, maybe_expr))
                 }
                 ExpressionInner::Single(single) => Tree::Unary(Self::Single(single)),
+                ExpressionInner::Error => Tree::Nullary,
             },
             Self::Block(statements, maybe_expr) => Tree::Nary(
                 statements
@@ -913,6 +924,7 @@ impl AbstractSyntaxTree for Expression {
                     span: *from.as_ref(),
                 })
             }
+            parse::ExpressionInner::Error => Ok(Self::error(*from.as_ref())),
         }
     }
 }

src/compile/mod.rs

@@ -294,6 +294,10 @@ impl Expression {
                 res
             }
             ExpressionInner::Single(e) => e.compile(scope),
+            ExpressionInner::Error => Err(Error::CannotCompile(
+                "Compiled from poisoned tree".to_string(),
+            )
+            .with_span(*self.as_ref())),
         }
     }
 }

src/parse.rs

@@ -288,6 +288,13 @@ impl Expression {
             span,
         }
     }
+
+    pub fn error(span: Span) -> Self {
+        Self {
+            inner: ExpressionInner::Error,
+            span,
+        }
+    }
 }
 
 impl_eq_hash!(Expression; inner);
@@ -301,6 +308,10 @@ pub enum ExpressionInner {
     /// Then, the block returns the value of its final expression.
     /// The block returns nothing (unit) if there is no final expression.
     Block(Arc<[Statement]>, Option<Arc<Expression>>),
+    /// An error expression state, which indicates that parser cannot recognize this expression.
+    /// Also tells an analyzer that we should skip analyzing this expression to not emmit more
+    /// errors.
+    Error,
 }
 
 /// A single expression directly returns a value.
@@ -399,7 +410,7 @@ impl Match {
             }
             (MatchPattern::None, MatchPattern::Some(_, ty_r)) => AliasedType::option(ty_r.clone()),
             (MatchPattern::False, MatchPattern::True) => AliasedType::boolean(),
-            _ => unreachable!("Match expressions have valid left and right arms"),
+            _ => AliasedType::error().with_span(*self.as_ref()),
         }
     }
 }
@@ -614,6 +625,7 @@ impl TreeLike for ExprTree<'_> {
                     Tree::Unary(Self::Block(statements, maybe_expr))
                 }
                 ExpressionInner::Single(single) => Tree::Unary(Self::Single(single)),
+                ExpressionInner::Error => Tree::Nullary,
             },
             Self::Block(statements, maybe_expr) => Tree::Nary(
                 statements
@@ -936,13 +948,7 @@ impl<A: ChumskyParse + std::fmt::Debug> ParseFromStrWithErrors for A {
 
         handler.update(parse_errs);
 
-        // TODO: We should return parsed result if we found errors, but because analyzing in `ast` module
-        // is not handling poisoned tree right now, we don't return parsed result
-        if handler.get().is_empty() {
-            ast
-        } else {
-            None
-        }
+        ast
     }
 }
 
@@ -1043,12 +1049,7 @@ impl ChumskyParse for AliasedType {
                     .then(ty.clone()),
                 Token::LAngle,
                 Token::RAngle,
-                |_| {
-                    (
-                        AliasedType::alias(AliasName::from_str_unchecked("error")),
-                        AliasedType::alias(AliasName::from_str_unchecked("error")),
-                    )
-                },
+                |_| (AliasedType::error(), AliasedType::error()),
             );
 
             let sum_type = just(Token::Ident("Either"))
@@ -1074,7 +1075,7 @@ impl ChumskyParse for AliasedType {
                     .map(|s: Vec<AliasedType>| AliasedType::tuple(s)),
                 Token::LParen,
                 Token::RParen,
-                |_| AliasedType::tuple(Vec::new()),
+                |_| AliasedType::error(),
             )
             .labelled("tuple");
 
@@ -1087,12 +1088,7 @@ impl ChumskyParse for AliasedType {
                     }),
                 Token::LBracket,
                 Token::RBracket,
-                |_| {
-                    AliasedType::array(
-                        AliasedType::alias(AliasName::from_str_unchecked("error")),
-                        0,
-                    )
-                },
+                |_| AliasedType::error(),
             )
             .labelled("array");
 
@@ -1114,18 +1110,13 @@ impl ChumskyParse for AliasedType {
                         })),
                     Token::LAngle,
                     Token::RAngle,
-                    |_| {
-                        (
-                            AliasedType::alias(AliasName::from_str_unchecked("error")),
-                            NonZeroPow2Usize::TWO,
-                        )
-                    },
+                    |_| (AliasedType::error(), NonZeroPow2Usize::TWO),
                 ))
                 .map(|(ty, size)| AliasedType::list(ty, size))
                 .labelled("List");
 
             choice((sum_type, option_type, tuple, array, list, atom))
-                .map_with(|inner, _| inner)
+                .map_with(|inner, e| inner.with_span(e.span()))
                 .labelled("type")
         })
     }
@@ -1165,7 +1156,7 @@ impl ChumskyParse for Item {
         let type_parser = TypeAlias::parser().map(Item::TypeAlias);
         let mod_parser = Module::parser().map(|_| Item::Module);
 
-        choice((func_parser, type_parser, mod_parser))
+        choice((func_parser, type_parser, mod_parser)).labelled("item")
     }
 }
 
@@ -1201,7 +1192,7 @@ impl ChumskyParse for Function {
                     (Token::LParen, Token::RParen),
                     (Token::LBracket, Token::RBracket),
                 ],
-                Expression::empty,
+                Expression::error,
             )))
             .labelled("function body");
 
@@ -1495,7 +1486,7 @@ impl ChumskyParse for Expression {
                         (Token::RAngle, Token::RAngle),
                         (Token::LBracket, Token::RBracket),
                     ],
-                    |span| Expression::empty(span).inner().clone(),
+                    |span| Expression::error(span).inner().clone(),
                 );
 
                 let statements = statement
@@ -1762,7 +1753,7 @@ impl Match {
                 }
                 _ => {
                     let match_arm_fallback = MatchArm {
-                        expression: Arc::new(Expression::empty(Span::new(0, 0))),
+                        expression: Arc::new(Expression::error(Span::new(0, 0))),
                         pattern: MatchPattern::False,
                     };
 

src/types.rs

@@ -28,6 +28,8 @@ pub enum TypeInner<A> {
     Array(A, usize),
     /// List of the same type
     List(A, NonZeroPow2Usize),
+    /// Error type
+    Error,
 }
 
 impl<A> TypeInner<A> {
@@ -86,6 +88,7 @@ impl<A> TypeInner<A> {
                     write!(f, ", {bound}>")
                 }
             },
+            TypeInner::Error => write!(f, "ERROR"),
         }
     }
 }
@@ -325,6 +328,14 @@ impl ResolvedType {
     pub fn as_inner(&self) -> &TypeInner<Arc<Self>> {
         &self.0
     }
+
+    pub const fn error() -> Self {
+        Self(TypeInner::Error)
+    }
+
+    pub fn is_error(&self) -> bool {
+        matches!(self.as_inner(), TypeInner::Error)
+    }
 }
 
 impl TypeConstructible for ResolvedType {
@@ -410,6 +421,7 @@ impl TreeLike for &ResolvedType {
             TypeInner::Option(l) | TypeInner::Array(l, _) | TypeInner::List(l, _) => Tree::Unary(l),
             TypeInner::Either(l, r) => Tree::Binary(l, r),
             TypeInner::Tuple(elements) => Tree::Nary(elements.iter().map(Arc::as_ref).collect()),
+            TypeInner::Error => Tree::Nullary,
         }
     }
 }
@@ -561,6 +573,10 @@ impl AliasedType {
         Self(self.0, span)
     }
 
+    pub fn error() -> Self {
+        Self::new(AliasedInner::Inner(TypeInner::Error))
+    }
+
     /// Create a type alias from the given `identifier`.
     pub const fn alias(name: AliasName) -> Self {
         Self::new(AliasedInner::Alias(name))
@@ -613,6 +629,7 @@ impl AliasedType {
                         let element = output.pop().unwrap();
                         output.push(ResolvedType::list(element, *bound));
                     }
+                    TypeInner::Error => return Ok(ResolvedType::error()),
                 },
             }
         }
@@ -724,6 +741,7 @@ impl TreeLike for &AliasedType {
                 TypeInner::Tuple(elements) => {
                     Tree::Nary(elements.iter().map(Arc::as_ref).collect())
                 }
+                TypeInner::Error => Tree::Nullary,
             },
         }
     }
@@ -1017,6 +1035,9 @@ impl From<&ResolvedType> for StructuralType {
                     let element = output.pop().unwrap();
                     output.push(StructuralType::list(element, *bound));
                 }
+                // Not sure what to put here, but it should not be unreachable in correctly builded
+                // AST.
+                TypeInner::Error => output.push(StructuralType::unit()),
             }
         }
         debug_assert_eq!(output.len(), 1);

src/value.rs

@@ -775,6 +775,7 @@ impl Value {
                         }
                     }
                 }
+                TypeInner::Error => return None,
             }
         }
         debug_assert_eq!(output.len(), 1);
@@ -836,6 +837,7 @@ impl crate::ArbitraryOfType for Value {
                     .collect::<arbitrary::Result<Vec<Self>>>()?;
                 Ok(Self::list(elements, ty.as_ref().clone(), *bound))
             }
+            TypeInner::Error => Self::arbitrary_of_type(u, &ResolvedType::error()),
         }
     }
 }
@@ -1159,6 +1161,7 @@ impl TreeLike for Destructor<'_> {
                 ),
                 None => Tree::Unary(Self::WrongType),
             },
+            TypeInner::Error => Tree::Nullary,
         }
     }
 }