jaclang 0.8.5__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)
 
 
 
@@ -36,6 +36,7 @@ Parameters to execute the tool command:
     - `sym.`: Generates a dot graph representation of the symbol table for the specified .jac file.
     - `ast`: Displays the Abstract Syntax Tree (AST) of the specified .jac file.
     - `ast.`: Generates a dot graph representation of the AST for the specified .jac file.
+    - `cfg.`: Generates a dot graph representatuin of the CFG(Control Flow Graph) for a specific .jac file
     - `pyast`: Generates the Python AST for a .py file or the relevant Python AST for the generated Python code from a .jac file.
     - `py`: Displays the relevant generated Python code for the respective Jac code in a .jac file.
   - `file_path`: Path to the .jac or .py file.

jaclang/cli/cli.py

@@ -11,22 +11,17 @@ 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
 from jaclang.runtimelib.constructs import WalkerArchetype
-from jaclang.runtimelib.machine import (
-    ExecutionContext,
-    JacMachine as Jac,
-    JacMachineInterface as JacInterface,
-)
+from jaclang.runtimelib.machine import ExecutionContext, JacMachine as Jac
 from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.utils.helpers import debugger as db
 from jaclang.utils.lang_tools import AstTool
 
-
-JacInterface.create_cmd()
+Jac.create_cmd()
 Jac.setup()
 
 
@@ -137,9 +132,10 @@ 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]
     Jac.set_base_path(base)
 
     if filename.endswith((".jac", ".py")):
@@ -148,6 +144,7 @@ def run(
                 target=mod,
                 base_path=base,
                 override_name="__main__" if main else None,
+                lng=lng,
             )
         except Exception as e:
             print(f"Error running {filename}: {e}", file=sys.stderr)
@@ -159,6 +156,7 @@ def run(
                     target=mod,
                     base_path=base,
                     override_name="__main__" if main else None,
+                    lng=lng,
                 )
         except Exception as e:
             print(f"Error running {filename}: {e}", file=sys.stderr)
@@ -219,7 +217,7 @@ def get_object(filename: str, id: str, session: str = "", main: bool = True) ->
 
 
 @cmd_registry.register
-def build(filename: str) -> None:
+def build(filename: str, typecheck: bool = False) -> None:
     """Build the specified .jac file.
 
     Compiles a Jac source file into a Jac Intermediate Representation (.jir) file,
@@ -227,21 +225,25 @@ def build(filename: str) -> None:
 
     Args:
         filename: Path to the .jac file to build
-        typecheck: Perform type checking during build (default: True)
+        typecheck: Perform type checking during build (default: False)
 
     Examples:
         jac build myprogram.jac
-        jac build myprogram.jac --no-typecheck
+        jac build myprogram.jac --typecheck
     """
-    if filename.endswith(".jac"):
-        (out := JacProgram()).compile(file_path=filename)
-        errs = len(out.errors_had)
-        warnings = len(out.warnings_had)
-        print(f"Errors: {errs}, Warnings: {warnings}")
-        with open(filename[:-4] + ".jir", "wb") as f:
-            pickle.dump(out, f)
-    else:
+    if not filename.endswith(".jac"):
         print("Not a .jac file.", file=sys.stderr)
+        exit(1)
+    (out := JacProgram()).compile(file_path=filename, type_check=typecheck)
+    errs = len(out.errors_had)
+    warnings = len(out.warnings_had)
+    print(f"Errors: {errs}, Warnings: {warnings}")
+
+    for alrt in out.errors_had + out.warnings_had:
+        print(alrt.pretty_print(), file=sys.stderr)
+
+    with open(filename[:-4] + ".jir", "wb") as f:
+        pickle.dump(out, f)
 
 
 @cmd_registry.register
@@ -325,6 +327,24 @@ def lsp() -> None:
     run_lang_server()
 
 
