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

jaclang/cli/cli.py

@@ -19,10 +19,11 @@ from jaclang.compiler.constant import Constants
 from jaclang.compiler.passes.main.pyast_load_pass import PyastBuildPass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool.schedules import format_pass
-from jaclang.core.constructs import Architype
 from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.constructs import Architype
+from jaclang.runtimelib.machine import JacProgram
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
@@ -86,11 +87,10 @@ def run(
             else ""
         )
 
-    Jac.context().init_memory(session)
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+    Jac.context().init_memory(base_path=base, session=session)
     if filename.endswith(".jac"):
         ret_module = jac_import(
             target=mod,
@@ -105,12 +105,13 @@ def run(
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             ir = pickle.load(f)
+            jac_program = JacProgram(mod_bundle=ir, bytecode=None)
+            Jac.context().jac_machine.attach_program(jac_program)
             ret_module = jac_import(
                 target=mod,
                 base_path=base,
                 cachable=cache,
                 override_name="__main__" if main else None,
-                mod_bundle=ir,
             )
             if ret_module is None:
                 loaded_mod = None
@@ -146,7 +147,7 @@ def get_object(id: str, session: str = "") -> dict:
     if session == "":
         session = cmd_registry.args.session if "session" in cmd_registry.args else ""
 
-    Jac.context().init_memory(session)
+    Jac.context().init_memory(session=session)
 
     if id == "root":
         id_uuid = UUID(int=0)
@@ -221,7 +222,7 @@ def enter(filename: str, entrypoint: str, args: list) -> None:
         base, mod_name = os.path.split(filename)
         base = base if base else "./"
         mod_name = mod_name[:-4]
-        mod = jac_import(target=mod_name, base_path=base)
+        (mod,) = jac_import(target=mod_name, base_path=base)
         if not mod:
             print("Errors occurred while importing the module.")
             return
@@ -357,11 +358,10 @@ def dot(
             else ""
         )
 
-    Jac.context().init_memory(session)
-
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
+    Jac.context().init_memory(base_path=base, session=session)
     if filename.endswith(".jac"):
         jac_import(
             target=mod,
@@ -437,12 +437,17 @@ def start_cli() -> None:
     parser = cmd_registry.parser
     args = parser.parse_args()
     cmd_registry.args = args
+
+    if args.version:
+        version = importlib.metadata.version("jaclang")
+        print(f"Jac version {version}")
+        return
+
     command = cmd_registry.get(args.command)
     if command:
         args_dict = vars(args)
         args_dict.pop("command")
-        if command not in ["run"]:
-            args_dict.pop("session")
+        args_dict.pop("version", None)
         ret = command.call(**args_dict)
         if ret:
             print(ret)

jaclang/cli/cmdreg.py

@@ -38,7 +38,7 @@ class CommandRegistry:
         self.registry = {}
         self.parser = argparse.ArgumentParser(prog="jac")
         self.parser.add_argument(
-            "--session", help="Session file path", nargs="?", default=""
+            "-V", "--version", action="store_true", help="Show the Jac version"
         )
         self.sub_parsers = self.parser.add_subparsers(title="commands", dest="command")
         self.args = argparse.Namespace()
@@ -172,17 +172,14 @@ class CommandShell(cmd.Cmd):
 
     def default(self, line: str) -> None:
         """Process the command line input."""
-        try:
-            args = vars(self.cmd_reg.parser.parse_args(line.split()))
-            command = self.cmd_reg.get(args["command"])
-            if command:
-                args.pop("command")
-                ret = command.call(**args)
-                if ret:
-                    ret_str = pprint.pformat(ret, indent=2)
-                    self.stdout.write(f"{ret_str}\n")
-        except Exception as e:
-            print(e)
+        args = vars(self.cmd_reg.parser.parse_args(line.split()))
+        command = self.cmd_reg.get(args["command"])
+        if command:
+            args.pop("command")
+            ret = command.call(**args)
+            if ret:
+                ret_str = pprint.pformat(ret, indent=2)
+                self.stdout.write(f"{ret_str}\n")
 
     def do_help(self, arg: str) -> None:
         """Jac CLI 'help' implementaion."""

jaclang/compiler/__init__.py

@@ -35,7 +35,6 @@ def generate_static_parser(force: bool = False) -> None:
             logging.error(f"Error generating reference files: {e}")
 
 
-generate_static_parser()
 try:
     from jaclang.compiler.generated import jac_parser as jac_lark
 except ModuleNotFoundError:
@@ -50,62 +49,29 @@ TOKEN_MAP = {
     for x in jac_lark.Lark_StandAlone().parser.lexer_conf.terminals
 }
 
+# fmt: off
 TOKEN_MAP.update(
     {
-        "CARROW_L": "<++",
-        "CARROW_R": "++>",
-        "GLOBAL_OP": ":global:",
-        "NONLOCAL_OP": ":nonlocal:",
-        "WALKER_OP": ":walker:",
-        "NODE_OP": ":node:",
-        "EDGE_OP": ":edge:",
-        "CLASS_OP": ":class:",
-        "OBJECT_OP": ":obj:",
-        "TYPE_OP": "`",
-        "ABILITY_OP": ":can:",
-        "ELVIS_OP": "?:",
-        "NULL_OK": "?",
-        "KW_OR": "|",
-        "ARROW_BI": "<-->",
-        "ARROW_L": "<--",
-        "ARROW_R": "-->",
-        "ARROW_L_P1": "<-:",
-        "ARROW_R_P2": ":->",
-        "ARROW_L_P2": ":-",
-        "ARROW_R_P1": "-:",
-        "CARROW_BI": "<++>",
-        "CARROW_L": "<++",
-        "CARROW_R": "++>",
-        "CARROW_L_P1": "<+:",
-        "CARROW_R_P2": ":+>",
-        "CARROW_L_P2": ":+",
-        "CARROW_R_P1": "+:",
-        "PIPE_FWD": "|>",
-        "PIPE_BKWD": "<|",
-        "A_PIPE_FWD": ":>",
-        "A_PIPE_BKWD": "<:",
-        "DOT_FWD": ".>",
-        "STAR_POW": "**",
-        "STAR_MUL": "*",
-        "FLOOR_DIV": "//",
-        "DIV": "/",
-        "PYNLINE": "::py::",
-        "ADD_EQ": "+=",
-        "SUB_EQ": "-=",
-        "STAR_POW_EQ": "**=",
-        "MUL_EQ": "*=",
-        "FLOOR_DIV_EQ": "//=",
-        "DIV_EQ": "/=",
-        "MOD_EQ": "%=",
-        "BW_AND_EQ": "&=",
-        "BW_OR_EQ": "|=",
-        "BW_XOR_EQ": "^=",
-        "BW_NOT_EQ": "~=",
-        "LSHIFT_EQ": "<<=",
-        "RSHIFT_EQ": ">>=",
-        "ELLIPSIS": "...",
+        "CARROW_L": "<++", "CARROW_R": "++>", "GLOBAL_OP": ":global:",
+        "NONLOCAL_OP": ":nonlocal:", "WALKER_OP": ":walker:", "NODE_OP": ":node:",
+        "EDGE_OP": ":edge:", "CLASS_OP": ":class:", "OBJECT_OP": ":obj:",
+        "TYPE_OP": "`", "ABILITY_OP": ":can:", "ELVIS_OP": "?:", "NULL_OK": "?",
+        "KW_OR": "|", "ARROW_BI": "<-->", "ARROW_L": "<--",
+        "ARROW_R": "-->", "ARROW_L_P1": "<-:", "ARROW_R_P2": ":->",
+        "ARROW_L_P2": ":-", "ARROW_R_P1": "-:", "CARROW_BI": "<++>",
+        "CARROW_L": "<++", "CARROW_R": "++>", "CARROW_L_P1": "<+:",
+        "CARROW_R_P2": ":+>", "CARROW_L_P2": ":+", "CARROW_R_P1": "+:",
+        "PIPE_FWD": "|>", "PIPE_BKWD": "<|", "A_PIPE_FWD": ":>",
+        "A_PIPE_BKWD": "<:", "DOT_FWD": ".>", "STAR_POW": "**",
+        "STAR_MUL": "*", "FLOOR_DIV": "//", "DIV": "/",
+        "PYNLINE": "::py::", "ADD_EQ": "+=", "SUB_EQ": "-=",
+        "STAR_POW_EQ": "**=", "MUL_EQ": "*=", "FLOOR_DIV_EQ": "//=",
+        "DIV_EQ": "/=", "MOD_EQ": "%=", "BW_AND_EQ": "&=",
+        "BW_OR_EQ": "|=", "BW_XOR_EQ": "^=", "BW_NOT_EQ": "~=",
+        "LSHIFT_EQ": "<<=", "RSHIFT_EQ": ">>=", "ELLIPSIS": "...",
     }
 )
+# fmt: on
 
 
 __all__ = ["jac_lark", "TOKEN_MAP"]

jaclang/compiler/absyntree.py

@@ -55,15 +55,10 @@ class AstNode:
         """Get symbol table."""
         # sym_tab should never be accessed without being set in codebase
         if not self._sym_tab:
-            import traceback
-
-            if self.parent:
-                print(f"Parent: {self.parent.pp()}")
-            print("Node: ", self.pp())
-            stack_trace = traceback.format_stack()
-            print("".join(stack_trace))
             raise ValueError(
-                f"Symbol table not set for {type(self).__name__}. Impossible."
+                f"Symbol table not set for {type(self).__name__}. Impossible.\n"
+                f"Node: {self.pp()}\n"
+                f"Parent: {self.parent.pp() if self.parent else None}\n"
             )
         return self._sym_tab
 
@@ -163,7 +158,7 @@ class AstNode:
         """Get parent of type."""
         from jaclang.compiler.passes import Pass
 
-        return Pass.has_parent_of_type(node=self, typ=typ)
+        return Pass.find_parent_of_type(node=self, typ=typ)
 
     def parent_of_type(self, typ: Type[T]) -> T:
         """Get parent of type."""
@@ -621,6 +616,7 @@ class Module(AstDocNode):
         doc: Optional[String],
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
+        terminals: list[Token],
         kid: Sequence[AstNode],
         stub_only: bool = False,
         registry: Optional[SemRegistry] = None,
@@ -635,6 +631,7 @@ class Module(AstDocNode):
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry
+        self.terminals: list[Token] = terminals
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -642,15 +639,15 @@ class Module(AstDocNode):
     def annexable_by(self) -> Optional[str]:
         """Get annexable by."""
         if not self.stub_only and (
-            self.loc.mod_path.endswith("impl.jac")
-            or self.loc.mod_path.endswith("test.jac")
+            self.loc.mod_path.endswith(".impl.jac")
+            or self.loc.mod_path.endswith(".test.jac")
         ):
             head_mod_name = self.name.split(".")[0]
             potential_path = os.path.join(
                 os.path.dirname(self.loc.mod_path),
                 f"{head_mod_name}.jac",
             )
-            if os.path.exists(potential_path):
+            if os.path.exists(potential_path) and potential_path != self.loc.mod_path:
                 return potential_path
             annex_dir = os.path.split(os.path.dirname(self.loc.mod_path))[-1]
             if annex_dir.endswith(".impl") or annex_dir.endswith(".test"):
@@ -661,7 +658,10 @@ class Module(AstDocNode):
                     os.path.dirname(os.path.dirname(self.loc.mod_path)),
                     f"{head_mod_name}.jac",
                 )
-                if os.path.exists(potential_path):
+                if (
+                    os.path.exists(potential_path)
+                    and potential_path != self.loc.mod_path
+                ):
                     return potential_path
         return None
 
@@ -858,7 +858,7 @@ class Import(ElementStmt, CodeBlockStmt):
 
     def __init__(
         self,
-        hint: SubTag[Name],
+        hint: Optional[SubTag[Name]],
         from_loc: Optional[ModulePath],
         items: SubNodeList[ModuleItem] | SubNodeList[ModulePath],
         is_absorb: bool,  # For includes
@@ -873,11 +873,52 @@ class Import(ElementStmt, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    @property
+    def is_py(self) -> bool:
+        """Check if import is python."""
+        if self.hint and self.hint.tag.value == "py":
+            return True
+        if not self.hint:
+            return not self.__jac_detected
+        return False
+
+    @property
+    def is_jac(self) -> bool:
+        """Check if import is jac."""
+        if self.hint and self.hint.tag.value == "jac":
+            return True
+        if not self.hint:
+            return self.__jac_detected
+        return False
+
+    @property
+    def __jac_detected(self) -> bool:
+        """Check if import is jac."""
+        if self.from_loc:
+            if self.from_loc.resolve_relative_path().endswith(".jac"):
+                return True
+            if os.path.isdir(self.from_loc.resolve_relative_path()):
+                if os.path.exists(
+                    os.path.join(self.from_loc.resolve_relative_path(), "__init__.jac")
+                ):
+                    return True
+                for i in self.items.items:
+                    if isinstance(
+                        i, ModuleItem
+                    ) and self.from_loc.resolve_relative_path(i.name.value).endswith(
+                        ".jac"
+                    ):
+                        return True
+        return any(
+            isinstance(i, ModulePath) and i.resolve_relative_path().endswith(".jac")
+            for i in self.items.items
+        )
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize import node."""
         res = True
         if deep:
-            res = self.hint.normalize(deep)
+            res = self.hint.normalize(deep) if self.hint else res
             res = res and self.from_loc.normalize(deep) if self.from_loc else res
             res = res and self.items.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
@@ -888,7 +929,8 @@ class Import(ElementStmt, CodeBlockStmt):
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
             new_kid.append(self.gen_token(Tok.KW_IMPORT))
-        new_kid.append(self.hint)
+        if self.hint:
+            new_kid.append(self.hint)
         if self.from_loc:
             new_kid.append(self.gen_token(Tok.KW_FROM))
             new_kid.append(self.from_loc)
@@ -941,6 +983,26 @@ class ModulePath(AstSymbolNode):
             [p.value for p in self.path] if self.path else [self.name_spec.sym_name]
         )
 
+    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
+        """Convert an import target string into a relative file path."""
+        target = self.path_str
+        if target_item:
+            target += f".{target_item}"
+        base_path = os.path.dirname(self.loc.mod_path)
+        base_path = base_path if base_path else os.getcwd()
+        parts = target.split(".")
+        traversal_levels = self.level - 1 if self.level > 0 else 0
+        actual_parts = parts[traversal_levels:]
+        for _ in range(traversal_levels):
+            base_path = os.path.dirname(base_path)
+        relative_path = os.path.join(base_path, *actual_parts)
+        relative_path = (
+            relative_path + ".jac"
+            if os.path.exists(relative_path + ".jac")
+            else relative_path
+        )
+        return relative_path
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize module path node."""
         res = True
@@ -1127,7 +1189,6 @@ class ArchDef(AstImplOnlyNode):
         body: SubNodeList[ArchBlockStmt],
         kid: Sequence[AstNode],
         doc: Optional[String] = None,
-        decorators: Optional[SubNodeList[Expr]] = None,
         decl_link: Optional[Architype] = None,
     ) -> None:
         """Initialize arch def node."""
@@ -1468,6 +1529,23 @@ class FuncSignature(AstSemStrNode):
             and self.parent.decl_link.is_static
         )
 
+    @property
+    def is_in_py_class(self) -> bool:
+        """Check if the ability belongs to a class."""
+        is_archi = self.find_parent_of_type(Architype)
+        is_class = is_archi is not None and is_archi.arch_type.name == Tok.KW_CLASS
+
+        return (
+            isinstance(self.parent, Ability)
+            and self.parent.is_method is not None
+            and is_class
+        ) or (
+            isinstance(self.parent, AbilityDef)
+            and isinstance(self.parent.decl_link, Ability)
+            and self.parent.decl_link.is_method
+            and is_class
+        )
+
 
 class EventSignature(AstSemStrNode):
     """EventSignature node type for Jac Ast."""

jaclang/compiler/jac.lark

@@ -16,8 +16,9 @@ element: import_stmt
        | test
 
 // Import/Include Statements
-import_stmt: KW_IMPORT sub_name KW_FROM from_path COMMA import_items SEMI
-           | KW_IMPORT sub_name import_path (COMMA import_path)* SEMI
+import_stmt: KW_IMPORT sub_name? KW_FROM from_path LBRACE import_items RBRACE
+           | KW_IMPORT sub_name? KW_FROM from_path COMMA import_items SEMI  //Deprecated
+           | KW_IMPORT sub_name? import_path (COMMA import_path)* SEMI
            | include_stmt
 
 from_path: (DOT | ELLIPSIS)* import_path
@@ -27,7 +28,7 @@ import_path: named_ref (DOT named_ref)* (KW_AS NAME)?
 import_items: (import_item COMMA)* import_item
 import_item: named_ref (KW_AS NAME)?
 sub_name: COLON NAME
-include_stmt: KW_INCLUDE sub_name import_path SEMI
+include_stmt: KW_INCLUDE sub_name? import_path SEMI
 
 // Architypes
 architype: decorators? architype_decl

jaclang/compiler/parser.py

@@ -56,6 +56,7 @@ class JacParser(Pass):
             source=self.source,
             doc=None,
             body=[],
+            terminals=[],
             is_imported=False,
             kid=[ast.EmptyToken()],
         )
@@ -120,6 +121,7 @@ class JacParser(Pass):
             """Initialize transformer."""
             super().__init__(*args, **kwargs)
             self.parse_ref = parser
+            self.terminals: list[ast.Token] = []
 
         def ice(self) -> Exception:
             """Raise internal compiler error."""
@@ -160,6 +162,7 @@ class JacParser(Pass):
                 doc=doc,
                 body=body,
                 is_imported=False,
+                terminals=self.terminals,
                 kid=kid if len(kid) else [ast.EmptyToken()],
             )
             return self.nu(mod)
