jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -128,6 +128,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             is_imported=False,
             kid=valid,
         )
+        ret.is_raised_from_py = True
         return self.nu(ret)
 
     def proc_function_def(
@@ -144,12 +145,15 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             if sys.version_info >= (3, 12):
             type_params: list[type_param]
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+
+        value = node.name if node.name not in reserved_keywords else f"<>{node.name}"
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=(
-                node.name if node.name != "root" else "root_"
-            ),  # root is a reserved keyword
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
@@ -1875,10 +1879,19 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         id: _Identifier
         ctx: expr_context
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [
+            v
+            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 = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.id if node.id != "root" else "root_",  # reserved word
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
@@ -1913,13 +1926,18 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         class Nonlocal(stmt):
             names: list[_Identifier]
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+
         names: list[ast.NameAtom] = []
         for name in node.names:
+            value = name if name not in reserved_keywords else f"<>{name}"
             names.append(
                 ast.Name(
                     file_path=self.mod_path,
                     name=Tok.NAME,
-                    value=name if name != "root" else "root_",
+                    value=value,
                     line=node.lineno,
                     end_line=node.end_lineno if node.end_lineno else node.lineno,
                     col_start=node.col_offset,
@@ -2238,10 +2256,19 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             arg: _Identifier
             annotation: expr | None
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [
+            v
+            for _, v in TOKEN_MAP.items()
+            if v not in ["float", "int", "str", "bool", "self"]
+        ]
+
+        value = node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.arg if node.arg != "root" else "root_",  # reserved word
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -162,6 +162,13 @@ class PyJacAstLinkPass(Pass):
                     py_nodes=node.parent.signature.return_type.gen.py_ast,
                 )
 
+        if isinstance(node.decl_link, ast.Ability) and isinstance(
+            node.target, ast.ArchRefChain
+        ):
+            for arch in node.target.archs:
+                if arch.arch_name.sym:
+                    arch.arch_name.sym.add_use(arch.arch_name)
+
     def exit_param_var(self, node: ast.ParamVar) -> None:
         """Sub objects.
 

jaclang/compiler/passes/main/registry_pass.py

@@ -13,7 +13,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
-from jaclang.core.utils import get_sem_scope
+from jaclang.runtimelib.utils import get_sem_scope
 
 
 class RegistryPass(Pass):
@@ -46,6 +46,7 @@ class RegistryPass(Pass):
         """Save architype information."""
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
             node.name.value,
             node.arch_type.value,
             node.semstr.lit_value if node.semstr else "",
@@ -61,7 +62,7 @@ class RegistryPass(Pass):
         """Save enum information."""
         scope = get_sem_scope(node)
         seminfo = SemInfo(
-            node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
+            node, node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
         )
         if (
             len(self.modules_visited)
@@ -77,6 +78,38 @@ class RegistryPass(Pass):
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
+            node.name.value,
+            extracted_type,
+            node.semstr.lit_value if node.semstr else "",
+        )
+        if len(self.modules_visited) and self.modules_visited[-1].registry:
+            self.modules_visited[-1].registry.add(scope, seminfo)
+
+    def exit_ability(self, node: ast.Ability) -> None:
+        """Save ability information."""
+        scope = get_sem_scope(node)
+        seminfo = SemInfo(
+            node,
+            node.name_ref.sym_name,
+            "Ability",
+            node.semstr.lit_value if node.semstr else "",
+        )
+        if len(self.modules_visited) and self.modules_visited[-1].registry:
+            (
+                self.modules_visited[-1].registry.add(scope.parent, seminfo)
+                if scope.parent
+                else None
+            )
+
+    def exit_param_var(self, node: ast.ParamVar) -> None:
+        """Save param information."""
+        scope = get_sem_scope(node)
+        extracted_type = (
+            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
+        )
+        seminfo = SemInfo(
+            node,
             node.name.value,
             extracted_type,
             node.semstr.lit_value if node.semstr else "",
@@ -94,6 +127,7 @@ class RegistryPass(Pass):
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
             (
                 node.target.items[0].value
                 if isinstance(node.target.items[0], ast.Name)
@@ -113,7 +147,7 @@ class RegistryPass(Pass):
             and node.parent.parent.__class__.__name__ == "Enum"
         ):
             scope = get_sem_scope(node)
-            seminfo = SemInfo(node.value, None, "")
+            seminfo = SemInfo(node, node.value, None, "")
             if len(self.modules_visited) and self.modules_visited[-1].registry:
                 self.modules_visited[-1].registry.add(scope, seminfo)
 

jaclang/compiler/passes/main/schedules.py

@@ -19,11 +19,11 @@ from .type_check_pass import JacTypeCheckPass  # noqa: I100
 from .fuse_typeinfo_pass import FuseTypeInfoPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
 from .access_modifier_pass import AccessCheckPass  # noqa: I100
+from .py_collect_dep_pass import PyCollectDepsPass  # noqa: I100
 
 py_code_gen = [
     SubNodeTabPass,
     JacImportPass,
-    PyImportPass,
     SymTabBuildPass,
     DeclImplMatchPass,
     DefUsePass,
@@ -33,6 +33,13 @@ py_code_gen = [
     PyBytecodeGenPass,
 ]
 
-type_checker_sched = [JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
+type_checker_sched = [
+    JacTypeCheckPass,
+    PyCollectDepsPass,
+    PyImportPass,
+    DefUsePass,
+    FuseTypeInfoPass,
+    AccessCheckPass,
+]
 py_code_gen_typed = [*py_code_gen, *type_checker_sched]
 py_compiler = [*py_code_gen, PyOutPass]

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -19,12 +19,16 @@ class SymTabBuildPass(Pass):
         """Before pass."""
         self.cur_sym_tab: list[SymbolTable] = []
 
-    def push_scope(self, name: str, key_node: ast.AstNode, fresh: bool = False) -> None:
+    def push_scope(self, name: str, key_node: ast.AstNode) -> None:
         """Push scope."""
-        if fresh:
+        inherit = key_node.parent
+        if not len(self.cur_sym_tab) and not inherit:
             self.cur_sym_tab.append(SymbolTable(name, key_node))
+        elif not len(self.cur_sym_tab) and inherit:
+            self.cur_sym_tab.append(inherit.sym_tab)
+            self.cur_sym_tab.append(self.cur_scope.push_kid_scope(name, key_node))
         else:
-            self.cur_sym_tab.append(self.cur_scope.push_scope(name, key_node))
+            self.cur_sym_tab.append(self.cur_scope.push_kid_scope(name, key_node))
 
     def pop_scope(self) -> SymbolTable:
         """Pop scope."""
@@ -48,7 +52,7 @@ class SymTabBuildPass(Pass):
         mod_path: str,
         is_imported: bool,
         """
-        self.push_scope(node.name, node, fresh=(node == self.ir))
+        self.push_scope(node.name, node)
         self.sync_node_to_scope(node)
         for obj in dir(builtins):
             builtin = ast.Name(
@@ -193,11 +197,11 @@ class SymTabBuildPass(Pass):
         if not node.is_absorb:
             for i in node.items.items:
                 i.sym_tab.def_insert(i, single_decl="import item")
-        elif node.is_absorb and node.hint.tag.value == "jac":
+        elif node.is_absorb and node.is_jac:
             source = node.items.items[0]
             if not isinstance(source, ast.ModulePath) or not source.sub_module:
                 self.error(
-                    f"Module {node.from_loc.path_str if node.from_loc else 'from location'}"
+                    f"Module {node.from_loc.dot_path_str if node.from_loc else 'from location'}"
                     f" not found to include *, or ICE occurred!"
                 )
             else:

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

@@ -1 +1 @@
-"""Tests for Jac passes."""
+"""Various tests for Jac passes."""

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

@@ -6,4 +6,4 @@ with entry {
     foo();
     bar();
     baz();
-}
+}

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

@@ -0,0 +1,29 @@
+import:py math;
+import:py argparse;
+import:py from pygame_mock { color, display }
+import:py pygame_mock;
+import:py os;
+
+can fool_me -> `Type[pygame_mock.constants.CL] {
+    return pygame_mock.constants.CL;
+}
+
+obj kk {
+    can fool_me -> `Type[pygame_mock.constants.CL] {
+        return pygame_mock.constants.CL;
+    }
+}
+
+with entry {
+    b = math.floor(1.7);
+    c: color.Color = color.Color(pygame_mock.constants.CONST_VALUE);
+    c2: pygame_mock.color.Color = color.Color(pygame_mock.constants.CL.CONST_VALUE2);
+    c3: pygame_mock.color.Color = color.Color(fool_me().CONST_VALUE2);
+    c4: pygame_mock.color.Color = color.Color(kk().fool_me().CONST_VALUE2);
+    g = fool_me();
+    c4: pygame_mock.color.Color = color.Color(g.CONST_VALUE2);
+    a: argparse.ArgumentParser = argparse.ArgumentParser();
+    print("Hello", 1, b);
+    pygame_mock.display.set_mode(WIN_WIDTH, WIN_HEIGHT);
+    print(os.path.isfile("/jj"));
+}

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/__init__.py

@@ -0,0 +1,3 @@
+from .display import *
+from .color import *
+from .constants import *

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/color.py

@@ -0,0 +1,3 @@
+class Color:
+    def __init__(self, value: int | str) -> None:
+        pass

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/constants.py

@@ -0,0 +1,5 @@
+CONST_VALUE: int = 0
+
+
+class CL:
+    CONST_VALUE2: str = "h"

jaclang/compiler/passes/main/tests/fixtures/pygame_mock/display.py

@@ -0,0 +1,2 @@
+def set_mode(a, b):
+    pass

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

@@ -1,8 +1,15 @@
 """Test pass module."""
 
+import io
+import re
+import sys
+
 import jaclang.compiler.absyntree as ast
+from jaclang.cli import cli
 from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import JacImportPass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import FuseTypeInfoPass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.utils.test import TestCase
 
 
@@ -24,7 +31,7 @@ class ImportPassPassTests(TestCase):
         state = jac_file_to_pass(self.fixture_abs_path("autoimpl.jac"), JacImportPass)
         num_modules = len(state.ir.get_all_sub_nodes(ast.Module))
         mod_names = [i.name for i in state.ir.get_all_sub_nodes(ast.Module)]
-        self.assertEqual(num_modules, 3)
+        self.assertEqual(num_modules, 4)
         self.assertIn("getme.impl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
         self.assertIn("autoimpl.something.else.impl", mod_names)
@@ -36,7 +43,7 @@ class ImportPassPassTests(TestCase):
         )
         num_modules = len(state.ir.get_all_sub_nodes(ast.Module))
         mod_names = [i.name for i in state.ir.get_all_sub_nodes(ast.Module)]
-        self.assertEqual(num_modules, 4)
+        self.assertEqual(num_modules, 5)
         self.assertIn("getme.impl", mod_names)
         self.assertIn("autoimpl", mod_names)
         self.assertIn("autoimpl.impl", mod_names)
@@ -52,17 +59,69 @@ class ImportPassPassTests(TestCase):
             if i.name != "autoimpl":
                 count += 1
                 self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
-        self.assertEqual(count, 3)
+        self.assertEqual(count, 4)
+
+    def test_py_raise_map(self) -> None:
+        """Basic test for pass."""
+        build = jac_file_to_pass(
+            self.fixture_abs_path("py_imp_test.jac"),
+            FuseTypeInfoPass,
+            schedule=py_code_gen_typed,
+        )
+        assert isinstance(build.ir, ast.Module)
+        p = {
+            "math": "jaclang/jaclang/vendor/mypy/typeshed/stdlib/math.pyi",
+            "pygame_mock": "pygame_mock/__init__.py",
+            "pygame_mock.color": "pygame_mock/color.py",
+            "pygame_mock.constants": "pygame_mock/constants.py",
+            "argparse": "jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi",
+            "builtins": "jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi",
+            "pygame_mock.display": "pygame_mock/display.py",
+            "os": "jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi",
+            "genericpath": "jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi",
+        }
+        for i in p:
+            self.assertIn(i, build.ir.py_raise_map)
+            self.assertIn(p[i], re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]))
 
