jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/compiler/passes/{ir_pass.py → uni_pass.py}

@@ -1,41 +1,44 @@
 """Abstract class for IR Passes for Jac."""
 
-import time
-from typing import Optional, Type, TypeVar
+from __future__ import annotations
 
-import jaclang.compiler.absyntree as ast
+from typing import Optional, TYPE_CHECKING, Type, TypeVar
+
+import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes.transform import Transform
-from jaclang.settings import settings
 from jaclang.utils.helpers import pascal_to_snake
 
-T = TypeVar("T", bound=ast.AstNode)
+if TYPE_CHECKING:
+    from jaclang.compiler.program import JacProgram
+
+T = TypeVar("T", bound=uni.UniNode)
 
 
-class Pass(Transform[T]):
+class UniPass(Transform[uni.Module, uni.Module]):
     """Abstract class for IR passes."""
 
-    def __init__(self, input_ir: T, prior: Optional[Transform]) -> None:
+    def __init__(
+        self,
+        ir_in: uni.Module,
+        prog: JacProgram,
+    ) -> None:
         """Initialize parser."""
         self.term_signal = False
         self.prune_signal = False
-        self.ir: ast.AstNode = input_ir
-        self.time_taken = 0.0
-        Transform.__init__(self, input_ir, prior)
+        Transform.__init__(self, ir_in, prog)
 
     def before_pass(self) -> None:
         """Run once before pass."""
-        pass
 
     def after_pass(self) -> None:
         """Run once after pass."""
-        pass
 
-    def enter_node(self, node: ast.AstNode) -> None:
+    def enter_node(self, node: uni.UniNode) -> None:
         """Run on entering node."""
         if hasattr(self, f"enter_{pascal_to_snake(type(node).__name__)}"):
             getattr(self, f"enter_{pascal_to_snake(type(node).__name__)}")(node)
 
-    def exit_node(self, node: ast.AstNode) -> None:
+    def exit_node(self, node: uni.UniNode) -> None:
         """Run on exiting node."""
         if hasattr(self, f"exit_{pascal_to_snake(type(node).__name__)}"):
             getattr(self, f"exit_{pascal_to_snake(type(node).__name__)}")(node)
@@ -50,7 +53,7 @@ class Pass(Transform[T]):
 
     @staticmethod
     def get_all_sub_nodes(
-        node: ast.AstNode, typ: Type[T], brute_force: bool = False
+        node: uni.UniNode, typ: Type[T], brute_force: bool = False
     ) -> list[T]:
         """Get all sub nodes of type."""
         result: list[T] = []
@@ -70,11 +73,11 @@ class Pass(Transform[T]):
                 for i in node.kid:
                     if isinstance(i, typ):
                         result.append(i)
-                    result.extend(Pass.get_all_sub_nodes(i, typ, brute_force))
+                    result.extend(UniPass.get_all_sub_nodes(i, typ, brute_force))
         return result
 
     @staticmethod
-    def find_parent_of_type(node: ast.AstNode, typ: Type[T]) -> Optional[T]:
+    def find_parent_of_type(node: uni.UniNode, typ: Type[T]) -> Optional[T]:
         """Check if node has parent of type."""
         while node.parent:
             if isinstance(node.parent, typ):
@@ -83,7 +86,7 @@ class Pass(Transform[T]):
         return None
 
     @staticmethod
-    def has_parent_of_node(node: ast.AstNode, parent: ast.AstNode) -> bool:
+    def has_parent_of_node(node: uni.UniNode, parent: uni.UniNode) -> bool:
         """Check if node has parent of type."""
         while node.parent:
             if node.parent == parent:
@@ -91,7 +94,7 @@ class Pass(Transform[T]):
             node = node.parent
         return False
 
-    def recalculate_parents(self, node: ast.AstNode) -> None:
+    def recalculate_parents(self, node: uni.UniNode) -> None:
         """Recalculate parents."""
         if not node:
             return
@@ -102,25 +105,20 @@ class Pass(Transform[T]):
 
     # Transform Implementations
     # -------------------------
-    def transform(self, ir: T) -> ast.AstNode:
+    def transform(self, ir_in: uni.Module) -> uni.Module:
         """Run pass."""
         # Only performs passes on proper ASTs