@@ -295,26 +298,29 @@ class JacParser(Pass):
         def import_stmt(self, kid: list[ast.AstNode]) -> ast.Import:
             """Grammar rule.
 
-            import_stmt: KW_IMPORT sub_name KW_FROM from_path COMMA import_items SEMI
-                    | KW_IMPORT sub_name import_path (COMMA import_path)* SEMI
+            import_stmt: KW_IMPORT sub_name? KW_FROM from_path LBRACE import_items RBRACE
+                    | KW_IMPORT sub_name? KW_FROM from_path COMMA import_items SEMI  //Deprecated
+                    | KW_IMPORT sub_name? import_path (COMMA import_path)* SEMI
                     | include_stmt
             """
             if len(kid) == 1 and isinstance(kid[0], ast.Import):
                 return self.nu(kid[0])
-            lang = kid[1]
-            from_path = kid[3] if isinstance(kid[3], ast.ModulePath) else None
+            chomp = [*kid]
+            lang = kid[1] if isinstance(kid[1], ast.SubTag) else None
+            chomp = chomp[2:] if lang else chomp[1:]
+            from_path = chomp[1] if isinstance(chomp[1], ast.ModulePath) else None
             if from_path:
                 items = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
             else:
                 paths = [i for i in kid if isinstance(i, ast.ModulePath)]
                 items = ast.SubNodeList[ast.ModulePath](
-                    items=paths, delim=Tok.COMMA, kid=kid[2:-1]
+                    items=paths, delim=Tok.COMMA, kid=kid[2 if lang else 1 : -1]
                 )
