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

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, T
+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

@@ -8,7 +8,7 @@ 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 AT, JacFeatureSpec, T
+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()

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/tests/test_workspace.py

@@ -40,13 +40,53 @@ class TestWorkspace(TestCase):
     def test_man_code_dir(self) -> None:
         """Test of circle workspace."""
         loc = os.path.join(os.path.dirname(__file__))
-        # print(loc)
         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))
-        # for i in ws.get_uses(key):
-        #     print(i.pp(depth=2))
-        # print(ws.get_uses(key))
-        self.assertGreater(len(ws.get_uses(key)), 5)
+        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)