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

jaclang/jac/passes/tool/sym_tab_printer_pass.py

@@ -1,64 +1,15 @@
 """Jac Blue pass for drawing AST."""
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 
 from jaclang.jac.passes import Pass
 from jaclang.jac.symtable import SymbolTable
-
-
-class _SymbolTree:
-    def __init__(
-        self,
-        node_name: str,
-        parent: Optional["_SymbolTree"] = None,
-        children: Optional[List["_SymbolTree"]] = None,
-    ) -> None:
-        self.parent = parent
-        self.kid = children if children is not None else []
-        self.name = node_name
-
-    @property
-    def parent(self) -> Optional["_SymbolTree"]:
-        return self.__parent
-
-    @parent.setter
-    def parent(self, parent_node: Optional["_SymbolTree"]) -> None:
-        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:
-            _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
+from jaclang.utils.treeprinter import (
+    SymbolTree,
+    _build_symbol_tree_common,
+    print_symtab_tree,
+)
 
 
 class SymbolTablePrinterPass(Pass):
@@ -69,44 +20,10 @@ class SymbolTablePrinterPass(Pass):
     def before_pass(self) -> None:
         """Initialize pass."""
         if isinstance(self.ir.sym_tab, SymbolTable):
-            root = _build_symbol_tree_common(self.ir.sym_tab)
-            self._print_tree(root)
+            print_symtab_tree(self.ir.sym_tab, output_file=self.SAVE_OUTPUT)
         self.terminate()
         return super().before_pass()
 
-    def _print_tree(
-        self,
-        root: _SymbolTree,
-        marker: str = "+-- ",
-        level_markers: Optional[List[bool]] = None,
-    ) -> None:
-        """Recursive function that prints the hierarchical structure of a tree."""
-        if root is None:
-            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 ""
-        if self.SAVE_OUTPUT:
-            with open(self.SAVE_OUTPUT, "a+") as f:
-                print(f"{markers}{root.name}", file=f)
-        else:
-            print(f"{markers}{root.name}")
-        # After root has been printed, recurse down (depth-first) the child nodes.
-        for i, child in enumerate(root.kid):
-            # The last child will not need connection markers on the current level
-            # (see example above)
-            is_last = i == len(root.kid) - 1
-            self._print_tree(child, marker, [*level_markers, not is_last])
-
 
 class SymbolTableDotGraphPass(Pass):
     """Jac AST conversion to DOT graph."""
@@ -123,13 +40,13 @@ class SymbolTableDotGraphPass(Pass):
         self.terminate()
         return super().before_pass()
 
-    def __gen_node_id(self, node: _SymbolTree) -> int:
+    def __gen_node_id(self, node: SymbolTree) -> int:
         if id(node) not in self.__id_map:
             self.__id_map[id(node)] = self.__lase_id_used
             self.__lase_id_used += 1
         return self.__id_map[id(node)]
 
-    def __gen_node_parameters(self, node: _SymbolTree) -> str:
+    def __gen_node_parameters(self, node: SymbolTree) -> str:
         shape = ""
         fillcolor = ""
         style = ""
@@ -137,7 +54,7 @@ class SymbolTableDotGraphPass(Pass):
         label = f"{label} {shape} {style} {fillcolor}".strip()
         return f"[label={label}]"
 
-    def __gen_dot_graph(self, node: _SymbolTree) -> None:
+    def __gen_dot_graph(self, node: SymbolTree) -> None:
         self.__dot_lines.append(
             f"{self.__gen_node_id(node)} {self.__gen_node_parameters(node)};"
         )

jaclang/jac/passes/tool/tests/test_ast_print_pass.py

@@ -67,6 +67,7 @@ class AstPrinterPassTest(TestCase):
         with open("out.txt") as f:
             res_lines = "".join(f.readlines())
 
+        # print(res_lines)
         with open(self.fixture_abs_path("multi_def_err.txt")) as f:
             ref_lines = "".join(f.readlines())
-        self.assertEqual(res_lines, ref_lines)
+        self.assertEqual(res_lines.split(), ref_lines.split())

jaclang/jac/passes/transform.py

@@ -6,8 +6,6 @@ from typing import Optional
 
 from jaclang.jac.absyntree import AstNode
 from jaclang.jac.codeloc import CodeLocInfo
