add pretty diagnostics

src/ast/expr.rs

@@ -1,17 +1,27 @@
 use crate::ast::*;
 use crate::typing::Type;
 
+#[derive(Debug, PartialEq)]
+pub struct SExpr {
+    pub expr: Expr,
+    pub span: Span,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct BinaryExpression {
+    pub lhs: Box<SExpr>,
+    pub op: BinaryOperator,
+    pub op_span: Span,
+    pub rhs: Box<SExpr>,
+    pub typ: Type,
+}
+
 #[derive(Debug, PartialEq)]
 pub enum Expr {
-    BinaryExpression {
-        lhs: Box<Expr>,
-        op: BinaryOperator,
-        rhs: Box<Expr>,
-        typ: Type,
-    },
+    BinaryExpression(BinaryExpression),
     UnaryExpression {
         op: UnaryOperator,
-        inner: Box<Expr>,
+        inner: Box<SExpr>,
     },
     Identifier {
         name: String,
@@ -21,9 +31,9 @@ pub enum Expr {
     Block(Box<Block>),
     /// Last field is either Expr::Block or Expr::IfExpr
     IfExpr {
-        cond: Box<Expr>,
+        cond: Box<SExpr>,
         then_body: Box<Block>,
-        else_body: Box<Expr>,
+        else_body: Box<SExpr>,
         typ: Type,
     },
     // Literals
@@ -45,22 +55,12 @@ impl Block {
 impl Expr {
     pub fn ty(&self) -> Type {
         match self {
-            Expr::BinaryExpression {
-                lhs: _,
-                op: _,
-                rhs: _,
-                typ,
-            } => typ.clone(),
-            Expr::UnaryExpression { op: _, inner } => inner.ty(), // XXX: problems will arise here
-            Expr::Identifier { name: _, typ } => typ.clone(),
+            Expr::BinaryExpression(BinaryExpression { typ, .. }) => typ.clone(),
+            Expr::UnaryExpression { inner, .. } => inner.ty(), // XXX: problems will arise here
+            Expr::Identifier { typ, .. } => typ.clone(),
             Expr::Call(call) => call.typ.clone(),
             Expr::Block(block) => block.typ.clone(),
-            Expr::IfExpr {
-                cond: _,
-                then_body: _,
-                else_body: _,
-                typ,
-            } => typ.clone(),
+            Expr::IfExpr { typ, .. } => typ.clone(),
             Expr::UnitLiteral => Type::Unit,
             Expr::BooleanLiteral(_) => Type::Bool,
             Expr::IntegerLiteral(_) => Type::Int,
@@ -69,3 +69,10 @@ impl Expr {
         }
     }
 }
+
+impl SExpr {
+    #[inline]
+    pub fn ty(&self) -> Type {
+        self.expr.ty()
+    }
+}