jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/__init__.py

@@ -1,19 +1,11 @@
 """The Jac Programming Language."""
 
-import os
-import sys
-
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "vendor"))
-
 from jaclang.plugin.default import (  # noqa: E402
     JacBuiltin,
     JacCmdDefaults,
     JacFeatureDefaults,
 )
 from jaclang.plugin.feature import JacFeature, pm  # noqa: E402
-from jaclang.vendor import lark  # noqa: E402
-from jaclang.vendor import mypy  # noqa: E402
-from jaclang.vendor import pluggy  # noqa: E402
 
 jac_import = JacFeature.jac_import
 
@@ -22,4 +14,4 @@ pm.register(JacBuiltin)
 pm.register(JacCmdDefaults)
 pm.load_setuptools_entrypoints("jac")
 
-__all__ = ["jac_import", "lark", "mypy", "pluggy"]
+__all__ = ["jac_import"]

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

@@ -193,6 +193,14 @@ def check(filename: str, print_errs: bool = True) -> None:
         print("Not a .jac file.")
 
 
+@cmd_registry.register
+def lsp() -> None:
+    """Run Jac Language Server Protocol."""
+    from jaclang.langserve.server import run_lang_server
+
+    run_lang_server()
+
+
 @cmd_registry.register
 def enter(filename: str, entrypoint: str, args: list) -> None:
     """Run the specified entrypoint function in the given .jac file.
@@ -380,22 +388,35 @@ def dot(
 
 
 @cmd_registry.register
-def py_to_jac(filename: str, tree: bool = False) -> None:
+def py2jac(filename: str) -> None:
     """Convert a Python file to Jac.
 
     :param filename: The path to the .py file.
-    :param tree: Flag to show the AST tree.(Default-False).
     """
     if filename.endswith(".py"):
         with open(filename, "r") as f:
-            mod = PyastBuildPass(
+            code = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(ast3.parse(f.read()), mod_path=filename),
             ).ir.unparse()
-        print(mod)
+        print(code)
     else:
         print("Not a .py file.")
 
 
+@cmd_registry.register
+def jac2py(filename: str) -> None:
+    """Convert a Jac file to Python.
+
+    :param filename: The path to the .jac file.
+    """
+    if filename.endswith(".jac"):
+        with open(filename, "r"):
+            code = jac_file_to_pass(file_path=filename).ir.gen.py
+        print(code)
+    else:
+        print("Not a .jac file.")
+
+
 def start_cli() -> None:
     """
     Start the command line interface.

jaclang/compiler/.gitignore

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

jaclang/compiler/__init__.py

@@ -104,6 +104,7 @@ TOKEN_MAP.update(
         "BW_NOT_EQ": "~=",
         "LSHIFT_EQ": "<<=",
         "RSHIFT_EQ": ">>=",
+        "ELLIPSIS": "...",
     }
 )
 

jaclang/compiler/absyntree.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast as ast3
+from hashlib import md5
 from types import EllipsisType
 from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar
 
@@ -660,6 +661,13 @@ class ModulePath(AstSymbolNode):
             sym_type=SymbolType.MODULE,
         )
 
