feat(rust-tyck): unary expr support

Author: Ray Redondo

rust/src/sema/mir.rs

@@ -451,6 +451,7 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Ctor(_)
             | ThirExprInner::BinaryExpr(_, _, _)
             | ThirExprInner::Array(_)
+            | ThirExprInner::UnaryExpr(_, _)
             | ThirExprInner::Index(_, _) => todo!(),
         }
     }
@@ -596,6 +597,7 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Ctor(_)
             | ThirExprInner::BinaryExpr(_, _, _)
             | ThirExprInner::Array(_)
+            | ThirExprInner::UnaryExpr(_, _)
             | ThirExprInner::Index(_, _) => unreachable!("cannot access"),
         }
     }
@@ -741,6 +743,7 @@ impl<'a> MirConverter<'a> {
             super::tyck::ThirExprInner::MemberAccess(_, _) => {
                 panic!("only top level rvalues get lowered by `lower_expr`")
             }
+            super::tyck::ThirExprInner::UnaryExpr(_, _) => todo!("unary expr"),
         }
     }
 
@@ -892,7 +895,8 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Ctor(_)
             | ThirExprInner::BinaryExpr(_, _, _)
             | ThirExprInner::Array(_)
-            | ThirExprInner::Index(_, _) => unreachable!(),
+            | ThirExprInner::Index(_, _)
+            | ThirExprInner::UnaryExpr(_, _) => unreachable!(),
         }
 
         Ok(())

rust/src/sema/tyck.rs

@@ -1,7 +1,7 @@
 use xlang::abi::collection::{HashMap, HashSet};
 
 use crate::{
-    ast::{self, Mutability, Safety, StringType},
+    ast::{self, Mutability, Safety, StringType, UnaryOp},
     helpers::{CyclicOperationStatus, FetchIncrement, TabPrinter},
     interning::Symbol,
     span::Span,
@@ -82,6 +82,10 @@ pub enum ThirExprInner {
     Tuple(Vec<Spanned<ThirExpr>>),
     Ctor(Spanned<ThirConstructor>),
     MemberAccess(Box<Spanned<ThirExpr>>, Spanned<FieldName>),
+    UnaryExpr(
+        Spanned<UnaryOp>,
+        Box<Spanned<ThirExpr>>,
+    ),
     BinaryExpr(
         Spanned<BinaryOp>,
         Box<Spanned<ThirExpr>>,
@@ -176,6 +180,9 @@ impl core::fmt::Display for ThirExprInner {
             ThirExprInner::BinaryExpr(op, lhs, rhs) => {
                 write!(f, "({} {} {})", lhs.body, op.body, rhs.body)
             }
+            ThirExprInner::UnaryExpr(op, val) => {
+                write!(f, "({}{})", op.body, val.body)
+            }
             ThirExprInner::Array(elements) => {
                 write!(f, "[")?;
                 let mut sep = "";
@@ -673,7 +680,16 @@ impl<'a> ThirConverter<'a> {
 
                 Ok(ThirExpr { ty, cat, inner })
             }
-            hir::HirExpr::UnaryExpr(_, _) => todo!("unary op"),
+            hir::HirExpr::UnaryExpr(op, val) => {
+                let val = self.convert_rvalue(val)?;
+                let ty = match &val.ty {
+                    Type::Int(x) => Type::Int(*x),
+                    Type::Float(x) => Type::Float(*x),
+                    Type::InferableInt(x) => Type::InferableInt(*x),
+                    _ => Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                };
+                Ok(ThirExpr { ty, cat: ValueCategory::Rvalue, inner: ThirExprInner::UnaryExpr(*op, Box::new(val)) })
+            }
             hir::HirExpr::BinaryExpr(op, lhs, rhs) => {
                 let lhs = self.convert_rvalue(lhs)?;
                 let rhs = self.convert_rvalue(rhs)?;
@@ -1100,6 +1116,10 @@ impl<'a> Inferer<'a> {
             ThirExprInner::Index(base, index) => {
                 todo!("index")
             }
+            ThirExprInner::UnaryExpr(op, val) => {
+                status &= self.unify_types(&mut left.ty, &mut val.ty)?;
+                status &= self.unify_single_expr(val)?;
+            }
         }
 
         Ok(status)