jaclang 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

jaclang/jac/plugin/spec.py

@@ -1,7 +1,7 @@
 """Jac Language Features."""
 from __future__ import annotations
 
-from typing import Any, Callable, Optional, Protocol, TypeVar
+from typing import Any, Callable, Optional, Protocol, Type, TypeVar
 
 from jaclang.jac.constant import EdgeDir
 
@@ -10,14 +10,26 @@ import pluggy
 hookspec = pluggy.HookspecMarker("jac")
 
 
-class ArchitypeProtocol(Protocol):
+class Architype:
     """Architype Protocol."""
 
-    _jac_: None
+    class ArchitypeProtocol(Protocol):
+        """Architype Protocol."""
+
+    _jac_: ArchitypeProtocol
+
+    def __call__(self, target: Architype) -> None:
+        """Call the architype's data spatial behavior."""
+        if callable(self._jac_):
+            return self._jac_(target)
+
+
+class AbsRootHook:
+    """Abstract Root Node."""
 
 
 T = TypeVar("T")
-AT = TypeVar("AT", bound=ArchitypeProtocol)
+AT = TypeVar("AT", bound=Architype)
 
 
 class JacFeatureSpec:
@@ -25,39 +37,45 @@ class JacFeatureSpec:
 
     @staticmethod
     @hookspec(firstresult=True)
-    def bind_architype(arch: AT) -> None:
+    def bind_architype(arch: Type[AT], arch_type: str) -> bool:
         """Create a new architype."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def make_ds_ability(event: str, trigger: Optional[type]) -> Callable[[type], type]:
         """Create a new architype."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def elvis(op1: Optional[T], op2: T) -> T:  # noqa: ANN401
         """Jac's elvis operator feature."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def report(expr: Any) -> Any:  # noqa: ANN401
         """Jac's report stmt feature."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def ignore(walker_obj: Any, expr: Any) -> bool:  # noqa: ANN401
         """Jac's ignore stmt feature."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def visit(walker_obj: Any, expr: Any) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
-        return True
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def disengage(walker_obj: Any) -> bool:  # noqa: ANN401
         """Jac's disengage stmt feature."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
@@ -65,6 +83,7 @@ class JacFeatureSpec:
         node_obj: Any, dir: EdgeDir, filter_type: Optional[type]  # noqa: ANN401
     ) -> list[Any]:
         """Jac's apply_dir stmt feature."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
@@ -73,11 +92,13 @@ class JacFeatureSpec:
 
         Note: connect needs to call assign compr with tuple in op
         """
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
     def disconnect(op1: Optional[T], op2: T, op: Any) -> T:  # noqa: ANN401
         """Jac's connect operator feature."""
+        raise NotImplementedError
 
     @staticmethod
     @hookspec(firstresult=True)
@@ -85,3 +106,10 @@ class JacFeatureSpec:
         target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
     ) -> list[T]:
         """Jac's assign comprehension feature."""
+        raise NotImplementedError
+
+    @staticmethod
+    @hookspec(firstresult=True)
+    def get_root() -> Architype:
+        """Jac's root getter."""
+        raise NotImplementedError

jaclang/jac/symtable.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 from enum import Enum
 from typing import Optional, TYPE_CHECKING
 
+from jaclang.utils.treeprinter import print_symtab_tree
+
 
 if TYPE_CHECKING:
     import jaclang.jac.absyntree as ast
@@ -158,6 +160,10 @@ class SymbolTable:
         self.kid.append(SymbolTable(name, key_node, self))
         return self.kid[-1]
 
+    def pp(self, depth: Optional[int] = None) -> str:
+        """Pretty print."""
+        return print_symtab_tree(root=self, depth=depth)
+
     def __repr__(self) -> str:
         """Repr."""
         out = f"{self.name} {super().__repr__()}:\n"

jaclang/jac/tests/test_workspace.py

@@ -5,7 +5,7 @@ from jaclang.jac.workspace import Workspace
 from jaclang.utils.test import TestCase
 
 
-class TestWrokspace(TestCase):
+class TestWorkspace(TestCase):
     """Test Jac Workspace."""
 
     def test_workspace_basic(self) -> None:
@@ -36,3 +36,57 @@ class TestWrokspace(TestCase):
         ws = Workspace(path=os.path.join(os.path.dirname(__file__)))
         key = [i for i in ws.modules.keys() if "fam.jac" in i][0]
         self.assertGreater(len(ws.get_uses(key)), 5)
