jaclang 0.7.14__py3-none-any.whl → 0.7.15__py3-none-any.whl

jaclang/cli/cli.py

@@ -19,10 +19,10 @@ 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.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
@@ -86,11 +86,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,
@@ -146,7 +145,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)
@@ -357,11 +356,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 +435,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

@@ -34,8 +34,6 @@ def generate_static_parser(force: bool = False) -> None:
         except Exception as e:
             logging.error(f"Error generating reference files: {e}")
 
-
-generate_static_parser()
 try:
     from jaclang.compiler.generated import jac_parser as jac_lark
 except ModuleNotFoundError:

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
 

jaclang/compiler/passes/ir_pass.py

@@ -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/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
 

jaclang/compiler/passes/main/import_pass.py

@@ -17,6 +17,9 @@ from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.settings import settings
 from jaclang.utils.helpers import import_target_to_relative_path, is_standard_lib_module
+from jaclang.utils.log import logging
+
+logger = logging.getLogger(__name__)
 
 
 class JacImportPass(Pass):
@@ -204,7 +207,7 @@ class JacImportPass(Pass):
             self.warnings_had += mod_pass.warnings_had
             mod = mod_pass.ir
         except Exception as e:
-            print(e)
+            logger.info(e)
             mod = None
         if isinstance(mod, ast.Module):
             self.import_table[target] = mod
@@ -252,7 +255,6 @@ class PyImportPass(JacImportPass):
                 if spec.origin in self.import_table:
                     return self.import_table[spec.origin]
                 with open(spec.origin, "r", encoding="utf-8") as f:
-                    # print(f"\nImporting python module {node.path_str}")
                     mod = PyastBuildPass(
                         input_ir=ast.PythonModuleAst(
                             py_ast.parse(f.read()), mod_path=spec.origin

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -11,7 +11,7 @@ from typing import Optional, Sequence, TypeVar
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con, EdgeDir, Tokens as Tok
 from jaclang.compiler.passes import Pass
-from jaclang.core.utils import extract_params, extract_type, get_sem_scope
+from jaclang.runtimelib.utils import extract_params, extract_type, get_sem_scope
 
 T = TypeVar("T", bound=ast3.AST)
 
@@ -19,24 +19,25 @@ T = TypeVar("T", bound=ast3.AST)
 class PyastGenPass(Pass):
     """Jac blue transpilation to python pass."""
 
-    @staticmethod
-    def node_compilable_test(node: ast3.AST) -> None:
-        """Convert any AST node to a compilable module node."""
-        if isinstance(node, ast3.Module):
-            pass
-        elif isinstance(node, (ast3.Expr, ast3.stmt)):
-            node = ast3.Module(body=[node], type_ignores=[])
-        elif isinstance(node, list) and all(isinstance(n, ast3.stmt) for n in node):
-            node = ast3.Module(body=node, type_ignores=[])
-        else:
-            node = ast3.Module(body=[], type_ignores=[])
-        try:
-            compile(node, "<ast>", "exec")
-        except TypeError as e:
-            print(ast3.dump(node, indent=2))
-            raise e
-        except Exception:
-            pass
+    # TODO: This should live in utils and perhaps a test added using it
+    # @staticmethod
+    # def node_compilable_test(node: ast3.AST) -> None:
+    #     """Convert any AST node to a compilable module node."""
+    #     if isinstance(node, ast3.Module):
+    #         pass
+    #     elif isinstance(node, (ast3.Expr, ast3.stmt)):
+    #         node = ast3.Module(body=[node], type_ignores=[])
+    #     elif isinstance(node, list) and all(isinstance(n, ast3.stmt) for n in node):
+    #         node = ast3.Module(body=node, type_ignores=[])
+    #     else:
+    #         node = ast3.Module(body=[], type_ignores=[])
+    #     try:
+    #         compile(node, "<ast>", "exec")
+    #     except TypeError as e:
+    #         print(ast3.dump(node, indent=2))
+    #         raise e
+    #     except Exception:
+    #         pass
 
     def before_pass(self) -> None:
         """Initialize pass."""
@@ -80,7 +81,7 @@ class PyastGenPass(Pass):
 
     def needs_jac_import(self) -> None:
         """Check if import is needed."""
-        if "jimport" in self.already_added:
+        if self.needs_jac_import.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -96,11 +97,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("jimport")
+        self.already_added.append(self.needs_jac_import.__name__)
 
     def needs_typing(self) -> None:
         """Check if enum is needed."""
-        if "typing" in self.already_added:
+        if self.needs_typing.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -115,11 +116,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("typing")
+        self.already_added.append(self.needs_typing.__name__)
 
     def needs_enum(self) -> None:
         """Check if enum is needed."""
-        if "enum" in self.already_added:
+        if self.needs_enum.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -134,11 +135,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("enum")
+        self.already_added.append(self.needs_enum.__name__)
 
     def needs_jac_feature(self) -> None:
         """Check if enum is needed."""
-        if "jac_feature" in self.already_added:
+        if self.needs_jac_feature.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -164,11 +165,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("jac_feature")
+        self.already_added.append(self.needs_jac_feature.__name__)
 
     def needs_dataclass(self) -> None:
         """Check if enum is needed."""
-        if "dataclass" in self.already_added:
+        if self.needs_dataclass.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -184,11 +185,11 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("dataclass")
+        self.already_added.append(self.needs_dataclass.__name__)
 
     def needs_dataclass_field(self) -> None:
         """Check if enum is needed."""
-        if "dataclass_field" in self.already_added:
+        if self.needs_dataclass_field.__name__ in self.already_added:
             return
         self.preamble.append(
             self.sync(
@@ -202,7 +203,7 @@ class PyastGenPass(Pass):
                 jac_node=self.ir,
             )
         )
-        self.already_added.append("dataclass_field")
+        self.already_added.append(self.needs_dataclass_field.__name__)
 
     def flatten(self, body: list[T | list[T] | None]) -> list[T]:
         """Flatten ast list."""

jaclang/compiler/passes/main/registry_pass.py

@@ -13,7 +13,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
-from jaclang.core.utils import get_sem_scope
+from jaclang.runtimelib.utils import get_sem_scope
 
 
 class RegistryPass(Pass):

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -212,7 +212,7 @@ class JacFormatPass(Pass):
         items: list[T],
         """
         prev_token = None
-        for i, stmt in enumerate(node.kid):
+        for stmt in node.kid:
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -240,27 +240,10 @@ class JacFormatPass(Pass):
                 elif stmt.name == Tok.RBRACE:
                     if self.indent_level > 0:
                         self.indent_level -= 1
-                    if (stmt.parent and stmt.parent.gen.jac.strip() == "{") or (
-                        stmt.parent
-                        and stmt.parent.parent
-                        and isinstance(
-                            stmt.parent.parent,
-                            (ast.ElseIf, ast.IfStmt, ast.IterForStmt, ast.TryStmt),
-                        )
-                    ):
+                    if stmt.parent and stmt.parent.gen.jac.strip() == "{":
                         self.emit(node, f"{stmt.value}")
                     else:
-                        next_kid = (
-                            node.kid[i + 1]
-                            if i < (len(node.kid) - 1)
-                            else ast.EmptyToken()
-                        )
-                        if (
-                            isinstance(next_kid, ast.CommentToken)
-                            and next_kid.is_inline
-                        ):
-                            self.emit(node, f" {stmt.value}")
-                        elif not (node.gen.jac).endswith("\n"):
+                        if not (node.gen.jac).endswith("\n"):
                             self.emit_ln(node, "")
                             self.emit(node, f"{stmt.value}")
                         else:

jaclang/compiler/passes/transform.py

@@ -70,3 +70,7 @@ class Transform(ABC, Generic[T]):
         )
         self.warnings_had.append(alrt)
         self.logger.warning(str(alrt))
+
+    def log_info(self, msg: str) -> None:
+        """Log info."""
+        self.logger.info(msg)

jaclang/compiler/semtable.py

@@ -127,9 +127,11 @@ class SemRegistry:
                 break
         return i
 
-    def pp(self) -> None:
+    def pp(self) -> str:
         """Pretty print the registry."""
+        ret_str = ""
         for k, v in self.registry.items():
-            print(k)
+            ret_str += f"{k}\n"
             for i in v:
-                print(f"  {i.name} {i.type} {i.semstr}")
+                ret_str += f"  {i.name} {i.type} {i.semstr}\n"
+        return ret_str

jaclang/compiler/tests/test_importer.py

@@ -5,6 +5,7 @@ import sys
 
 from jaclang import jac_import
 from jaclang.cli import cli
+from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.utils.test import TestCase
 
 
@@ -17,11 +18,13 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
+        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
         (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
+        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
         jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn("module 'hello_world'", str(sys.modules))
         self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))