jaclang 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -94,6 +94,8 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
                 part_str = self.format_doc_ir(
                     part, indent_level, current_line_budget, is_broken
                 )
+                if part_str.startswith("\n"):
+                    result = result.rstrip(" ")
                 result += part_str
 
                 if "\n" in part_str:

jaclang/compiler/passes/tool/tests/fixtures/archetype_frmt.jac

@@ -0,0 +1,14 @@
+obj Anchor(ArchetypeProtocol) {
+    static def on_entry(cls: type, triggers: list[type]);
+    static def on_exit(cls: type, triggers: list[type]);
+    def make_public_ro;
+    def make_public_rw;
+    def make_private;
+    def is_public_ro -> bool;
+    def is_public_rw -> bool;
+    def is_private -> bool;
+    def is_readable(caller_id: UUID) -> bool;
+    def is_writable(caller_id: UUID) -> bool;
+    def give_access(caller_id: UUID, read_write: bool = False);
+    def revoke_access(caller_id: UUID);
+}

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/triple_quoted_string.jac

@@ -1,6 +1,7 @@
 with entry {
-    triple_quoted_string = """This is a triple quoted string.
-    It can span multiple lines.
-    It can contain any number of quotes or apostrophes.
-    """;
+    triple_quoted_string =
+        """This is a triple quoted string.
+        It can span multiple lines.
+        It can contain any number of quotes or apostrophes.
+        """;
 }

jaclang/compiler/passes/tool/tests/fixtures/import_fmt.jac

@@ -0,0 +1,6 @@
+import from datetime { datetime }
+import from uuid { UUID, uuid4 }
+import from jaclang.compiler.constant { EdgeDir }
+import from jaclang.plugin { Archetype, ArchetypeProtocol, DSFunc, AbsRootHook, hookimpl }
+import math;
+import numpy as np;

jaclang/compiler/passes/tool/tests/fixtures/simple_walk_fmt.jac

@@ -10,7 +10,7 @@ edge Checking {}
 
 walker Creator {
     has count: int = 0;
-    
+
     can create with `root | Item entry {
         here ++> Item();
         self.count += 1;
@@ -24,11 +24,11 @@ walker Creator {
 walker Walk {
     has count: int = 0;
     has value: int = 0;
-    
+
     can skip_root with `root entry {
         visit [-->];
     }
-    
+
     can step with Item entry {
         here.value = self.count;
         self.count += 1;

jaclang/compiler/passes/tool/tests/fixtures/tagbreak.jac

@@ -0,0 +1,9 @@
+class SemTokManager {
+    """Initialize semantic token manager."""
+    def init(self: SemTokManager, ir: uni.Module) -> None {
+        self.sem_tokens: List[int] = self.gen_sem_tokens(ir);
+        self.aaaaastatic_sem_tokens:
+            List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]] =
+            self.gen_sem_tok_node(ir);
+    }
+}

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -51,6 +51,23 @@ class JacFormatPassTests(TestCaseMicroSuite):
             os.path.join(self.fixture_abs_path(""), "simple_walk_fmt.jac"),
         )
 
+    def test_tagbreak(self) -> None:
+        """Tests if the file matches a particular format."""
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "tagbreak.jac"),
+        )
+
+    def test_import_fmt(self) -> None:
+        """Tests if the file matches a particular format."""
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "import_fmt.jac"),
+        )
+
+    def test_archetype(self) -> None:
+        """Tests if the file matches a particular format."""
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "archetype_frmt.jac"),
+        )
     # def test_corelib_fmt(self) -> None:
     #     """Tests if the file matches a particular format."""
     #     self.compare_files(