-    def test_py_resolve_list(self) -> None:
+    def test_py_raised_mods(self) -> None:
         """Basic test for pass."""
-        state: JacImportPass = jac_file_to_pass(
-            self.examples_abs_path("rpg_game/jac_impl/jac_impl_5/main.jac"),
-            JacImportPass,
+        state = jac_file_to_pass(
+            self.fixture_abs_path("py_imp_test.jac"), schedule=py_code_gen_typed
+        )
+        self.assertEqual(
+            len(
+                list(
+                    filter(
+                        lambda x: x.is_raised_from_py,
+                        state.ir.get_all_sub_nodes(ast.Module),
+                    )
+                )
+            ),
+            7,
         )
-        self.assertGreater(len(state.py_resolve_list), 20)
-        self.assertIn("pygame.sprite.Sprite.__init__", state.py_resolve_list)
-        self.assertIn("pygame.mouse.get_pressed", state.py_resolve_list)
-        self.assertIn("pygame.K_SPACE", state.py_resolve_list)
-        self.assertIn("random.randint", state.py_resolve_list)
-        self.assertIn("pygame.font.Font", state.py_resolve_list)
+
+    # def test_py_resolve_list(self) -> None:
+    #     """Basic test for pass."""
+    #     state: JacImportPass = jac_file_to_pass(
+    #         self.examples_abs_path("rpg_game/jac_impl/jac_impl_5/main.jac"),
+    #         JacImportPass,
+    #     )
+    #     self.assertGreater(len(state.py_resolve_list), 20)
+    #     self.assertIn("pygame.sprite.Sprite.__init__", state.py_resolve_list)
+    #     self.assertIn("pygame.mouse.get_pressed", state.py_resolve_list)
+    #     self.assertIn("pygame.K_SPACE", state.py_resolve_list)
+    #     self.assertIn("random.randint", state.py_resolve_list)
+    #     self.assertIn("pygame.font.Font", state.py_resolve_list)
+
+    def test_double_empty_anx(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("autoimpl.jac"))
+        cli.run(self.fixture_abs_path("autoimpl.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("foo", stdout_value)
+        self.assertIn("bar", stdout_value)
+        self.assertIn("baz", stdout_value)

jaclang/compiler/passes/main/type_check_pass.py

@@ -8,7 +8,6 @@ import os
 import pathlib
 import sys
 
-# import jaclang
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
 from jaclang.compiler.constant import Constants as Con
@@ -35,7 +34,7 @@ class JacTypeCheckPass(Pass):
     def after_pass(self) -> None:
         """Call mypy api after traversing all the modules."""
         try:
-            self.api()
+            self.api(os.path.dirname(self.ir.loc.mod_path))
         except Exception as e:
             self.error(f"Unable to run type checking: {e}")
         return super().after_pass()
@@ -45,11 +44,21 @@ class JacTypeCheckPass(Pass):
     ) -> None:
         """Mypy errors reporter."""
 
-    def api(self) -> None:
+    def api(self, top_module_path: str = "") -> None:
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
+        options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
+        options.mypy_path = [
+            str(
+                pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
+                / "stubs"
+            )
+        ]
+        if top_module_path != "":
+            options.mypy_path.append(top_module_path)
+
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))
@@ -94,7 +103,9 @@ class JacTypeCheckPass(Pass):
             mypy_graph[module.name] = st
             new_modules.append(st)
 
-        graph = myab.load_graph(
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice("Expected module node. Impossible")
+        mypy_graph = myab.load_graph(
             [
                 myab.BuildSource(
                     path=str(self.__path / "typeshed" / "stdlib" / "builtins.pyi"),
@@ -105,4 +116,10 @@ class JacTypeCheckPass(Pass):
             old_graph=mypy_graph,
             new_modules=new_modules,  # To parse the dependancies of modules
         )
-        myab.process_graph(graph, manager)
+        for i in mypy_graph:
+            self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
+            for j in mypy_graph[i].dependencies:
+                self.ir.py_mod_dep_map[j] = str(
+                    myab.find_module_with_reason(j, manager)
+                )
+        myab.process_graph(mypy_graph, manager)