jaclang 0.7.23__py3-none-any.whl → 0.7.25__py3-none-any.whl

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -16,6 +16,7 @@ import mypy.build as myb
 import mypy.checkexpr as mycke
 import mypy.errors as mye
 import mypy.fastparse as myfp
+import mypy.nodes as mypy_nodes
 from mypy.build import BuildSource
 from mypy.build import BuildSourceSet
 from mypy.build import FileSystemCache
@@ -36,6 +37,55 @@ if TYPE_CHECKING:
     from mypy.report import Reports  # Avoid unconditional slow import
 
 
+# All the expression nodes of mypy.
+EXPRESSION_NODES = (
+    mypy_nodes.AssertTypeExpr,
+    mypy_nodes.AssignmentExpr,
+    mypy_nodes.AwaitExpr,
+    mypy_nodes.BytesExpr,
+    mypy_nodes.CallExpr,
+    mypy_nodes.CastExpr,
+    mypy_nodes.ComparisonExpr,
+    mypy_nodes.ComplexExpr,
+    mypy_nodes.ConditionalExpr,
+    mypy_nodes.DictionaryComprehension,
+    mypy_nodes.DictExpr,
+    mypy_nodes.EllipsisExpr,
+    mypy_nodes.EnumCallExpr,
+    mypy_nodes.Expression,
+    mypy_nodes.FloatExpr,
+    mypy_nodes.GeneratorExpr,
+    mypy_nodes.IndexExpr,
+    mypy_nodes.IntExpr,
+    mypy_nodes.LambdaExpr,
+    mypy_nodes.ListComprehension,
+    mypy_nodes.ListExpr,
+    mypy_nodes.MemberExpr,
+    mypy_nodes.NamedTupleExpr,
+    mypy_nodes.NameExpr,
+    mypy_nodes.NewTypeExpr,
+    mypy_nodes.OpExpr,
+    mypy_nodes.ParamSpecExpr,
+    mypy_nodes.PromoteExpr,
+    mypy_nodes.RefExpr,
+    mypy_nodes.RevealExpr,
+    mypy_nodes.SetComprehension,
+    mypy_nodes.SetExpr,
+    mypy_nodes.SliceExpr,
+    mypy_nodes.StarExpr,
+    mypy_nodes.StrExpr,
+    mypy_nodes.SuperExpr,
+    mypy_nodes.TupleExpr,
+    mypy_nodes.TypeAliasExpr,
+    mypy_nodes.TypedDictExpr,
+    mypy_nodes.TypeVarExpr,
+    mypy_nodes.TypeVarTupleExpr,
+    mypy_nodes.UnaryExpr,
+    mypy_nodes.YieldExpr,
+    mypy_nodes.YieldFromExpr,
+)
+
+
 mypy_to_jac_node_map: dict[
     tuple[int, int | None, int | None, int | None], list[AstNode]
 ] = {}
@@ -131,61 +181,231 @@ class ExpressionChecker(mycke.ExpressionChecker):
         """Override to mypy expression checker for direct AST pass through."""
         super().__init__(tc, msg, plugin, per_line_checking_time_ns)
 