-from jaclang.jac.constant import Constants as Con, Values as Val
-from jaclang.utils.helpers import add_line_numbers, clip_code_section
 from jaclang.utils.log import logging
 
 
@@ -31,37 +29,6 @@ class Alert:
         return self.__str__()
 
 
-class TransformError(Exception):
-    """Error during transformation."""
-
-    def __init__(
-        self, message: str, errors: list[Alert], warnings: list[Alert]
-    ) -> None:
-        """Initialize error."""
-        self.errors = errors
-        self.warnings = warnings
-        if len(errors):
-            message += "\nErrors:"
-            for i in self.errors:
-                message += "\n" + str(i)
-        if len(warnings):
-            message += "\nWarnings:"
-            for i in self.warnings:
-                message += "\n" + str(i)
-        if len(errors) or len(warnings):
-            jac_err_line = (
-                errors[0].loc.first_line if len(errors) else warnings[0].loc.first_line
-            )
-            with open(errors[0].loc.mod_path, "r") as file:
-                jac_code_string = file.read()
-            message += f"\n{Con.JAC_ERROR_PREAMBLE}\n" + clip_code_section(
-                add_line_numbers(jac_code_string),
-                jac_err_line,
-                Val.JAC_ERROR_LINE_RANGE,
-            )
-        super().__init__(message)
-
-
 class Transform(ABC):
     """Abstract class for IR passes."""
 
@@ -93,9 +60,3 @@ class Transform(ABC):
         alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
         self.warnings_had.append(alrt)
         self.logger.warning(str(alrt))
-
-    def gen_exception(
-        self, msg: str = "Error in code transform, see above for details."
-    ) -> TransformError:
-        """Raise error."""
-        return TransformError(msg, self.errors_had, self.warnings_had)

