jaclang 0.8.5__py3-none-any.whl → 0.8.7__py3-none-any.whl

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -141,17 +141,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
 
         reserved_keywords = [v for _, v in TOKEN_MAP.items()]
 
-        value = node.name if node.name not in reserved_keywords else f"<>{node.name}"
         name = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=value,
+            value=node.name,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.name),
             pos_start=0,
             pos_end=0,
+            is_kwesc=(node.name in reserved_keywords),
         )
         body = [self.convert(i) for i in node.body]
         valid = [i for i in body if isinstance(i, (uni.CodeBlockStmt))]
@@ -285,8 +285,8 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
                 and body_stmt.signature.params
             ):
                 for param in body_stmt.signature.params:
-                    if param.name.value == "self":
-                        param.type_tag = uni.SubTag[uni.Expr](name, kid=[name])
+                    if param.name.value == "self" and param.type_tag:
+                        param.type_tag.tag.value = name.value
         doc = (
             body[0].expr
             if isinstance(body[0], uni.ExprStmt)
@@ -748,17 +748,14 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
         attribute = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=(
-                ("<>" + node.attr)
-                if node.attr == "init"
-                else "init" if node.attr == "__init__" else node.attr
-            ),
+            value="init" if node.attr == "__init__" else node.attr,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.attr),
             pos_start=0,
             pos_end=0,
+            is_kwesc=node.attr == "init",
         )
         if isinstance(value, uni.Expr):
             return uni.AtomTrailer(
@@ -1680,18 +1677,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             for _, v in TOKEN_MAP.items()
             if v not in ["float", "int", "str", "bool", "self"]
         ]
-
-        value = node.id if node.id not in reserved_keywords else f"<>{node.id}"
         ret = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=value,
+            value=node.id,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.id),
             pos_start=0,
             pos_end=0,
+            is_kwesc=(node.id in reserved_keywords),
         )
         return ret
 
@@ -1735,18 +1731,18 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
 
         names: list[uni.NameAtom] = []
         for name in node.names:
-            value = name if name not in reserved_keywords else f"<>{name}"
             names.append(
                 uni.Name(
                     orig_src=self.orig_src,
                     name=Tok.NAME,
-                    value=value,
+                    value=name,
                     line=node.lineno,
                     end_line=node.end_lineno if node.end_lineno else node.lineno,
                     col_start=node.col_offset,
                     col_end=node.col_offset + len(name),
                     pos_start=0,
                     pos_end=0,
+                    is_kwesc=(name in reserved_keywords),
                 )
             )
         return uni.NonLocalStmt(target=names, kid=names)
@@ -2056,17 +2052,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             if v not in ["float", "int", "str", "bool", "self"]
         ]
 
-        value = node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
         name = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=value,
+            value=node.arg,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.arg),
             pos_start=0,
             pos_end=0,
