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

jaclang/utils/helpers.py

@@ -40,23 +40,23 @@ def clip_code_section(s: str, target_line: int, line_range: int) -> str:
     return "\n".join(result)
 
 
-def get_ast_nodes_as_snake_case() -> list[str]:
+def get_uni_nodes_as_snake_case() -> list[str]:
     """Get all AST nodes as snake case."""
     import inspect
     import sys
-    import jaclang.compiler.absyntree as ast
+    import jaclang.compiler.unitree as uni
 
-    module_name = ast.__name__
+    module_name = uni.__name__
     module = sys.modules[module_name]
 
     # Retrieve the source code of the module
     source_code = inspect.getsource(module)
 
     classes = inspect.getmembers(module, inspect.isclass)
-    ast_node_classes = [cls for _, cls in classes if issubclass(cls, ast.AstNode)]
+    uni_node_classes = [cls for _, cls in classes if issubclass(cls, uni.UniNode)]
 
     ordered_classes = sorted(
-        ast_node_classes, key=lambda cls: source_code.find(f"class {cls.__name__}")
+        uni_node_classes, key=lambda cls: source_code.find(f"class {cls.__name__}")
     )
     snake_names = []
     for cls in ordered_classes:
@@ -88,44 +88,29 @@ def extract_headings(file_path: str) -> dict[str, tuple[int, int]]:
     return headings
 
 
-def auto_generate_refs() -> None:
+def auto_generate_refs() -> str:
     """Auto generate lang reference for docs."""
     file_path = os.path.join(
         os.path.split(os.path.dirname(__file__))[0], "../jaclang/compiler/jac.lark"
     )
     result = extract_headings(file_path)
-    created_file_path = os.path.join(
-        os.path.split(os.path.dirname(__file__))[0],
-        "../support/jac-lang.org/docs/lang_ref/jac_ref.md",
-    )
-    destination_folder = os.path.join(
-        os.path.split(os.path.dirname(__file__))[0], "../examples/reference/"
-    )
-    with open(created_file_path, "w") as md_file:
-        md_file.write(
-            '# Jac Language Reference\n\n--8<-- "examples/reference/introduction.md"\n\n'
-        )
+    md_str = '# Jac Language Reference\n\n--8<-- "jac/examples/reference/introduction.md"\n\n'
     for heading, lines in result.items():
         heading = heading.strip()
         heading_snakecase = heading_to_snake(heading)
         content = (
-            f'## {heading}\n**Code Example**\n=== "Jac"\n    ```jac linenums="1"\n    --8<-- "examples/reference/'
+            f'## {heading}\n**Code Example**\n=== "Jac"\n    ```jac linenums="1"\n    --8<-- "jac/examples/reference/'
             f'{heading_snakecase}.jac"\n'
-            f'    ```\n=== "Python"\n    ```python linenums="1"\n    --8<-- "examples/reference/'
+            f'    ```\n=== "Python"\n    ```python linenums="1"\n    --8<-- "jac/examples/reference/'
             f'{heading_snakecase}.py"\n    ```\n'
             f'??? example "Jac Grammar Snippet"\n    ```yaml linenums="{lines[0]}"\n    --8<-- '
             f'"jaclang/compiler/jac.lark:{lines[0]}:{lines[1]}"\n    ```\n'
             "**Description**\n\n--8<-- "
-            f'"examples/reference/'
+            f'"jac/examples/reference/'
             f'{heading_snakecase}.md"\n'
         )
-        with open(created_file_path, "a") as md_file:
-            md_file.write(f"{content}\n")
-        md_file_name = f"{heading_snakecase}.md"
-        md_file_path = os.path.join(destination_folder, md_file_name)
-        if not os.path.exists(md_file_path):
-            with open(md_file_path, "w") as md_file:
-                md_file.write("")
+        md_str += f"{content}\n"
+    return md_str
 
 
 def is_standard_lib_module(module_path: str) -> bool:

jaclang/utils/lang_tools.py

@@ -6,12 +6,11 @@ import os
 import sys
 from typing import List, Optional, Type
 
-import jaclang.compiler.absyntree as ast
-from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
-from jaclang.compiler.passes.main.schedules import py_code_gen, type_checker_sched
-from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-from jaclang.compiler.symtable import SymbolTable
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.passes.main import CompilerMode as CMode, PyastBuildPass
+from jaclang.compiler.passes.tool.doc_ir_gen_pass import DocIRGenPass
+from jaclang.compiler.program import JacProgram
+from jaclang.compiler.unitree import UniScopeNode
 from jaclang.utils.helpers import auto_generate_refs, pascal_to_snake
 
 
