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

jaclang/compiler/passes/tool/tests/fixtures/myca_formatted_code/simple_walker.jac

@@ -3,14 +3,14 @@ edge future {}
 edge parent {}
 
 walker get_last_active_day {
-    can post_init() {
+    def post_init() {
         self.last_active_day: day | None = None;
     }
     # has last_active_day: day | None by postinit;
     can go_back with day entry {
-        items = [-:parent:->];
+        items = [->:parent:->];
         if items == [] {
-            old_day = [<-:future:-];
+            old_day = [<-:future:<-];
             if len(old_day) == 0 {
                 self.last_active_day = here;
                 return;

jaclang/compiler/passes/tool/tests/fixtures/myca_formatted_code/try_block_and_walker_spawn_and_fstrings.jac

@@ -5,7 +5,7 @@ walker cycle {
     can cycle with user_root entry {
         self.jaseci_sdk = {};
         res = f"> Processing for {here.name} {here.jid}";
-        try  {
+        try {
             user_jid = here.jid;
             day_graph = self.jaseci_sdk.fetch_graph(
                 user_jid=user_jid,

jaclang/compiler/passes/tool/tests/fixtures/myca_formatted_code/type_annotation.jac

@@ -1,3 +1,3 @@
-can gen_node(node_info: dict) -> day | item | None {
+def gen_node(node_info: dict) -> day | item | None {
     n: day | item | None = None;
 }

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

@@ -37,7 +37,7 @@ walker Walk {
     }
 }
 
-can test_run {
+def test_run {
     root spawn Creator();
     Walk() spawn root;
 }

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

@@ -4,11 +4,13 @@ node Item {
     has value: int = 1;
 }
 
+
 edge Checking {}
 
+
 walker Creator {
     has count: int = 0;
-
+    
     can create with `root | Item entry {
         here ++> Item();
         self.count += 1;
@@ -18,13 +20,15 @@ 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;
@@ -37,11 +41,13 @@ walker Walk {
     }
 }
 
-can test_run {
+
+def test_run {
     root spawn Creator();
     Walk() spawn root;
 }
 
+
 with entry {
     test_run();
 }

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

@@ -0,0 +1,29 @@
+"""Test ast build pass module."""
+
+import ast as ast3
+import os
+from difflib import unified_diff
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.passes.tool import DocIRGenPass
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.helpers import add_line_numbers
+from jaclang.utils.test import AstSyncTestMixin, TestCase
+
+
+class DocIrGenPassTests(TestCase, AstSyncTestMixin):
+    """Test pass module."""
+
+    TargetPass = DocIRGenPass
+
+    def test_corelib_fmt(self) -> None:
+        """Parse micro jac file."""
+        code_gen_format = JacProgram.jac_file_formatter(
+            self.fixture_abs_path("corelib.jac"))
+        print(code_gen_format)
+
+    def test_circle_fmt(self) -> None:
+        """Parse micro jac file."""
+        code_gen_format = JacProgram.jac_file_formatter(
+            self.examples_abs_path("manual_code/circle.jac"))
+        print(code_gen_format)

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

@@ -2,25 +2,18 @@
 
 import ast as ast3
 import os
-import shutil
-from contextlib import suppress
 from difflib import unified_diff
 
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_file_to_pass, jac_str_to_pass
-from jaclang.compiler.passes.main import PyastGenPass
-from jaclang.compiler.passes.main.schedules import py_code_gen as without_format
+import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes.tool import JacFormatPass
-from jaclang.compiler.passes.tool.schedules import format_pass
+from jaclang.compiler.program import JacProgram
 from jaclang.utils.helpers import add_line_numbers
 from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
 
 
-class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
+class JacFormatPassTests(TestCaseMicroSuite):
     """Test pass module."""
 
-    TargetPass = JacFormatPass
-
     def compare_files(self, original_file: str, formatted_file: str = None) -> None:
         """Compare the original file with a provided formatted file or a new formatted version."""
         try:
@@ -28,8 +21,7 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             with open(original_path, "r") as file:
                 original_file_content = file.read()
             if formatted_file is None:
-                code_gen_format = jac_file_to_pass(original_path, schedule=format_pass)
-                formatted_content = code_gen_format.ir.gen.jac
+                formatted_content = JacProgram.jac_file_formatter(original_path)
             else:
                 with open(self.fixture_abs_path(formatted_file), "r") as file:
                     formatted_content = file.read()
@@ -44,7 +36,7 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
             if diff:
                 print(f"Differences found in comparison:\n{diff}")
-                raise AssertionError("Files differ after formatting.")
+                raise AssertionError("Files differ after formattinclearg.")
 
         except FileNotFoundError:
             print(f"File not found: {original_file} or {formatted_file}")
@@ -53,84 +45,65 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             print(f"Error comparing files: {e}")
             raise
 
-    def setUp(self) -> None:
-        """Set up test."""
-        root_dir = self.fixture_abs_path("")
-        directories_to_clean = [
-            os.path.join(root_dir, "myca_formatted_code", "__jac_gen__"),
-            os.path.join(root_dir, "genai", "__jac_gen__"),
-        ]
-
-        for directory in directories_to_clean:
-            with suppress(Exception):
-                if os.path.exists(directory):
-                    shutil.rmtree(directory)
-        return super().setUp()
-
-    def test_jac_file_compr(self) -> None:
+    def test_simple_walk_fmt(self) -> None:
         """Tests if the file matches a particular format."""
         self.compare_files(
             os.path.join(self.fixture_abs_path(""), "simple_walk_fmt.jac"),
         )
 
-        self.compare_files(
-            os.path.join(self.fixture_abs_path(""), "corelib_fmt.jac"),
-        )
-        self.compare_files(
-            os.path.join(self.fixture_abs_path(""), "doc_string.jac"),
-        )
-
-    def test_compare_myca_fixtures(self) -> None:
-        """Tests if files in the myca fixtures directory do not change after being formatted."""
-        fixtures_dir = os.path.join(self.fixture_abs_path(""), "myca_formatted_code")
-        fixture_files = os.listdir(fixtures_dir)
-        for file_name in fixture_files:
-            if file_name == "__jac_gen__":
-                continue
-            with self.subTest(file=file_name):
-                file_path = os.path.join(fixtures_dir, file_name)
-                self.compare_files(file_path)
-
-    def test_compare_genai_fixtures(self) -> None:
-        """Tests if files in the genai fixtures directory do not change after being formatted."""
-        fixtures_dir = os.path.join(self.fixture_abs_path(""), "genai")
-        fixture_files = os.listdir(fixtures_dir)
-        for file_name in fixture_files:
-            if file_name == "__jac_gen__":
-                continue
-            with self.subTest(file=file_name):
-                file_path = os.path.join(fixtures_dir, file_name)
-                self.compare_files(file_path)
-
-    def test_general_format_fixtures(self) -> None:
-        """Tests if files in the general fixtures directory do not change after being formatted."""
-        fixtures_dir = os.path.join(self.fixture_abs_path(""), "general_format_checks")
-        fixture_files = os.listdir(fixtures_dir)
-        for file_name in fixture_files:
-            if file_name == "__jac_gen__":
-                continue
-            with self.subTest(file=file_name):
-                file_path = os.path.join(fixtures_dir, file_name)
-                self.compare_files(file_path)
+    # def test_corelib_fmt(self) -> None:
+    #     """Tests if the file matches a particular format."""
+    #     self.compare_files(
+    #         os.path.join(self.fixture_abs_path(""), "corelib_fmt.jac"),
+    #     )
+
+    # def test_doc_string_fmt(self) -> None:
+    #     """Tests if the file matches a particular format."""
+    #     self.compare_files(
+    #         os.path.join(self.fixture_abs_path(""), "doc_string.jac"),
+    #     )
+
+    # def test_compare_myca_fixtures(self) -> None:
+    #     """Tests if files in the myca fixtures directory do not change after being formatted."""
+    #     fixtures_dir = os.path.join(self.fixture_abs_path(""), "myca_formatted_code")
+    #     fixture_files = os.listdir(fixtures_dir)
+    #     for file_name in fixture_files:
+    #         if file_name == "__jac_gen__":
+    #             continue
+    #         with self.subTest(file=file_name):
+    #             file_path = os.path.join(fixtures_dir, file_name)
+    #             self.compare_files(file_path)
+
+    # def test_general_format_fixtures(self) -> None:
+    #     """Tests if files in the general fixtures directory do not change after being formatted."""
+    #     fixtures_dir = os.path.join(self.fixture_abs_path(""), "general_format_checks")
+    #     fixture_files = os.listdir(fixtures_dir)
+    #     for file_name in fixture_files:
+    #         if file_name == "__jac_gen__":
+    #             continue
+    #         with self.subTest(file=file_name):
+    #             file_path = os.path.join(fixtures_dir, file_name)
+    #             self.compare_files(file_path)
 
     def micro_suite_test(self, filename: str) -> None:
-        """Parse micro jac file."""
-        code_gen_pure = jac_file_to_pass(
-            self.fixture_abs_path(filename),
-            target=PyastGenPass,
-            schedule=without_format,
-        )
-        code_gen_format = jac_file_to_pass(
-            self.fixture_abs_path(filename), schedule=format_pass
-        )
-        code_gen_jac = jac_str_to_pass(
-            jac_str=code_gen_format.ir.gen.jac,
-            file_path=filename,
-            target=PyastGenPass,
-            schedule=without_format,
+        """
+        Tests the Jac formatter by:
+        1. Compiling a given Jac file.
+        2. Formatting the Jac file content.
+        3. Compiling the formatted content.
+        4. Asserting that the AST of the original compilation and the
+           AST of the formatted compilation are identical.
+        This ensures that the formatting process does not alter the
+        syntactic structure of the code.
+        Includes a specific token check for 'circle_clean_tests.jac'.
+        """
+        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
         )
         if "circle_clean_tests.jac" in filename:
-            tokens = code_gen_format.ir.gen.jac.split()
+            tokens = code_gen_format.split()
             num_test = 0
             for i in range(len(tokens)):
                 if tokens[i] == "test":
@@ -139,20 +112,22 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             self.assertEqual(num_test, 3)
             return
         try:
+            before = ast3.dump(code_gen_pure.gen.py_ast[0], indent=2)
+            after = ast3.dump(code_gen_jac.gen.py_ast[0], indent=2)
             self.assertTrue(
-                isinstance(code_gen_pure.ir, ast.Module)
-                and isinstance(code_gen_jac.ir, ast.Module),
+                isinstance(code_gen_pure, uni.Module)
+                and isinstance(code_gen_jac, uni.Module),
                 "Parsed objects are not modules.",
             )
-            before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
-            after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
+
             diff = "\n".join(unified_diff(before.splitlines(), after.splitlines()))
             self.assertFalse(diff, "AST structures differ after formatting.")
 
         except Exception as e:
-            print(add_line_numbers(code_gen_pure.ir.source.code))
+            print(f"Error in {filename}: {e}")
+            print(add_line_numbers(code_gen_pure.source.code))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
-            print(add_line_numbers(code_gen_format.ir.gen.jac))
+            print(add_line_numbers(code_gen_format))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
             raise e

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

@@ -4,14 +4,12 @@ import ast as ast3
 from difflib import unified_diff
 
 
-from jaclang.compiler.compile import jac_file_to_pass, jac_str_to_pass
-from jaclang.compiler.passes.main import PyastGenPass
-from jaclang.compiler.passes.main.schedules import py_code_gen as without_format
 from jaclang.compiler.passes.tool import JacFormatPass
-from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCaseMicroSuite
 
 
-class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
+class JacUnparseTests(TestCaseMicroSuite):
     """Test pass module."""
 
     TargetPass = JacFormatPass
@@ -19,13 +17,11 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
     def test_double_unparse(self) -> None:
         """Parse micro jac file."""
         try:
-            code_gen_pure = jac_file_to_pass(
-                self.examples_abs_path("manual_code/circle.jac"),
-                target=PyastGenPass,
-                schedule=without_format,
+            code_gen_pure = JacProgram().compile(
+                self.examples_abs_path("manual_code/circle.jac")
             )
-            x = code_gen_pure.ir.unparse()
-            y = code_gen_pure.ir.unparse()
+            x = code_gen_pure.unparse()
+            y = code_gen_pure.unparse()
             self.assertEqual(x, y)
         except Exception as e:
             print("\n".join(unified_diff(x.splitlines(), y.splitlines())))
@@ -33,23 +29,16 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        code_gen_pure = jac_file_to_pass(
+        code_gen_pure = JacProgram().compile(
             self.fixture_abs_path(filename),
-            target=PyastGenPass,
-            schedule=without_format,
         )
-        before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
-        x = code_gen_pure.ir.unparse()
-        # print(x)
-        # print(f"Testing {code_gen_pure.ir.name}")
-        # print(code_gen_pure.ir.pp())
-        code_gen_jac = jac_str_to_pass(
-            jac_str=x,
+        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,
             file_path=filename,
-            target=PyastGenPass,
-            schedule=without_format,
         )
-        after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
+        after = ast3.dump(code_gen_jac.gen.py_ast[0], indent=2)
         if "circle_clean_tests.jac" in filename:
             self.assertEqual(
                 len(
@@ -64,10 +53,20 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
                 5,
             )
         else:
-            self.assertEqual(
-                len("\n".join(unified_diff(before.splitlines(), after.splitlines()))),
-                0,
-            )
+            try:
+                self.assertEqual(
+                    len(
+                        "\n".join(unified_diff(before.splitlines(), after.splitlines()))
+                    ),
+                    0,
+                )
+            except Exception as e:
+                print(
+                    "\n".join(
+                        unified_diff(before.splitlines(), after.splitlines(), n=10)
+                    )
+                )
+                raise e
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/compiler/passes/transform.py

@@ -2,14 +2,22 @@
 
 from __future__ import annotations
 
+import time
 from abc import ABC, abstractmethod
-from typing import Generic, Optional, Type
+from typing import Generic, Optional, TYPE_CHECKING, Type, TypeVar
 
-from jaclang.compiler.absyntree import AstNode, T
-from jaclang.compiler.codeloc import CodeLocInfo
+from jaclang.compiler.codeinfo import CodeLocInfo
+from jaclang.compiler.unitree import UniNode
+from jaclang.settings import settings
 from jaclang.utils.helpers import pretty_print_source_location
 from jaclang.utils.log import logging
 
+if TYPE_CHECKING:
+    from jaclang.compiler.program import JacProgram
+
+T = TypeVar("T", bound=UniNode)
+R = TypeVar("R", bound=UniNode)
+
 
 class Alert:
     """Alert interface."""
@@ -55,27 +63,50 @@ class Alert:
         return self.as_log() + pretty_dump
 
 
-class Transform(ABC, Generic[T]):
+class Transform(ABC, Generic[T, R]):
     """Abstract class for IR passes."""
 
-    def __init__(
-        self,
-        input_ir: T,
-        prior: Optional[Transform] = None,
-    ) -> None:
+    def __init__(self, ir_in: T, prog: JacProgram) -> None:
         """Initialize pass."""
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.errors_had: list[Alert] = [] if not prior else prior.errors_had
-        self.warnings_had: list[Alert] = [] if not prior else prior.warnings_had
-        self.cur_node: AstNode = input_ir  # tracks current node during traversal
-        self.ir = self.transform(ir=input_ir)
+        self.errors_had: list[Alert] = []
+        self.warnings_had: list[Alert] = []
+        self.cur_node: UniNode = ir_in  # tracks current node during traversal
+        self.prog = prog
+        self.time_taken = 0.0
+        self.ir_in: T = ir_in
+        self.pre_transform()
+        self.ir_out: R = self.timed_transform(ir_in=ir_in)
+        self.post_transform()
+
+    def timed_transform(
+        self,
+        ir_in: T,
+    ) -> R:
+        """Transform with time tracking."""
+        start_time = time.time()
+        ir_out = self.transform(ir_in=ir_in)
+        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 ir_out
+
+    def pre_transform(self) -> None:
+        """Pre-transform hook."""
+        pass
+
+    def post_transform(self) -> None:
+        """Post-transform hook."""
+        pass
 
     @abstractmethod
-    def transform(self, ir: T) -> AstNode:
+    def transform(self, ir_in: T) -> R:
         """Transform interface."""
         pass
 
-    def log_error(self, msg: str, node_override: Optional[AstNode] = None) -> None:
+    def log_error(self, msg: str, node_override: Optional[UniNode] = None) -> None:
         """Pass Error."""
         alrt = Alert(
             msg,
@@ -83,9 +114,10 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.errors_had.append(alrt)
+        self.prog.errors_had.append(alrt)
         self.logger.error(alrt.as_log())
 
-    def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
+    def log_warning(self, msg: str, node_override: Optional[UniNode] = None) -> None:
         """Pass Error."""
         alrt = Alert(
             msg,
@@ -93,8 +125,16 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.warnings_had.append(alrt)
+        self.prog.warnings_had.append(alrt)
         self.logger.warning(alrt.as_log())
 
     def log_info(self, msg: str) -> None:
         """Log info."""
         self.logger.info(msg)
+
+    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}"
+        )