Don't generate access for equality check (#399)

* Don't generate access for equality check

Also inherit constraints when entering class.
Useful if you have defined variables you use
within the class outside the class.

* Add test for equality of different types

Author: JSAbrahams

src/check/constrain/constraint/builder.rs

@@ -29,7 +29,7 @@ impl ConstrBuilder {
     pub fn is_top_level(&self) -> bool { self.level == 0 }
 
     pub fn new_set_in_class(&mut self, inherit_class: bool, class: &StringName) {
-        self.new_set(false);
+        self.new_set(true);
         if self.level > 0 && inherit_class {
             let mut previous = self.constraints[self.level - 1].0.clone();
             self.constraints[self.level].0.append(&mut previous);

src/check/constrain/generate/operation.rs

@@ -9,9 +9,7 @@ use crate::check::constrain::generate::collection::{constr_col, gen_collection_l
 use crate::check::constrain::generate::env::Environment;
 use crate::check::context::{clss, Context, LookupClass};
 use crate::check::context::clss::{FLOAT, INT, STRING};
-use crate::check::context::function::{
-    ADD, DIV, EQ, FDIV, GE, GEQ, LE, LEQ, MOD, MUL, POW, SQRT, SUB,
-};
+use crate::check::context::function::{ADD, DIV, EQ, FDIV, GE, GEQ, LE, LEQ, MOD, MUL, NEQ, POW, SQRT, SUB};
 use crate::check::name::{Any, Name};
 use crate::check::name::string_name::StringName;
 use crate::check::name::true_name::TrueName;
@@ -92,9 +90,8 @@ pub fn gen_op(
         Node::Ge { left, right } => impl_bool_op(GE, ast, left, right, env, ctx, constr),
         Node::Leq { left, right } => impl_bool_op(LEQ, ast, left, right, env, ctx, constr),
         Node::Geq { left, right } => impl_bool_op(GEQ, ast, left, right, env, ctx, constr),
-        Node::Neq { left, right } | Node::Eq { left, right } => {
-            impl_bool_op(EQ, ast, left, right, env, ctx, constr)
-        }
+        Node::Neq { left, right } => impl_bool_op(EQ, ast, left, right, env, ctx, constr),
+        Node::Eq { left, right } => impl_bool_op(EQ, ast, left, right, env, ctx, constr),
 
         Node::AddU { expr } | Node::SubU { expr } => generate(expr, env, ctx, constr),
         Node::Sqrt { expr } => {
@@ -307,26 +304,29 @@ fn impl_bool_op(
     ctx: &Context,
     constr: &mut ConstrBuilder,
 ) -> Constrained {
-    constr.add(
-        "bool operation",
-        &Expected::try_from((ast, &env.var_mappings))?,
-        &Expected::new(
-            left.pos,
-            &Access {
-                entity: Box::new(Expected::try_from((left, &env.var_mappings))?),
-                name: Box::new(Expected::new(
-                    left.pos,
-                    &Function {
-                        name: StringName::from(fun),
-                        args: vec![
-                            Expected::try_from((left, &env.var_mappings))?,
-                            Expected::try_from((right, &env.var_mappings))?,
-                        ],
-                    },
-                )),
-            },
-        ),
-    );
+    if fun != EQ && fun != NEQ {
+        constr.add(
+            "bool operation",
+            &Expected::try_from((ast, &env.var_mappings))?,
+            &Expected::new(
+                left.pos,
+                &Access {
+                    entity: Box::new(Expected::try_from((left, &env.var_mappings))?),
+                    name: Box::new(Expected::new(
+                        left.pos,
+                        &Function {
+                            name: StringName::from(fun),
+                            args: vec![
+                                Expected::try_from((left, &env.var_mappings))?,
+                                Expected::try_from((right, &env.var_mappings))?,
+                            ],
+                        },
+                    )),
+                },
+            ),
+        );
+    }
+
     let ty = Type { name: Name::from(clss::BOOL) };
     constr.add(
         "bool operation",

tests/resource/valid/class/var_from_outside_class.mamba

@@ -0,0 +1,5 @@
+def message := "may be mutable, for now"
+
+class MyClass
+    def f(self) =>
+        print(message)

tests/resource/valid/class/var_from_outside_class_check.py

@@ -0,0 +1,5 @@
+message: str = "may be mutable, for now"
+
+class MyClass:
+    def f(self):
+        print(message)

tests/resource/valid/function/print_string.mamba

@@ -0,0 +1,3 @@
+def my_string := "asdf"
+
+print(my_string)

tests/resource/valid/function/print_string_check.py

@@ -0,0 +1,3 @@
+my_string: str = "asdf"
+
+print(my_string)

tests/resource/valid/operation/equality_different_types.mamba

@@ -0,0 +1,8 @@
+class MyClass
+class MyOtherClass
+
+def a := MyClass()
+def b := MyOtherClass()
+
+a = b
+a != b

tests/resource/valid/operation/equality_different_types_check.py

@@ -0,0 +1,10 @@
+class MyClass:
+    pass
+class MyOtherClass:
+    pass
+
+a: MyClass = MyClass()
+b: MyOtherClass = MyOtherClass()
+
+a == b
+a != b

tests/system/valid/class.rs

@@ -84,3 +84,8 @@ fn tuple_as_class() -> OutTestRet {
 fn unassigned_tuple_second_nullable() -> OutTestRet {
     test_directory(true, &["class"], &["class", "target"], "unassigned_tuple_second_nullable")
 }
+
+#[test]
+fn var_from_outside_class() -> OutTestRet {
+    test_directory(true, &["class"], &["class", "target"], "var_from_outside_class")
+}

tests/system/valid/function.rs

@@ -25,6 +25,11 @@ fn match_function() -> OutTestRet {
     test_directory(true, &["function"], &["function", "target"], "match_function")
 }
 
+#[test]
+fn print_string() -> OutTestRet {
+    test_directory(true, &["function"], &["function", "target"], "print_string")
+}
+
 #[test]
 fn return_last_expression() -> OutTestRet {
     test_directory(true, &["function"], &["function", "target"], "return_last_expression")