jaclang/jac/passes/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility packages for passes."""

jaclang/jac/passes/utils/mypy_ast_build.py

@@ -0,0 +1,302 @@
+"""Overrides to mypy build manager for direct AST pass through."""
+from __future__ import annotations
+
+import ast
+
+import jaclang.vendor.mypy.build as myb
+from jaclang.vendor.mypy.build import BuildSource
+from jaclang.vendor.mypy.build import BuildSourceSet
+from jaclang.vendor.mypy.build import FileSystemCache
+from jaclang.vendor.mypy.build import compute_search_paths
+from jaclang.vendor.mypy.build import load_graph
+from jaclang.vendor.mypy.build import load_plugins
+from jaclang.vendor.mypy.build import process_graph
+from jaclang.vendor.mypy.errors import Errors
+from jaclang.vendor.mypy.fastparse import ASTConverter
+from jaclang.vendor.mypy.options import Options
+from jaclang.vendor.mypy.semanal_main import semantic_analysis_for_scc
+
+
+class BuildManager(myb.BuildManager):
+    """Overrides to mypy build manager for direct AST pass through."""
+
+    def parse_file(
+        self,
+        id: str,
+        path: str,
+        source: str,
+        ignore_errors: bool,
+        options: myb.Options,
+        ast_override: ast.AST | None = None,
+    ) -> myb.MypyFile:
+        """Parse the source of a file with the given name.
+
+        Raise CompileError if there is a parse error.
+        """
+        t0 = myb.time.time()
+        if ignore_errors:
+            self.errors.ignored_files.add(path)
+        tree = (
+            ast_override
+            if ast_override
+            else myb.parse(source, path, id, self.errors, options=options)
+        )
+        tree._fullname = id
+        self.add_stats(
+            files_parsed=1,
+            modules_parsed=int(not tree.is_stub),
+            stubs_parsed=int(tree.is_stub),
+            parse_time=myb.time.time() - t0,
+        )
+
+        if self.errors.is_blockers():
+            self.log("Bailing due to parse errors")
+            self.errors.raise_error()
+
+        self.errors.set_file_ignored_lines(path, tree.ignored_lines, ignore_errors)
+        return tree
+
+
+class State(myb.State):
+    """Overrides to mypy state for direct AST pass through."""
+
+    manager: BuildManager
+    tree: myb.MypyFile | None = None
+
+    def __init__(
+        self,
+        id: str | None,
+        path: str | None,
+        source: str | None,
+        manager: BuildManager,
+        caller_state: myb.State | None = None,
+        caller_line: int = 0,
+        ancestor_for: myb.State | None = None,
+        root_source: bool = False,
+        # If `temporary` is True, this State is being created to just
+        # quickly parse/load the tree, without an intention to further
+        # process it. With this flag, any changes to external state as well
+        # as error reporting should be avoided.
+        temporary: bool = False,
+        ast_override: ast.AST | None = None,
+    ) -> None:
+        """Override to mypy state for AST pass through."""
+        if not temporary:
+            assert id or path or source is not None, "Neither id, path nor source given"
+        self.manager = manager
+        State.order_counter += 1
+        self.order = State.order_counter
+        self.caller_state = caller_state
+        self.caller_line = caller_line
+        if caller_state:
+            self.import_context = caller_state.import_context.copy()
+            self.import_context.append((caller_state.xpath, caller_line))
+        else:
+            self.import_context = []
+        self.id = id or "__main__"
+        self.options = manager.options.clone_for_module(self.id)
+        self.early_errors: list[myb.ErrorInfo] = []
+        self._type_checker = None
+        if not path and source is None:
+            assert id is not None
+            try:
+                path, follow_imports = myb.find_module_and_diagnose(
+                    manager,
+                    id,
+                    self.options,
+                    caller_state,
+                    caller_line,
+                    ancestor_for,
+                    root_source,
+                    skip_diagnose=temporary,
+                )
+            except myb.ModuleNotFound:
+                if not temporary:
+                    manager.missing_modules.add(id)
+                raise
+            if follow_imports == "silent":
+                self.ignore_all = True
+        elif path and myb.is_silent_import_module(manager, path) and not root_source:
+            self.ignore_all = True
+        self.path = path
+        if path:
+            self.abspath = myb.os.path.abspath(path)
+        self.xpath = path or "<string>"
+        if path and source is None and self.manager.cache_enabled:
+            self.meta = myb.find_cache_meta(self.id, path, manager)
+            # TODO: Get mtime if not cached.
+            if self.meta is not None:
+                self.interface_hash = self.meta.interface_hash
+                self.meta_source_hash = self.meta.hash
+        if path and source is None and self.manager.fscache.isdir(path):
+            source = ""
+        self.source = source
+        self.add_ancestors()
+        self.per_line_checking_time_ns = myb.collections.defaultdict(int)
+        t0 = myb.time.time()
+        self.meta = myb.validate_meta(
+            self.meta, self.id, self.path, self.ignore_all, manager
+        )
+        self.manager.add_stats(validate_meta_time=myb.time.time() - t0)
+        if self.meta:
+            # Make copies, since we may modify these and want to
+            # compare them to the originals later.
+            self.dependencies = list(self.meta.dependencies)
+            self.dependencies_set = set(self.dependencies)
+            self.suppressed = list(self.meta.suppressed)
+            self.suppressed_set = set(self.suppressed)
+            all_deps = self.dependencies + self.suppressed
+            assert len(all_deps) == len(self.meta.dep_prios)
+            self.priorities = dict(zip(all_deps, self.meta.dep_prios))
+
+            assert len(all_deps) == len(self.meta.dep_lines)
+            self.dep_line_map = dict(zip(all_deps, self.meta.dep_lines))
+            if temporary:
+                self.load_tree(temporary=True)
+            if not manager.use_fine_grained_cache() and myb.exist_added_packages(
+                self.suppressed, manager, self.options
+            ):
+                # Special case: if there were a previously missing package imported here
+                # and it is not present, then we need to re-calculate dependencies.
+                # This is to support patterns like this:
+                #     from missing_package import missing_module  # type: ignore
+                # At first mypy doesn't know that `missing_module` is a module
+                # (it may be a variable, a class, or a function), so it is not added to
+                # suppressed dependencies. Therefore, when the package with module is added,
+                # we need to re-calculate dependencies.
+                # NOTE: see comment below for why we skip this in fine grained mode.
+                self.parse_file(
+                    ast_override=ast_override
+                )  # This is safe because the cache is anyway stale.
+                self.compute_dependencies()
+        else:
+            # When doing a fine-grained cache load, pretend we only
+            # know about modules that have cache information and defer
+            # handling new modules until the fine-grained update.
+            if manager.use_fine_grained_cache():
+                manager.log(f"Deferring module to fine-grained update {path} ({id})")
+                raise myb.ModuleNotFound
+
+            # Parse the file (and then some) to get the dependencies.
+            self.parse_file(temporary=temporary, ast_override=ast_override)
+            self.compute_dependencies()
+
+    def parse_file(
+        self, *, temporary: bool = False, ast_override: ast.AST | None = None
+    ) -> None:
+        """Parse file and run first pass of semantic analysis.
+
+        Everything done here is local to the file. Don't depend on imported
+        modules in any way. Also record module dependencies based on imports.
+        """
+        if self.tree is not None:
+            # The file was already parsed (in __init__()).
+            return
+
+        manager = self.manager
+
+        # Can we reuse a previously parsed AST? This avoids redundant work in daemon.
+        cached = self.id in manager.ast_cache
+        modules = manager.modules
+        if not cached:
+            manager.log(f"Parsing {self.xpath} ({self.id})")
+        else:
+            manager.log(f"Using cached AST for {self.xpath} ({self.id})")
+
+        t0 = myb.time_ref()
+
+        with self.wrap_context():
+            source = self.source
+            self.source = None  # We won't need it again.
+            if self.path and source is None:
+                try:
+                    path = manager.maybe_swap_for_shadow_path(self.path)
+                    source = myb.decode_python_encoding(manager.fscache.read(path))
+                    self.source_hash = manager.fscache.hash_digest(path)
+                except OSError as ioerr:
+                    # ioerr.strerror differs for os.stat failures between Windows and
+                    # other systems, but os.strerror(ioerr.errno) does not, so we use that.
+                    # (We want the error messages to be platform-independent so that the
+                    # tests have predictable output.)
+                    raise myb.CompileError(
+                        [
+                            "mypy: can't read file '{}': {}".format(
+                                self.path, myb.os.strerror(ioerr.errno)
+                            )
+                        ],
+                        module_with_blocker=self.id,
+                    ) from ioerr
+                except (UnicodeDecodeError, myb.DecodeError) as decodeerr:
+                    if self.path.endswith(".pyd"):
+                        err = (
+                            f"mypy: stubgen does not support .pyd files: '{self.path}'"
+                        )
+                    else:
+                        err = f"mypy: can't decode file '{self.path}': {str(decodeerr)}"
+                    raise myb.CompileError(
+                        [err], module_with_blocker=self.id
+                    ) from decodeerr
+            elif self.path and self.manager.fscache.isdir(self.path):
+                source = ""
+                self.source_hash = ""
+            else:
+                assert source is not None
+                self.source_hash = myb.compute_hash(source)
+
+            self.parse_inline_configuration(source)
+            if not cached:
+                self.tree = manager.parse_file(
+                    self.id,
+                    self.xpath,
+                    source,
+                    self.ignore_all or self.options.ignore_errors,
+                    self.options,
+                    ast_override=ast_override,
+                )
+
+            else:
+                # Reuse a cached AST
+                self.tree = manager.ast_cache[self.id][0]
+                manager.errors.set_file_ignored_lines(
+                    self.xpath,
+                    self.tree.ignored_lines,
+                    self.ignore_all or self.options.ignore_errors,
+                )
+
+        self.time_spent_us += myb.time_spent_us(t0)
+
+        if not cached:
+            # Make a copy of any errors produced during parse time so that
+            # fine-grained mode can repeat them when the module is
+            # reprocessed.
+            self.early_errors = list(manager.errors.error_info_map.get(self.xpath, []))
+        else:
+            self.early_errors = manager.ast_cache[self.id][1]
+
+        if not temporary:
+            modules[self.id] = self.tree
+
+        if not cached:
+            self.semantic_analysis_pass1()
+
+        if not temporary:
+            self.check_blockers()
+
+        manager.ast_cache[self.id] = (self.tree, self.early_errors)
+
+
+__all__ = [
+    "BuildManager",
+    "State",
+    "BuildSource",
+    "BuildSourceSet",
+    "FileSystemCache",
+    "compute_search_paths",
+    "load_graph",
+    "load_plugins",
+    "process_graph",
+    "Errors",
+    "Options",
+    "ASTConverter",
+    "semantic_analysis_for_scc",
+]

jaclang/jac/plugin/__init__.py

@@ -1,4 +1,7 @@
 """Plugin interface for Jac."""
-import pluggy
+from __future__ import annotations
 
-hookimpl = pluggy.HookimplMarker("jac")
+from .default import hookimpl
+from .spec import AbsRootHook, Architype
+
+__all__ = ["Architype", "AbsRootHook", "hookimpl"]

jaclang/jac/plugin/default.py

@@ -2,11 +2,14 @@
 from __future__ import annotations
 
 
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Type
 
 from jaclang.jac.constant import EdgeDir
-from jaclang.jac.plugin import hookimpl
-from jaclang.jac.plugin.spec import AT
+from jaclang.jac.plugin.spec import AT, Architype, T
+
+import pluggy
+
+hookimpl = pluggy.HookimplMarker("jac")
 
 
 class JacFeatureDefaults:
@@ -14,9 +17,10 @@ class JacFeatureDefaults:
 
     @staticmethod
     @hookimpl
-    def bind_architype(arch: AT) -> None:
+    def bind_architype(arch: Type[AT], arch_type: str) -> bool:
         """Create a new architype."""
         arch._jac_ = None
+        return True
 
     @staticmethod
     @hookimpl
@@ -44,6 +48,7 @@ class JacFeatureDefaults:
     @hookimpl
     def ignore(walker_obj: Any, expr: Any) -> bool:  # noqa: ANN401
         """Jac's ignore stmt feature."""
