jaclang 0.8.6__py3-none-any.whl → 0.8.7__py3-none-any.whl

jaclang/cli/cli.md

@@ -1,12 +1,12 @@
 # **Jac Language Command Line Interface (CLI)**
 
-Jac Language CLI is with a variety of commands to facilitate users. Additionally, Jac language offers users the ability to define custom CLI commands through plugins. This document aims to provide an overview of each command along with clear usage instructions.
+git Jac Language CLI provides a variety of commands to facilitate users. Additionally, Jac language offers users the ability to define custom CLI commands through plugins. This document aims to provide an overview of each command along with clear usage instructions.
 
 > [!TIP]
-> Type "help" on Jac CLI and see!
+> Use `jac --help` to see available commands and usage.
 
 ### Click one of the default commands below and see the usage.
-- [tool](#tool) , [run](#run) , [clean](#clean) , [format](#format) , [check](#check) , [build](#build)  , [enter](#enter) , [test](#test)
+- [tool](#tool) , [run](#run) , [clean](#clean) , [format](#format) , [check](#check) , [build](#build) , [enter](#enter) , [test](#test)
 
 
 

jaclang/cli/cli.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from typing import Optional
 
 import jaclang.compiler.unitree as uni
-from jaclang.cli.cmdreg import CommandShell, cmd_registry
+from jaclang.cli.cmdreg import cmd_registry
 from jaclang.compiler.passes.main import PyastBuildPass
 from jaclang.compiler.program import JacProgram
 from jaclang.runtimelib.builtin import printgraph
@@ -132,7 +132,7 @@ def run(
         jac run myprogram.jac --session mysession
         jac run myprogram.jac --no-main
     """
-    # if no session specified, check if it was defined when starting the command shell
+    # if no session specified, check if it was defined via global CLI args
     # otherwise default to jaclang.session
     base, mod, mach = proc_file_sess(filename, session)
     lng = filename.split(".")[-1]
@@ -662,6 +662,14 @@ def start_cli() -> None:
     - None
     """
     parser = cmd_registry.parser
+    # Default to `run` when a file is provided without a subcommand
+    raw_argv = sys.argv[1:]
+    if (
+        raw_argv
+        and not raw_argv[0].startswith("-")
+        and raw_argv[0].lower().endswith((".jac", ".jir", ".py"))
+    ):
+        sys.argv = [sys.argv[0], "run"] + raw_argv
     args = parser.parse_args()
     cmd_registry.args = args
 
@@ -671,16 +679,22 @@ def start_cli() -> None:
         print("Jac path:", __file__)
         return
 
+    if args.command is None:
+        parser.print_help()
+        return
+
     command = cmd_registry.get(args.command)
-    if command:
-        args_dict = vars(args)
-        args_dict.pop("command")
-        args_dict.pop("version", None)
-        ret = command.call(**args_dict)
-        if ret:
-            print(ret)
-    else:
-        CommandShell(cmd_registry).cmdloop()
+    if not command:
+        print(f"Unknown command: {args.command}", file=sys.stderr)
+        parser.print_help()
+        return
+
+    args_dict = vars(args)
+    args_dict.pop("command")
+    args_dict.pop("version", None)
+    ret = command.call(**args_dict)
+    if ret:
+        print(ret)
 
 
 if __name__ == "__main__":

jaclang/cli/cmdreg.py

@@ -3,9 +3,7 @@
 from __future__ import annotations
 
 import argparse
-import cmd
 import inspect
-import pprint
 import re
 from typing import Callable, Dict, Optional
 
@@ -241,141 +239,4 @@ class CommandRegistry:
 cmd_registry = CommandRegistry()
 
 
-class CommandShell(cmd.Cmd):
-    """Command shell for the command line interface."""
-
-    intro = "Welcome to the Jac CLI!"
-    prompt = "jac> "
-    cmd_reg: CommandRegistry
-
-    def __init__(self, cmd_reg: CommandRegistry) -> None:
-        """Initialize a CommandShell instance."""
-        self.cmd_reg = cmd_reg
-        super().__init__()
-
-    def do_exit(self, arg: list) -> bool:
-        """Exit the command shell."""
-        return True
-
-    def default(self, line: str) -> None:
-        """Process the command line input."""
-        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 implementation."""
-
-        def get_info(name: str, doc: str, args: dict[str, inspect.Parameter]) -> None:
-            """Format and display detailed command information."""
-            # Format the command header
-            self.stdout.write(f"\n{'=' * 80}\n")
-            self.stdout.write(f"COMMAND: {name}\n")
-            self.stdout.write(f"{'=' * 80}\n\n")
-
-            # Format the command description
-            doc_lines = doc.strip().split("\n")
-            for line in doc_lines:
-                self.stdout.write(f"{line}\n")
-
-            # Format the command arguments
-            if args:
-                self.stdout.write("\nARGUMENTS:\n")
-                for param_name, param in args.items():
-                    # Get parameter type
-                    type_name = (
-                        param.annotation.__name__
-                        if hasattr(param.annotation, "__name__")
-                        else str(param.annotation)
-                    )
-
-                    # Format default value if present
-                    default_str = ""
-                    if param.default is not param.empty:
-                        default_str = f" (default: {param.default})"
-
-                    # Format required/optional status
-                    req_str = (
-                        " [required]"
-                        if param.default is param.empty and param_name != "args"
-                        else " [optional]"
-                    )
-
-                    self.stdout.write(
-                        f"  {param_name}: {type_name}{default_str}{req_str}\n"
-                    )
-            else:
-                self.stdout.write("\nNo arguments\n")
-
-            # Format usage examples
-            command_parser = self.cmd_reg.sub_parsers.choices[name]
-            self.stdout.write(f"\nUSAGE:\n  {command_parser.format_usage()[7:]}\n")
-
-            # Extract and format examples from docstring if present
-            if "Examples:" in doc:
-                examples_section = doc.split("Examples:")[1].strip()
-                example_lines = examples_section.split("\n")
-                self.stdout.write("\nEXAMPLES:\n")
-                for example in example_lines:
-                    if example.strip():
-                        self.stdout.write(f"  {example.strip()}\n")
-
-            self.stdout.write("\n")
-
-        if arg == "all":
-            # Display all commands with their details
-            command_details = self.cmd_reg.get_all_commands()
-            for name, (doc, args) in sorted(command_details.items()):
-                get_info(name, doc, args)
-
-        elif arg:
-            # Display help for a specific command
-            command = self.cmd_reg.get(arg)
-            if command:
-                doc = command.func.__doc__ or "No help available."
-                args = command.sig.parameters
-                get_info(arg, doc, args)
-            else:
-                self.stdout.write(f"\nUnknown command: '{arg}'\n")
-                self.stdout.write("Type 'help' to see available commands.\n")
-        else:
-            # Display general help information
-            self.stdout.write("\n")
-            self.stdout.write("JAC PROGRAMMING LANGUAGE COMMAND LINE INTERFACE\n")
-            self.stdout.write("=" * 50 + "\n\n")
-
-            self.stdout.write("AVAILABLE COMMANDS:\n")
-
-            # Get all command names and sort them alphabetically
-            command_names = sorted(self.cmd_reg.registry.keys())
-
-            # Get brief descriptions for each command
-            command_descriptions: dict[str, str] = {}
-            for name in command_names:
-                command = self.cmd_reg.get(name)
-                if command and command.func.__doc__:
-                    # Extract the first line of the docstring as a brief description
-                    brief = command.func.__doc__.split("\n")[0].strip()
-                    command_descriptions[name] = brief
-                else:
-                    command_descriptions[name] = "No description available"
-
-            # Display commands with their brief descriptions
-            for name in command_names:
-                self.stdout.write(
-                    f"  {name.ljust(15)} - {command_descriptions[name]}\n"
-                )
-
-            self.stdout.write("\nFor detailed information on a specific command:\n")
-            self.stdout.write("  help <command>\n")
-
-            self.stdout.write("\nTo see detailed information for all commands:\n")
-            self.stdout.write("  help all\n")
-
-            self.stdout.write("\nTo exit the Jac CLI:\n")
-            self.stdout.write("  exit\n\n")
+# Shell mode removed; interactive cmd-based shell is no longer supported.

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -1002,7 +1002,8 @@ class PyastGenPass(UniPass):
     def exit_func_signature(self, node: uni.FuncSignature) -> None:
         params = (
             [self.sync(ast3.arg(arg="self", annotation=None))]
-            if (abl := node.find_parent_of_type(uni.Ability))
+            if (abl := node.parent)
+            and isinstance(abl, uni.Ability)
             and abl.is_method
             and not node.is_static
             and not node.is_in_py_class
@@ -2123,6 +2124,10 @@ class PyastGenPass(UniPass):
         ]
 
     def exit_lambda_expr(self, node: uni.LambdaExpr) -> None:
+        # Python lambda expressions don't support type annotations
+        if node.signature:
+            self._remove_lambda_param_annotations(node.signature)
+
         node.gen.py_ast = [
             self.sync(
                 ast3.Lambda(
@@ -2144,6 +2149,11 @@ class PyastGenPass(UniPass):
             )
         ]
 
+    def _remove_lambda_param_annotations(self, signature: uni.FuncSignature) -> None:
+        for param in signature.params:
+            if param.gen.py_ast and isinstance(param.gen.py_ast[0], ast3.arg):
+                param.gen.py_ast[0].annotation = None
+
     def exit_unary_expr(self, node: uni.UnaryExpr) -> None:
         op_cls = UNARY_OP_MAP.get(node.op.name)
         if op_cls:
@@ -2400,7 +2410,7 @@ class PyastGenPass(UniPass):
                     self.sync(
                         ast3.Attribute(
                             value=cast(ast3.expr, node.target.gen.py_ast[0]),
-                            attr=(node.right.sym_name),
+                            attr=node.right.sym_name,
                             ctx=cast(ast3.expr_context, node.right.py_ctx_func()),
                         )
                     )
@@ -2997,7 +3007,7 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [self.sync(op_cls())]
 
     def exit_name(self, node: uni.Name) -> None:
-        name = node.sym_name[2:] if node.sym_name.startswith("<>") else node.sym_name
+        name = node.sym_name
         node.gen.py_ast = [self.sync(ast3.Name(id=name, ctx=node.py_ctx_func()))]
 
     def exit_float(self, node: uni.Float) -> None:

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -141,17 +141,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
 
         reserved_keywords = [v for _, v in TOKEN_MAP.items()]
 
-        value = node.name if node.name not in reserved_keywords else f"<>{node.name}"
         name = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=value,
+            value=node.name,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.name),
             pos_start=0,
             pos_end=0,
+            is_kwesc=(node.name in reserved_keywords),
         )
         body = [self.convert(i) for i in node.body]
         valid = [i for i in body if isinstance(i, (uni.CodeBlockStmt))]
@@ -285,8 +285,8 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
                 and body_stmt.signature.params
             ):
                 for param in body_stmt.signature.params:
-                    if param.name.value == "self":
-                        param.type_tag = uni.SubTag[uni.Expr](name, kid=[name])
+                    if param.name.value == "self" and param.type_tag:
+                        param.type_tag.tag.value = name.value
         doc = (
             body[0].expr
             if isinstance(body[0], uni.ExprStmt)
@@ -748,17 +748,14 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
         attribute = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=(
-                ("<>" + node.attr)
-                if node.attr == "init"
-                else "init" if node.attr == "__init__" else node.attr
-            ),
+            value="init" if node.attr == "__init__" else node.attr,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.attr),
             pos_start=0,
             pos_end=0,
+            is_kwesc=node.attr == "init",
         )
         if isinstance(value, uni.Expr):
             return uni.AtomTrailer(
@@ -1680,18 +1677,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             for _, v in TOKEN_MAP.items()
             if v not in ["float", "int", "str", "bool", "self"]
         ]
-
-        value = node.id if node.id not in reserved_keywords else f"<>{node.id}"
         ret = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=value,
+            value=node.id,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.id),
             pos_start=0,
             pos_end=0,
+            is_kwesc=(node.id in reserved_keywords),
         )
         return ret
 
@@ -1735,18 +1731,18 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
 
         names: list[uni.NameAtom] = []
         for name in node.names:
-            value = name if name not in reserved_keywords else f"<>{name}"
             names.append(
                 uni.Name(
                     orig_src=self.orig_src,
                     name=Tok.NAME,
-                    value=value,
+                    value=name,
                     line=node.lineno,
                     end_line=node.end_lineno if node.end_lineno else node.lineno,
                     col_start=node.col_offset,
                     col_end=node.col_offset + len(name),
                     pos_start=0,
                     pos_end=0,
+                    is_kwesc=(name in reserved_keywords),
                 )
             )
         return uni.NonLocalStmt(target=names, kid=names)
@@ -2056,17 +2052,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             if v not in ["float", "int", "str", "bool", "self"]
         ]
 
-        value = node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
         name = uni.Name(
             orig_src=self.orig_src,
             name=Tok.NAME,
-            value=value,
+            value=node.arg,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
             col_end=node.col_offset + len(node.arg),
             pos_start=0,
             pos_end=0,
+            is_kwesc=(node.arg in reserved_keywords),
         )
         ann_expr = (
             self.convert(node.annotation)
@@ -2343,19 +2339,17 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
             from jaclang.compiler import TOKEN_MAP
 
             reserved_keywords = [v for _, v in TOKEN_MAP.items()]
-            arg_value = (
-                node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
-            )
             arg = uni.Name(
                 orig_src=self.orig_src,
                 name=Tok.NAME,
-                value=arg_value,
+                value=node.arg,
                 line=node.lineno,
                 end_line=node.end_lineno if node.end_lineno else node.lineno,
                 col_start=node.col_offset,
                 col_end=node.col_offset + len(node.arg if node.arg else "_"),
                 pos_start=0,
                 pos_end=0,
+                is_kwesc=(node.arg in reserved_keywords),
             )
         value = self.convert(node.value)
         if isinstance(value, uni.Expr):

jaclang/compiler/passes/main/tests/fixtures/checker_binary_op.jac

@@ -0,0 +1,21 @@
+node B {
+  def __mul__(other: B) -> int {
+    return 0;
+  }
+}
+
+node A {
+  def __add__(other: A) -> B {
+    return B();
+  }
+}
+
+with entry {
+  a: A = A();
+
+  r1: B = a + a;  # <-- Ok
+  r2: A = a + a;  # <-- Error
+
+  r3: int = (a+a) * B(); # <-- Ok
+  r4: str = (a+a) * B(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_call_expr_class.jac

@@ -0,0 +1,12 @@
+
+node Foo {
+    has i: int = 0;
+}
+
+with entry {
+    cls = Foo;
+    inst = cls(); # <-- Call expression target of class type
+
+    inst.i = 42;     # <-- Ok
+    inst.i = 'str'; # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_cyclic_symbol.jac

@@ -0,0 +1,4 @@
+
+with entry {
+    x = x;
+}

jaclang/compiler/passes/main/tests/fixtures/checker_expr_call.jac

@@ -0,0 +1,9 @@
+
+def foo() -> int {
+    return 42;
+}
+
+with entry {
+    i: int = foo(); # <-- Ok
+    s: str = foo(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_import_missing_module.jac

@@ -0,0 +1,13 @@
+import from scipy { stats, optimize }
+import from utils.fake_helpers { helper_func }
+import from non_existent_module { foo }
+import nonexistent_module as nm;
+
+
+with entry {
+    a: int = stats.norm.cdf(0);
+    d: float = optimize.minimize_scalar(lambda  x: int: x ** 2).fun;
+    result = helper_func();
+    b: int = foo();
+    c = nm.some_func();
+}

jaclang/compiler/passes/main/tests/fixtures/checker_magic_call.jac

@@ -0,0 +1,17 @@
+
+node Bar {}
+
+node Foo {
+    def __call__() -> Bar {
+        return Bar();
+    }
+}
+
+def fn() -> Foo {
+    return Foo();
+}
+
+with entry{
+    b: Bar = fn()(); # <-- Ok
+    f: Foo = fn()(); # <-- Error
+}

jaclang/compiler/passes/main/tests/fixtures/checker_mod_path.jac

@@ -0,0 +1,8 @@
+
+
+import jaclang.compiler.unitree as uni;
+
+
+with entry{
+    a:int = uni.Module; # <-- Error
+}

jaclang/compiler/passes/main/tests/test_checker_pass.py

@@ -81,6 +81,80 @@ class TypeCheckerPassTests(TestCase):
                ^^^^^^^^^^^^^^
         """, program.errors_had[0].pretty_print())
 
+    def test_call_expr(self) -> None:
+        path = self.fixture_abs_path("checker_expr_call.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+          s: str = foo();
+          ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_call_expr_magic(self) -> None:
+        path = self.fixture_abs_path("checker_magic_call.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            b: Bar = fn()(); # <-- Ok
+            f: Foo = fn()(); # <-- Error
+            ^^^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_binary_op(self) -> None:
+        program = JacProgram()
+        mod = program.compile(self.fixture_abs_path("checker_binary_op.jac"))
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 2)
+        self._assert_error_pretty_found("""
+            r2: A = a + a;  # <-- Error
+            ^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+        self._assert_error_pretty_found("""
+            r4: str = (a+a) * B(); # <-- Error
+            ^^^^^^^^^^^^^^^^^^^^^
+        """, program.errors_had[1].pretty_print())
+
+    def test_checker_call_expr_class(self) -> None:
+        path = self.fixture_abs_path("checker_call_expr_class.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            inst.i = 'str'; # <-- Error
+            ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_mod_path(self) -> None:
+        path = self.fixture_abs_path("checker_mod_path.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 1)
+        self._assert_error_pretty_found("""
+            a:int = uni.Module; # <-- Error
+            ^^^^^^^^^^^^^^
+        """, program.errors_had[0].pretty_print())
+
+    def test_checker_import_missing_module(self) -> None:
+        path = self.fixture_abs_path("checker_import_missing_module.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 0)
+
+    def test_cyclic_symbol(self) -> None:
+        path = self.fixture_abs_path("checker_cyclic_symbol.jac")
+        program = JacProgram()
+        mod = program.compile(path)
+        # This will result in a stack overflow if not handled properly.
+        # So the fact that it has 0 errors means it passed.
+        TypeCheckPass(ir_in=mod, prog=program)
+        self.assertEqual(len(program.errors_had), 0)
 
     def _assert_error_pretty_found(self, needle: str, haystack: str) -> None:
         for line in [line.strip() for line in needle.splitlines() if line.strip()]:

jaclang/compiler/passes/main/type_checker_pass.py

@@ -36,16 +36,28 @@ class TypeCheckPass(UniPass):
     # Cache the builtins module once it parsed.
     _BUILTINS_MODULE: uni.Module | None = None
 
+    # REVIEW: Making the evaluator a static (singleton) variable to make sure only one
+    # instance is used across mulitple compilation units. This can also be attached to an
+    # attribute of JacProgram, however the evaluator is a temproary object that we dont
+    # want bound to the program for long term, Also the program is the one that will be
+    # dumped in the compiled bundle.
+    _EVALUATOR: TypeEvaluator | None = None
+
     def before_pass(self) -> None:
         """Initialize the checker pass."""
         self._load_builtins_stub_module()
         self._insert_builtin_symbols()
 
-        assert TypeCheckPass._BUILTINS_MODULE is not None
-        self.evaluator = TypeEvaluator(
-            builtins_module=TypeCheckPass._BUILTINS_MODULE,
-            program=self.prog,
-        )
+    @property
+    def evaluator(self) -> TypeEvaluator:
+        """Return the type evaluator."""
+        if TypeCheckPass._EVALUATOR is None:
+            assert TypeCheckPass._BUILTINS_MODULE is not None
+            TypeCheckPass._EVALUATOR = TypeEvaluator(
+                builtins_module=TypeCheckPass._BUILTINS_MODULE,
+                program=self.prog,
+            )
+        return TypeCheckPass._EVALUATOR
 
     # --------------------------------------------------------------------------
     # Internal helper functions
@@ -126,3 +138,10 @@ class TypeCheckPass(UniPass):
     def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
         """Handle the atom trailer node."""
         self.evaluator.get_type_of_expression(node)
+
+    def exit_func_call(self, node: uni.FuncCall) -> None:
+        """Handle the function call node."""
+        # TODO:
+        # 1. Function Existence & Callable Validation
+        # 2. Argument Matching(count, types, names)
+        self.evaluator.get_type_of_expression(node)