@@ -25,7 +24,7 @@ class AstKidInfo:
         self.default = default
 
 
-class AstNodeInfo:
+class UniNodeInfo:
     """Meta data about AST nodes."""
 
     type_map: dict[str, type] = {}
@@ -35,11 +34,11 @@ class AstNodeInfo:
         self.cls = cls
         self.process(cls)
 
-    def process(self, cls: Type[ast.AstNode]) -> None:
-        """Process AstNode class."""
+    def process(self, cls: Type[uni.UniNode]) -> None:
+        """Process UniNode class."""
         self.name = cls.__name__
         self.doc = cls.__doc__
-        AstNodeInfo.type_map[self.name] = cls
+        UniNodeInfo.type_map[self.name] = cls
         self.class_name_snake = pascal_to_snake(cls.__name__)
         self.init_sig = inspect.signature(cls.__init__)
         self.kids: list[AstKidInfo] = []
@@ -67,25 +66,29 @@ class AstTool:
 
     def __init__(self) -> None:
         """Initialize."""
-        module = sys.modules[ast.__name__]
+        module = sys.modules[uni.__name__]
         source_code = inspect.getsource(module)
         classes = inspect.getmembers(module, inspect.isclass)
-        ast_node_classes = [
-            AstNodeInfo(cls)
+        uni_node_classes = [
+            UniNodeInfo(cls)
             for _, cls in classes
-            if issubclass(cls, ast.AstNode)
+            if issubclass(cls, uni.UniNode)
             and cls.__name__
             not in [
-                "AstNode",
+                "UniNode",
+                "UniScopeNode",
+                "UniCFGNode",
+                "ProgramModule",
                 "OOPAccessNode",
                 "WalkerStmtOnlyNode",
-                "JacSource",
+                "Source",
                 "EmptyToken",
                 "AstSymbolNode",
                 "AstSymbolStubNode",
                 "AstAccessNode",
                 "Literal",
                 "AstDocNode",
+                "AstImplNeedingNode",
                 "AstSemStrNode",
                 "PythonModuleAst",
                 "AstAsyncNode",
@@ -105,14 +108,14 @@ class AstTool:
         ]
 
         self.ast_classes = sorted(
-            ast_node_classes,
+            uni_node_classes,
             key=lambda cls: source_code.find(f"class {cls.name}"),
         )
 
     def pass_template(self) -> str:
         """Generate pass template."""
         output = (
-            "import jaclang.compiler.absyntree as ast\n"
+            "import jaclang.compiler.unitree as ast\n"
             "from jaclang.compiler.passes import Pass\n\n"
             "class SomePass(Pass):\n"
         )
@@ -135,7 +138,7 @@ class AstTool:
 
             emit('    """\n')
         output = (
-            output.replace("jaclang.compiler.absyntree.", "")
+            output.replace("jaclang.compiler.unitree.", "")
             .replace("typing.", "")
             .replace("<enum '", "")
             .replace("'>", "")
@@ -145,7 +148,7 @@ class AstTool:
         )
         return output
 
-    def py_ast_nodes(self) -> str:
+    def py_uni_nodes(self) -> str:
         """List python ast nodes."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
@@ -162,7 +165,7 @@ class AstTool:
         for i in node_names:
             nd = pascal_to_snake(i)
             this_func = (
-                f"def proc_{nd}(self, node: py_ast.{i}) -> ast.AstNode:\n"
+                f"def proc_{nd}(self, node: py_ast.{i}) -> ast.UniNode:\n"
                 + '    """Process python node."""\n\n'
             )
             if nd not in pass_func_names:
@@ -172,40 +175,17 @@ class AstTool:
             output += f"# missing: \n{i}\n"
         return output
 
-    def md_doc(self) -> str:
-        """Generate mermaid markdown doc."""
-        output = ""
-        for cls in self.ast_classes:
-            if not len(cls.kids):
-                continue
-            output += f"## {cls.name}\n"
-            output += "```mermaid\nflowchart LR\n"
-            for kid in cls.kids:
-                if "_end" in kid.name:
-                    kid.name = kid.name.replace("_end", "_end_")
-                arrow = "-.->" if "Optional" in kid.typ else "-->"
-                typ = (
-                    kid.typ.replace("Optional[", "")
-                    .replace("SubNodeList[", "")
-                    .replace("SubTag[", "")
-                    .replace("Sequence[", "")
-                    .replace("]", "")
-                    .replace("|", ",")
-                    .replace("list[", "list - ")
-                )
-                output += f"{cls.name} {arrow}|{typ}| {kid.name}\n"
-            output += "```\n\n"
-            output += f"{cls.doc} \n\n"
-        return output
-
     def ir(self, args: List[str]) -> str:
         """Generate a AST, SymbolTable tree for .jac file, or Python AST for .py file."""
-        error = "Usage: ir <choose one of (sym / sym. / ast / ast. / pyast / py / unparse)> <.py or .jac file_path>"
+        error = (
+            "Usage: ir <choose one of (sym / sym. / ast / ast. / docir / "
+            "pyast / py / unparse)> <.py or .jac file_path>"
+        )
         if len(args) != 2:
             return error
 
         output, file_name = args
-
+        prog = JacProgram()
         if not os.path.isfile(file_name):
             return f"Error: {file_name} not found"
 
@@ -221,42 +201,45 @@ class AstTool:
                     return f"\n{py_ast.dump(parsed_ast, indent=2)}"
                 try:
                     rep = PyastBuildPass(
-                        input_ir=ast.PythonModuleAst(
+                        ir_in=uni.PythonModuleAst(
                             parsed_ast,
-                            orig_src=ast.JacSource(file_source, file_name),
+                            orig_src=uni.Source(file_source, file_name),
                         ),
-                    ).ir
-
-                    schedule = py_code_gen_typed
-                    target = schedule[-1]
-                    for i in schedule:
-                        if i == target:
-                            break
-                        ast_ret = i(input_ir=rep, prior=None)
-                    ast_ret = target(input_ir=rep, prior=None)
-                    ir = ast_ret.ir
+                        prog=prog,
+                    ).ir_out
+                    print(rep.unparse())
+
+                    ir = prog.compile_from_str(
+                        source_str=rep.unparse(),
+                        file_path=file_name[:-3] + ".jac",
+                        mode=CMode.NO_CGEN,
+                    )
                 except Exception as e:
                     return f"Error While Jac to Py AST conversion: {e}"
             else:
-                ir = jac_file_to_pass(
-                    file_name, schedule=[*(py_code_gen[:-1]), *type_checker_sched]
-                ).ir
+                ir = prog.compile(file_name, mode=CMode.NO_CGEN)
 
             match output:
                 case "sym":
-                    return (
-                        ir.sym_tab.pp()
-                        if isinstance(ir.sym_tab, SymbolTable)
-                        else "Sym_tab is None."
-                    )
+                    out = ""
+                    for module_ in prog.mod.hub.values():
+                        mod_name = module_.name
+                        t = "#" * len(mod_name)
+                        out += f"##{t}##\n# {mod_name} #\n##{t}##\n{module_.sym_tab.sym_pp()}\n"
+                    return out
                 case "sym.":
                     return (
-                        ir.sym_tab.dotgen()
-                        if isinstance(ir.sym_tab, SymbolTable)
+                        ir.sym_tab.sym_dotgen()
+                        if isinstance(ir.sym_tab, UniScopeNode)
                         else "Sym_tab is None."
                     )
                 case "ast":
-                    return ir.pp()
+                    out = ""
+                    for module_ in prog.mod.hub.values():
+                        mod_name = module_.name
+                        t = "#" * len(mod_name)
+                        out += f"##{t}##\n# {mod_name} #\n##{t}##\n{module_.pp()}\n"
+                    return out
                 case "ast.":
                     return ir.dotgen()
                 case "unparse":
@@ -267,6 +250,8 @@ class AstTool:
                         if isinstance(ir.gen.py_ast[0], py_ast.AST)
                         else "Compile failed."
                     )
+                case "docir":
+                    return str(DocIRGenPass(ir, prog).ir_out.gen.doc_ir)
                 case "py":
                     return (
                         f"\n{ir.gen.py}"
@@ -278,10 +263,35 @@ class AstTool:
         else:
             return "Not a .jac or .py file, or invalid command for file type."
 
+    def autodoc_uninode(self) -> str:
+        """Generate mermaid markdown doc for uninodes."""
+        output = ""
+        for cls in self.ast_classes:
+            if not len(cls.kids):
+                continue
+            output += f"## {cls.name}\n"
+            output += "```mermaid\nflowchart LR\n"
+            for kid in cls.kids:
+                if "_end" in kid.name:
+                    kid.name = kid.name.replace("_end", "_end_")
+                arrow = "-.->" if "Optional" in kid.typ else "-->"
+                typ = (
+                    kid.typ.replace("Optional[", "")
+                    .replace("SubNodeList[", "")
+                    .replace("SubTag[", "")
+                    .replace("Sequence[", "")
+                    .replace("]", "")
+                    .replace("|", ",")
+                    .replace("list[", "list - ")
+                )
+                output += f"{cls.name} {arrow}|{typ}| {kid.name}\n"
+            output += "```\n\n"
+            output += f"{cls.doc} \n\n"
+        return output
+
     def automate_ref(self) -> str:
         """Automate the reference guide generation."""
-        auto_generate_refs()
-        return "References generated."
+        return auto_generate_refs()
 
     def gen_parser(self) -> str:
         """Generate static parser."""

jaclang/utils/module_resolver.py

@@ -0,0 +1,69 @@
+"""Module resolver utilities."""
+
+from __future__ import annotations
+
+import os
+import site
+from typing import Optional, Tuple
+
+
+def _candidate_from(base: str, parts: list[str]) -> Optional[Tuple[str, str]]:
+    candidate = os.path.join(base, *parts)
+    if os.path.isdir(candidate):
+        if os.path.isfile(os.path.join(candidate, "__init__.jac")):
+            return os.path.join(candidate, "__init__.jac"), "jac"
+        if os.path.isfile(os.path.join(candidate, "__init__.py")):
+            return os.path.join(candidate, "__init__.py"), "py"
+    if os.path.isfile(candidate + ".jac"):
+        return candidate + ".jac", "jac"
+    if os.path.isfile(candidate + ".py"):
+        return candidate + ".py", "py"
+    return None
+
+
+def resolve_module(target: str, base_path: str) -> Tuple[str, str]:
+    """Resolve module path and infer language."""
+    parts = target.split(".")
+    level = 0
+    while level < len(parts) and parts[level] == "":
+        level += 1
+    actual_parts = parts[level:]
+
+    for sp in site.getsitepackages():
+        res = _candidate_from(sp, actual_parts)
+        if res:
+            return res
+
+    base_dir = base_path if os.path.isdir(base_path) else os.path.dirname(base_path)
+    for _ in range(max(level - 1, 0)):
+        base_dir = os.path.dirname(base_dir)
+    res = _candidate_from(base_dir, actual_parts)
+    if res:
+        return res
+
+    jacpath = os.getenv("JACPATH")
+    if jacpath:
+        res = _candidate_from(jacpath, actual_parts)
+        if res:
+            return res
+        target_jac = actual_parts[-1] + ".jac"
+        target_py = actual_parts[-1] + ".py"
+        for root, _, files in os.walk(jacpath):
+            if target_jac in files:
+                return os.path.join(root, target_jac), "jac"
+            if target_py in files:
+                return os.path.join(root, target_py), "py"
+
+    return os.path.join(base_dir, *actual_parts), "py"
+
+
+def infer_language(target: str, base_path: str) -> str:
+    """Infer language for target relative to base path."""
+    _, lang = resolve_module(target, base_path)
+    return lang
+
+
+def resolve_relative_path(target: str, base_path: str) -> str:
+    """Resolve only the path component for a target."""
+    path, _ = resolve_module(target, base_path)
+    return path

jaclang/utils/test.py

@@ -8,8 +8,8 @@ from unittest import TestCase as _TestCase
 from _pytest.logging import LogCaptureFixture
 
 import jaclang
-from jaclang.compiler.passes import Pass
-from jaclang.utils.helpers import get_ast_nodes_as_snake_case as ast_snakes
+from jaclang.compiler.passes import UniPass
+from jaclang.utils.helpers import get_uni_nodes_as_snake_case as ast_snakes
 
 import pytest
 
@@ -110,7 +110,7 @@ class TestCaseMicroSuite(TestCase):
 class AstSyncTestMixin:
     """Mixin for testing AST sync."""
 
-    TargetPass: Optional[Pass] = None
+    TargetPass: Optional[UniPass] = None
 
     def test_pass_ast_complete(self) -> None:
         """Test for enter/exit name diffs with parser."""
@@ -119,9 +119,12 @@ class AstSyncTestMixin:
             for x in ast_snakes()
             if x
             not in [
-                "ast_node",
+                "uni_node",
+                "uni_scope_node",
+                "uni_c_f_g_node",
+                "program_module",
                 "walker_stmt_only_node",
-                "jac_source",
+                "source",
                 "empty_token",
                 "ast_symbol_node",
                 "ast_symbol_stub_node",

jaclang/utils/tests/test_lang_tools.py

@@ -8,16 +8,17 @@ from jaclang.utils.lang_tools import AstTool
 from jaclang.utils.test import TestCase
 
 
-class JacFormatPassTests(TestCase):
+class JacAstToolTests(TestCase):
     """Test pass module."""
 
     def setUp(self) -> None:
         """Set up test."""
+        self.tool = AstTool()
         return super().setUp()
 
     def test_pass_template(self) -> None:
         """Basic test for pass."""
-        out = AstTool().pass_template()
+        out = self.tool.pass_template()
         self.assertIn("target: Expr,", out)
         self.assertIn("self, node: ast.ReturnStmt", out)
         self.assertIn("exprs: SubNodeList[ExprAsItem],", out)
@@ -30,7 +31,7 @@ class JacFormatPassTests(TestCase):
         jac_file_path = os.path.join(
             os.path.dirname(jaclang.__file__), "../examples/reference/edges_walk.jac"
         )
-        out = AstTool().ir(["ast.", jac_file_path])
+        out = self.tool.ir(["ast.", jac_file_path])
         forbidden_strings = ["<<", ">>", "init", "super"]
         for i in forbidden_strings:
             self.assertNotIn(i, out)
@@ -42,7 +43,7 @@ class JacFormatPassTests(TestCase):
             "../examples/reference/names_and_references.jac",
         )
         msg = "error in " + jac_file
-        out = AstTool().ir(["ast", jac_file])
+        out = self.tool.ir(["ast", jac_file])
         self.assertIn("+-- Token", out, msg)
         self.assertIsNotNone(out, msg=msg)
 
@@ -59,7 +60,7 @@ class JacFormatPassTests(TestCase):
 
         for file in jac_py_files:
             msg = "error in " + file
-            out = AstTool().ir(["pyast", jac_py_directory + file])
+            out = self.tool.ir(["pyast", jac_py_directory + file])
             if file.endswith(".jac"):
                 self.assertIn("Module(", out, msg)
                 self.assertIsNotNone(out, msg=msg)
@@ -97,13 +98,14 @@ class JacFormatPassTests(TestCase):
             for file in all_reference_files
             if file not in created_files
         ]
+        print(other_reference_files)
         self.assertEqual(len(other_reference_files), 0)
 
     def test_py_jac_mode(self) -> None:
         """Testing for py_jac_mode support."""
         file = self.fixture_abs_path("../../../tests/fixtures/pyfunc.py")
-        out = AstTool().ir(["unparse", file])
-        self.assertIn("can my_print(x: object) -> None", out)
+        out = self.tool.ir(["unparse", file])
+        self.assertIn("def my_print(x: object) -> None", out)
 
     def test_sym_sym_dot(self) -> None:
         """Testing for sym, sym. AstTool."""
@@ -112,14 +114,37 @@ class JacFormatPassTests(TestCase):
                 os.path.dirname(jaclang.__file__), "../examples/reference/atom.jac"
             )
         )
-        out = AstTool().ir(["sym", jac_file])
+        out = self.tool.ir(["sym", jac_file])
         self.assertNotIn(
             "\n|   +-- ConnectionAbortedError\n|   |   +-- public var\n|   +-- ConnectionError\n|",
             out,
         )
-        self.assertTrue(
-            out.startswith("SymTable::Module(atom)\n+-- Symbols\n|   +-- (e)x\n|")
-        )
-        out = AstTool().ir(["sym.", jac_file])
-        self.assertEqual('2 [label="(e)x"];', out.split("\n")[4])
+        check_list = [
+            "########",
+            "# atom #",
+            "########",
+            "SymTable::Module(atom)",
+            "|   +-- list1",
+            "|   +-- x",
+            "|   +-- impl.x",
+            "|   +-- c",
+            "|   +-- d",
+            "|   +-- a",
+            "|   +-- b",
+            "+-- SymTable::ImplDef(impl.x)",
+            " SymTable::Enum(x)",
+            "+-- line 19, col 13",
+        ]
+        for i in check_list:
+            self.assertIn(i, out)
+        out = self.tool.ir(["sym.", jac_file])
+        self.assertIn('[label="impl.x"];', out)
         self.assertNotIn('[label="str"];', out)
+
+    def test_uninode_doc(self) -> None:
+        """Testing for Autodoc for Uninodes."""
+        auto_uni = self.tool.autodoc_uninode()
+        self.assertIn(
+            "## LambdaExpr\n```mermaid\nflowchart LR\nLambdaExpr -->|Expr| body",
+            auto_uni,
+        )