+        return True
 
     @staticmethod
     @hookimpl
@@ -55,6 +60,7 @@ class JacFeatureDefaults:
     @hookimpl
     def disengage(walker_obj: Any) -> bool:  # noqa: ANN401
         """Jac's disengage stmt feature."""
+        return True
 
     @staticmethod
     @hookimpl
@@ -88,3 +94,13 @@ class JacFeatureDefaults:
     ) -> list[T]:
         """Jac's assign comprehension feature."""
         return target
+
+    @staticmethod
+    @hookimpl
+    def get_root() -> Architype:
+        """Jac's assign comprehension feature."""
+
+        class Blank(Architype):
+            _jac_: Any = None
+
+        return Blank()

jaclang/jac/plugin/feature.py

@@ -1,14 +1,14 @@
 """Jac Language Features."""
 from __future__ import annotations
 
-from dataclasses import dataclass
 import inspect
+from dataclasses import dataclass
 from types import FunctionType, MethodType
 from typing import Any, Callable, Optional, Type
 
 from jaclang.jac.constant import EdgeDir
 from jaclang.jac.plugin.default import JacFeatureDefaults
-from jaclang.jac.plugin.spec import JacFeatureSpec, T, AT
+from jaclang.jac.plugin.spec import AT, AbsRootHook, Architype, JacFeatureSpec, T
 
 import pluggy
 