+
+    def test_man_code_dir(self) -> None:
+        """Test of circle workspace."""
+        loc = os.path.join(os.path.dirname(__file__))
+        ws = Workspace(path=loc + "/../../../examples/manual_code")
+        key = [i for i in ws.modules.keys() if "circle.jac" in i][0]
+        # print(ws.modules[key].ir.sym_tab.pp())
+        # for i in ws.get_symbols(key):
+        #     print(i.decl.pp(depth=2))
+        out = ""
+        for i in ws.get_uses(key):
+            # print(i.pp(depth=2).strip())
+            out += i.pp(depth=2)
+        for i in [
+            "math",
+            "calculate_area",
+            "RAD",
+            "expected_area",
+            "Circle",
+            "c",
+            "ShapeType",
+            "float",
+            "radius",
+            "CIRCLE",
+            "Shape",
+            "__init__",
+            "print",
+        ]:
+            self.assertIn(i, out)
+
+    # def test_decl_impl(self) -> None:
+    #     """Test of circle workspace."""
+    #     loc = os.path.join(os.path.dirname(__file__))
+    #     ws = Workspace(path=loc + "/../../../examples/manual_code")
+    #     key = [i for i in ws.modules.keys() if "circle_clean.jac" in i][0]
+    #     out = ""
+    #     for i in ws.get_uses(key):
+    #         out += i.pp(depth=2)
+    #     for i in [
+    #         "math",
+    #         "calculate_area",
+    #         "RAD",
+    #         "expected_area",
+    #         "Circle",
+    #         "c",
+    #         "ShapeType",
+    #         "float",
+    #         "radius",
+    #         "CIRCLE",
+    #         "Shape",
+    #         "__init__",
+    #         "print",
+    #     ]:
+    #         self.assertIn(i, out)

jaclang/jac/transpiler.py

@@ -4,11 +4,7 @@ from typing import Optional, Type
 import jaclang.jac.absyntree as ast
 from jaclang.jac.parser import JacParser
 from jaclang.jac.passes import Pass
-from jaclang.jac.passes.main import (
-    PyOutPass,
-    PyastGenPass,
-    pass_schedule,
-)
+from jaclang.jac.passes.main import PyOutPass, pass_schedule
 from jaclang.jac.passes.tool import JacFormatPass
 from jaclang.jac.passes.tool.schedules import format_pass
 from jaclang.jac.passes.transform import Alert
@@ -18,7 +14,6 @@ def transpile_jac(file_path: str) -> list[Alert]:
     """Transpiler Jac file and return python code as string."""
     code = jac_file_to_pass(
         file_path=file_path,
-        target=PyastGenPass,
         schedule=pass_schedule,
     )
     if isinstance(code.ir, ast.Module) and not code.errors_had:
@@ -30,7 +25,7 @@ def transpile_jac(file_path: str) -> list[Alert]:
 
 def jac_file_to_pass(
     file_path: str,
-    target: Optional[Type[Pass]] = PyastGenPass,
+    target: Optional[Type[Pass]] = None,
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
@@ -46,7 +41,7 @@ def jac_file_to_pass(
 def jac_str_to_pass(
     jac_str: str,
     file_path: str,
-    target: Optional[Type[Pass]] = PyastGenPass,
+    target: Optional[Type[Pass]] = None,
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""
@@ -64,7 +59,7 @@ def jac_str_to_pass(
 
 def jac_pass_to_pass(
     in_pass: Pass,
-    target: Optional[Type[Pass]] = PyastGenPass,
+    target: Optional[Type[Pass]] = None,
     schedule: list[Type[Pass]] = pass_schedule,
 ) -> Pass:
     """Convert a Jac file to an AST."""

jaclang/utils/helpers.py

@@ -1,11 +1,9 @@
 """Utility functions and classes for Jac compilation toolchain."""
 import re
 import textwrap
-import traceback
 
 
 import jaclang.jac.absyntree as ast
-from jaclang.jac.constant import Constants as Con, Values as Val
 
 
 def pascal_to_snake(pascal_string: str) -> str:
@@ -44,37 +42,6 @@ def dedent_code_block(code: str) -> str:
     return textwrap.dedent(code)
 
 
-def handle_jac_error(code_string: str, e: Exception, tb: traceback.StackSummary) -> str:
-    """Handle Jac Error."""
-    except_line = e.end_lineno if isinstance(e, SyntaxError) else list(tb)[-1].lineno
-    if not isinstance(except_line, int) or except_line == 0:
-        return ""
-    py_error_region = clip_code_section(
-        add_line_numbers(code_string), except_line, Val.JAC_ERROR_LINE_RANGE
-    )
-    try:
-        jac_err_line = int(code_string.splitlines()[except_line - 1].split()[-1])
-        mod_index = int(code_string.splitlines()[except_line - 1].split()[-2])
-        mod_paths = code_string.split(Con.JAC_DEBUG_SPLITTER)[1].strip().splitlines()
-        target_mod = mod_paths[mod_index]
-        with open(target_mod, "r") as file:
-            jac_code_string = file.read()
-        jac_error_region = clip_code_section(
-            add_line_numbers(jac_code_string), jac_err_line, Val.JAC_ERROR_LINE_RANGE
-        )
-        target_mod = f"JacCode File: {target_mod}:{jac_err_line}"
-    except Exception as e:
-        jac_error_region = str(e)
-        target_mod = ""
-    snippet = (
-        f"{Con.JAC_ERROR_PREAMBLE}\n"
-        f"{target_mod}\n"
-        f"JacCode Snippet:\n{jac_error_region}\n"
-        f"PyCode Snippet:\n{py_error_region}\n"
-    )
-    return snippet
-
-
 def get_ast_nodes_as_snake_case() -> list[str]:
     """Get all AST nodes as snake case."""
     import inspect

jaclang/utils/lang_tools.py

@@ -191,6 +191,9 @@ class AstTool:
                 arrow = "-.->" if "Optional" in kid.typ else "-->"
                 typ = (
                     kid.typ.replace("Optional[", "")
+                    .replace("SubNodeList[", "")
+                    .replace("SubTag[", "")
+                    .replace("Sequence[", "")
                     .replace("]", "")
                     .replace("|", ",")
                     .replace("list[", "list - ")

jaclang/utils/test.py

@@ -65,7 +65,9 @@ class TestCaseMicroSuite(ABC, TestCase):
         """Attach micro tests."""
         for filename in [
             os.path.normpath(os.path.join(root, name))
-            for root, _, files in os.walk(os.path.dirname(jaclang.__file__))
+            for root, _, files in os.walk(
+                os.path.dirname(os.path.dirname(jaclang.__file__))
+            )
             for name in files
             if name.endswith(".jac") and not name.startswith("err")
         ]:

jaclang/utils/treeprinter.py

@@ -0,0 +1,171 @@
+"""Tree Printing Helpers for Jac."""
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from jaclang.jac.absyntree import AstNode, SymbolTable
+
+
+def print_ast_tree(
+    root: AstNode,
+    marker: str = "+-- ",
+    level_markers: Optional[list[bool]] = None,
+    output_file: Optional[str] = None,
+    max_depth: Optional[int] = None,
+) -> str:
+    """Recursively print ast tree."""
+    from jaclang.jac.absyntree import AstSymbolNode, Token
+
+    def __node_repr_in_tree(node: AstNode) -> str:
+        if isinstance(node, Token):
+            return f"{node.__class__.__name__} - {node.value}"
+        elif isinstance(node, AstSymbolNode):
+            return f"{node.__class__.__name__} - {node.sym_name}"
+        else:
+            return f"{node.__class__.__name__}"
+
+    if root is None or (
+        max_depth is not None and len(level_markers or []) >= max_depth
+    ):
+        return ""
+
+    empty_str = " " * len(marker)
+    connection_str = "|" + empty_str[:-1]
+    if not level_markers:
+        level_markers = []
+    level = len(level_markers)  # recursion level
+
+    def mapper(draw: bool) -> str:
+        return connection_str if draw else empty_str
+
+    markers = "".join(map(mapper, level_markers[:-1]))
+    markers += marker if level > 0 else ""
+
+    tree_str = f"{root.loc}\t{markers}{__node_repr_in_tree(root)}\n"
+
+    for i, child in enumerate(root.kid):
+        is_last = i == len(root.kid) - 1
+        tree_str += print_ast_tree(
+            child, marker, [*level_markers, not is_last], output_file, max_depth
+        )
+
+    # Write to file only at the top level call
+    if output_file and level == 0:
+        with open(output_file, "w") as f:
+            f.write(tree_str)
+
+    return tree_str
+
+
+class SymbolTree:
+    """Symbol Tree Node."""
+
+    def __init__(
+        self,
+        node_name: str,
+        parent: Optional[SymbolTree] = None,
+        children: Optional[list[SymbolTree]] = None,
+    ) -> None:
+        """Initialize Symbol Tree Node."""
+        self.parent = parent
+        self.kid = children if children is not None else []
+        self.name = node_name
+
+    @property
+    def parent(self) -> Optional[SymbolTree]:
+        """Get parent node."""
+        return self.__parent
+
+    @parent.setter
+    def parent(self, parent_node: Optional[SymbolTree]) -> None:
+        """Set parent node."""
+        if parent_node:
+            self.__parent = parent_node
+            parent_node.kid.append(self)
+
+
+def _build_symbol_tree_common(
+    node: SymbolTable, parent_node: Optional[SymbolTree] = None
+) -> SymbolTree:
+    root = SymbolTree(
+        node_name=f"SymTable::{node.owner.__class__.__name__}({node.name})",
+        parent=parent_node,
+    )
+    symbols = SymbolTree(node_name="Symbols", parent=root)
+    children = SymbolTree(node_name="Sub Tables", parent=root)
+
+    for sym in node.tab.values():
+        symbol_node = SymbolTree(node_name=f"{sym.sym_name}", parent=symbols)
+        SymbolTree(node_name=f"{sym.access} {sym.sym_type}", parent=symbol_node)
+
+        if sym.decl and sym.decl.loc.first_line > 0:
+            SymbolTree(
+                node_name=f"decl: line {sym.decl.loc.first_line}, col {sym.decl.loc.col_start}",
+                parent=symbol_node,
+            )
+            defn = SymbolTree(node_name="defn", parent=symbol_node)
+            [
+                SymbolTree(
+                    node_name=f"line {n.loc.first_line}, col {n.loc.col_start}",
+                    parent=defn,
+                )
+                for n in sym.defn
+            ]
+
+    for k in node.kid:
+        _build_symbol_tree_common(k, children)
+    return root
+
+
+def print_symtab_tree(
+    root: SymbolTable,
+    marker: str = "+-- ",
+    level_markers: Optional[list[bool]] = None,
+    output_file: Optional[str] = None,
+    depth: Optional[int] = None,
+) -> str:
+    """Recursively print symbol table tree."""
+    return get_symtab_tree_str(
+        _build_symbol_tree_common(root),
+        marker,
+        level_markers,
+        output_file,
+        depth,
+    )
+
+
+def get_symtab_tree_str(
+    root: SymbolTree,
+    marker: str = "+-- ",
+    level_markers: Optional[list[bool]] = None,
+    output_file: Optional[str] = None,
+    depth: Optional[int] = None,
+) -> str:
+    """Recursively print symbol table tree."""
+    if root is None or depth == 0:
+        return ""
+
+    level_markers = level_markers or []
+    markers = "".join(
+        [
+            "|" + " " * (len(marker) - 1) if draw else " " * len(marker)
+            for draw in level_markers[:-1]
+        ]
+    ) + (marker if level_markers else "")
+    line = f"{markers}{root.name}\n"
+
+    if output_file:
+        with open(output_file, "a+") as f:
+            f.write(line)
+
+    return line + "".join(
+        get_symtab_tree_str(
+            child,
+            marker,
+            level_markers + [i < len(root.kid) - 1],
+            output_file,
+            None if depth is None else depth - 1,
+        )
+        for i, child in enumerate(root.kid)
+    )

jaclang/vendor/mypy/checker.py

@@ -6106,24 +6106,31 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
                     if node.arg_kinds[0] != nodes.ARG_POS:
                         # the first argument might be used as a kwarg
                         called_type = get_proper_type(self.lookup_type(node.callee))
-                        assert isinstance(called_type, (CallableType, Overloaded))
+
+                        # TODO: there are some more cases in check_call() to handle.
+                        if isinstance(called_type, Instance):
+                            call = find_member(
+                                "__call__", called_type, called_type, is_operator=True
+                            )
+                            if call is not None:
+                                called_type = get_proper_type(call)
 
                         # *assuming* the overloaded function is correct, there's a couple cases:
                         #  1) The first argument has different names, but is pos-only. We don't
                         #     care about this case, the argument must be passed positionally.
                         #  2) The first argument allows keyword reference, therefore must be the
                         #     same between overloads.
-                        name = called_type.items[0].arg_names[0]
-
-                        if name in node.arg_names:
-                            idx = node.arg_names.index(name)
-                            # we want the idx-th variable to be narrowed
-                            expr = collapse_walrus(node.args[idx])
-                        else:
-                            self.fail(
-                                message_registry.TYPE_GUARD_POS_ARG_REQUIRED, node
-                            )
-                            return {}, {}
+                        if isinstance(called_type, (CallableType, Overloaded)):
+                            name = called_type.items[0].arg_names[0]
+                            if name in node.arg_names:
+                                idx = node.arg_names.index(name)
+                                # we want the idx-th variable to be narrowed
+                                expr = collapse_walrus(node.args[idx])
+                            else:
+                                self.fail(
+                                    message_registry.TYPE_GUARD_POS_ARG_REQUIRED, node
+                                )
+                                return {}, {}
                     if literal(expr) == LITERAL_TYPE:
                         # Note: we wrap the target type, so that we can special case later.
                         # Namely, for isinstance() we use a normal meet, while TypeGuard is

jaclang/vendor/mypy/checkexpr.py

@@ -3870,8 +3870,9 @@ class ExpressionChecker(ExpressionVisitor[Type]):
         self,
         left: Type,
         right: Type,
-        original_container: Type | None = None,
         *,
+        original_container: Type | None = None,
+        seen_types: set[tuple[Type, Type]] | None = None,
         prefer_literal: bool = True,
     ) -> bool:
         """Check for dangerous non-overlapping comparisons like 42 == 'no'.
@@ -3892,6 +3893,12 @@ class ExpressionChecker(ExpressionVisitor[Type]):
         if not self.chk.options.strict_equality:
             return False
 
+        if seen_types is None:
+            seen_types = set()
+        if (left, right) in seen_types:
+            return False
+        seen_types.add((left, right))
+
         left, right = get_proper_types((left, right))
 
         # We suppress the error if there is a custom __eq__() method on either
@@ -3949,7 +3956,9 @@ class ExpressionChecker(ExpressionVisitor[Type]):
                 abstract_set = self.chk.lookup_typeinfo("typing.AbstractSet")
                 left = map_instance_to_supertype(left, abstract_set)
                 right = map_instance_to_supertype(right, abstract_set)
-                return self.dangerous_comparison(left.args[0], right.args[0])
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                )
             elif left.type.has_base("typing.Mapping") and right.type.has_base(
                 "typing.Mapping"
             ):
@@ -3958,13 +3967,17 @@ class ExpressionChecker(ExpressionVisitor[Type]):
                 left = map_instance_to_supertype(left, abstract_map)
                 right = map_instance_to_supertype(right, abstract_map)
                 return self.dangerous_comparison(
-                    left.args[0], right.args[0]
-                ) or self.dangerous_comparison(left.args[1], right.args[1])
+                    left.args[0], right.args[0], seen_types=seen_types
+                ) or self.dangerous_comparison(
+                    left.args[1], right.args[1], seen_types=seen_types
+                )
             elif (
                 left_name in ("builtins.list", "builtins.tuple")
                 and right_name == left_name
             ):
-                return self.dangerous_comparison(left.args[0], right.args[0])
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                )
             elif left_name in OVERLAPPING_BYTES_ALLOWLIST and right_name in (
                 OVERLAPPING_BYTES_ALLOWLIST
             ):
@@ -6624,11 +6637,16 @@ class PolyTranslator(TypeTranslator):
     See docstring for apply_poly() for details.
     """
 
-    def __init__(self, poly_tvars: Sequence[TypeVarLikeType]) -> None:
+    def __init__(
+        self,
+        poly_tvars: Iterable[TypeVarLikeType],
+        bound_tvars: frozenset[TypeVarLikeType] = frozenset(),
+        seen_aliases: frozenset[TypeInfo] = frozenset(),
+    ) -> None:
         self.poly_tvars = set(poly_tvars)
         # This is a simplified version of TypeVarScope used during semantic analysis.
-        self.bound_tvars: set[TypeVarLikeType] = set()
-        self.seen_aliases: set[TypeInfo] = set()
+        self.bound_tvars = bound_tvars
+        self.seen_aliases = seen_aliases
 
     def collect_vars(self, t: CallableType | Parameters) -> list[TypeVarLikeType]:
         found_vars = []
@@ -6706,10 +6724,13 @@ class PolyTranslator(TypeTranslator):
         if t.args and t.type.is_protocol and t.type.protocol_members == ["__call__"]:
             if t.type in self.seen_aliases:
                 raise PolyTranslationError()
-            self.seen_aliases.add(t.type)
             call = find_member("__call__", t, t, is_operator=True)
             assert call is not None
-            return call.accept(self)
+            return call.accept(
+                PolyTranslator(
+                    self.poly_tvars, self.bound_tvars, self.seen_aliases | {t.type}
+                )
+            )
         return super().visit_instance(t)