+    @property
+    def path_str(self) -> str:
+        """Get path string."""
+        return ("." * self.level) + ".".join(
+            [p.value for p in self.path] if self.path else ""
+        )
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize module path node."""
         res = True
@@ -684,13 +692,6 @@ class ModulePath(AstSymbolNode):
         self.set_kids(nodes=new_kid)
         return res
 
-    @property
-    def path_str(self) -> str:
-        """Get path string."""
-        return ("." * self.level) + ".".join(
-            [p.value for p in self.path] if self.path else ""
-        )
-
 
 class ModuleItem(AstSymbolNode):
     """ModuleItem node type for Jac Ast."""
@@ -4081,6 +4082,7 @@ class JacSource(EmptyToken):
         """Initialize source string."""
         super().__init__()
         self.value = source
+        self.hash = md5(source.encode()).hexdigest()
         self.file_path = mod_path
         self.comments: list[CommentToken] = []
 

jaclang/compiler/compile.py

@@ -46,14 +46,14 @@ def jac_str_to_pass(
 ) -> Pass:
     """Convert a Jac file to an AST."""
     if not target:
-        target = schedule[-1]
+        target = schedule[-1] if schedule else None
     source = ast.JacSource(jac_str, mod_path=file_path)
     ast_ret: Pass = JacParser(input_ir=source)
     for i in schedule:
         if i == target:
             break
         ast_ret = i(input_ir=ast_ret.ir, prior=ast_ret)
-    ast_ret = target(input_ir=ast_ret.ir, prior=ast_ret)
+    ast_ret = target(input_ir=ast_ret.ir, prior=ast_ret) if target else ast_ret
     return ast_ret
 
 
@@ -64,13 +64,13 @@ def jac_pass_to_pass(
 ) -> Pass:
     """Convert a Jac file to an AST."""
     if not target:
-        target = schedule[-1]
+        target = schedule[-1] if schedule else None
     ast_ret = in_pass
     for i in schedule:
         if i == target:
             break
         ast_ret = i(input_ir=ast_ret.ir, prior=ast_ret)
-    ast_ret = target(input_ir=ast_ret.ir, prior=ast_ret)
+    ast_ret = target(input_ir=ast_ret.ir, prior=ast_ret) if target else ast_ret
     return ast_ret
 
 

jaclang/compiler/jac.lark

@@ -219,6 +219,7 @@ return_stmt: KW_RETURN expression?
 
 // Yield statements
 yield_expr: KW_YIELD KW_FROM? expression
+          | KW_YIELD
 
 // Raise statements
 raise_stmt: KW_RAISE (expression (KW_FROM expression)?)?

jaclang/compiler/parser.py

@@ -28,7 +28,7 @@ class JacParser(Pass):
             JacParser.make_dev()
         Pass.__init__(self, input_ir=input_ir, prior=None)
 
-    def transform(self, ir: ast.AstNode) -> ast.AstNode:
+    def transform(self, ir: ast.AstNode) -> ast.Module:
         """Transform input IR."""
         try:
             tree, comments = JacParser.parse(
@@ -36,6 +36,10 @@ class JacParser(Pass):
             )
             mod = JacParser.TreeToAST(parser=self).transform(tree)
             self.source.comments = [self.proc_comment(i, mod) for i in comments]
+            if isinstance(mod, ast.Module):
+                return mod
+            else:
+                raise self.ice()
         except jl.UnexpectedInput as e:
             catch_error = ast.EmptyToken()
             catch_error.file_path = self.mod_path
@@ -43,11 +47,16 @@ class JacParser(Pass):
             catch_error.c_start = e.column
             catch_error.c_end = e.column
             self.error(f"Syntax Error: {e}", node_override=catch_error)
-            mod = self.source
         except Exception as e:
-            mod = self.source
             self.error(f"Internal Error: {e}")
-        return mod
+        return ast.Module(
+            name="",
+            source=self.source,
+            doc=None,
+            body=[],
+            is_imported=False,
+            kid=[ast.EmptyToken()],
+        )
 
     @staticmethod
     def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken:
@@ -2454,8 +2463,8 @@ class JacParser(Pass):
             """Grammar rule.
 
             yield_expr:
-                | KW_YIELD KW_FROM expression
-                | KW_YIELD expression
+                | KW_YIELD KW_FROM? expression
+                | KW_YIELD
             """
             if isinstance(kid[-1], ast.Expr):
                 return self.nu(
@@ -2465,6 +2474,19 @@ class JacParser(Pass):
                         kid=kid,
                     )
                 )
+            elif (
+                len(kid) == 1
+                and isinstance(kid[0], ast.Token)
+                and kid[0].name == Tok.KW_YIELD
+            ):
+                return self.nu(
+                    ast.YieldExpr(
+                        expr=None,
+                        with_from=False,
+                        kid=kid,
+                    )
+                )
+
             else:
                 raise self.ice()
 

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -43,6 +43,10 @@ class DeclDefMatchPass(Pass):
                 # currently strips the type info from impls
                 arch_refs = [x[3:] for x in sym.sym_name.split(".")]
                 lookup = sym_tab.lookup(arch_refs[0])
+                # Below may need to be a while instead of if to skip over local
+                # import name collisions (see test: test_impl_decl_resolution_fix)
+                if lookup and not isinstance(lookup.decl, ast.AstImplNeedingNode):
+                    lookup = sym_tab.parent.lookup(arch_refs[0])
                 decl_node = (
                     self.defn_lookup(lookup)
                     if len(arch_refs) == 1 and lookup

jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -126,7 +126,16 @@ class FuseTypeInfoPass(Pass):
     def __collect_type_from_symbol(self, node: ast.AstSymbolNode) -> None:
         mypy_node = node.gen.mypy_ast[0]
 
-        if hasattr(mypy_node, "node"):
+        if isinstance(mypy_node, MypyNodes.MemberExpr):
+            if mypy_node in self.node_type_hash:
+                t = str(self.node_type_hash[mypy_node])
+                if "->" in t:
+                    t = t.split("->")[1].strip()
+                node.sym_info.typ = t
+            else:
+                self.__debug_print(f"{node.loc} MemberExpr type is not found")
+
+        elif hasattr(mypy_node, "node"):
             # orig_node = mypy_node
             mypy_node = mypy_node.node
 

jaclang/compiler/passes/main/import_pass.py

@@ -16,7 +16,7 @@ import jaclang.compiler.absyntree as ast
 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
+from jaclang.utils.helpers import import_target_to_relative_path, is_standard_lib_module
 
 
 class JacImportPass(Pass):
@@ -30,7 +30,7 @@ class JacImportPass(Pass):
         """Run Importer."""
         self.cur_node = node
         self.import_table[node.loc.mod_path] = node
-        self.annex_impl(node)
+        self.__annex_impl(node)
         self.terminate()  # Turns off auto traversal for deliberate traversal
         self.run_again = True
         while self.run_again:
@@ -46,7 +46,7 @@ class JacImportPass(Pass):
         """Process an import."""
         lang = i.parent_of_type(ast.Import).hint.tag.value
         if lang == "jac" and not i.sub_module:
-            mod = self.import_module(
+            mod = self.import_jac_module(
                 node=i,
                 mod_path=node.loc.mod_path,
             )
@@ -55,7 +55,7 @@ class JacImportPass(Pass):
                 i.sub_module = mod
                 i.add_kids_right([mod], pos_update=False)
 
-    def annex_impl(self, node: ast.Module) -> None:
+    def __annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         if not node.loc.mod_path:
             self.error("Module has no path")
@@ -67,6 +67,7 @@ class JacImportPass(Pass):
             directory = os.getcwd()
             base_path = os.path.join(directory, base_path)
         impl_folder = base_path + ".impl"
+        test_folder = base_path + ".test"
         search_files = [
             os.path.join(directory, impl_file) for impl_file in os.listdir(directory)
         ]
@@ -75,21 +76,28 @@ class JacImportPass(Pass):
                 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):
+        if os.path.exists(test_folder):
+            search_files += [
+                os.path.join(test_folder, test_file)
+                for test_file in os.listdir(test_folder)
+            ]
+        for cur_file in search_files:
+            if node.loc.mod_path.endswith(cur_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)
+                cur_file.startswith(f"{base_path}.")
+                or impl_folder == os.path.dirname(cur_file)
+            ) and cur_file.endswith(".impl.jac"):
+                mod = self.import_jac_mod_from_file(cur_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)
+                cur_file.startswith(f"{base_path}.")
+                or test_folder == os.path.dirname(cur_file)
+            ) and cur_file.endswith(".test.jac"):
+                mod = self.import_jac_mod_from_file(cur_file)
                 if mod:
                     node.test_mod = mod
                     node.add_kids_right([mod], pos_update=False)
@@ -106,18 +114,17 @@ class JacImportPass(Pass):
             node.sub_module.name = node.alias.value
         # Items matched during def/decl pass
 
-    # Utility functions
-    # -----------------
-
-    def import_module(self, node: ast.ModulePath, mod_path: str) -> ast.Module | None:
+    def import_jac_module(
+        self, node: ast.ModulePath, mod_path: str
+    ) -> ast.Module | None:
         """Import a module."""
         self.cur_node = node  # impacts error reporting
         target = import_target_to_relative_path(
             node.level, node.path_str, os.path.dirname(node.loc.mod_path)
         )
-        return self.import_mod_from_file(target)
+        return self.import_jac_mod_from_file(target)
 
-    def import_mod_from_file(self, target: str) -> ast.Module | None:
+    def import_jac_mod_from_file(self, target: str) -> ast.Module | None:
         """Import a module from a file."""
         from jaclang.compiler.compile import jac_file_to_pass
         from jaclang.compiler.passes.main import SubNodeTabPass
@@ -144,6 +151,26 @@ class JacImportPass(Pass):
             self.error(f"Module {target} is not a valid Jac module.")
             return None
 
+
+class PyImportPass(JacImportPass):
+    """Jac statically imports Python modules."""
+
+    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
+        """Process an import."""
+        lang = i.parent_of_type(ast.Import).hint.tag.value
+        if (
+            lang == "py"
+            and not i.sub_module
+            and settings.py_raise
+            and not is_standard_lib_module(i.path_str)
+        ):
+            mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
+            if mod:
+                i.sub_module = mod
+                i.add_kids_right([mod], pos_update=False)
+                if settings.py_raise_deep:
+                    self.run_again = True
+
     def import_py_module(
         self, node: ast.ModulePath, mod_path: str
     ) -> Optional[ast.Module]:
@@ -152,7 +179,6 @@ class JacImportPass(Pass):
 
         base_dir = os.path.dirname(mod_path)
         sys.path.append(base_dir)
-
         try:
             # Dynamically import the module
             spec = importlib.util.find_spec(node.path_str)
@@ -175,23 +201,11 @@ class JacImportPass(Pass):
                         f"Failed to import python module {node.path_str}: {spec.origin}"
                     )
         except Exception as e:
+            if "Empty kid for Token ModulePath" in str(e) or "utf-8" in str(e):  # FIXME
+                return None
             self.error(
                 f"Failed to import python module {node.path_str}: {e}",
                 node_override=node,
             )
             raise e
         return None
-
-
-class PyImportPass(JacImportPass):
-    """Jac statically imports Python modules."""
-
-    def process_import(self, node: ast.Module, i: ast.ModulePath) -> None:
-        """Process an import."""
-        lang = i.parent_of_type(ast.Import).hint.tag.value
-        if lang == "py" and not i.sub_module and settings.py_raise:
-            mod = self.import_py_module(node=i, mod_path=node.loc.mod_path)
-            if mod:
-                # self.run_again = True
-                i.sub_module = mod
-                i.add_kids_right([mod], pos_update=False)