+            is_kwesc=(node.arg in reserved_keywords),
         )
         ann_expr = (
             self.convert(node.annotation)
@@ -2343,19 +2339,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             from jaclang.compiler import TOKEN_MAP
 
             reserved_keywords = [v for _, v in TOKEN_MAP.items()]
-            arg_value = (
-                node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
-            )
             arg = uni.Name(
                 orig_src=self.orig_src,
                 name=Tok.NAME,
-                value=arg_value,
+                value=node.arg,
                 line=node.lineno,
                 end_line=node.end_lineno if node.end_lineno else node.lineno,
                 col_start=node.col_offset,
                 col_end=node.col_offset + len(node.arg if node.arg else "_"),
                 pos_start=0,
                 pos_end=0,
+                is_kwesc=(node.arg in reserved_keywords),
             )
         value = self.convert(node.value)
         if isinstance(value, uni.Expr):

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -84,6 +84,10 @@ class SymTabBuildPass(UniPass):
         else:
             pass  # Need to support pythonic import symbols with dots in it
 
+    def exit_module_item(self, node: uni.ModuleItem) -> None:
+        sym_node = node.alias or node.name
+        sym_node.sym_tab.def_insert(sym_node, single_decl="import")
+
     def enter_archetype(self, node: uni.Archetype) -> None:
         self.push_scope_and_link(node)
         assert node.parent_scope is not None

jaclang/compiler/passes/main/tests/fixtures/cfg_has_var.jac

@@ -0,0 +1,12 @@
+obj Rock {
+    has pellets:list;
+
+    def count_pellets() -> int {
+        return self.pellets.length();
+    }
+}
+
+with entry {
+    rock = Rock(pellets=[1, 2, 3]);
+    print("Number of pellets: " + rock.count_pellets().to_string());
+}

jaclang/compiler/passes/main/tests/fixtures/cfg_if_no_else.jac

@@ -0,0 +1,11 @@
+def test_if_without_else(x: int) {
+    if (x > 0) {
+        print("Positive");
+    }
+    print("Done");
+}
+
+with entry {
+    test_if_without_else(5);
+    test_if_without_else(-3);
+}

jaclang/compiler/passes/main/tests/fixtures/cfg_return.jac

@@ -0,0 +1,9 @@
+def test_return_direct() {
+    print("Before return");
+    return;
+    print("After return");
+}
+
+with entry {
+    test_return_direct();
+}

jaclang/compiler/passes/main/tests/fixtures/checker_binary_op.jac

@@ -0,0 +1,21 @@
+node B {
+  def __mul__(other: B) -> int {
+    return 0;
+  }
+}
+
+node A {
+  def __add__(other: A) -> B {
+    return B();
+  }
+}
+
+with entry {
+  a: A = A();
+
+  r1: B = a + a;  # <-- Ok
+  r2: A = a + a;  # <-- Error
+
+  r3: int = (a+a) * B(); # <-- Ok
+  r4: str = (a+a) * B(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_call_expr_class.jac

@@ -0,0 +1,12 @@
+
+node Foo {
+    has i: int = 0;
+}
+
+with entry {
+    cls = Foo;
+    inst = cls(); # <-- Call expression target of class type
+
+    inst.i = 42;     # <-- Ok
+    inst.i = 'str'; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_cyclic_symbol.jac

@@ -0,0 +1,4 @@
+
+with entry {
+    x = x;
+}

jaclang/compiler/passes/main/tests/fixtures/checker_expr_call.jac

@@ -0,0 +1,9 @@
+
+def foo() -> int {
+    return 42;
+}
+
+with entry {
+    i: int = foo(); # <-- Ok
+    s: str = foo(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_import_missing_module.jac

@@ -0,0 +1,13 @@
+import from scipy { stats, optimize }
+import from utils.fake_helpers { helper_func }
+import from non_existent_module { foo }
+import nonexistent_module as nm;
+
+
+with entry {
+    a: int = stats.norm.cdf(0);
+    d: float = optimize.minimize_scalar(lambda  x: int: x ** 2).fun;
+    result = helper_func();
+    b: int = foo();
+    c = nm.some_func();
+}

jaclang/compiler/passes/main/tests/fixtures/checker_imported.jac

@@ -0,0 +1,2 @@
+
+glob some_int: int = 42;

jaclang/compiler/passes/main/tests/fixtures/checker_importer.jac

@@ -0,0 +1,6 @@
+import from checker_imported {
+    some_int as alias
+}
+
+glob i: int = alias;  # <-- Ok
+glob s: str = alias;  # <-- Error

jaclang/compiler/passes/main/tests/fixtures/checker_magic_call.jac

@@ -0,0 +1,17 @@
+
+node Bar {}
+
+node Foo {
+    def __call__() -> Bar {
+        return Bar();
+    }
+}
+
+def fn() -> Foo {
+    return Foo();
+}
+
+with entry{
+    b: Bar = fn()(); # <-- Ok
+    f: Foo = fn()(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_mod_path.jac

@@ -0,0 +1,8 @@
+
+
+import jaclang.compiler.unitree as uni;
+
+
+with entry{
+    a:int = uni.Module; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/data_spatial_types.jac

@@ -126,5 +126,5 @@ with entry {
     root spawn walker1();
     root spawn walker2();
     root spawn walker3();
-    print(_.node_dot(root));
+    print(printgraph(root));
 }

jaclang/compiler/passes/main/tests/fixtures/import_symbol_type_infer.jac

@@ -0,0 +1,11 @@
+import math as alias;
+with entry {
+
+  # math module imports sys so it has the symbol
+  # we're not using math.pi since it's a Final[float]
+  # and we haven't implemented generic types yet.
+  m = alias;
+
+  i: int = m.sys.prefix; # <-- Error
+  s: str = m.sys.prefix; # <-- Ok
+}

jaclang/compiler/passes/main/tests/fixtures/infer_type_assignment.jac

@@ -0,0 +1,5 @@
+with entry {
+  some_int_inferred = 42;
+  assigning_to_int: int = some_int_inferred; # <-- Ok
+  assigning_to_str: str = some_int_inferred; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/member_access_type_inferred.jac

@@ -0,0 +1,13 @@
+node Foo {
+  # We can infer the type of `bar` but the jac
+  # syntax makes the type annotation a must here.
+  has bar: int = 42;
+}
+with entry {
+  f: Foo = Foo();
+
+  i = 42; s = "foo";
+
+  i = f.bar; # <-- Ok
+  s = f.bar; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/member_access_type_resolve.jac

@@ -0,0 +1,11 @@
+node Bar {
+  has baz: int;
+}
+node Foo {
+  has bar: Bar;
+}
+with entry {
+  f: Foo = Foo();
+  i: int = f.bar.baz; # <-- Ok
+  s: str = f.bar.baz; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/type_annotation_assignment.jac

@@ -0,0 +1,8 @@
+glob should_pass1: int = 42;
+glob should_fail1: int = "foo";
+glob should_pass2: str = "bar";
+glob should_fail2: str = 42;
+
+# This is without any explicit type annotation.
+# was failing after the first PR.
+glob should_be_fine = "baz";

jaclang/compiler/passes/main/tests/test_cfg_build_pass.py

@@ -16,19 +16,9 @@ class TestCFGBuildPass(TestCase):
         """Test basic blocks."""
         file_name = self.fixture_abs_path("cfg_gen.jac")
 
-        from jaclang.compiler.passes.main.cfg_build_pass import CoalesceBBPass
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
 
-        with open(file_name, "r") as f:
-            file_source = f.read()
-
-        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
-
-        cfg_pass = CoalesceBBPass(
-            ir_in=ir,
-            prog=prog,
-        )
-
-        dot = cfg_pass.printgraph_cfg()
+        dot = cfg_dot_from_file(file_name=file_name)
 
         expected_dot = (
             "digraph G {\n"
@@ -62,19 +52,9 @@ class TestCFGBuildPass(TestCase):
         """Test basic blocks."""
         file_name = self.fixture_abs_path("cfg_ability_test.jac")
 
-        from jaclang.compiler.passes.main.cfg_build_pass import CoalesceBBPass
-
-        with open(file_name, "r") as f:
-            file_source = f.read()
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
 
-        ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
-
-        cfg_pass = CoalesceBBPass(
-            ir_in=ir,
-            prog=prog,
-        )
-
-        dot = cfg_pass.printgraph_cfg()
+        dot = cfg_dot_from_file(file_name=file_name)
 
         expected_dot = (
             "digraph G {\n"
@@ -93,3 +73,61 @@ class TestCFGBuildPass(TestCase):
         )
 
         self.assertEqual(dot, expected_dot)
+
+    def test_cfg_ability_with_has(self) -> None:
+        """Test basic blocks with ability and has."""
+        file_name = self.fixture_abs_path("cfg_has_var.jac")
+
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
+
+        dot = cfg_dot_from_file(file_name=file_name)
+
+        expected_dot = (
+            "digraph G {\n"
+            '  0 [label="BB0\\nobj Rock", shape=box];\n'
+            '  1 [label="BB1\\nhas pellets : list ;", shape=box];\n'
+            '  2 [label="BB2\\ncan count_pellets( ) -> int\\nreturn self . pellets . length ( ) ;", shape=box];\n'
+            '  3 [label="BB3\\nrock = Rock ( pellets = [ 1 , 2 , 3 ] ) ;\\nprint ( \\"Number of pellets: \\" + rock . count_pellets ( ) . to_string ( ) ) ;", shape=box];\n'
+            "  0 -> 1;\n"
+            "  0 -> 2;\n"
+            "}\n"
+        )
+
+        self.assertEqual(dot, expected_dot)
+
+    def test_cfg_if_no_else(self) -> None:
+        """Test basic blocks with if without else."""
+        file_name = self.fixture_abs_path("cfg_if_no_else.jac")
+
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
+
+        dot = cfg_dot_from_file(file_name=file_name)
+
+        expected_dot = (
+            "digraph G {\n"
+            '  0 [label="BB0\\ncan test_if_without_else( x : int )\\nif ( x > 0 )", shape=box];\n'
+            '  1 [label="BB1\\nprint ( \\"Positive\\" ) ;", shape=box];\n'
+            '  2 [label="BB2\\nprint ( \\"Done\\" ) ;", shape=box];\n'
+            '  3 [label="BB3\\ntest_if_without_else ( 5 ) ;\\ntest_if_without_else ( - 3 ) ;", shape=box];\n'
+            "  0 -> 1;\n"
+            "  0 -> 2;\n"
+            "  1 -> 2;\n"
+            "}\n"
+        )
+        self.assertEqual(dot, expected_dot)
+
+    def test_cfg_return_stmt(self) -> None:
+        """Test basic blocks with return statement."""
+        file_name = self.fixture_abs_path("cfg_return.jac")
+
+        from jaclang.compiler.passes.main.cfg_build_pass import cfg_dot_from_file
+
+        dot = cfg_dot_from_file(file_name=file_name)
+
+        expected_dot = (
+            "digraph G {\n"
+            '  0 [label="BB0\\ncan test_return_direct( )\\nprint ( \\"Before return\\" ) ;\\nreturn ;\\nprint ( \\"After return\\" ) ;", shape=box];\n'
+            '  1 [label="BB1\\ntest_return_direct ( ) ;", shape=box];\n'
+            "}\n"
+        )
+        self.assertEqual(dot, expected_dot)

jaclang/compiler/passes/main/tests/test_checker_pass.py

@@ -0,0 +1,161 @@
+
+"""Tests for typechecker pass (the pyright implementation)."""
+
+from tempfile import NamedTemporaryFile
+
+from jaclang.utils.test import TestCase
+from jaclang.compiler.passes.main import TypeCheckPass
+from jaclang.compiler.program import JacProgram
+
+
+class TypeCheckerPassTests(TestCase):
+    """Test class obviously."""
+
+    def test_explicit_type_annotation_in_assignment(self) -> None:
+        """Test explicit type annotation in assignment."""
+        program = JacProgram()
+        program.build(
+            self.fixture_abs_path("type_annotation_assignment.jac"), type_check=True
+        )
+        self.assertEqual(len(program.errors_had), 2)
+        self._assert_error_pretty_found("""
+            glob should_fail1: int = "foo";
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+        self._assert_error_pretty_found("""
+            glob should_fail2: str = 42;
+                 ^^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[1].pretty_print())
+
+    def test_infer_type_of_assignment(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("infer_type_assignment.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+
+        self._assert_error_pretty_found("""
+          assigning_to_str: str = some_int_inferred;
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_member_access_type_resolve(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("member_access_type_resolve.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s: str = f.bar.baz;
+          ^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_member_access_type_infered(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("member_access_type_inferred.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s = f.bar;
+          ^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_import_symbol_type_infer(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("import_symbol_type_infer.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            i: int = m.sys.prefix;
+            ^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_from_import(self) -> None:
+        path = self.fixture_abs_path("checker_importer.jac")
+
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          glob s: str = alias;
+               ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_call_expr(self) -> None:
+        path = self.fixture_abs_path("checker_expr_call.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s: str = foo();
+          ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_call_expr_magic(self) -> None:
+        path = self.fixture_abs_path("checker_magic_call.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            b: Bar = fn()(); # <-- Ok
+            f: Foo = fn()(); # <-- Error
+            ^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_binary_op(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("checker_binary_op.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 2)
+        self._assert_error_pretty_found("""
+            r2: A = a + a;  # <-- Error
+            ^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+        self._assert_error_pretty_found("""
+            r4: str = (a+a) * B(); # <-- Error
+            ^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[1].pretty_print())
+
+    def test_checker_call_expr_class(self) -> None:
+        path = self.fixture_abs_path("checker_call_expr_class.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            inst.i = 'str'; # <-- Error
+            ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_mod_path(self) -> None:
+        path = self.fixture_abs_path("checker_mod_path.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            a:int = uni.Module; # <-- Error
+            ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_import_missing_module(self) -> None:
+        path = self.fixture_abs_path("checker_import_missing_module.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 0)
+
+    def test_cyclic_symbol(self) -> None:
+        path = self.fixture_abs_path("checker_cyclic_symbol.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        # This will result in a stack overflow if not handled properly.
+        # So the fact that it has 0 errors means it passed.
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 0)
+
+    def _assert_error_pretty_found(self, needle: str, haystack: str) -> None:
+        for line in [line.strip() for line in needle.splitlines() if line.strip()]:
+            self.assertIn(line, haystack, f"Expected line '{line}' not found in:\n{haystack}")