jaclang 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -1,4 +1,6 @@
+# type: ignore
 """Lark parser for Jac Lang."""
+
 from __future__ import annotations
 
 import ast as py_ast
@@ -69,7 +71,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             is_imported=False,
             kid=elements,
         )
-        ret.gen.py_ast = node
+        ret.gen.py_ast = [node]
         return self.nu(ret)
 
     def proc_function_def(

jaclang/compiler/passes/main/pybc_gen_pass.py

@@ -0,0 +1,46 @@
+"""Connect Decls and Defs in AST.
+
+This pass creates and manages compilation of Python code from the AST. This pass
+also creates bytecode files from the Python code, and manages the caching of
+relevant files.
+"""
+
+import ast as ast3
+import marshal
+
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass
+
+
+class PyBytecodeGenPass(Pass):
+    """Python and bytecode file printing pass."""
+
+    def before_pass(self) -> None:
+        """Before pass."""
+        return super().before_pass()
+
+    def enter_module(self, node: ast.Module) -> None:
+        """Sub objects.
+
+        name: str,
+        doc: Token,
+        body: Optional['Elements'],
+        mod_path: str,
+        is_imported: bool,
+        sym_tab: Optional[SymbolTable],
+        """
+        mods = [node] + self.get_all_sub_nodes(node, ast.Module)
+        for mod in mods:
+            if not mod.gen.py_ast or not isinstance(node.gen.py_ast[0], ast3.Module):
+                self.error(
+                    f"Unable to find ast for module {node.loc.mod_path}.",
+                    node,
+                )
+                continue
+            mod.gen.py_bytecode = marshal.dumps(
+                compile(
+                    source=mod.gen.py_ast[0], filename=mod.loc.mod_path, mode="exec"
+                )
+            )
+        self.terminate()

jaclang/compiler/passes/main/pyout_pass.py

@@ -4,8 +4,8 @@ This pass creates and manages compilation of Python code from the AST. This pass
 also creates bytecode files from the Python code, and manages the caching of
 relevant files.
 """
+
 import ast as ast3
-import marshal
 import os
 
 
@@ -44,7 +44,7 @@ class PyOutPass(Pass):
             ) > os.path.getmtime(mod_path):
                 continue
             self.gen_python(mod, out_path=out_path_py)
-            self.compile_bytecode(mod, mod_path=mod_path, out_path=out_path_pyc)
+            self.dump_bytecode(mod, mod_path=mod_path, out_path=out_path_pyc)
         self.terminate()
 
     def gen_python(self, node: ast.Module, out_path: str) -> None:
@@ -53,15 +53,14 @@ class PyOutPass(Pass):
             with open(out_path, "w") as f:
                 f.write(node.gen.py)
         except Exception as e:
-            print(ast3.dump(node.gen.py_ast, indent=2))
+            print(ast3.dump(node.gen.py_ast[0], indent=2))
             raise e
 
-    def compile_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None:
+    def dump_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None:
         """Generate Python."""
-        if isinstance(node.gen.py_ast, ast3.Module):
-            codeobj = compile(source=node.gen.py_ast, filename=mod_path, mode="exec")
+        if node.gen.py_bytecode:
             with open(out_path, "wb") as f:
-                marshal.dump(codeobj, f)
+                f.write(node.gen.py_bytecode)
         else:
             self.error(
                 f"Soemthing went wrong with {node.loc.mod_path} compilation.", node

jaclang/compiler/passes/main/schedules.py

@@ -2,6 +2,7 @@
 
 These are various pass schedules for the Jac compiler and static analysis.
 """
+
 from __future__ import annotations
 
 
@@ -11,6 +12,7 @@ from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
 from .def_impl_match_pass import DeclDefMatchPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
+from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100
 from .type_check_pass import JacTypeCheckPass  # noqa: I100
 
@@ -21,14 +23,8 @@ py_code_gen = [
     DeclDefMatchPass,
     DefUsePass,
     PyastGenPass,
+    PyBytecodeGenPass,
 ]
 
-py_code_gen_typed = [
-    *py_code_gen,
-    JacTypeCheckPass,
-]
-
-py_compiler = [
-    *py_code_gen,
-    PyOutPass,
-]
+py_code_gen_typed = [*py_code_gen, JacTypeCheckPass]
+py_compiler = [*py_code_gen, PyOutPass]

jaclang/compiler/passes/main/sub_node_tab_pass.py

@@ -4,6 +4,7 @@ This pass builds a table of subnodes for each node in the AST. This is used
 for fast lookup of nodes of a certain type in the AST. This is just a utility
 pass and is not required for any other pass to work.
 """
+
 from copy import copy
 from typing import Optional
 

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -3,6 +3,7 @@
 This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
+
 import ast as ast3
 import builtins
 from typing import Optional, Sequence
@@ -379,26 +380,37 @@ class SymTabBuildPass(SymTabPass):
             for i in node.items.items:
                 self.def_insert(i, single_use="import item")
         elif node.is_absorb and node.lang.tag.value == "jac":
-            if not node.sub_module or not node.sub_module.sym_tab:
+            if not node.paths[0].sub_module or not node.paths[0].sub_module.sym_tab:
                 self.error(
-                    f"Module {node.path.path_str} not found to include *, or ICE occurred!"
+                    f"Module {node.paths[0].path_str} not found to include *, or ICE occurred!"
                 )
             else:
-                for v in node.sub_module.sym_tab.tab.values():
+                for v in node.paths[0].sub_module.sym_tab.tab.values():
                     self.def_insert(v.decl, table_override=self.cur_scope())
-        else:
-            self.def_insert(
-                node.path,
-                single_use="import",
-            )
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
 
-        path: list[Token],
+        path: Sequence[Token],
+        alias: Optional[Name],
+        sub_module: Optional[Module] = None,
         """
         self.sync_node_to_scope(node)
 
+    def exit_module_path(self, node: ast.ModulePath) -> None:
+        """Sub objects.
+
+        path: Sequence[Token],
+        alias: Optional[Name],
+        sub_module: Optional[Module] = None,
+        """
+        if node.alias:
+            self.def_insert(node.alias, single_use="import")
+        elif isinstance(node.path[0], ast.Name):
+            self.def_insert(node.path[0])
+        else:
+            pass  # Need to support pythonic import symbols with dots in it
+
     def enter_module_item(self, node: ast.ModuleItem) -> None:
         """Sub objects.
 

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

@@ -1,6 +1,7 @@
 """Test pass module."""
+
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import DeclDefMatchPass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 

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

@@ -1,6 +1,7 @@
 """Test pass module."""
+
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import DefUsePass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 

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

@@ -1,6 +1,7 @@
 """Test pass module."""
+
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import ImportPass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 

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

@@ -1,4 +1,5 @@
 """Test pass module."""
+
 import ast as py_ast
 import inspect
 

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

@@ -1,12 +1,13 @@
 """Test ast build pass module."""
+
 import ast as ast3
 import io
 import sys
 import types
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import PyastGenPass, SubNodeTabPass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import AstSyncTestMixin, TestCaseMicroSuite
 
 
@@ -39,10 +40,6 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             target=PyastGenPass,
         )
 
-        # if isinstance(code_gen.ir.gen.py_ast, ast3.AST):
-        #     print(ast3.dump(code_gen.ir.gen.py_ast, indent=2))
-        #     print(ast3.unparse(code_gen.ir.gen.py_ast))
-        #     exec(compile(code_gen.ir.gen.py_ast, "<string>", "exec"))
         self.assertFalse(code_gen.errors_had)
 
     def test_circle_py_ast(self) -> None:
@@ -53,21 +50,10 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         )
         import ast as ast3
 
-        if isinstance(code_gen.ir.gen.py_ast, ast3.AST):
-            # from_jac_str = ast3.dump(code_gen.ir.gen.py_ast, indent=2)
-            # back_to_py = ast3.unparse(code_gen.ir.gen.py_ast)
-            # from_py = ast3.parse(back_to_py)
-            # from_py_str = ast3.dump(from_py, indent=2)
-            # import difflib
-
-            # print(
-            #     "\n".join(
-            #         difflib.unified_diff(
-            #             from_jac_str.splitlines(), from_py_str.splitlines(), n=0
-            #         )
-            #     )
-            # )
-            prog = compile(code_gen.ir.gen.py_ast, filename="<ast>", mode="exec")
+        if code_gen.ir.gen.py_ast and isinstance(
+            code_gen.ir.gen.py_ast[0], ast3.Module
+        ):
+            prog = compile(code_gen.ir.gen.py_ast[0], filename="<ast>", mode="exec")
             captured_output = io.StringIO()
             sys.stdout = captured_output
             module = types.ModuleType("__main__")
@@ -101,29 +87,20 @@ class PyastGenPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         code_gen = jac_file_to_pass(
             self.fixture_abs_path(filename), target=PyastGenPass
         )
-        from_jac_str = ast3.dump(code_gen.ir.gen.py_ast, indent=2)
-        from_jac = code_gen.ir.gen.py_ast
+        from_jac_str = ast3.dump(code_gen.ir.gen.py_ast[0], indent=2)
+        from_jac = code_gen.ir.gen.py_ast[0]
         try:
-            # back_to_py = ast3.unparse(from_jac)
             compile(from_jac, filename="<ast>", mode="exec")
         except Exception as e:
             print(from_jac_str)
             raise e
-        # from_py = ast3.parse(back_to_py)
-        # from_py_str = ast3.dump(from_py, indent=2)
-        # import difflib
-        # print(from_jac_str)
-        # print(
-        #     "\n".join(
-        #         difflib.unified_diff(
-        #             from_jac_str.splitlines(), from_py_str.splitlines(), n=6
-        #         )
-        #     )
-        # )
-        # if len(ast_to_list(from_jac)) != len(ast_to_list(from_py)):
-        #     print(
-        #         f"\n{filename} - AST node length diff: {len(ast_to_list(from_jac))} vs {len(ast_to_list(from_py))}"
-        #     )
+        for i in ast3.walk(from_jac):
+            try:
+                if not isinstance(i, (ast3.Load, ast3.Store, ast3.Del)):
+                    self.assertTrue(hasattr(i, "jac_link"))
+            except Exception as e:
+                print(filename, ast3.dump(i, indent=2))
+                raise e
         self.assertTrue(self.parent_scrub(code_gen.ir))
         self.assertGreater(len(from_jac_str), 10)
 

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

@@ -0,0 +1,25 @@
+"""Test pass module."""
+
+import marshal
+
+from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.utils.test import TestCase
+
+
+class PyBytecodeGenPassTests(TestCase):
+    """Test pass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_simple_bcgen(self) -> None:
+        """Basic test for pass."""
+        jac_code = jac_file_to_pass(
+            file_path=self.fixture_abs_path("func.jac"),
+        )
+        try:
+            marshal.loads(jac_code.ir.gen.py_bytecode)
+            self.assertTrue(True)
+        except ValueError:
+            self.fail("Invalid bytecode generated")

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

@@ -1,7 +1,7 @@
 """Test sub node pass module."""
 
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import SubNodeTabPass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 

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

@@ -1,6 +1,7 @@
 """Test pass module."""
+
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import SymTabBuildPass
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import AstSyncTestMixin, TestCase
 
 

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

@@ -1,8 +1,9 @@
 """Test pass module."""
+
 from typing import List
 
+from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
-from jaclang.compiler.transpiler import jac_file_to_pass
 from jaclang.utils.test import TestCase
 
 
@@ -31,3 +32,18 @@ class MypyTypeCheckPassTests(TestCase):
             '(got "str", expected "int")',
         ]:
             self.assertIn(i, errs + files)
