jaclang 0.7.16__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/compiler/passes/main/type_check_pass.py

@@ -8,7 +8,6 @@ import os
 import pathlib
 import sys
 
-# import jaclang
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
 from jaclang.compiler.constant import Constants as Con
@@ -35,7 +34,7 @@ class JacTypeCheckPass(Pass):
     def after_pass(self) -> None:
         """Call mypy api after traversing all the modules."""
         try:
-            self.api()
+            self.api(os.path.dirname(self.ir.loc.mod_path))
         except Exception as e:
             self.error(f"Unable to run type checking: {e}")
         return super().after_pass()
@@ -45,7 +44,7 @@ class JacTypeCheckPass(Pass):
     ) -> None:
         """Mypy errors reporter."""
 
-    def api(self) -> None:
+    def api(self, top_module_path: str = "") -> None:
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
@@ -57,6 +56,9 @@ class JacTypeCheckPass(Pass):
                 / "stubs"
             )
         ]
+        if top_module_path != "":
+            options.mypy_path.append(top_module_path)
+
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))
@@ -101,7 +103,9 @@ class JacTypeCheckPass(Pass):
             mypy_graph[module.name] = st
             new_modules.append(st)
 
-        graph = myab.load_graph(
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice("Expected module node. Impossible")
+        mypy_graph = myab.load_graph(
             [
                 myab.BuildSource(
                     path=str(self.__path / "typeshed" / "stdlib" / "builtins.pyi"),
@@ -112,4 +116,10 @@ class JacTypeCheckPass(Pass):
             old_graph=mypy_graph,
             new_modules=new_modules,  # To parse the dependancies of modules
         )
-        myab.process_graph(graph, manager)
+        for i in mypy_graph:
+            self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
+            for j in mypy_graph[i].dependencies:
+                self.ir.py_mod_dep_map[j] = str(
+                    myab.find_module_with_reason(j, manager)
+                )
+        myab.process_graph(mypy_graph, manager)

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -322,6 +322,7 @@ class JacFormatPass(Pass):
         tag: T,
         """
         start = True
+        prev_token = None
         for i in node.kid:
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
@@ -336,8 +337,13 @@ class JacFormatPass(Pass):
             elif i.gen.jac == ",":
                 self.emit(node, f"{i.gen.jac} ")
             else:
-                if start:
-                    self.emit(node, i.gen.jac)
+                if isinstance(i, ast.Token) and not isinstance(i, ast.BuiltinType):
+                    try:
+                        prev_token = self.token_before(i)
+                    except Exception:
+                        prev_token = None
+                if start or (prev_token and prev_token.gen.jac.strip() == ":"):
+                    self.emit(node, i.gen.jac.strip())
                     start = False
                 else:
                     self.emit(node, f" {i.gen.jac}")
@@ -439,7 +445,7 @@ class JacFormatPass(Pass):
         path: list[Token],
         alias: Optional[Name],
         """
-        self.emit(node, node.path_str)
+        self.emit(node, node.dot_path_str)
         if node.alias:
             self.emit(node, " as " + node.alias.gen.jac)
 
@@ -651,6 +657,8 @@ class JacFormatPass(Pass):
                 self.emit(node, i.gen.jac)
             elif isinstance(i, ast.SubNodeList) and i.gen.jac.startswith("@"):
                 self.emit_ln(node, i.gen.jac)
+            elif isinstance(i, ast.SubTag):
+                self.emit(node, i.gen.jac)
             else:
                 if start:
                     self.emit(node, i.gen.jac)

jaclang/compiler/passes/tool/tests/fixtures/corelib.jac

@@ -32,7 +32,7 @@ obj ExecutionContext {
 "Global Execution Context, should be monkey patched by the user."
 glob exec_ctx = ExecutionContext();
 
-obj ElementAnchor {
+obj Anchor :ArchitypeProtocol: {
     has ob: object,
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
@@ -41,8 +41,12 @@ obj ElementAnchor {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory;
+        mem: Memory = exec_ctx.memory,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc];
 
+    static can on_entry(cls: type, triggers: list[type]);
+    static can on_exit(cls: type, triggers: list[type]);
     can make_public_ro;
     can make_public_rw;
     can make_private;
@@ -55,15 +59,7 @@ obj ElementAnchor {
     can revoke_access(caller_id: UUID);
 }
 
-obj ObjectAnchor :ElementAnchor, ArchitypeProtocol: {
-    has ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
-
-    static can on_entry(cls: type, triggers: list[type]);
-    static can on_exit(cls: type, triggers: list[type]);
-}
-
-obj NodeAnchor :ObjectAnchor: {
+obj NodeAnchor :Anchor: {
     has edges: dict[EdgeDir, list[Edge]] = {EdgeDir.IN: [], EdgeDir.OUT: []};
 
     can connect_node(nd: Node, edg: Edge) -> Node;
@@ -71,7 +67,7 @@ obj NodeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj EdgeAnchor :ObjectAnchor: {
+obj EdgeAnchor :Anchor: {
     has source: Node = None,
         target: Node = None,
         dir: EdgeDir = None;
@@ -81,7 +77,7 @@ obj EdgeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj WalkerAnchor :ObjectAnchor: {
+obj WalkerAnchor :Anchor: {
     has path: list[Node] = [],
         next: list[Node] = [],
         ignores: list[Node] = [],
@@ -94,27 +90,27 @@ obj WalkerAnchor :ObjectAnchor: {
 }
 
 obj Root :AbsRootHook: {
-    has _jac_: NodeAnchor | None = None;
+    has __jac__: NodeAnchor | None = None;
 
     can postinit {
-        self._jac_ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj GenericEdge :ArchitypeProtocol: {
-    has _jac_: EdgeAnchor | None = None;
+    has __jac__: EdgeAnchor | None = None;
 
     can postinit {
-        self._jac_ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj Master {
-    has _jac_: ElementAnchor | None = None;
+    has __jac__: Anchor | None = None;
     has root_node: Root = Root(Root);
 
     can postinit {
-        self._jac_ = ElementAnchor(self);
+        self.__jac__ = Anchor(self);
     }
 }
 
@@ -204,31 +200,31 @@ obj JacPlugin {
     PRIVATE
 }
 
-:obj:ElementAnchor:can:make_public_ro {
+:obj:Anchor:can:make_public_ro {
     self.__jinfo.access_mode = AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:make_public_rw {
+:obj:Anchor:can:make_public_rw {
     self.__jinfo.access_mode = AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:make_private {
+:obj:Anchor:can:make_private {
     self.__jinfo.access_mode = AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_public_ro -> bool {
+:obj:Anchor:can:is_public_ro -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:is_public_rw -> bool {
+:obj:Anchor:can:is_public_rw -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:is_private -> bool {
+:obj:Anchor:can:is_private -> bool {
     return self.__jinfo.access_mode == AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_readable
+:obj:Anchor:can:is_readable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_read
@@ -236,14 +232,14 @@ obj JacPlugin {
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:is_writable
+:obj:Anchor:can:is_writable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_write
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:give_access
+:obj:Anchor:can:give_access
 (caller_id: UUID, read_write: bool=False) {
     if read_write {
         caller_id |> self.rw_access.add;
@@ -252,13 +248,13 @@ obj JacPlugin {
     }
 }
 
-:obj:ElementAnchor:can:revoke_access
+:obj:Anchor:can:revoke_access
 (caller_id: UUID) {
     caller_id |> self.ro_access.discard;
     caller_id |> self.rw_access.discard;
 }
 
-:obj:ObjectAnchor:can:on_entry
+:obj:Anchor:can:on_entry
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_entry_funcs.append(
@@ -272,7 +268,7 @@ obj JacPlugin {
     return decorator;
 }
 
-:obj:ObjectAnchor:can:on_exit
+:obj:Anchor:can:on_exit
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_exit_funcs.append(
@@ -361,7 +357,7 @@ obj JacPlugin {
 
 :obj:NodeAnchor:can:__call__
 (walk: object) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
     walk(self);
@@ -369,10 +365,10 @@ obj JacPlugin {
 
 :obj:EdgeAnchor:can:__call__
 (walk: EdgeInterface) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
-    walk(self._jac_.target);
+    walk(self.__jac__.target);
 }
 
 :obj:WalkerAnchor:can:__call__
@@ -423,25 +419,25 @@ obj JacPlugin {
 (arch: AT, arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]) -> bool {
     match arch_type {
         case 'obj':
-            arch._jac_ = ObjectAnchor(
+            arch.__jac__ = Anchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'node':
-            arch._jac_ = NodeAnchor(
+            arch.__jac__ = NodeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'edge':
-            arch._jac_ = EdgeAnchor(
+            arch.__jac__ = EdgeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'walker':
-            arch._jac_ = WalkerAnchor(
+            arch.__jac__ = WalkerAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
@@ -464,19 +460,19 @@ obj JacPlugin {
         edg_type = edge_spec[1];
     }
     edg = edg_type(*(edge_spec[2])) if edge_spec[2] else edg_type();
-    edg._jac_.apply_dir(edge_spec[0]);
+    edg.__jac__.apply_dir(edge_spec[0]);
     return edg;
 }
 
 :obj:JacPlugin:can:connect
 (left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {
     edg = JacPlugin.build_edge(edge_spec);
-    left.connect_node(right._jac_, edg._jac_);
+    left.connect_node(right.__jac__, edg.__jac__);
 }
 
 :obj:JacPlugin:can:visit_node
 (walker_obj: Any, expr: Any) -> bool {
-    return walker_obj._jac_.visit_node(expr);
+    return walker_obj.__jac__.visit_node(expr);
 }
 
 glob expected_area = 78.53981633974483;

jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac

@@ -31,7 +31,7 @@ obj ExecutionContext {
 "Global Execution Context, should be monkey patched by the user."
 glob exec_ctx = ExecutionContext();
 
-obj ElementAnchor {
+obj Anchor :ArchitypeProtocol: {
     has ob: object,
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
@@ -40,8 +40,12 @@ obj ElementAnchor {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory;
+        mem: Memory = exec_ctx.memory,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc];
 
+    static can on_entry(cls: type, triggers: list[type]);
+    static can on_exit(cls: type, triggers: list[type]);
     can make_public_ro;
     can make_public_rw;
     can make_private;
@@ -54,15 +58,7 @@ obj ElementAnchor {
     can revoke_access(caller_id: UUID);
 }
 
-obj ObjectAnchor :ElementAnchor, ArchitypeProtocol: {
-    has ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
-
-    static can on_entry(cls: type, triggers: list[type]);
-    static can on_exit(cls: type, triggers: list[type]);
-}
-
-obj NodeAnchor :ObjectAnchor: {
+obj NodeAnchor :Anchor: {
     has edges: dict[EdgeDir, list[Edge]] = {EdgeDir.IN: [], EdgeDir.OUT: []};
 
     can connect_node(nd: Node, edg: Edge) -> Node;
@@ -70,7 +66,7 @@ obj NodeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj EdgeAnchor :ObjectAnchor: {
+obj EdgeAnchor :Anchor: {
     has source: Node = None,
         target: Node = None,
         dir: EdgeDir = None;
@@ -80,7 +76,7 @@ obj EdgeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj WalkerAnchor :ObjectAnchor: {
+obj WalkerAnchor :Anchor: {
     has path: list[Node] = [],
         next: list[Node] = [],
         ignores: list[Node] = [],
@@ -93,27 +89,27 @@ obj WalkerAnchor :ObjectAnchor: {
 }
 
 obj Root :AbsRootHook: {
-    has _jac_: NodeAnchor | None = None;
+    has __jac__: NodeAnchor | None = None;
 
     can postinit {
-        self._jac_ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj GenericEdge :ArchitypeProtocol: {
-    has _jac_: EdgeAnchor | None = None;
+    has __jac__: EdgeAnchor | None = None;
 
     can postinit {
-        self._jac_ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj Master {
-    has _jac_: ElementAnchor | None = None;
+    has __jac__: Anchor | None = None;
     has root_node: Root = Root(Root);
 
     can postinit {
-        self._jac_ = ElementAnchor(self);
+        self.__jac__ = Anchor(self);
     }
 }
 
@@ -203,31 +199,31 @@ obj JacPlugin {
     PRIVATE
 }
 
-:obj:ElementAnchor:can:make_public_ro {
+:obj:Anchor:can:make_public_ro {
     self.__jinfo.access_mode = AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:make_public_rw {
+:obj:Anchor:can:make_public_rw {
     self.__jinfo.access_mode = AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:make_private {
+:obj:Anchor:can:make_private {
     self.__jinfo.access_mode = AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_public_ro -> bool {
+:obj:Anchor:can:is_public_ro -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:is_public_rw -> bool {
+:obj:Anchor:can:is_public_rw -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:is_private -> bool {
+:obj:Anchor:can:is_private -> bool {
     return self.__jinfo.access_mode == AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_readable
+:obj:Anchor:can:is_readable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_read
@@ -235,14 +231,14 @@ obj JacPlugin {
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:is_writable
+:obj:Anchor:can:is_writable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_write
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:give_access
+:obj:Anchor:can:give_access
 (caller_id: UUID, read_write: bool=False) {
     if read_write {
         caller_id |> self.rw_access.add;
@@ -251,13 +247,13 @@ obj JacPlugin {
     }
 }
 
-:obj:ElementAnchor:can:revoke_access
+:obj:Anchor:can:revoke_access
 (caller_id: UUID) {
     caller_id |> self.ro_access.discard;
     caller_id |> self.rw_access.discard;
 }
 
-:obj:ObjectAnchor:can:on_entry
+:obj:Anchor:can:on_entry
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_entry_funcs.append(
@@ -271,7 +267,7 @@ obj JacPlugin {
     return decorator;
 }
 
-:obj:ObjectAnchor:can:on_exit
+:obj:Anchor:can:on_exit
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_exit_funcs.append(
@@ -360,7 +356,7 @@ obj JacPlugin {
 
 :obj:NodeAnchor:can:__call__
 (walk: object) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
     walk(self);
@@ -368,10 +364,10 @@ obj JacPlugin {
 
 :obj:EdgeAnchor:can:__call__
 (walk: EdgeInterface) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
-    walk(self._jac_.target);
+    walk(self.__jac__.target);
 }
 
 :obj:WalkerAnchor:can:__call__
@@ -422,25 +418,25 @@ obj JacPlugin {
 (arch: AT, arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]) -> bool {
     match arch_type {
         case 'obj':
-            arch._jac_ = ObjectAnchor(
+            arch.__jac__ = Anchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'node':
-            arch._jac_ = NodeAnchor(
+            arch.__jac__ = NodeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'edge':
-            arch._jac_ = EdgeAnchor(
+            arch.__jac__ = EdgeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'walker':
-            arch._jac_ = WalkerAnchor(
+            arch.__jac__ = WalkerAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
@@ -463,19 +459,19 @@ obj JacPlugin {
         edg_type = edge_spec[1];
     }
     edg = edg_type(*(edge_spec[2])) if edge_spec[2] else edg_type();
-    edg._jac_.apply_dir(edge_spec[0]);
+    edg.__jac__.apply_dir(edge_spec[0]);
     return edg;
 }
 
 :obj:JacPlugin:can:connect
 (left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {
     edg = JacPlugin.build_edge(edge_spec);
-    left.connect_node(right._jac_, edg._jac_);
+    left.connect_node(right.__jac__, edg.__jac__);
 }
 
 :obj:JacPlugin:can:visit_node
 (walker_obj: Any, expr: Any) -> bool {
-    return walker_obj._jac_.visit_node(expr);
+    return walker_obj.__jac__.visit_node(expr);
 }
 
 glob expected_area = 78.53981633974483;

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/access_mod_check.jac

@@ -0,0 +1,27 @@
+can:priv hash(func: Any) {
+    can inner(a: Any) {
+        print(("#" * 20));
+        func(a);
+        print(("#" * 20));
+    }
+    return inner;
+}
+
+can:protect exclaim(func: Any) {
+    can inner(b: Any) {
+        print(("!" * 20));
+        func(b);
+        print(("!" * 20));
+    }
+    return inner;
+}
+
+@hash
+@exclaim
+can greeter(name: Any) {
+    print("Hello, " + name + "!");
+}
+
+with entry {
+    greeter("World");
+}

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import ast
 import os
+from typing import Callable, TYPE_CHECKING, TextIO
 
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.passes import Pass
@@ -21,13 +22,19 @@ from mypy.build import FileSystemCache
 from mypy.build import Graph
 from mypy.build import ModuleNotFound
 from mypy.build import PRI_INDIRECT
+from mypy.build import Plugin
+from mypy.build import SearchPaths
 from mypy.build import compute_search_paths
 from mypy.build import find_module_simple
+from mypy.build import find_module_with_reason
 from mypy.build import load_plugins
 from mypy.build import process_graph
 from mypy.options import Options
 from mypy.semanal_main import semantic_analysis_for_scc
 
+if TYPE_CHECKING:
+    from mypy.report import Reports  # Avoid unconditional slow import
+
 
 mypy_to_jac_node_map: dict[
     tuple[int, int | None, int | None, int | None], list[AstNode]
@@ -37,6 +44,43 @@ mypy_to_jac_node_map: dict[
 class BuildManager(myb.BuildManager):
     """Overrides to mypy build manager for direct AST pass through."""
 
+    def __init__(
+        self,
+        data_dir: str,
+        search_paths: SearchPaths,
+        ignore_prefix: str,
+        source_set: BuildSourceSet,
+        reports: Reports | None,
+        options: Options,
+        version_id: str,
+        plugin: Plugin,
+        plugins_snapshot: dict[str, str],
+        errors: Errors,
+        flush_errors: Callable[[str | None, list[str], bool], None],
+        fscache: FileSystemCache,
+        stdout: TextIO,
+        stderr: TextIO,
+    ) -> None:
+        """Override mypy BuildManager constructor to initialize jac related map."""
+        global mypy_to_jac_node_map
+        super().__init__(
+            data_dir,
+            search_paths,
+            ignore_prefix,
+            source_set,
+            reports,
+            options,
+            version_id,
+            plugin,
+            plugins_snapshot,
+            errors,
+            flush_errors,
+            fscache,
+            stdout,
+            stderr,
+        )
+        mypy_to_jac_node_map = {}
+
     def parse_file(
         self,
         id: str,
@@ -664,6 +708,7 @@ __all__ = [
     "BuildSource",
     "BuildSourceSet",
     "FileSystemCache",
+    "find_module_with_reason",
     "compute_search_paths",
     "load_graph",
     "load_plugins",