jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/cli/.gitignore

@@ -0,0 +1,3 @@
+jac_cli.py
+build.py
+run.py

jaclang/cli/cli.md

@@ -0,0 +1,190 @@
+# **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.
+
+> [!TIP]
+> Type "help" on Jac CLI and see!
+
+### 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)
+
+
+
+# 1. Command `tool`:
+### tool
+Jac Language offers language tools to perform various tasks efficiently. The `tool` command is utilized to execute specific language tools along with any optional arguments as needed. This command enables users to interact with language-specific command line tools designed to manage the language effectively.
+### Usage:
+```bash
+$ jac tool <jac_tool> <args>
+```
+Parameters to execute the tool command:
+- `jac_tool`: The name of the language tool to execute.
+    - `ir`, `pass_template`, `py_ast_nodes`,  `md_doc`, `automate_ref` are the jac_tools used to handle (Usage instruction is below)
+- `args`: Optional arguments for the specific language tool.
+
+
+    ## 1. jac_tool `ir`:
+     `ir` tool generates an Abstract Syntax Tree (AST) and SymbolTable tree for a .jac file, or a Python AST for a .py file. `ir` tool is used with `tool` cli command.
+    ### Usage
+    ```bash
+    $ jac tool ir <output_type> <file_path>
+    ```
+
+    ### Parameters to use the ir tool:
+  - `output_type`: Choose one of the following options:
+    - `sym`: Provides the symbol table of the specified .jac file.
+    - `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.
+    - `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.
+
+    ### Examples
+    >To get the symbol table tree of a Jac file:
+    >```bash
+    >$ jac tool ir sym <file_path>
+    >```
+    >To generate a dot graph of the symbol table tree for a Jac file:
+    >```bash
+    >$ jac tool ir sym. <file_path>
+    >```
+    >To view the AST tree of a Jac file:
+    >```bash
+    >$ jac tool ir ast <file_path>
+    >```
+
+
+    ## 2. jac_tool `pass_template`:
+     `pass_template` tool generates pass template for jac.
+    ```bash
+    $ jac tool pass_template
+    ```
+    No Parameters needed to use the pass_template tool
+
+
+    ## 3. jac_tool `py_ast_nodes`:
+     `py_ast_nodes` tool lists python ast nodes.
+    ```bash
+    $ jac tool py_ast_nodes
+    ```
+    No Parameters needed to use the py_ast_nodes tool
+
+
+    ## 4. jac_tool `md_doc`:
+     `md_doc` tool generate mermaid markdown doc.
+    ```bash
+    $ jac tool md_doc
+    ```
+    No Parameters needed to use the md_doc tool
+
+
+    ## 5. jac_tool `automate_ref`:
+     `automate_ref` tool automates the reference guide generation.
+    ```bash
+    $ jac tool automate_ref
+    ```
+    No Parameters needed to use the automate_ref tool
+
+
+
+# 2. Command `run`:
+### run
+The `run` command is utilized to run the specified .jac or .jir file.
+### Usage:
+```bash
+$ jac run <file_path> [main] [cache]
+```
+  Parameters to execute the run command:
+  - `file_path`: Path of .jac or .jir file to run.
+  - `main`: (Optional, bool) A flag indicating whether the module being executed is the main module. Defaults to True
+  - `cache` :The cache flag to cache
+  ### Examples
+  >To run file_path Jac file:
+  >```bash
+  >$ jac run <file_path>
+  >```
+
+
+
+# 3. Command `clean`:
+### clean
+The `clean` command is utilized to remove the __jac_gen__ , __pycache__ folders from the current directory recursively.
+### Usage:
+```bash
+$ jac clean
+```
+No Parameters needed to execute the clean command
+
+
+
+# 4. Command `format`:
+### format
+The `format` command is utilized to run the specified .jac file or format all .jac files in a given directory.
+### Usage:
+```bash
+$ jac format <file_path/directory_path> [outfile] [debug]
+```
+  Parameters to execute the format command:
+  - `file_path/directory_path`: The path to the .jac file or directory containing .jac files.
+  - `outfile`: (Optional) The output file path (only applies when formatting a single file).
+  - `debug` :(Optional) If True, print debug information.  Defaults to False
+  ### Examples
+  >To format all .jac files from walking through current located directory:
+  >```bash
+  >$ jac format .
+  >```
+
+
+
+# 5. Command `check`:
+### check
+The `check` command is utilized to run type checker for a specified .jac file.
+### Usage:
+```bash
+$ jac check <file_path>
+```
+Parameters to execute the check command:
+- `file_path`: Path of .jac file to run type checker.
+
+
+
+# 6. Command `build`:
+### build
+The `build` command is utilized to build the specified .jac file.
+### Usage:
+```bash
+$ jac build <file_path>
+```
+  Parameters to execute the build command:
+  - `file_path`: Path of .jac file to build.
+
+
+
+# 7. Command `enter`:
+### enter
+The `enter` command is utilized to run the specified entrypoint function in the given .jac file.
+### Usage:
+```bash
+$ jac enter <file_path> <entrypoint> <args>
+```
+Parameters to execute the enter command:
+- `file_path`: The path to the .jac file.
+- `entrypoint`: The name of the entrypoint function.
+- `args`: Arguments to pass to the entrypoint function.
+### Examples
+>To enter file_path Jac file
+>```bash
+>$ jac enter <file_path>
+>```
+
+
+
+# 8. Command `test`:
+### test
+The `test` command is utilized to run the test suite in the specified .jac file.
+```bash
+$ jac test <file_path>
+```
+Parameters to execute the test command:
+- `file_path`: The path to the .jac file.

