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

jaclang/cli/cli.md

@@ -36,6 +36,7 @@ Parameters to execute the tool command:
     - `sym.`: Generates a dot graph representation of the symbol table for the specified .jac file.
     - `ast`: Displays the Abstract Syntax Tree (AST) of the specified .jac file.
     - `ast.`: Generates a dot graph representation of the AST for the specified .jac file.
+    - `cfg.`: Generates a dot graph representatuin of the CFG(Control Flow Graph) for a specific .jac file
     - `pyast`: Generates the Python AST for a .py file or the relevant Python AST for the generated Python code from a .jac file.
     - `py`: Displays the relevant generated Python code for the respective Jac code in a .jac file.
   - `file_path`: Path to the .jac or .py file.

jaclang/cli/cli.py

@@ -16,17 +16,12 @@ from jaclang.compiler.passes.main import PyastBuildPass
 from jaclang.compiler.program import JacProgram
 from jaclang.runtimelib.builtin import printgraph
 from jaclang.runtimelib.constructs import WalkerArchetype
-from jaclang.runtimelib.machine import (
-    ExecutionContext,
-    JacMachine as Jac,
-    JacMachineInterface as JacInterface,
-)
+from jaclang.runtimelib.machine import ExecutionContext, JacMachine as Jac
 from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
-
-JacInterface.create_cmd()
+Jac.create_cmd()
 Jac.setup()
 
 