-        if not isinstance(ir, ast.AstNode):
-            return ir
-        start_time = time.time()
+        self.ir_out = ir_in  # TODO: this should go away and just be orig
+        if not isinstance(ir_in, uni.UniNode):
+            return ir_in
         self.before_pass()
-        if not isinstance(ir, ast.AstNode):
-            raise ValueError("Current node is not an AstNode.")
-        self.traverse(ir)
+        if not isinstance(ir_in, uni.UniNode):
+            raise ValueError("Current node is not an UniNode.")
+        self.traverse(ir_in)
         self.after_pass()
-        self.time_taken = time.time() - start_time
-        if settings.pass_timer:
-            self.log_info(
-                f"Time taken in {self.__class__.__name__}: {self.time_taken:.4f} seconds"
-            )
-        return self.ir
-
-    def traverse(self, node: ast.AstNode) -> ast.AstNode:
+        return self.ir_in
+
+    def traverse(self, node: uni.UniNode) -> uni.UniNode:
         """Traverse tree."""
         if self.term_signal:
             return node
@@ -138,31 +136,16 @@ class Pass(Transform[T]):
         self.exit_node(node)
         return node
 
-    def error(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
-        """Pass Error."""
-        self.log_error(msg, node_override=node_override)
-
-    def warning(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
-        """Pass Error."""
-        self.log_warning(msg, node_override=node_override)
-
-    def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError:
-        """Pass Error."""
-        self.log_error(f"ICE: Pass {self.__class__.__name__} - {msg}")
-        return RuntimeError(
-            f"Internal Compiler Error: Pass {self.__class__.__name__} - {msg}"
-        )
-
 
-class PrinterPass(Pass):
+class PrinterPass(UniPass):
     """Printer Pass for Jac AST."""
 
-    def enter_node(self, node: ast.AstNode) -> None:
+    def enter_node(self, node: uni.UniNode) -> None:
         """Run on entering node."""
         self.log_info(f"Entering: {node.__class__.__name__}: {node.loc}")
         super().enter_node(node)
 
-    def exit_node(self, node: ast.AstNode) -> None:
+    def exit_node(self, node: uni.UniNode) -> None:
         """Run on exiting node."""
         super().exit_node(node)
         self.log_info(f"Exiting: {node.__class__.__name__}: {node.loc}")

jaclang/compiler/program.py

@@ -0,0 +1,200 @@
+"""Jac Machine module."""
+
+from __future__ import annotations
+
+import ast as py_ast
+import marshal
+import types
+from typing import Optional
+
+import jaclang.compiler.unitree as uni
+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,
+    SymTabBuildPass,
+    SymTabLinkPass,
+    Transform,
+)
+from jaclang.compiler.passes.tool import (
+    DocIRGenPass,
+    FuseCommentsPass,
+    JacFormatPass,
+)
+from jaclang.utils.log import logging
+
+
+logger = logging.getLogger(__name__)
+
+ir_gen_sched = [
+    DeclImplMatchPass,
+    DefUsePass,
+    CFGBuildPass,
+    InheritancePass,
+]
+py_code_gen = [
+    PyastGenPass,
+    PyJacAstLinkPass,
+    PyBytecodeGenPass,
+]
+format_sched = [FuseCommentsPass, DocIRGenPass, JacFormatPass]
+
+
+class JacProgram:
+    """JacProgram to handle the Jac program-related functionalities."""
+
+    def __init__(self, main_mod: Optional[uni.ProgramModule] = None) -> None:
+        """Initialize the JacProgram object."""
+        self.mod: uni.ProgramModule = main_mod if main_mod else uni.ProgramModule()
+        self.py_raise_map: dict[str, str] = {}
+        self.errors_had: list[Alert] = []
+        self.warnings_had: list[Alert] = []
+
+    def get_bytecode(self, full_target: str) -> Optional[types.CodeType]:
+        """Get the bytecode for a specific module."""
+        if full_target in self.mod.hub:
+            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_SINGLE)
+        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:
+        """Convert a Jac file to an AST."""
+        had_error = False
+        if file_path.endswith(".py"):
+            parsed_ast = py_ast.parse(source_str)
+            py_ast_ret = PyastBuildPass(
+                ir_in=uni.PythonModuleAst(
+                    parsed_ast,
+                    orig_src=uni.Source(source_str, mod_path=file_path),
+                ),
+                prog=self,
+            )
+            had_error = len(py_ast_ret.errors_had) > 0
+            mod = py_ast_ret.ir_out
+        else:
+            source = uni.Source(source_str, mod_path=file_path)
+            jac_ast_ret: Transform[uni.Source, uni.Module] = JacParser(
+                root_ir=source, prog=self
+            )
+            had_error = len(jac_ast_ret.errors_had) > 0
+            mod = jac_ast_ret.ir_out
+        if had_error:
+            return mod
+        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)
+
+    def run_pass_schedule(
+        self,
+        mod_targ: uni.Module,
+        mode: CompilerMode = CompilerMode.COMPILE,
+    ) -> 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
+        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)
+        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,
+        passes: list[type[Transform[uni.Module, uni.Module]]],
+    ) -> None:
+        """Run the passes on the module."""
+        final_pass: Optional[type[Transform[uni.Module, uni.Module]]] = None
+        for current_pass in passes:
+            if current_pass == PyBytecodeGenPass:
+                final_pass = current_pass
+                break
+            current_pass(ir_in=mod, prog=self)  # type: ignore
+        if final_pass:
+            final_pass(mod, prog=self)
+
+    @staticmethod
+    def jac_file_formatter(file_path: str) -> str:
+        """Convert a Jac file to an AST."""
+        prog = JacProgram()
+        with open(file_path) as file:
+            source = uni.Source(file.read(), mod_path=file_path)
+            prse: Transform = JacParser(root_ir=source, prog=prog)
+        for i in format_sched:
+            prse = i(ir_in=prse.ir_out, prog=prog)
+        prse.errors_had = prog.errors_had
+        prse.warnings_had = prog.warnings_had
+        return prse.ir_out.gen.jac
+
+    @staticmethod
+    def jac_str_formatter(source_str: str, file_path: str) -> str:
+        """Convert a Jac file to an AST."""
+        prog = JacProgram()
+        source = uni.Source(source_str, mod_path=file_path)
+        prse: Transform = JacParser(root_ir=source, prog=prog)
+        for i in format_sched:
+            prse = i(ir_in=prse.ir_out, prog=prog)
+        prse.errors_had = prog.errors_had
+        prse.warnings_had = prog.warnings_had
+        return prse.ir_out.gen.jac if not prse.errors_had else source_str