jaclang/cli/cli.py

@@ -2,12 +2,14 @@
 
 import ast as ast3
 import importlib
+import inspect
 import marshal
 import os
 import pickle
 import shutil
 import types
 from typing import Optional
+from uuid import UUID
 
 import jaclang.compiler.absyntree as ast
 from jaclang import jac_import
@@ -17,6 +19,7 @@ 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.construct import Architype
 from jaclang.plugin.builtin import dotgen
 from jaclang.plugin.feature import JacCmd as Cmd
 from jaclang.plugin.feature import JacFeature as Jac
@@ -63,13 +66,33 @@ def format(path: str, outfile: str = "", debug: bool = False) -> None:
 
 
 @cmd_registry.register
-def run(filename: str, main: bool = True, cache: bool = True) -> None:
+def run(
+    filename: str,
+    session: str = "",
+    main: bool = True,
+    cache: bool = True,
+    walker: str = "",
+    node: str = "",
+) -> None:
     """Run the specified .jac file."""
+    # if no session specified, check if it was defined when starting the command shell
+    # otherwise default to jaclang.session
+    if session == "":
+        session = (
+            cmd_registry.args.session
+            if hasattr(cmd_registry, "args")
+            and hasattr(cmd_registry.args, "session")
+            and cmd_registry.args.session
+            else ""
+        )
+
+    Jac.context().init_memory(session)
+
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
     if filename.endswith(".jac"):