@@ -140,6 +135,7 @@ def run(
     # if no session specified, check if it was defined when starting the command shell
     # otherwise default to jaclang.session
     base, mod, mach = proc_file_sess(filename, session)
+    lng = filename.split(".")[-1]
     Jac.set_base_path(base)
 
     if filename.endswith((".jac", ".py")):
@@ -148,6 +144,7 @@ def run(
                 target=mod,
                 base_path=base,
                 override_name="__main__" if main else None,
+                lng=lng,
             )
         except Exception as e:
             print(f"Error running {filename}: {e}", file=sys.stderr)
@@ -159,6 +156,7 @@ def run(
                     target=mod,
                     base_path=base,
                     override_name="__main__" if main else None,
+                    lng=lng,
                 )
         except Exception as e:
             print(f"Error running {filename}: {e}", file=sys.stderr)
@@ -219,7 +217,7 @@ def get_object(filename: str, id: str, session: str = "", main: bool = True) ->
 
 
 @cmd_registry.register
-def build(filename: str) -> None:
+def build(filename: str, typecheck: bool = False) -> None:
     """Build the specified .jac file.
 
     Compiles a Jac source file into a Jac Intermediate Representation (.jir) file,
@@ -227,21 +225,25 @@ def build(filename: str) -> None:
 
     Args:
         filename: Path to the .jac file to build
-        typecheck: Perform type checking during build (default: True)
+        typecheck: Perform type checking during build (default: False)
 
     Examples:
         jac build myprogram.jac
-        jac build myprogram.jac --no-typecheck
+        jac build myprogram.jac --typecheck
     """
-    if filename.endswith(".jac"):
-        (out := JacProgram()).compile(file_path=filename)
-        errs = len(out.errors_had)
-        warnings = len(out.warnings_had)
-        print(f"Errors: {errs}, Warnings: {warnings}")
-        with open(filename[:-4] + ".jir", "wb") as f:
-            pickle.dump(out, f)
-    else:
+    if not filename.endswith(".jac"):
         print("Not a .jac file.", file=sys.stderr)
+        exit(1)
+    (out := JacProgram()).compile(file_path=filename, type_check=typecheck)
+    errs = len(out.errors_had)
+    warnings = len(out.warnings_had)
+    print(f"Errors: {errs}, Warnings: {warnings}")
+
+    for alrt in out.errors_had + out.warnings_had:
+        print(alrt.pretty_print(), file=sys.stderr)
+
+    with open(filename[:-4] + ".jir", "wb") as f:
+        pickle.dump(out, f)
 
 
 @cmd_registry.register
@@ -325,6 +327,24 @@ def lsp() -> None:
     run_lang_server()
 
 
+@cmd_registry.register
+def lsp_dev() -> None:
+    """Run Jac Language Server Protocol in Developer Mode.
+
+    Starts the experimental Jac Language Server with enhanced features
+    for development and testing. Used by editor extensions in developer mode.
+
+    Args:
+        This command takes no parameters.
+
+    Examples:
+        jac lsp_dev
+    """
+    from jaclang.langserve.dev_server import run_lang_server
+
+    run_lang_server()
+
+
 @cmd_registry.register
 def enter(
     filename: str,

jaclang/compiler/passes/main/__init__.py

@@ -9,6 +9,7 @@ from .def_use_pass import DefUsePass  # noqa: I100
 from .sem_def_match_pass import SemDefMatchPass  # noqa: I100
 from .import_pass import JacImportDepsPass  # noqa: I100
 from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
+from .type_checker_pass import TypeCheckPass  # noqa: I100
 from .pyast_load_pass import PyastBuildPass  # type: ignore # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
@@ -25,6 +26,7 @@ __all__ = [
     "JacImportDepsPass",
     "PyImportDepsPass",
     "BinderPass",
+    "TypeCheckPass",
     "SymTabBuildPass",
     "SymTabLinkPass",
     "DeclImplMatchPass",

jaclang/compiler/passes/main/cfg_build_pass.py

@@ -152,7 +152,7 @@ class CFGBuildPass(UniPass):
         """Exit BasicBlockStmt nodes."""
         if isinstance(node, uni.UniCFGNode) and not isinstance(node, uni.Semi):
             self.first_exit = True
-            if not node.bb_out:
+            if not node.bb_out and not isinstance(node, (uni.ReturnStmt, uni.ArchHas)):
                 self.to_connect.append(node)
             if (
                 isinstance(node, (uni.InForStmt, uni.IterForStmt))
@@ -176,6 +176,8 @@ class CFGBuildPass(UniPass):
                     if from_node in self.to_connect:
                         self.to_connect.remove(from_node)
                 self.ability_stack.pop()
+            elif isinstance(node, (uni.IfStmt, uni.ElseIf)) and not node.else_body:
+                self.to_connect.append(node)
 
     def after_pass(self) -> None:
         """After pass."""
@@ -299,3 +301,21 @@ class CoalesceBBPass(UniPass):
 
         dot += "}\n"
         return dot
+
+
+def cfg_dot_from_file(file_name: str) -> str:
+    """Print the control flow graph."""
+    from jaclang.compiler.program import JacProgram
+
+    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()
+    return dot

jaclang/compiler/passes/main/inheritance_pass.py

@@ -62,9 +62,16 @@ class InheritancePass(Transform[uni.Module, uni.Module]):
 
         base_class_symbol_table = base_class_symbol.symbol_table
 
+        # FIXME: If the base class symbol is imported from another module, the symbol table
+        # will be None. The imported symbols were ignored and introduced in the typecheck
+        # for imported module items. This needs to be investigated to ensure that even imported
+        # classes should have a symbol table (unless the module is not parsed and decided not to).
+        if base_class_symbol_table is None:
+            return
+
         if self.is_missing_py_symbol_table(base_class_symbol, base_class_symbol_table):
             return
-        assert base_class_symbol_table is not None
+
         node.sym_tab.inherit_sym_tab(base_class_symbol_table)
 
     def inherit_from_atom_trailer(

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -187,6 +187,15 @@ class PyastGenPass(UniPass):
             ),
         )
 
+    def needs_mtllm(self) -> None:
+        """Ensure byLLM is imported only once."""
+        self._add_preamble_once(
+            self.needs_mtllm.__name__,
+            ast3.Import(
+                names=[self.sync(ast3.alias(name="byllm"), jac_node=self.ir_out)]
+            ),
+        )
+
     def needs_enum(self) -> None:
         """Ensure Enum utilities are imported only once."""
         self._add_preamble_once(
@@ -735,17 +744,25 @@ class PyastGenPass(UniPass):
         self, model: ast3.expr, caller: ast3.expr, args: ast3.Dict
     ) -> ast3.Call:
         """Reusable method to codegen call_llm(model, caller, args)."""
-        return self.sync(
+        self.needs_mtllm()
+        mtir_cls_ast = self.sync(
+            ast3.Attribute(
+                value=self.sync(ast3.Name(id="byllm", ctx=ast3.Load())),
+                attr="MTIR",
+                ctx=ast3.Load(),
+            )
+        )
+        mtir_ast = self.sync(
             ast3.Call(
-                func=self.jaclib_obj("call_llm"),
+                func=self.sync(
+                    ast3.Attribute(
+                        value=mtir_cls_ast,
+                        attr="factory",
+                        ctx=ast3.Load(),
+                    )
+                ),
                 args=[],
                 keywords=[
-                    self.sync(
-                        ast3.keyword(
-                            arg="model",
-                            value=model,
-                        )
-                    ),
                     self.sync(
                         ast3.keyword(
                             arg="caller",
@@ -758,6 +775,38 @@ class PyastGenPass(UniPass):
                             value=args,
                         )
                     ),
+                    self.sync(
+                        ast3.keyword(
+                            arg="call_params",
+                            value=self.sync(
+                                ast3.Attribute(
+                                    value=model,
+                                    attr="call_params",
+                                    ctx=ast3.Load(),
+                                ),
+                            ),
+                        )
+                    ),
+                ],
+            )
+        )
+        return self.sync(
+            ast3.Call(
+                func=self.jaclib_obj("call_llm"),
+                args=[],
+                keywords=[
+                    self.sync(
+                        ast3.keyword(
+                            arg="model",
+                            value=model,
+                        )
+                    ),
+                    self.sync(
+                        ast3.keyword(
+                            arg="mtir",
+                            value=mtir_ast,
+                        )
+                    ),
                 ],
             )
         )

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_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/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,87 @@
+
+"""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 _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}")