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

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

@@ -4,6 +4,8 @@ import ast as py_ast
 import inspect
 
 from jaclang.compiler.passes.main import PyastBuildPass
+from jaclang.compiler.program import JacProgram
+from jaclang.compiler.unitree import PythonModuleAst, Source
 from jaclang.utils.helpers import pascal_to_snake
 from jaclang.utils.test import TestCase
 
@@ -40,3 +42,16 @@ class PyastBuildPassTests(TestCase):
             self.assertIn(name, node_names)
         for name in node_names:
             self.assertIn(name, pass_func_names)
+
+    def test_str2doc(self) -> None:
+        """Test str2doc."""
+        with open(self.fixture_abs_path("str2doc.py"), "r") as f:
+            file_source = f.read()
+        code = PyastBuildPass(
+            ir_in=PythonModuleAst(
+                py_ast.parse(file_source),
+                orig_src=Source(file_source, "str2doc.py"),
+            ),
+            prog=JacProgram(),
+        ).ir_out.unparse()
+        self.assertIn('"""This is a test function."""\ndef foo()', code)

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

@@ -5,9 +5,10 @@ import io
 import sys
 import types
 
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import PyastGenPass, SubNodeTabPass
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.passes.main import CompilerMode as CMode, PyastGenPass
+from jaclang.compiler.program import JacProgram
+from jaclang.runtimelib.machine import JacMachine
 from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
 
 
@@ -35,30 +36,24 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def test_hodge_podge(self) -> None:
         """Basic test for pass."""