@@ -18,9 +18,10 @@ class JacFeature:
 
     pm = pluggy.PluginManager("jac")
     pm.add_hookspecs(JacFeatureSpec)
-    pm.load_setuptools_entrypoints("jac")
     pm.register(JacFeatureDefaults)
 
+    RootType: Type[AbsRootHook] = AbsRootHook
+
     @staticmethod
     def make_architype(arch_type: str) -> Callable[[type], type]:
         """Create a new architype."""
@@ -43,15 +44,18 @@ class JacFeature:
                         for k, v in cls_module_globals.items():  # Risky!
                             if k not in func_module_globals and not k.startswith("__"):
                                 func_module_globals[k] = v
-            JacFeature.bind_architype(cls)
-            return dataclass(cls)
+            cls = dataclass(cls)
+            if not issubclass(cls, Architype):
+                cls = type(cls.__name__, (cls, Architype), {})
+            JacFeature.bind_architype(cls, arch_type)
+            return cls
 
         return decorator
 
     @staticmethod
-    def bind_architype(arch: AT) -> None:
+    def bind_architype(arch: Type[AT], arch_type: str) -> bool:
         """Create a new architype."""
-        return JacFeature.pm.hook.bind_architype(arch=arch)
+        return JacFeature.pm.hook.bind_architype(arch=arch, arch_type=arch_type)
 
     @staticmethod
     def make_ds_ability(event: str, trigger: Optional[type]) -> Callable[[type], type]:
@@ -113,3 +117,8 @@ class JacFeature:
     ) -> list[T]:
         """Jac's assign comprehension feature."""
         return JacFeature.pm.hook.assign_compr(target=target, attr_val=attr_val)
+
+    @staticmethod
+    def get_root() -> Architype:
+        """Jac's assign comprehension feature."""
+        return JacFeature.pm.hook.get_root()