jaclang/compiler/tests/fixtures/codegentext.jac

@@ -0,0 +1,31 @@
+"""Various samples to see code generated correctly"""
+
+with entry {
+    a = (5 + 10) * 2;
+    {"name":"value" } |> (len |> print |> dump) |> say;
+}
+
+with entry {
+    a = (5 + 10) * 2;
+    {"name":"value" } |> (len |> print :> dump) |> say;
+}
+
+with entry {
+    len <| print <| print <| print <| {"name":"value" };
+}
+
+with entry {
+    (*args, **kwargs) |> self.func;
+    self.sig = func |> inspect.signature;
+    |> self.registry.items;
+}
+
+with entry {
+    with open("file.txt") as f, open("file2.txt") as f2 {}
+}
+
+enum Color  {
+    RED=1,
+    GREEN,
+    BLUE=3
+}

jaclang/compiler/tests/fixtures/fam.jac

@@ -9,8 +9,8 @@ These are doc strings and can be used as comments
 Use them to document your code
 """
 
-import:jac stuff;
-import:py from .activity, Activity as Actvy;
+import stuff;
+import from .activity { Activity as Actvy }
 
 node location {
     has x: int,
@@ -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);
             }
         }
     }
@@ -46,22 +46,22 @@ walker tourist {
     can make_visit with location | other exit {
         b = tourist;
         a = spawn tourist;
-        a = [<-:myedge:a == 1, b == 2:-];
-        a = b +:myedge:a=1:+> c;
-        a = b <+:myedge:a=1:+ c;
-        a = here +:myedge:a=1:+> spawn tourist;
+        a = [<-:myedge:a == 1, b == 2:<-];
+        a = b +>:myedge:a=1:+> c;
+        a = b <+:myedge:a=1:<+ c;
+        a = here +>:myedge:a=1:+> spawn tourist;
         tourist |> here;
         report here.activities;
     }
 
-    can do_something(app: int=Actvy) -> Actvy {
+    def do_something(app: int=Actvy) -> Actvy {
         app.do_something();
     }
 
-    can do_something(app: int=Actvy, other: float=Actvy) -> Actvy {
+    def do_something(app: int=Actvy, other: float=Actvy) -> Actvy {
         return app?.do_something(other);
     }
-    can outside_func() -> None;
+    def outside_func() -> None;
 }
 
-:walker:tourist:can:outside_func {}
+impl tourist.outside_func {}

jaclang/compiler/tests/fixtures/hello_world.jac

@@ -1,5 +1,5 @@
 """ Basic Hello World function """
 
-can hello() {
+def hello() {
     return "Hello World!";
 }

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,11 @@
+
+
+from jaclang import JacMachineInterface as _
+
+(tool_func,) = _.py_jac_import(
+    target="tools",
+    base_path=__file__,
+    items={"tool_func": None},
+)
+
+glob_var_lib = 'pkg_import_lib_py.glob_var_lib'

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

@@ -0,0 +1,7 @@
+from jaclang import JacMachineInterface as _
+
+(help_func,) = _.py_jac_import(
+    target=".helper",
+    base_path=__file__,
+    items={"help_func": None},
+)

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/fixtures/staticcheck.jac

@@ -1,12 +1,12 @@
 obj Calc {
     @staticmethod
-    can add(a: int, b: int) -> int {
+    def add(a: int, b: int) -> int {
         return a + b;
     }
 
     @staticmethod
     static
-    can sub(a: int, b: int) -> int {
+    def sub(a: int, b: int) -> int {
         return a - b;
     }
 }

jaclang/compiler/tests/test_importer.py

@@ -3,9 +3,10 @@
 import io
 import sys
 
-from jaclang import jac_import
+from jaclang import JacMachineInterface as Jac
 from jaclang.cli import cli
-from jaclang.runtimelib.machine import JacMachine, JacProgram
+from jaclang.compiler.program import JacProgram
+from jaclang.runtimelib.machine import JacMachineInterface, JacMachine
 from jaclang.utils.test import TestCase
 
 
@@ -14,28 +15,30 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        JacMachine(self.fixture_abs_path(__file__)).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+        mach = JacMachine(self.fixture_abs_path(__file__))
+        JacMachineInterface.attach_program(
+            mach,
+            JacProgram(),
         )
-        (h,) = jac_import("fixtures.hello_world", base_path=__file__)
+        (h,) = Jac.jac_import(mach, "fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
-        JacMachine.detach()
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
-        JacMachine(self.fixture_abs_path(__file__)).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+        mach = JacMachine(self.fixture_abs_path(__file__))
+        JacMachineInterface.attach_program(
+            mach,
+            JacProgram(),
         )
-        jac_import("fixtures.hello_world", base_path=__file__)
+        Jac.jac_import(mach, "fixtures.hello_world", base_path=__file__)
         self.assertIn(
             "module 'fixtures.hello_world'",
-            str(JacMachine.get().loaded_modules),
+            str(mach.loaded_modules),
         )
         self.assertIn(
             "/tests/fixtures/hello_world.jac",
-            str(JacMachine.get().loaded_modules).replace("\\\\", "/"),
+            str(mach.loaded_modules).replace("\\\\", "/"),
         )
-        JacMachine.detach()
 
     def test_jac_py_import(self) -> None:
         """Basic test for pass."""
@@ -89,10 +92,12 @@ class TestLoader(TestCase):
         sys.stdout = captured_output
 
         try:
-            JacMachine(self.fixture_abs_path(__file__)).attach_program(
-                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            mach = JacMachine(self.fixture_abs_path(__file__))
+            JacMachineInterface.attach_program(
+                mach,
+                JacProgram(),
             )
-            jac_import(module_name, base_path=__file__)
+            Jac.jac_import(mach, module_name, base_path=__file__)
             cli.run(jac_file_path)
 
             # Reset stdout and get the output
@@ -103,6 +108,26 @@ class TestLoader(TestCase):
 
         finally:
             captured_output.close()
-            JacMachine.detach()
+
             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)