-        code_gen = jac_file_to_pass(
+        (out := JacProgram()).compile(
             self.examples_abs_path("micro/hodge_podge.jac"),
-            target=PyastGenPass,
         )
 
-        self.assertFalse(code_gen.errors_had)
+        self.assertFalse(out.errors_had)
 
     def test_circle_py_ast(self) -> None:
         """Basic test for pass."""
-        code_gen = jac_file_to_pass(
+        code_gen = (out := JacProgram()).compile(
             self.examples_abs_path("manual_code/circle.jac"),
-            target=PyastGenPass,
         )
-        import ast as ast3
-
-        if code_gen.ir.gen.py_ast and isinstance(
-            code_gen.ir.gen.py_ast[0], ast3.Module
-        ):
-            prog = compile(code_gen.ir.gen.py_ast[0], filename="<ast>", mode="exec")
+        if code_gen.gen.py_ast and isinstance(code_gen.gen.py_ast[0], ast3.Module):
+            prog = compile(code_gen.gen.py_ast[0], filename="<ast>", mode="exec")
             captured_output = io.StringIO()
             sys.stdout = captured_output
             module = types.ModuleType("__main__")
-            module.__dict__["__file__"] = code_gen.ir.loc.mod_path
-            module.__dict__["__jac_mod_bundle__"] = None
+            module.__dict__["__file__"] = code_gen.loc.mod_path
+            module.__dict__["__jac_mach__"] = JacMachine()
             exec(prog, module.__dict__)
             sys.stdout = sys.__stdout__
             stdout_value = captured_output.getvalue()
@@ -71,13 +66,13 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
                 stdout_value,
             )
 
-        self.assertFalse(code_gen.errors_had)
+        self.assertFalse(out.errors_had)
 
-    def parent_scrub(self, node: ast.AstNode) -> bool:
+    def parent_scrub(self, node: uni.UniNode) -> bool:
         """Validate every node has parent."""
         success = True
         for i in node.kid:
-            if not isinstance(i, ast.Module) and i.parent is None:
+            if not isinstance(i, uni.Module) and i.parent is None:
                 success = False
                 break
             else:
@@ -86,11 +81,9 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        code_gen = jac_file_to_pass(
-            self.fixture_abs_path(filename), target=PyastGenPass
-        )
-        from_jac_str = ast3.dump(code_gen.ir.gen.py_ast[0], indent=2)
-        from_jac = code_gen.ir.gen.py_ast[0]
+        code_gen = JacProgram().compile(self.fixture_abs_path(filename))
+        from_jac_str = ast3.dump(code_gen.gen.py_ast[0], indent=2)
+        from_jac = code_gen.gen.py_ast[0]
         try:
             compile(from_jac, filename="<ast>", mode="exec")
         except Exception as e:
@@ -103,7 +96,7 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             except Exception as e:
                 print(filename, ast3.dump(i, indent=2))
                 raise e
-        self.assertTrue(self.parent_scrub(code_gen.ir))
+        self.assertTrue(self.parent_scrub(code_gen))
         self.assertGreater(len(from_jac_str), 10)
 
 
@@ -117,11 +110,11 @@ class ValidateTreeParentTest(TestCaseMicroSuite):
         """Set up test."""
         return super().setUp()
 
-    def parent_scrub(self, node: ast.AstNode) -> bool:
+    def parent_scrub(self, node: uni.UniNode) -> bool:
         """Validate every node has parent."""
         success = True
         for i in node.kid:
-            if not isinstance(i, ast.Module) and i.parent is None:
+            if not isinstance(i, uni.Module) and i.parent is None:
                 success = False
                 break
             else:
@@ -130,14 +123,12 @@ class ValidateTreeParentTest(TestCaseMicroSuite):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        code_gen = jac_file_to_pass(
-            self.fixture_abs_path(filename), target=SubNodeTabPass
-        )
-        self.assertTrue(self.parent_scrub(code_gen.ir))
-        code_gen = jac_file_to_pass(
-            self.fixture_abs_path(filename), target=PyastGenPass
+        code_gen = JacProgram().compile(
+            self.fixture_abs_path(filename), mode=CMode.PARSE
         )
-        self.assertTrue(self.parent_scrub(code_gen.ir))
+        self.assertTrue(self.parent_scrub(code_gen))
+        code_gen = JacProgram().compile(self.fixture_abs_path(filename))
+        self.assertTrue(self.parent_scrub(code_gen))
 
 
 ValidateTreeParentTest.self_attach_micro_tests()

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

@@ -2,7 +2,7 @@
 
 import marshal
 
-from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
 
@@ -15,11 +15,11 @@ class PyBytecodeGenPassTests(TestCase):
 
     def test_simple_bcgen(self) -> None:
         """Basic test for pass."""
-        jac_code = jac_file_to_pass(
+        jac_code = JacProgram().compile(
             file_path=self.fixture_abs_path("func.jac"),
         )
         try:
-            marshal.loads(jac_code.ir.gen.py_bytecode)
+            marshal.loads(jac_code.gen.py_bytecode)
             self.assertTrue(True)
         except ValueError:
             self.fail("Invalid bytecode generated")

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

@@ -1,7 +1,8 @@
 """Test sub node pass module."""
 
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import SubNodeTabPass
+from jaclang.compiler.passes import UniPass
+from jaclang.compiler.passes.main import CompilerMode as CMode
+from jaclang.compiler.program import JacProgram
 from jaclang.utils.test import TestCase
 
 
@@ -14,12 +15,12 @@ class SubNodePassTests(TestCase):
 
     def test_sub_node_pass(self) -> None:
         """Basic test for pass."""
-        code_gen = jac_file_to_pass(
+        code_gen = (out := JacProgram()).compile(
             file_path=self.examples_abs_path("manual_code/circle.jac"),
-            target=SubNodeTabPass,
+            mode=CMode.PARSE,
         )
-        for i in code_gen.ir.kid[1].kid:
+        for i in code_gen.kid[1].kid:
             for k, v in i._sub_node_tab.items():
                 for n in v:
-                    self.assertIn(n, code_gen.get_all_sub_nodes(i, k, brute_force=True))
-        self.assertFalse(code_gen.errors_had)
+                    self.assertIn(n, UniPass.get_all_sub_nodes(i, k, brute_force=True))
+        self.assertFalse(out.errors_had)

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

@@ -1,11 +1,11 @@
 """Test pass module."""
 
-# from jaclang.compiler.compile import jac_file_to_pass
+# from jaclang.compiler.program import JacProgram
 from jaclang.compiler.passes.main import SymTabBuildPass
-from jaclang.utils.test import AstSyncTestMixin, TestCase
+from jaclang.utils.test import TestCase
 
 
-class SymTabBuildPassTests(TestCase, AstSyncTestMixin):
+class SymTabBuildPassTests(TestCase):
     """Test pass module."""
 
     TargetPass = SymTabBuildPass
@@ -16,7 +16,7 @@ class SymTabBuildPassTests(TestCase, AstSyncTestMixin):
 
     # def test_name_collision(self) -> None:
     #     """Basic test for pass."""
-    #     state = jac_file_to_pass(
+    #     state = JacProgram().jac_file_to_pass(
     #         self.fixture_abs_path("multi_def_err.jac"), SymTabBuildPass
     #     )
     #     self.assertGreater(len(state.warnings_had), 0)

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

@@ -0,0 +1,62 @@
+"""Test SymTable Link Pass."""
+
+import os
+
+from jaclang.compiler.passes.main import CompilerMode as CMode
+from jaclang.compiler.program import JacProgram
+from jaclang.utils.test import TestCase
+
+
+class SymTabLinkPassTests(TestCase):
+    """Test pass module."""
+
+    # Need change
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_no_dupl_symbols(self) -> None:
+        """Basic test for pass."""
+        file_path = os.path.join(
+            os.path.dirname(__file__),
+            "fixtures",
+            "symtab_link_tests",
+            "no_dupls.jac",
+        )
+        mod = JacProgram().compile(file_path, mode=CMode.TYPECHECK)
+        self.assertEqual(
+            len(mod.sym_tab.names_in_scope.values()),
+            3,
+        )
+        for i in ["[Symbol(a,", "Symbol(Man,", "Symbol(p,"]:
+            self.assertIn(
+                i,
+                str(mod.sym_tab.names_in_scope.values()),
+            )
+        self.assertEqual(len(mod.sym_tab.names_in_scope["a"].uses), 2)
+        self.assertEqual(
+            len(
+                list(
+                    mod.sym_tab.kid_scope[0]
+                    .kid_scope[0]
+                    .kid_scope[0]
+                    .kid_scope[0]
+                    .inherited_scope[0]
+                    .base_symbol_table.names_in_scope.values()
+                )[0].uses,
+            ),
+            3,
+        )
+
+    def test_package(self) -> None:
+        """Test package."""
+        file_path = os.path.join(
+            os.path.dirname(__file__),
+            "fixtures",
+            "symtab_link_tests",
+            "main.jac",
+        )
+        prog = JacProgram()
+        prog.compile(file_path, mode=CMode.COMPILE)
+        self.assertEqual(prog.errors_had, [])
+        self.assertEqual(prog.warnings_had, [])

jaclang/compiler/passes/tool/__init__.py

@@ -2,8 +2,10 @@
 
 from .fuse_comments_pass import FuseCommentsPass  # noqa: I100
 from .jac_formatter_pass import JacFormatPass  # noqa: I100
+from .doc_ir_gen_pass import DocIRGenPass  # noqa: I100
 
 __all__ = [
+    "DocIRGenPass",
     "FuseCommentsPass",
     "JacFormatPass",
 ]

jaclang/compiler/passes/tool/doc_ir.py

@@ -0,0 +1,179 @@
+"""Document Intermediate Representation (DocIR) classes."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+# Define DocType for self-referential typing
+DocType = Union["Doc", "Text", "Line", "Group", "Indent", "Concat", "IfBreak", "Align"]
+
+
+class Doc:
+    """Base class for document parts."""
+
+    def __str__(self) -> str:
+        """Return a string representation of the Doc object."""
+        return self.__class__.__name__
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Doc object."""
+        return self.treeprint()
+
+    def treeprint(self, level: int = 0) -> str:
+        """Return an indented string representation of the Doc object."""
+        indent = "  " * level
+        return f"{indent}{self.__class__.__name__}"
+
+
+class Text(Doc):
+    """Simple text content."""
+
+    def __init__(self, text: str) -> None:
+        """Initialize a Text object."""
+        self.text: str = text
+
+    def __str__(self) -> str:
+        """Return a string representation of the Text object."""
+        return f'Text("{self.text}")'
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        return f'{indent}Text("{self.text}")'
+
+
+class Line(Doc):
+    """Represents a line break that can be preserved or flattened."""
+
+    def __init__(
+        self, hard: bool = False, literal: bool = False, tight: bool = False
+    ) -> None:
+        """Initialize a Line object."""
+        self.hard: bool = hard  # If True, always break
+        self.literal: bool = literal  # includes the literal newline in flattened output
+        self.tight: bool = tight  # If True, no space is added
+
+    def __str__(self) -> str:
+        """Return a string representation of the Line object."""
+        attrs: list[str] = []
+        if self.hard:
+            attrs.append("hard")
+        if self.literal:
+            attrs.append("literal")
+        return f"Line({', '.join(attrs)})"
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        attrs: list[str] = []
+        if self.hard:
+            attrs.append("hard=True")
+        if self.literal:
+            attrs.append("literal=True")
+        return f"{indent}Line({', '.join(attrs)})"
+
+
+class Group(Doc):
+    """A group that can be printed flat or broken into multiple lines."""
+
+    def __init__(
+        self,
+        contents: DocType,
+        break_contiguous: bool = False,
+        id: Optional[str] = None,
+    ) -> None:
+        """Initialize a Group object."""
+        self.contents: DocType = contents
+        self.break_contiguous: bool = break_contiguous
+        self.id: Optional[str] = id
+
+    def __str__(self) -> str:
+        """Return a string representation of the Group object."""
+        return f"Group({self.contents})"
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        header = (
+            f"{indent}Group(id={self.id}, break_contiguous={self.break_contiguous}):"
+        )
+        children_repr: list[str] = [self.contents.treeprint(level + 1)]
+        return f"{header}\n" + "\n".join(children_repr)
+
+
+class Indent(Doc):
+    """Indented content."""
+
+    def __init__(self, contents: DocType) -> None:
+        """Initialize an Indent object."""
+        self.contents: DocType = contents
+
+    def __str__(self) -> str:
+        """Return a string representation of the Indent object."""
+        return f"Indent({self.contents})"
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        header = f"{indent}Indent:"
+        children_repr: list[str] = [self.contents.treeprint(level + 1)]
+        return f"{header}\n" + "\n".join(children_repr)
+
+
+class Concat(Doc):
+    """A sequence of doc parts."""
+
+    def __init__(self, parts: list[DocType]) -> None:
+        """Initialize a Concat object."""
+        self.parts: list[DocType] = parts
+
+    def __str__(self) -> str:
+        """Return a string representation of the Concat object."""
+        return f"Concat({self.parts})"
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        header = f"{indent}Concat:"
+        children_repr = [part.treeprint(level + 1) for part in self.parts]
+        return f"{header}\n" + "\n".join(children_repr)
+
+
+class IfBreak(Doc):
+    """Content that differs based on whether the parent group is broken."""
+
+    def __init__(self, break_contents: DocType, flat_contents: DocType) -> None:
+        """Initialize an IfBreak object."""
+        self.break_contents: DocType = break_contents
+        self.flat_contents: DocType = flat_contents
+
+    def __str__(self) -> str:
+        """Return a string representation of the IfBreak object."""
+        return f"IfBreak({self.break_contents}, {self.flat_contents})"
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        header = f"{indent}IfBreak:"
+        break_repr: list[str] = [f"{indent}  break_contents:"]
+        break_repr.append(self.break_contents.treeprint(level + 2))
+
+        flat_repr: list[str] = [f"{indent}  flat_contents:"]
+        flat_repr.append(self.flat_contents.treeprint(level + 2))
+
+        return f"{header}\n" + "\n".join(break_repr) + "\n" + "\n".join(flat_repr)
+
+
+class Align(Doc):
+    """Alignment relative to the current indentation level."""
+
+    def __init__(self, contents: DocType, n: Optional[int] = None) -> None:
+        """Initialize an Align object."""
+        self.contents: DocType = contents
+        self.n: Optional[int] = (
+            n  # Number of spaces, or null to use current indentation level
+        )
+
+    def __str__(self) -> str:
+        """Return a string representation of the Align object."""
+        return f"Align({self.n}, {self.contents})"
+
+    def treeprint(self, level: int = 0) -> str:
+        indent = "  " * level
+        header = f"{indent}Align(n={self.n}):"
+        children_repr: list[str] = [self.contents.treeprint(level + 1)]
+        return f"{header}\n" + "\n".join(children_repr)