Type function works as a successful gate

Author: kajacx

crates/lust-lib/src/grammar/tokens/equals_op.rs

@@ -1,4 +1,7 @@
-use crate::grammar::LuaExpression;
+use crate::{
+    grammar::LuaExpression,
+    typecheck::{LustType, TypeGate},
+};
 
 #[derive(PartialEq, PartialOrd, Debug, Clone)]
 pub struct EqualsOperation {
@@ -13,6 +16,39 @@ impl EqualsOperation {
             right: Box::new(right),
         }
     }
+
+    pub fn get_type_gate(&self) -> Option<TypeGate> {
+        // panic!("Hellxo? {:?}", self);
+        // type(varname) == "string"
+        match (&*self.left, &*self.right) {
+            (LuaExpression::FunctionCall(call), LuaExpression::StringLiteral(value))
+            | (LuaExpression::StringLiteral(value), LuaExpression::FunctionCall(call)) => {
+                let var_name = if call.function_name == "type" && call.arguments.len() == 1 {
+                    if let LuaExpression::VarName(name) = &call.arguments[0] {
+                        name
+                    } else {
+                        return None;
+                    }
+                } else {
+                    return None;
+                };
+
+                let lust_type = runtime_string_to_type(value)?;
+                Some(TypeGate::new_single(var_name.clone(), [lust_type.clone()]))
+            }
+            _ => None,
+        }
+    }
+}
+
+fn runtime_string_to_type(value: &str) -> Option<LustType> {
+    match value {
+        "nil" => Some(LustType::Nil),
+        "boolean" => Some(LustType::boolean()),
+        "number" => Some(LustType::Number),
+        "string" => Some(LustType::String),
+        _ => None,
+    }
 }
 
 impl std::fmt::Display for EqualsOperation {

crates/lust-lib/src/grammar/tokens/expression.rs

@@ -39,6 +39,7 @@ impl LuaExpression {
         match self {
             LuaExpression::VarName(name) => Some(TypeGate::new_truthy(name.clone(), true)),
             LuaExpression::AndOperation(and_op) => and_op.get_type_gate(),
+            LuaExpression::EqualsOperation(eq_op) => eq_op.get_type_gate(),
             _ => None,
         }
     }

crates/lust-lib/src/typecheck/gates/mod.rs

@@ -1,14 +1,14 @@
 use crate::typecheck::LustType;
 
 mod and;
-mod truthy;
+mod single;
 
 pub use and::*;
-pub use truthy::*;
+pub use single::*;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
 pub enum TypeGate {
-    Truthy(TruthyGate),
+    Single(SingleGate),
     And(AndGate),
 }
 
@@ -34,7 +34,16 @@ impl TypeGate {
     }
 
     pub fn new_truthy(varname: String, truthy: bool) -> Self {
-        Self::Truthy(TruthyGate::new(varname, truthy))
+        let falsy_types = [LustType::Nil, LustType::False];
+        if truthy {
+            Self::Single(SingleGate::new_exclude(varname, falsy_types))
+        } else {
+            Self::Single(SingleGate::new_intersect(varname, falsy_types))
+        }
+    }
+
+    pub fn new_single(varname: String, types: impl IntoIterator<Item = LustType>) -> Self {
+        Self::Single(SingleGate::new_intersect(varname, types))
     }
 
     pub fn new_and(gates: impl IntoIterator<Item = TypeGate>) -> Self {
@@ -43,7 +52,7 @@ impl TypeGate {
 
     pub fn get_restrictions(&self) -> &[GateRestriction] {
         match self {
-            TypeGate::Truthy(gate) => gate.get_restrictions(),
+            TypeGate::Single(gate) => gate.get_restrictions(),
             TypeGate::And(gate) => gate.get_restrictions(),
         }
     }

crates/lust-lib/src/typecheck/gates/single.rs

@@ -0,0 +1,34 @@
+use crate::typecheck::{GateRestriction, GateRestrictionKind, LustType};
+
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct SingleGate {
+    pub restriction: [GateRestriction; 1],
+}
+
+impl SingleGate {
+    pub fn new_intersect(varname: String, types: impl IntoIterator<Item = LustType>) -> Self {
+        let restriction = GateRestriction {
+            varname,
+            kind: GateRestrictionKind::Intersect,
+            types: types.into_iter().collect(),
+        };
+        Self {
+            restriction: [restriction],
+        }
+    }
+
+    pub fn new_exclude(varname: String, types: impl IntoIterator<Item = LustType>) -> Self {
+        let restriction = GateRestriction {
+            varname,
+            kind: GateRestrictionKind::Exclude,
+            types: types.into_iter().collect(),
+        };
+        Self {
+            restriction: [restriction],
+        }
+    }
+
+    pub fn get_restrictions(&self) -> &[GateRestriction] {
+        &self.restriction
+    }
+}