@@ -99,9 +116,7 @@ class JacFormatPassTests(TestCaseMicroSuite):
         """
         code_gen_pure = JacProgram().compile(self.fixture_abs_path(filename))
         code_gen_format = JacProgram.jac_file_formatter(self.fixture_abs_path(filename))
-        code_gen_jac = JacProgram().compile_from_str(
-            source_str=code_gen_format, file_path=filename
-        )
+        code_gen_jac = JacProgram().compile(use_str=code_gen_format, file_path=filename)
         if "circle_clean_tests.jac" in filename:
             tokens = code_gen_format.split()
             num_test = 0

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -34,8 +34,8 @@ class JacUnparseTests(TestCaseMicroSuite):
         )
         before = ast3.dump(code_gen_pure.gen.py_ast[0], indent=2)
         x = code_gen_pure.unparse()
-        code_gen_jac = JacProgram().compile_from_str(
-            source_str=x,
+        code_gen_jac = JacProgram().compile(
+            use_str=x,
             file_path=filename,
         )
         after = ast3.dump(code_gen_jac.gen.py_ast[0], indent=2)

jaclang/compiler/program.py

@@ -12,14 +12,12 @@ from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes.main import (
     Alert,
     CFGBuildPass,
-    CompilerMode,
     DeclImplMatchPass,
     DefUsePass,
     InheritancePass,
     JacAnnexPass,
     JacImportDepsPass,
     PyBytecodeGenPass,
-    PyImportDepsPass,
     PyJacAstLinkPass,
     PyastBuildPass,
     PyastGenPass,
@@ -38,6 +36,7 @@ from jaclang.utils.log import logging
 logger = logging.getLogger(__name__)
 
 ir_gen_sched = [
+    SymTabBuildPass,
     DeclImplMatchPass,
     DefUsePass,
     CFGBuildPass,
@@ -61,36 +60,15 @@ class JacProgram:
         self.errors_had: list[Alert] = []
         self.warnings_had: list[Alert] = []
 
-    def get_bytecode(
-        self, full_target: str, full_compile: bool = True
-    ) -> Optional[types.CodeType]:
+    def get_bytecode(self, full_target: str) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
-        if full_target in self.mod.hub:
+        if full_target in self.mod.hub and self.mod.hub[full_target].gen.py_bytecode:
             codeobj = self.mod.hub[full_target].gen.py_bytecode
             return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
-        result = self.compile(
-            file_path=full_target,
-            mode=CompilerMode.COMPILE if full_compile else CompilerMode.COMPILE_SINGLE,
-        )
+        result = self.compile(file_path=full_target)
         return marshal.loads(result.gen.py_bytecode) if result.gen.py_bytecode else None
 
-    def compile(
-        self,
-        file_path: str,
-        mode: CompilerMode = CompilerMode.COMPILE,
-    ) -> uni.Module:
-        """Convert a Jac file to an AST."""
-        with open(file_path, "r", encoding="utf-8") as file:
-            return self.compile_from_str(
-                source_str=file.read(), file_path=file_path, mode=mode
-            )
-
-    def compile_from_str(
-        self,
-        source_str: str,
-        file_path: str,
-        mode: CompilerMode = CompilerMode.COMPILE,
-    ) -> uni.Module:
+    def parse_str(self, source_str: str, file_path: str) -> uni.Module:
         """Convert a Jac file to an AST."""
         had_error = False
         if file_path.endswith(".py"):
@@ -116,54 +94,32 @@ class JacProgram:
         if self.mod.main.stub_only:
             self.mod = uni.ProgramModule(mod)
         self.mod.hub[mod.loc.mod_path] = mod
-        return self.run_pass_schedule(mod_targ=mod, mode=mode)
+        JacAnnexPass(ir_in=mod, prog=self)
+        return mod
 
-    def run_pass_schedule(
-        self,
-        mod_targ: uni.Module,
-        mode: CompilerMode = CompilerMode.COMPILE,
+    def compile(
+        self, file_path: str, use_str: str | None = None, no_cgen: bool = False
     ) -> uni.Module:
         """Convert a Jac file to an AST."""
-        JacAnnexPass(ir_in=mod_targ, prog=self)
-        SymTabBuildPass(ir_in=mod_targ, prog=self)
-        if mode == CompilerMode.PARSE:
-            return mod_targ
-        elif mode in (CompilerMode.COMPILE_SINGLE, CompilerMode.NO_CGEN_SINGLE):
-            self.schedule_runner(mod_targ, mode=mode)
-            return mod_targ
+        if not use_str:
+            with open(file_path, "r", encoding="utf-8") as file:
+                use_str = file.read()
+        mod_targ = self.parse_str(use_str, file_path)
+        self.run_schedule(mod=mod_targ, passes=ir_gen_sched)
+        if not no_cgen:
+            self.run_schedule(mod=mod_targ, passes=py_code_gen)
+        return mod_targ
+
+    def build(self, file_path: str, use_str: str | None = None) -> uni.Module:
+        """Convert a Jac file to an AST."""
+        mod_targ = self.compile(file_path, use_str)
         JacImportDepsPass(ir_in=mod_targ, prog=self)
-        if len(self.errors_had):
-            return mod_targ
-        SymTabLinkPass(ir_in=mod_targ, prog=self)
         for mod in self.mod.hub.values():
-            self.schedule_runner(mod, mode=CompilerMode.COMPILE)
-        if mode == CompilerMode.COMPILE:
-            return mod_targ
-        PyImportDepsPass(mod_targ, prog=self)
-        SymTabLinkPass(ir_in=mod_targ, prog=self)
+            SymTabLinkPass(ir_in=mod, prog=self)
         for mod in self.mod.hub.values():
             DefUsePass(mod, prog=self)
-        for mod in self.mod.hub.values():
-            self.schedule_runner(mod, mode=CompilerMode.TYPECHECK)
         return mod_targ
 
-    def schedule_runner(
-        self,
-        mod: uni.Module,
-        mode: CompilerMode = CompilerMode.COMPILE,
-    ) -> None:
-        """Run premade passes on the module."""
-        match mode:
-            case CompilerMode.NO_CGEN | CompilerMode.NO_CGEN_SINGLE:
-                passes = ir_gen_sched
-            case CompilerMode.COMPILE | CompilerMode.COMPILE_SINGLE:
-                passes = [*ir_gen_sched, *py_code_gen]
-            case CompilerMode.TYPECHECK:
-                passes = []
-            case _:
-                raise ValueError(f"Invalid mode: {mode}")
-        self.run_schedule(mod, passes)
-
     def run_schedule(
         self,
         mod: uni.Module,

jaclang/compiler/tests/fixtures/fam.jac

@@ -25,14 +25,14 @@ node location {
 
         for i in activities {
             i.duration = visitor.duration;
-            if here.name not in visitor.passport {
+            if visitor.name not in visitor.passport {
                 if i.name == "Hiking" {
                     for j=0 to j<3 by j+=1  {
                         i.duration+=1;
                     }
                     i.duration+=1;
                 }
-                visitor.passport.append(here.name);
+                visitor.passport.append(visitor.name);
             }
         }
     }

jaclang/compiler/tests/fixtures/pkg_import_lib/__init__.jac

@@ -0,0 +1 @@
+import from .tools { tool_func }

jaclang/compiler/tests/fixtures/pkg_import_lib/sub/__init__.jac

@@ -0,0 +1 @@
+import from .helper { help_func }

jaclang/compiler/tests/fixtures/pkg_import_lib/sub/helper.jac

@@ -0,0 +1,3 @@
+def help_func() {
+    return 'Helper function called' ;
+}

jaclang/compiler/tests/fixtures/pkg_import_lib/tools.jac

@@ -0,0 +1,3 @@
+def tool_func() {
+    return 'Tool function executed' ;
+}

jaclang/compiler/tests/fixtures/pkg_import_lib_py/__init__.py

@@ -0,0 +1,5 @@
+from jaclang import JacMachineInterface as _
+
+from .tools import tool_func
+
+glob_var_lib = "pkg_import_lib_py.glob_var_lib"

jaclang/compiler/tests/fixtures/pkg_import_lib_py/sub/__init__.py

@@ -0,0 +1,3 @@
+from jaclang import JacMachineInterface as _
+
+from .helper import help_func

jaclang/compiler/tests/fixtures/pkg_import_lib_py/sub/helper.jac

@@ -0,0 +1,3 @@
+def help_func() {
+    return 'Helper function called' ;
+}

jaclang/compiler/tests/fixtures/pkg_import_lib_py/tools.jac

@@ -0,0 +1,3 @@
+def tool_func() {
+    return 'Tool function executed' ;
+}

jaclang/compiler/tests/fixtures/pkg_import_main.jac

@@ -0,0 +1,10 @@
+import from pkg_import_lib { tool_func }
+import from pkg_import_lib.sub { help_func }
+
+with entry {
+    print('Main Execution:\n') ;
+    print('Calling from tools.jac...') ;
+    print('Tool says:', tool_func()) ;
+    print('\nCalling from helper.jac...') ;
+    print('Helper says:', help_func()) ;
+}

jaclang/compiler/tests/fixtures/pkg_import_main_py.jac

@@ -0,0 +1,11 @@
+import from pkg_import_lib_py { tool_func,glob_var_lib }
+import from pkg_import_lib_py.sub { help_func }
+
+with entry {
+    print('Main Execution:\n') ;
+    print('Calling from tools.jac...') ;
+    print('Tool says:', tool_func()) ;
+    print('\nCalling from helper.jac...') ;
+    print('Helper says:', help_func()) ;
+    print('\nGlobal variable from lib:', glob_var_lib) ;
+}

jaclang/compiler/tests/test_importer.py

@@ -3,10 +3,10 @@
 import io
 import sys
 
-from jaclang import JacMachineInterface as Jac
+from jaclang import JacMachine as Jac
 from jaclang.cli import cli
 from jaclang.compiler.program import JacProgram
-from jaclang.runtimelib.machine import JacMachineInterface, JacMachine
+from jaclang.runtimelib.machine import JacMachineInterface
 from jaclang.utils.test import TestCase
 
 
@@ -15,29 +15,27 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        mach = JacMachine(self.fixture_abs_path(__file__))
+        Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
-            mach,
             JacProgram(),
         )
-        (h,) = Jac.jac_import(mach, "fixtures.hello_world", base_path=__file__)
+        (h,) = Jac.jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
-        mach = JacMachine(self.fixture_abs_path(__file__))
+        Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
-            mach,
             JacProgram(),
         )
-        Jac.jac_import(mach, "fixtures.hello_world", base_path=__file__)
+        Jac.jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn(
             "module 'fixtures.hello_world'",
-            str(mach.loaded_modules),
+            str(Jac.loaded_modules),
         )
         self.assertIn(
             "/tests/fixtures/hello_world.jac",
-            str(mach.loaded_modules).replace("\\\\", "/"),
+            str(Jac.loaded_modules).replace("\\\\", "/"),
         )
 
     def test_jac_py_import(self) -> None:
@@ -92,12 +90,11 @@ class TestLoader(TestCase):
         sys.stdout = captured_output
 
         try:
-            mach = JacMachine(self.fixture_abs_path(__file__))
+            Jac.set_base_path(self.fixture_abs_path(__file__))
             JacMachineInterface.attach_program(
-                mach,
                 JacProgram(),
             )
-            Jac.jac_import(mach, module_name, base_path=__file__)
+            Jac.jac_import(module_name, base_path=__file__)
             cli.run(jac_file_path)
 
             # Reset stdout and get the output
@@ -111,3 +108,23 @@ class TestLoader(TestCase):
 
             os.environ.pop("JACPATH", None)
             jacpath_dir.cleanup()
+
+    def test_importer_with_submodule_jac(self) -> None:
+        """Test basic self loading."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("pkg_import_main.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Helper function called", stdout_value)
+        self.assertIn("Tool function executed", stdout_value)
+
+    def test_importer_with_submodule_py(self) -> None:
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("pkg_import_main_py.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("Helper function called", stdout_value)
+        self.assertIn("Tool function executed", stdout_value)
+        self.assertIn("pkg_import_lib_py.glob_var_lib", stdout_value)

jaclang/compiler/tests/test_parser.py

@@ -111,6 +111,7 @@ class TestLarkParser(TestCaseMicroSuite):
                 "consume_token",
                 "match_many",
                 "consume_many",
+                "extract_from_list",
             ]:
                 continue
             self.assertIn(fn, rules)