-                kid = kid[:2] + [items] + kid[-1:]
+                kid = (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
 
             is_absorb = False
-            if isinstance(lang, ast.SubTag) and (isinstance(items, ast.SubNodeList)):
-                return self.nu(
+            if isinstance(items, ast.SubNodeList):
+                ret = self.nu(
                     ast.Import(
                         hint=lang,
                         from_loc=from_path,
@@ -323,7 +329,15 @@ class JacParser(Pass):
                         kid=kid,
                     )
                 )
-
+                if (
+                    from_path
+                    and isinstance(kid[-1], ast.Token)
+                    and kid[-1].name == Tok.SEMI
+                ):
+                    self.parse_ref.warning(
+                        "Deprecated syntax, use braces for multiple imports (e.g, import from mymod {a, b, c})",
+                    )
+                return ret
             else:
                 raise self.ice()
 
@@ -361,27 +375,24 @@ class JacParser(Pass):
 
             include_stmt: KW_INCLUDE sub_name import_path SEMI
             """
-            lang = kid[1]
-            from_path = kid[2]
+            lang = kid[1] if isinstance(kid[1], ast.SubTag) else None
+            from_path = kid[2] if lang else kid[1]
             if not isinstance(from_path, ast.ModulePath):
                 raise self.ice()
             items = ast.SubNodeList[ast.ModulePath](
                 items=[from_path], delim=Tok.COMMA, kid=[from_path]
             )
-            kid = kid[:2] + [items] + kid[3:]
+            kid = (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
             is_absorb = True
-            if isinstance(lang, ast.SubTag):
-                return self.nu(
-                    ast.Import(
-                        hint=lang,
-                        from_loc=None,
-                        items=items,
-                        is_absorb=is_absorb,
-                        kid=kid,
-                    )
+            return self.nu(
+                ast.Import(
+                    hint=lang,
+                    from_loc=None,
+                    items=items,
+                    is_absorb=is_absorb,
+                    kid=kid,
                 )
-            else:
-                raise self.ice()
+            )
 
         def import_path(self, kid: list[ast.AstNode]) -> ast.ModulePath:
             """Grammar rule.
@@ -3983,4 +3994,5 @@ class JacParser(Pass):
                     err.line = ret.loc.first_line
                     err.column = ret.loc.col_start
                     raise err
+            self.terminals.append(ret)
             return self.nu(ret)

jaclang/compiler/passes/ir_pass.py

@@ -74,7 +74,7 @@ class Pass(Transform[T]):
         return result
 
     @staticmethod
-    def has_parent_of_type(node: ast.AstNode, typ: Type[T]) -> Optional[T]:
+    def find_parent_of_type(node: ast.AstNode, typ: Type[T]) -> Optional[T]:
         """Check if node has parent of type."""
         while node.parent:
             if isinstance(node.parent, typ):
@@ -115,7 +115,7 @@ class Pass(Transform[T]):
         self.after_pass()
         self.time_taken = time.time() - start_time
         if settings.pass_timer:
-            print(
+            self.log_info(
                 f"Time taken in {self.__class__.__name__}: {self.time_taken:.4f} seconds"
             )
         return self.ir
@@ -136,21 +136,12 @@ class Pass(Transform[T]):
         self.exit_node(node)
         return node
 
-    def update_code_loc(self, node: Optional[ast.AstNode] = None) -> None:
-        """Update code location."""
-        if node is None:
-            node = self.cur_node
-        if not isinstance(node, ast.AstNode):
-            self.ice("Current node is not an AstNode.")
-
     def error(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.update_code_loc(node_override)
         self.log_error(f"{msg}", node_override=node_override)
 
     def warning(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.update_code_loc(node_override)
         self.log_warning(f"{msg}", node_override=node_override)
 
     def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError:
@@ -166,10 +157,10 @@ class PrinterPass(Pass):
 
     def enter_node(self, node: ast.AstNode) -> None:
         """Run on entering node."""
-        print("Entering:", node)
+        self.log_info(f"Entering: {node.__class__.__name__}: {node.loc}")
         super().enter_node(node)
 
     def exit_node(self, node: ast.AstNode) -> None:
         """Run on exiting node."""
         super().exit_node(node)
-        print("Exiting:", node)
+        self.log_info(f"Exiting: {node.__class__.__name__}: {node.loc}")

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -175,7 +175,7 @@ class AccessCheckPass(Pass):
         if isinstance(node.parent, ast.FuncCall):
             self.access_check(node)
 
-        if node.sym and Pass.has_parent_of_type(
+        if node.sym and Pass.find_parent_of_type(
             node=node.sym.defn[-1], typ=ast.GlobalVars
         ):
             self.access_check(node)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,7 +6,6 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
-import traceback
 from typing import Callable, TypeVar
 
 import jaclang.compiler.absyntree as ast
@@ -32,7 +31,7 @@ class FuseTypeInfoPass(Pass):
 
     def __debug_print(self, *argv: object) -> None:
         if settings.fuse_type_info_debug:
-            print("FuseTypeInfo::", *argv)
+            self.log_info("FuseTypeInfo::", *argv)
 
     def __call_type_handler(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.ProperType
@@ -72,7 +71,9 @@ class FuseTypeInfoPass(Pass):
     ) -> Callable[[FuseTypeInfoPass, T], None]:
         def node_handler(self: FuseTypeInfoPass, node: T) -> None:
             if not isinstance(node, ast.AstSymbolNode):
-                print(f"Warning {node.__class__.__name__} is not an AstSymbolNode")
+                self.__debug_print(
+                    f"Warning {node.__class__.__name__} is not an AstSymbolNode"
+                )
 
             try:
                 jac_node_str = f'jac node "{node.loc}::{node.__class__.__name__}'
@@ -119,8 +120,6 @@ class FuseTypeInfoPass(Pass):
                 self.__debug_print(
                     f'Internal error happened while parsing "{e.obj.__class__.__name__}"'
                 )
-                traceback.print_exc()
-                print(e)
 
         return node_handler