+
+    def test_imported_module_typecheck(self) -> None:
+        """Basic test for pass."""
+        type_checked = jac_file_to_pass(
+            file_path=self.fixture_abs_path("game1.jac"),
+            schedule=py_code_gen_typed,
+        )
+
+        errs = "\n".join([i.msg for i in type_checked.warnings_had])
+        files = "\n".join([i.loc.mod_path for i in type_checked.warnings_had])
+
+        for i in [
+            'Argument 2 to "is_pressed" of "Button" has incompatible type "int"; expected "str"',
+        ]:
+            self.assertIn(i, errs + files)

jaclang/compiler/passes/main/type_check_pass.py

@@ -3,6 +3,7 @@
 This is used to call mypy type checking into Jac files by integrating
 mypy apis into Jac and use jac py ast in it.
 """
+
 import os
 import pathlib
 import sys
@@ -42,8 +43,8 @@ class JacTypeCheckPass(Pass):
 
     def api(self) -> None:
         """Call mypy APIs to implement type checking in Jac."""
-        # Creating mypy api obbjects
-        options = myab.Options()
+        # Creating mypy api objects
+        options = myab.myb.Options()
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))
@@ -66,16 +67,16 @@ class JacTypeCheckPass(Pass):
             stderr=sys.stderr,
         )
 
-        mypy_graph = {}
-
+        mypy_graph: myab.Graph = {}
+        new_modules = []
         for module in self.__modules:
             tree = myab.ASTConverter(
                 options=options,
                 is_stub=False,
                 errors=errors,
-                ignore_errors=False,
                 strip_function_bodies=False,
-            ).visit(module.gen.py_ast)
+                path=module.loc.mod_path,
+            ).visit(module.gen.py_ast[0])
 
             st = myab.State(
                 id=module.name,
@@ -86,6 +87,7 @@ class JacTypeCheckPass(Pass):
                 ast_override=tree,
             )
             mypy_graph[module.name] = st
+            new_modules.append(st)
 
         graph = myab.load_graph(
             [
@@ -96,6 +98,7 @@ class JacTypeCheckPass(Pass):
             ],
             manager,
             old_graph=mypy_graph,
+            new_modules=new_modules,  # To parse the dependancies of modules
         )
         myab.process_graph(graph, manager)
         myab.semantic_analysis_for_scc(graph, [self.__modules[0].name], errors)

jaclang/compiler/passes/tool/__init__.py

@@ -1,4 +1,5 @@
 """Collection of passes for Jac IR."""
+
 from .ast_printer_pass import AstDotGraphPass, AstPrinterPass  # noqa: I100
 from .sym_tab_printer_pass import (  # noqa: I100
     SymbolTableDotGraphPass,

jaclang/compiler/passes/tool/ast_printer_pass.py

@@ -1,4 +1,5 @@
 """Jac Blue pass for drawing AST."""
+
 import html
 import inspect
 from typing import Optional

jaclang/compiler/passes/tool/fuse_comments_pass.py

@@ -27,7 +27,7 @@ class FuseCommentsPass(Pass):
         """Insert comment tokens into all_tokens."""
         comment_stream = iter(self.comments)  # Iterator for comments
         code_stream = iter(self.all_tokens)  # Iterator for code tokens
-        new_stream = []  # New stream to hold ordered tokens
+        new_stream: list[ast.AstNode] = []  # New stream to hold ordered tokens
 
         try:
             next_comment = next(comment_stream)  # Get the first comment