-        jac_import(
+        loaded_mod = jac_import(
             target=mod,
             base_path=base,
             cachable=cache,
@@ -78,7 +101,7 @@ def run(filename: str, main: bool = True, cache: bool = True) -> None:
     elif filename.endswith(".jir"):
         with open(filename, "rb") as f:
             ir = pickle.load(f)
-            jac_import(
+            loaded_mod = jac_import(
                 target=mod,
                 base_path=base,
                 cachable=cache,
@@ -87,6 +110,49 @@ def run(filename: str, main: bool = True, cache: bool = True) -> None:
             )
     else:
         print("Not a .jac file.")
+        return
+
+    if not node or node == "root":
+        entrypoint: Architype = Jac.get_root()
+    else:
+        obj = Jac.context().get_obj(UUID(node))
+        if obj is None:
+            print(f"Entrypoint {node} not found.")
+            return
+        entrypoint = obj
+
+    # TODO: handle no override name
+    if walker:
+        walker_module = dict(inspect.getmembers(loaded_mod)).get(walker)
+        if walker_module:
+            Jac.spawn_call(entrypoint, walker_module())
+        else:
+            print(f"Walker {walker} not found.")
+
+    Jac.reset_context()
+
+
+@cmd_registry.register
+def get_object(id: str, session: str = "") -> dict:
+    """Get the object with the specified id."""
+    if session == "":
+        session = cmd_registry.args.session if "session" in cmd_registry.args else ""
+
+    Jac.context().init_memory(session)
+
+    if id == "root":
+        id_uuid = UUID(int=0)
+    else:
+        id_uuid = UUID(id)
+
+    obj = Jac.context().get_obj(id_uuid)
+    if obj is None:
+        print(f"Object with id {id} not found.")
+        Jac.reset_context()
+        return {}
+    else:
+        Jac.reset_context()
+        return obj.__getstate__()
 
 
 @cmd_registry.register
@@ -242,6 +308,7 @@ def debug(filename: str, main: bool = True, cache: bool = False) -> None:
 @cmd_registry.register
 def dot(
     filename: str,
+    session: str = "",
     initial: str = "",
     depth: int = -1,
     traverse: bool = False,
@@ -263,6 +330,17 @@ def dot(
     :param node_limit: The maximum number of nodes allowed in the graph.
     :param saveto: Path to save the generated graph.
     """
+    if session == "":
+        session = (
+            cmd_registry.args.session
+            if hasattr(cmd_registry, "args")
+            and hasattr(cmd_registry.args, "session")
+            and cmd_registry.args.session
+            else ""
+        )
+
+    Jac.context().init_memory(session)
+
     base, mod = os.path.split(filename)
     base = base if base else "./"
     mod = mod[:-4]
@@ -286,6 +364,10 @@ def dot(
             )
         except Exception as e:
             print(f"Error while generating graph: {e}")
+            import traceback
+
+            traceback.print_exc()
+            Jac.reset_context()
             return
         file_name = saveto if saveto else f"{mod}.dot"
         with open(file_name, "w") as file:
@@ -294,6 +376,8 @@ def dot(
     else:
         print("Not a .jac file.")
 
+    Jac.reset_context()
+
 
 @cmd_registry.register
 def py_to_jac(filename: str, tree: bool = False) -> None:
@@ -321,10 +405,13 @@ def start_cli() -> None:
     """
     parser = cmd_registry.parser
     args = parser.parse_args()
+    cmd_registry.args = args
     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")
         ret = command.call(**args_dict)
         if ret:
             print(ret)

jaclang/cli/cmdreg.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import cmd
 import inspect
+import pprint
 from typing import Callable, Optional
 
 
@@ -30,12 +31,17 @@ class CommandRegistry:
     registry: dict[str, Command]
     sub_parsers: argparse._SubParsersAction
     parser: argparse.ArgumentParser
+    args: argparse.Namespace
 
     def __init__(self) -> None:
         """Initialize a CommandRegistry instance."""
         self.registry = {}
-        self.parser = argparse.ArgumentParser(prog="CLI")
+        self.parser = argparse.ArgumentParser(prog="jac")
+        self.parser.add_argument(
+            "--session", help="Session file path", nargs="?", default=""
+        )
         self.sub_parsers = self.parser.add_subparsers(title="commands", dest="command")
+        self.args = argparse.Namespace()
 
     def register(self, func: Callable) -> Callable:
         """Register a command in the registry."""
@@ -48,6 +54,11 @@ class CommandRegistry:
         first = True
         for param_name, param in cmd.sig.parameters.items():
             arg_msg = f"type: {param.annotation.__name__}"
+            # shorthand is first character by default,
+            # If already taken, use the first 2 characters
+            shorthand = param_name[:1]
+            if f"-{shorthand}" in cmd_parser._option_string_actions:
+                shorthand = param_name[:2]
             if param_name == "args":
                 cmd_parser.add_argument("args", nargs=argparse.REMAINDER, help=arg_msg)
             elif param_name == "filepath":
@@ -76,7 +87,7 @@ class CommandRegistry:
                     )
                 else:
                     cmd_parser.add_argument(
-                        f"-{param_name[:1]}",
+                        f"-{shorthand}",
                         f"--{param_name}",
                         required=True,
                         type=(
@@ -99,14 +110,14 @@ class CommandRegistry:
                 arg_msg += f", default: {param.default}"
                 if param.annotation == bool:
                     cmd_parser.add_argument(
-                        f"-{param_name[:1]}",
+                        f"-{shorthand}",
                         f"--{param_name}",
                         default=param.default,
                         action="store_true",
                         help=arg_msg,
                     )
                     cmd_parser.add_argument(
-                        f"-n{param_name[:1]}",
+                        f"-n{shorthand}",
                         f"--no-{param_name}",
                         dest=param_name,
                         action="store_false",
@@ -114,7 +125,7 @@ class CommandRegistry:
                     )
                 else:
                     cmd_parser.add_argument(
-                        f"-{param_name[:1]}",
+                        f"-{shorthand}",
                         f"--{param_name}",
                         default=param.default,
                         help=arg_msg,
@@ -168,7 +179,8 @@ class CommandShell(cmd.Cmd):
                 args.pop("command")
                 ret = command.call(**args)
                 if ret:
-                    self.stdout.write(ret + "\n")
+                    ret_str = pprint.pformat(ret, indent=2)
+                    self.stdout.write(f"{ret_str}\n")
         except Exception as e:
             print(e)
 

jaclang/compiler/.gitignore

@@ -0,0 +1 @@
+generated

jaclang/compiler/absyntree.py

@@ -391,7 +391,6 @@ class Module(AstDocNode):
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
         kid: Sequence[AstNode],
-        impl_mod: Optional[Module] = None,
         test_mod: Optional[Module] = None,
         registry: Optional[SemRegistry] = None,
     ) -> None:
@@ -400,7 +399,7 @@ class Module(AstDocNode):
         self.source = source
         self.body = body
         self.is_imported = is_imported
-        self.impl_mod = impl_mod
+        self.impl_mod: list[Module] = []
         self.test_mod = test_mod
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry

jaclang/compiler/parser.py

@@ -140,7 +140,7 @@ class JacParser(Pass):
             body = kid[1:] if doc else kid
             body = [i for i in body if isinstance(i, ast.ElementStmt)]
             mod = ast.Module(
-                name=self.parse_ref.mod_path.split(os.path.sep)[-1].split(".")[0],
+                name=self.parse_ref.mod_path.split(os.path.sep)[-1].rstrip(".jac"),
                 source=self.parse_ref.source,
                 doc=doc,
                 body=body,

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -72,7 +72,10 @@ class DeclDefMatchPass(Pass):
                     continue
                 decl_node.body = sym.decl  # type: ignore
                 sym.decl.decl_link = decl_node  # type: ignore
-                decl_node.add_kids_right([sym.decl], pos_update=False)  # type: ignore
+                source_node = sym.decl.parent
+                decl_node.add_kids_right([sym.decl])  # type: ignore
+                if source_node and sym.decl in source_node.kid:
+                    source_node.kid.remove(sym.decl)
                 decl_node.sym_tab.tab = sym.decl.sym_tab.tab  # type: ignore
         for i in sym_tab.kid:
             self.connect_def_impl(i)

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -48,8 +48,16 @@ class FuseTypeInfoPass(Pass):
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
         typ = node.sym_info.typ.split(".")
         typ_sym_table = self.ir.sym_tab
-        if typ_sym_table and typ[0] == typ_sym_table.name:
-            for i in typ[1:]:
+
+        if typ[0] == "builtins":
+            return
+
+        assert isinstance(self.ir, ast.Module)
+
+        if typ_sym_table:
+            for i in typ:
+                if i == self.ir.name:
+                    continue
                 f = typ_sym_table.find_scope(i)
                 if f:
                     typ_sym_table = f
@@ -159,11 +167,6 @@ class FuseTypeInfoPass(Pass):
                     type(mypy_node),
                 )
 
-    def enter_import(self, node: ast.Import) -> None:
-        """Pass handler for import nodes."""
-        # Pruning the import nodes
-        self.prune()
-
     @__handle_node
     def enter_name(self, node: ast.NameSpec) -> None:
         """Pass handler for name nodes."""

jaclang/compiler/passes/main/import_pass.py

@@ -7,8 +7,8 @@ symbols are available for matching.
 
 import ast as py_ast
 import importlib.util
+import os
 import sys
-from os import path
 from typing import Optional
 
 
@@ -40,7 +40,6 @@ class JacImportPass(Pass):
                 self.process_import(node, i)
                 self.enter_module_path(i)
             SubNodeTabPass(prior=self, input_ir=node)
-        self.annex_impl(node)
         node.mod_deps = self.import_table
 
     def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
@@ -53,7 +52,6 @@ class JacImportPass(Pass):
             )
             if mod:
                 self.run_again = True
-                self.annex_impl(mod)
                 i.sub_module = mod
                 i.add_kids_right([mod], pos_update=False)
 
@@ -61,22 +59,41 @@ class JacImportPass(Pass):
         """Annex impl and test modules."""
         if not node.loc.mod_path:
             self.error("Module has no path")
-        if node.loc.mod_path.endswith(".jac") and path.exists(
-            f"{node.loc.mod_path[:-4]}.impl.jac"
-        ):
-            mod = self.import_mod_from_file(f"{node.loc.mod_path[:-4]}.impl.jac")
-            if mod:
-                node.impl_mod = mod
-                node.add_kids_left([mod], pos_update=False)
-                mod.parent = node
-        if node.loc.mod_path.endswith(".jac") and path.exists(
-            f"{node.loc.mod_path[:-4]}.test.jac"
-        ):
-            mod = self.import_mod_from_file(f"{node.loc.mod_path[:-4]}.test.jac")
-            if mod:
-                node.test_mod = mod
-                node.add_kids_right([mod], pos_update=False)
-                mod.parent = node
+        if not node.loc.mod_path.endswith(".jac"):
+            return
+        base_path = node.loc.mod_path[:-4]
+        directory = os.path.dirname(node.loc.mod_path)
+        if not directory:
+            directory = os.getcwd()
+            base_path = os.path.join(directory, base_path)
+        impl_folder = base_path + ".impl"
+        search_files = [
+            os.path.join(directory, impl_file) for impl_file in os.listdir(directory)
+        ]
+        if os.path.exists(impl_folder):
+            search_files += [
+                os.path.join(impl_folder, impl_file)
+                for impl_file in os.listdir(impl_folder)
+            ]
+        for impl_file in search_files:
+            if node.loc.mod_path.endswith(impl_file):
+                continue
+            if (
+                impl_file.startswith(f"{base_path}.") or impl_folder in impl_file
+            ) and impl_file.endswith(".impl.jac"):
+                mod = self.import_mod_from_file(impl_file)
+                if mod:
+                    node.impl_mod.append(mod)
+                    node.add_kids_left([mod], pos_update=False)
+                    mod.parent = node
+            if (
+                impl_file.startswith(f"{base_path}.") or impl_folder in impl_file
+            ) and impl_file.endswith(".test.jac"):
+                mod = self.import_mod_from_file(impl_file)
+                if mod:
+                    node.test_mod = mod
+                    node.add_kids_right([mod], pos_update=False)
+                    mod.parent = node
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
@@ -96,7 +113,7 @@ class JacImportPass(Pass):
         """Import a module."""
         self.cur_node = node  # impacts error reporting
         target = import_target_to_relative_path(
-            node.level, node.path_str, path.dirname(node.loc.mod_path)
+            node.level, node.path_str, os.path.dirname(node.loc.mod_path)
         )
         return self.import_mod_from_file(target)
 
@@ -105,7 +122,7 @@ class JacImportPass(Pass):
         from jaclang.compiler.compile import jac_file_to_pass
         from jaclang.compiler.passes.main import SubNodeTabPass
 
-        if not path.exists(target):
+        if not os.path.exists(target):
             self.error(f"Could not find module {target}")
             return None
         if target in self.import_table:
@@ -133,7 +150,7 @@ class JacImportPass(Pass):
         """Import a module."""
         from jaclang.compiler.passes.main import PyastBuildPass
 
-        base_dir = path.dirname(mod_path)
+        base_dir = os.path.dirname(mod_path)
         sys.path.append(base_dir)
 
         try: