fix some nice tests for the nullable_types

4 files changed, 14 insertions, 4 deletions

diff --git a/src/compiler.rs b/src/compiler.rs
index 47b8b84..4fdd13b 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -634,10 +634,11 @@ impl Compiler {
             Token::LeftParen => self.grouping_or_tuple(block),
             Token::Minus => self.unary(block),
 
-            Token::Float(_) => self.value(block),
-            Token::Int(_) => self.value(block),
-            Token::Bool(_) => self.value(block),
-            Token::String(_) => self.value(block),
+            Token::Float(_)
+                | Token::Int(_)
+                | Token::Bool(_)
+                | Token::String(_)
+                | Token::Nil => self.value(block),
 
             Token::Bang => self.unary(block),
 
@@ -676,6 +677,7 @@ impl Compiler {
             Token::Float(f) => { Value::Float(f) },
             Token::Int(i) => { Value::Int(i) }
             Token::Bool(b) => { Value::Bool(b) }
+            Token::Nil => { Value::Nil }
             Token::String(s) => { Value::String(Rc::from(s)) }
             _ => { error!(self, "Cannot parse value."); Value::Bool(false) }
         };
diff --git a/src/lib.rs b/src/lib.rs
index d0a45f6..e7c4a35 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -685,6 +685,7 @@ mod op {
             (Value::Unknown, a) | (a, Value::Unknown) if !matches!(a, Value::Unknown) => eq(a, a),
             (Value::Unknown, Value::Unknown) => Value::Unknown,
             (Value::Union(a), b) | (b, Value::Union(a)) => union_bin_op(&a, b, eq),
+            (Value::Nil, Value::Nil) => Value::Bool(true),
             _ => Value::Nil,
         }
     }
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index 6e142e3..664532a 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -15,6 +15,9 @@ pub enum Token {
     #[regex(r"[\d]+", |lex| lex.slice().parse())]
     Int(i64),
 
+    #[regex(r"nil")]
+    Nil,
+
     #[regex(r"true|false", |lex| lex.slice().parse(), priority=2)]
     Bool(bool),
 
diff --git a/src/vm.rs b/src/vm.rs
index 2859d83..0595639 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -669,6 +669,10 @@ impl VM {
                 let ty = self.ty(ty);
                 let top_type = self.stack.last().unwrap().into();
                 match (ty, top_type) {
+                    (a, b) if matches!(a, Type::Union(_)) && a == &b => {
+                        let last = self.stack.len() - 1;
+                        self.stack[last] = Value::from(a);
+                    }
                     (Type::Unknown, top_type)
                         if top_type != Type::Unknown => {}
                     (a, b) if a != &b => {