+    def visit_assert_type_expr(self, e: mycke.AssertTypeExpr) -> mycke.Type:
+        """Type check AssertTypeExpr expression."""
+        out = super().visit_assert_type_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_assignment_expr(self, e: mycke.AssignmentExpr) -> mycke.Type:
+        """Type check AssignmentExpr expression."""
+        out = super().visit_assignment_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_await_expr(
+        self, e: mycke.AwaitExpr, allow_none_return: bool = False
+    ) -> mycke.Type:
+        """Type check AwaitExpr expression."""
+        out = super().visit_await_expr(e, allow_none_return)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_bytes_expr(self, e: mycke.BytesExpr) -> mycke.Type:
+        """Type check BytesExpr expression."""
+        out = super().visit_bytes_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_call_expr(
+        self, e: mycke.CallExpr, allow_none_return: bool = False
+    ) -> mycke.Type:
+        """Type check CallExpr expression."""
+        out = super().visit_call_expr(e, allow_none_return)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_cast_expr(self, e: mycke.CastExpr) -> mycke.Type:
+        """Type check CastExpr expression."""
+        out = super().visit_cast_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_comparison_expr(self, e: mycke.ComparisonExpr) -> mycke.Type:
+        """Type check ComparisonExpr expression."""
+        out = super().visit_comparison_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_complex_expr(self, e: mycke.ComplexExpr) -> mycke.Type:
+        """Type check ComplexExpr expression."""
+        out = super().visit_complex_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_conditional_expr(
+        self, e: mycke.ConditionalExpr, allow_none_return: bool = False
+    ) -> mycke.Type:
+        """Type check ConditionalExpr expression."""
+        out = super().visit_conditional_expr(e, allow_none_return)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_dictionary_comprehension(
+        self, e: mycke.DictionaryComprehension
+    ) -> mycke.Type:
+        """Type check DictionaryComprehension expression."""
+        out = super().visit_dictionary_comprehension(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_dict_expr(self, e: mycke.DictExpr) -> mycke.Type:
+        """Type check DictExpr expression."""
+        out = super().visit_dict_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_enum_call_expr(self, e: mycke.EnumCallExpr) -> mycke.Type:
+        """Type check EnumCallExpr expression."""
+        out = super().visit_enum_call_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_float_expr(self, e: mycke.FloatExpr) -> mycke.Type:
+        """Type check FloatExpr expression."""
+        out = super().visit_float_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_generator_expr(self, e: mycke.GeneratorExpr) -> mycke.Type:
+        """Type check GeneratorExpr expression."""
+        out = super().visit_generator_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_index_expr(self, e: mycke.IndexExpr) -> mycke.Type:
+        """Type check IndexExpr expression."""
+        out = super().visit_index_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_int_expr(self, e: mycke.IntExpr) -> mycke.Type:
+        """Type check IntExpr expression."""
+        out = super().visit_int_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_lambda_expr(self, e: mycke.LambdaExpr) -> mycke.Type:
+        """Type check LambdaExpr expression."""
+        out = super().visit_lambda_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_list_comprehension(self, e: mycke.ListComprehension) -> mycke.Type:
+        """Type check ListComprehension expression."""
+        out = super().visit_list_comprehension(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
     def visit_list_expr(self, e: mycke.ListExpr) -> mycke.Type:
-        """Type check a list expression [...]."""
+        """Type check ListExpr expression."""
         out = super().visit_list_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
+    def visit_member_expr(
+        self, e: mycke.MemberExpr, is_lvalue: bool = False
+    ) -> mycke.Type:
+        """Type check MemberExpr expression."""
+        out = super().visit_member_expr(e, is_lvalue)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_name_expr(self, e: mycke.NameExpr) -> mycke.Type:
+        """Type check NameExpr expression."""
+        out = super().visit_name_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_op_expr(self, e: mycke.OpExpr) -> mycke.Type:
+        """Type check OpExpr expression."""
+        out = super().visit_op_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_reveal_expr(self, e: mycke.RevealExpr) -> mycke.Type:
+        """Type check RevealExpr expression."""
+        out = super().visit_reveal_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_set_comprehension(self, e: mycke.SetComprehension) -> mycke.Type:
+        """Type check SetComprehension expression."""
+        out = super().visit_set_comprehension(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
     def visit_set_expr(self, e: mycke.SetExpr) -> mycke.Type:
-        """Type check a set expression {...}."""
+        """Type check SetExpr expression."""
         out = super().visit_set_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_tuple_expr(self, e: myfp.TupleExpr) -> myb.Type:
-        """Type check a tuple expression (...)."""
+    def visit_slice_expr(self, e: mycke.SliceExpr) -> mycke.Type:
+        """Type check SliceExpr expression."""
+        out = super().visit_slice_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_star_expr(self, e: mycke.StarExpr) -> mycke.Type:
+        """Type check StarExpr expression."""
+        out = super().visit_star_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_str_expr(self, e: mycke.StrExpr) -> mycke.Type:
+        """Type check StrExpr expression."""
+        out = super().visit_str_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_super_expr(self, e: mycke.SuperExpr) -> mycke.Type:
+        """Type check SuperExpr expression."""
+        out = super().visit_super_expr(e)
+        FuseTypeInfoPass.node_type_hash[e] = out
+        return out
+
+    def visit_tuple_expr(self, e: mycke.TupleExpr) -> mycke.Type:
+        """Type check TupleExpr expression."""
         out = super().visit_tuple_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_dict_expr(self, e: myfp.DictExpr) -> myb.Type:
-        """Type check a dictionary expression {...}."""
-        out = super().visit_dict_expr(e)
+    def visit_type_alias_expr(self, e: mycke.TypeAliasExpr) -> mycke.Type:
+        """Type check TypeAliasExpr expression."""
+        out = super().visit_type_alias_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_list_comprehension(self, e: myfp.ListComprehension) -> myb.Type:
-        """Type check a list comprehension."""
-        out = super().visit_list_comprehension(e)
+    def visit_type_var_expr(self, e: mycke.TypeVarExpr) -> mycke.Type:
+        """Type check TypeVarExpr expression."""
+        out = super().visit_type_var_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_set_comprehension(self, e: myfp.SetComprehension) -> myb.Type:
-        """Type check a set comprehension."""
-        out = super().visit_set_comprehension(e)
+    def visit_type_var_tuple_expr(self, e: mycke.TypeVarTupleExpr) -> mycke.Type:
+        """Type check TypeVarTupleExpr expression."""
+        out = super().visit_type_var_tuple_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_generator_expr(self, e: myfp.GeneratorExpr) -> myb.Type:
-        """Type check a generator expression."""
-        out = super().visit_generator_expr(e)
+    def visit_unary_expr(self, e: mycke.UnaryExpr) -> mycke.Type:
+        """Type check UnaryExpr expression."""
+        out = super().visit_unary_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_dictionary_comprehension(
-        self, e: myfp.DictionaryComprehension
-    ) -> myb.Type:
-        """Type check a dict comprehension."""
-        out = super().visit_dictionary_comprehension(e)
+    def visit_yield_expr(self, e: mycke.YieldExpr) -> mycke.Type:
+        """Type check YieldExpr expression."""
+        out = super().visit_yield_expr(e)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 
-    def visit_member_expr(
-        self, e: myfp.MemberExpr, is_lvalue: bool = False
-    ) -> myb.Type:
-        """Type check a member expr."""
-        out = super().visit_member_expr(e, is_lvalue)
+    def visit_yield_from_expr(
+        self, e: mycke.YieldFromExpr, allow_none_return: bool = False
+    ) -> mycke.Type:
+        """Type check YieldFromExpr expression."""
+        out = super().visit_yield_from_expr(e, allow_none_return)
         FuseTypeInfoPass.node_type_hash[e] = out
         return out
 

jaclang/compiler/symtable.py

@@ -88,6 +88,12 @@ class SymbolTable:
         self.tab: dict[str, Symbol] = {}
         self.inherit: list[SymbolTable] = []
 
+    def get_type(self) -> SymbolType:
+        """Get type."""
+        if isinstance(self.owner, ast.AstSymbolNode):
+            return self.owner.sym_category
+        return SymbolType.VAR
+
     def get_parent(self) -> Optional[SymbolTable]:
         """Get parent."""
         return self.parent

jaclang/compiler/tests/test_importer.py

@@ -15,7 +15,7 @@ class TestLoader(TestCase):
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
         JacMachine(self.fixture_abs_path(__file__)).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
@@ -24,7 +24,7 @@ class TestLoader(TestCase):
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
         JacMachine(self.fixture_abs_path(__file__)).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn(

jaclang/langserve/engine.py

@@ -18,6 +18,7 @@ from jaclang.langserve.sem_manager import SemTokManager
 from jaclang.langserve.utils import (
     add_unique_text_edit,
     collect_all_symbols_in_scope,
+    collect_child_tabs,
     create_range,
     find_deepest_symbol_node_at_pos,
     find_index,
@@ -44,6 +45,7 @@ class ModuleInfo:
         self.ir = ir
         self.impl_parent: Optional[ModuleInfo] = impl_parent
         self.sem_manager = SemTokManager(ir=ir)
+        self.is_modified: bool = False
 
     @property
     def uri(self) -> str:
@@ -171,22 +173,20 @@ class JacLangServer(LanguageServer):
         self, file_path: str, position: lspt.Position, completion_trigger: Optional[str]
     ) -> lspt.CompletionList:
         """Return completion for a file."""
-        completion_items = []
         document = self.workspace.get_text_document(file_path)
+        mod_ir = self.modules[file_path].ir
         current_line = document.lines[position.line]
         current_pos = position.character
         current_symbol_path = parse_symbol_path(current_line, current_pos)
+        builtin_tab = mod_ir.sym_tab.kid[-1]
+        completion_items = []
 
         node_selected = find_deepest_symbol_node_at_pos(
-            self.modules[file_path].ir,
+            mod_ir,
             position.line,
             position.character - 2,
         )
-        mod_tab = (
-            self.modules[file_path].ir.sym_tab
-            if not node_selected
-            else node_selected.sym_tab
-        )
+        mod_tab = mod_ir.sym_tab if not node_selected else node_selected.sym_tab
         current_symbol_table = mod_tab
 
         if completion_trigger == ".":
@@ -238,7 +238,9 @@ class JacLangServer(LanguageServer):
                             )
                     else:
                         break
-                completion_items = collect_all_symbols_in_scope(temp_tab, up_tree=False)
+                completion_items += collect_all_symbols_in_scope(
+                    temp_tab, up_tree=False
+                )
                 if (
                     isinstance(temp_tab.owner, ast.Architype)
                     and temp_tab.owner.base_classes
@@ -254,8 +256,6 @@ class JacLangServer(LanguageServer):
                                 up_tree=False,
                             )
 
-            else:
-                completion_items = []
         else:
             if node_selected and (
                 node_selected.find_parent_of_type(ast.Architype)
@@ -269,8 +269,10 @@ class JacLangServer(LanguageServer):
             else:
                 self_symbol = []
 
-            completion_items = (
-                collect_all_symbols_in_scope(current_symbol_table) + self_symbol
+            completion_items += (
+                collect_all_symbols_in_scope(current_symbol_table)
+                + self_symbol
+                + collect_child_tabs(builtin_tab)
             )
         return lspt.CompletionList(is_incomplete=False, items=completion_items)
 

jaclang/langserve/server.py

@@ -26,8 +26,11 @@ async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) ->
 @server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
 async def did_save(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    await ls.launch_deep_check(params.text_document.uri)
-    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
+    file_path = params.text_document.uri
+    if ls.modules[file_path].is_modified:
+        await ls.launch_deep_check(file_path)
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
+        ls.modules[file_path].is_modified = False
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
@@ -35,6 +38,8 @@ async def did_change(
     ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
 ) -> None:
     """Check syntax on change."""
+    module = ls.modules[params.text_document.uri]
+    module.is_modified = True
     await ls.launch_quick_check(file_path := params.text_document.uri)
     if file_path in ls.modules:
         document = ls.workspace.get_text_document(file_path)

jaclang/langserve/tests/test_server.py

@@ -369,7 +369,7 @@ class TestJacLangServer(TestCase):
             (
                 lspt.Position(37, 12),
                 ["self", "add", "subtract", "x", "Colorenum", "Colour1", "red", "r"],
-                8,
+                160,
                 None,
             ),
         ]

jaclang/langserve/utils.py

@@ -133,9 +133,12 @@ def find_index(
 ) -> Optional[int]:
     """Find index."""
     index = None
-    for i, j in enumerate(
-        [get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5)]
-    ):
+
+    # A list contains all the token start positions.
+    token_start_list = [
+        get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5)
+    ]
+    for i, j in enumerate(token_start_list):
         if j[0] == line and j[1] <= char <= j[2]:
             return i
 
@@ -302,6 +305,17 @@ def collect_all_symbols_in_scope(
     return symbols
 
 
+def collect_child_tabs(sym_tab: SymbolTable) -> list[lspt.CompletionItem]:
+    """Return all child tab's as completion items."""
+    symbols: list[lspt.CompletionItem] = []
+    for tab in sym_tab.kid:
+        if tab.name not in [i.label for i in symbols]:
+            symbols.append(
+                lspt.CompletionItem(label=tab.name, kind=label_map(tab.get_type()))
+            )
+    return symbols
+
+
 def parse_symbol_path(text: str, dot_position: int) -> list[str]:
     """Parse text and return a list of symbols."""
     text = text[:dot_position][:-1].strip()

jaclang/plugin/default.py

@@ -6,7 +6,6 @@ import ast as ast3
 import fnmatch
 import html
 import os
-import pickle
 import types
 from collections import OrderedDict
 from dataclasses import field
@@ -510,9 +509,10 @@ class JacBuiltinImpl:
             'fillcolor="invis", fontcolor="black"];\n'
         )
         for source, target, edge in connections:
+            edge_label = html.escape(str(edge.__jac__.architype))
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{html.escape(str(edge.__jac__.architype))} "];\n'
+                f' [label="{edge_label if "GenericEdge" not in edge_label else ""}"];\n'
             )
         for node_ in visited_nodes:
             color = (
@@ -751,7 +751,9 @@ class JacFeatureImpl(
 
         jac_machine = JacMachine.get(base_path)
         if not jac_machine.jac_program:
-            jac_machine.attach_program(JacProgram(mod_bundle=None, bytecode=None))
+            jac_machine.attach_program(
+                JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
+            )
 
         if lng == "py":
             import_result = PythonImporter(JacMachine.get()).run_import(spec)
@@ -800,7 +802,7 @@ class JacFeatureImpl(
                 if mod_name.endswith(".test"):
                     mod_name = mod_name[:-5]
                 JacTestCheck.reset()
-                Jac.jac_import(target=mod_name, base_path=base)
+                Jac.jac_import(target=mod_name, base_path=base, cachable=False)
                 JacTestCheck.run_test(xit, maxfail, verbose)
                 ret_count = JacTestCheck.failcount
             else:
@@ -854,8 +856,13 @@ class JacFeatureImpl(
 
     @staticmethod
     @hookimpl
-    def report(expr: Any) -> Any:  # noqa: ANN401
+    def report(expr: Any, custom: bool) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
+        ctx = Jac.get_context()
+        if custom:
+            ctx.custom = expr
+        else:
+            ctx.reports.append(expr)
 
     @staticmethod
     @hookimpl
@@ -1059,16 +1066,14 @@ class JacFeatureImpl(
         file_loc: str, scope: str, attr: str, return_semstr: bool
     ) -> Optional[str]:
         """Jac's get_semstr_type feature."""
+        from jaclang.compiler.semtable import SemInfo, SemScope, SemRegistry
+        from jaclang.runtimelib.machine import JacMachine
+
         _scope = SemScope.get_scope_from_str(scope)
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry: SemRegistry = pickle.load(f)
+        jac_program = JacMachine.get().jac_program
+        mod_registry: SemRegistry = (
+            jac_program.sem_ir if jac_program is not None else SemRegistry()
+        )
         _, attr_seminfo = mod_registry.lookup(_scope, attr)
         if attr_seminfo and isinstance(attr_seminfo, SemInfo):
             return attr_seminfo.semstr if return_semstr else attr_seminfo.type
@@ -1078,15 +1083,12 @@ class JacFeatureImpl(
     @hookimpl
     def obj_scope(file_loc: str, attr: str) -> str:
         """Jac's gather_scope feature."""
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry: SemRegistry = pickle.load(f)
+        from jaclang.runtimelib.machine import JacMachine
+
+        jac_program = JacMachine.get().jac_program
+        mod_registry: SemRegistry = (
+            jac_program.sem_ir if jac_program is not None else SemRegistry()
+        )
 
         attr_scope = None
         for x in attr.split("."):
@@ -1119,15 +1121,13 @@ class JacFeatureImpl(
     @hookimpl
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
         """Jac's get_semstr_type implementation."""
-        with open(
-            os.path.join(
-                os.path.dirname(file_loc),
-                "__jac_gen__",
-                os.path.basename(file_loc).replace(".jac", ".registry.pkl"),
-            ),
-            "rb",
-        ) as f:
-            mod_registry: SemRegistry = pickle.load(f)
+        from jaclang.runtimelib.machine import JacMachine
+        from jaclang.compiler.semtable import SemInfo, SemScope
+
+        jac_program = JacMachine.get().jac_program
+        mod_registry: SemRegistry = (
+            jac_program.sem_ir if jac_program is not None else SemRegistry()
+        )
 
         attr_scope = None
         for x in attr.split("."):

jaclang/plugin/feature.py

@@ -371,9 +371,9 @@ class JacFeature(
         return plugin_manager.hook.has_instance_default(gen_func=gen_func)
 
     @staticmethod
-    def report(expr: Any) -> Any:  # noqa: ANN401
+    def report(expr: Any, custom: bool = False) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
-        return plugin_manager.hook.report(expr=expr)
+        plugin_manager.hook.report(expr=expr, custom=custom)
 
     @staticmethod
     def edge_ref(