+@cmd_registry.register
+def lsp_dev() -> None:
+    """Run Jac Language Server Protocol in Developer Mode.
+
+    Starts the experimental Jac Language Server with enhanced features
+    for development and testing. Used by editor extensions in developer mode.
+
+    Args:
+        This command takes no parameters.
+
+    Examples:
+        jac lsp_dev
+    """
+    from jaclang.langserve.dev_server import run_lang_server
+
+    run_lang_server()
+
+
 @cmd_registry.register
 def enter(
     filename: str,
@@ -642,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
 
@@ -651,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/__init__.py

@@ -9,6 +9,7 @@ from .def_use_pass import DefUsePass  # noqa: I100
 from .sem_def_match_pass import SemDefMatchPass  # noqa: I100
 from .import_pass import JacImportDepsPass  # noqa: I100
 from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
+from .type_checker_pass import TypeCheckPass  # noqa: I100
 from .pyast_load_pass import PyastBuildPass  # type: ignore # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
@@ -25,6 +26,7 @@ __all__ = [
     "JacImportDepsPass",
     "PyImportDepsPass",
     "BinderPass",
+    "TypeCheckPass",
     "SymTabBuildPass",
     "SymTabLinkPass",
     "DeclImplMatchPass",

jaclang/compiler/passes/main/cfg_build_pass.py

@@ -152,7 +152,7 @@ class CFGBuildPass(UniPass):
         """Exit BasicBlockStmt nodes."""
         if isinstance(node, uni.UniCFGNode) and not isinstance(node, uni.Semi):
             self.first_exit = True
-            if not node.bb_out:
+            if not node.bb_out and not isinstance(node, (uni.ReturnStmt, uni.ArchHas)):
                 self.to_connect.append(node)
             if (
                 isinstance(node, (uni.InForStmt, uni.IterForStmt))
@@ -176,6 +176,8 @@ class CFGBuildPass(UniPass):
                     if from_node in self.to_connect:
                         self.to_connect.remove(from_node)
                 self.ability_stack.pop()
+            elif isinstance(node, (uni.IfStmt, uni.ElseIf)) and not node.else_body:
+                self.to_connect.append(node)
 
     def after_pass(self) -> None:
         """After pass."""
@@ -299,3 +301,21 @@ class CoalesceBBPass(UniPass):
 
         dot += "}\n"
         return dot
+
+
+def cfg_dot_from_file(file_name: str) -> str:
+    """Print the control flow graph."""
+    from jaclang.compiler.program import JacProgram
+
+    with open(file_name, "r") as f:
+        file_source = f.read()
+
+    ir = (prog := JacProgram()).compile(use_str=file_source, file_path=file_name)
+
+    cfg_pass = CoalesceBBPass(
+        ir_in=ir,
+        prog=prog,
+    )
+
+    dot = cfg_pass.printgraph_cfg()
+    return dot

jaclang/compiler/passes/main/inheritance_pass.py

@@ -62,9 +62,16 @@ class InheritancePass(Transform[uni.Module, uni.Module]):
 
         base_class_symbol_table = base_class_symbol.symbol_table
 
+        # FIXME: If the base class symbol is imported from another module, the symbol table
+        # will be None. The imported symbols were ignored and introduced in the typecheck
+        # for imported module items. This needs to be investigated to ensure that even imported
+        # classes should have a symbol table (unless the module is not parsed and decided not to).
+        if base_class_symbol_table is None:
+            return
+
         if self.is_missing_py_symbol_table(base_class_symbol, base_class_symbol_table):
             return
-        assert base_class_symbol_table is not None
+
         node.sym_tab.inherit_sym_tab(base_class_symbol_table)
 
     def inherit_from_atom_trailer(

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -187,6 +187,15 @@ class PyastGenPass(UniPass):
             ),
         )
 
+    def needs_mtllm(self) -> None:
+        """Ensure byLLM is imported only once."""
+        self._add_preamble_once(
+            self.needs_mtllm.__name__,
+            ast3.Import(
+                names=[self.sync(ast3.alias(name="byllm"), jac_node=self.ir_out)]
+            ),
+        )
+
     def needs_enum(self) -> None:
         """Ensure Enum utilities are imported only once."""
         self._add_preamble_once(
@@ -735,17 +744,25 @@ class PyastGenPass(UniPass):
         self, model: ast3.expr, caller: ast3.expr, args: ast3.Dict
     ) -> ast3.Call:
         """Reusable method to codegen call_llm(model, caller, args)."""
-        return self.sync(
+        self.needs_mtllm()
+        mtir_cls_ast = self.sync(
+            ast3.Attribute(
+                value=self.sync(ast3.Name(id="byllm", ctx=ast3.Load())),
+                attr="MTIR",
+                ctx=ast3.Load(),
+            )
+        )
+        mtir_ast = self.sync(
             ast3.Call(
-                func=self.jaclib_obj("call_llm"),
+                func=self.sync(
+                    ast3.Attribute(
+                        value=mtir_cls_ast,
+                        attr="factory",
+                        ctx=ast3.Load(),
+                    )
+                ),
                 args=[],
                 keywords=[
-                    self.sync(
-                        ast3.keyword(
-                            arg="model",
-                            value=model,
-                        )
-                    ),
                     self.sync(
                         ast3.keyword(
                             arg="caller",
@@ -758,6 +775,38 @@ class PyastGenPass(UniPass):
                             value=args,
                         )
                     ),
+                    self.sync(
+                        ast3.keyword(
+                            arg="call_params",
+                            value=self.sync(
+                                ast3.Attribute(
+                                    value=model,
+                                    attr="call_params",
+                                    ctx=ast3.Load(),
+                                ),
+                            ),
+                        )
+                    ),
+                ],
+            )
+        )
+        return self.sync(
+            ast3.Call(
+                func=self.jaclib_obj("call_llm"),
+                args=[],
+                keywords=[
+                    self.sync(
+                        ast3.keyword(
+                            arg="model",
+                            value=model,
+                        )
+                    ),
+                    self.sync(
+                        ast3.keyword(
+                            arg="mtir",
+                            value=mtir_ast,
+                        )
+                    ),
                 ],
             )
         )
@@ -953,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
@@ -2074,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(
@@ -2095,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:
@@ -2351,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()),
                         )
                     )
@@ -2948,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: