jaclang 0.7.27__py3-none-any.whl → 0.7.28__py3-none-any.whl

jaclang/compiler/passes/main/inheritance_pass.py

@@ -0,0 +1,103 @@
+"""Pass used to add the inherited symbols for architypes."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass
+from jaclang.compiler.symtable import Symbol, SymbolTable
+from jaclang.settings import settings
+
+
+class InheritancePass(Pass):
+    """Add inherited abilities in the target symbol tables."""
+
+    def __debug_print(self, msg: str) -> None:
+        if settings.inherit_pass_debug:
+            self.log_info("[PyImportPass] " + msg)
+
+    def __lookup(self, name: str, sym_table: SymbolTable) -> Optional[Symbol]:
+        symbol = sym_table.lookup(name)
+        if symbol is None:
+            # Check if the needed symbol in builtins
+            builtins_symtable = self.ir.sym_tab.find_scope("builtins")
+            assert builtins_symtable is not None
+            symbol = builtins_symtable.lookup(name)
+        return symbol
+
+    def enter_architype(self, node: ast.Architype) -> None:
+        """Fill architype symbol tables with abilities from parent architypes."""
+        if node.base_classes is None:
+            return
+
+        for item in node.base_classes.items:
+            # The assumption is that the base class can only be a name node
+            # or an atom trailer only.
+            assert isinstance(item, (ast.Name, ast.AtomTrailer))
+
+            # In case of name node, then get the symbol table that contains
+            # the current class and lookup for that name after that use the
+            # symbol to get the symbol table of the base class
+            if isinstance(item, ast.Name):
+                assert node.sym_tab.parent is not None
+                base_class_symbol = self.__lookup(item.sym_name, node.sym_tab.parent)
+                if base_class_symbol is None:
+                    msg = "Missing symbol for base class "
+                    msg += f"{ast.Module.get_href_path(item)}.{item.sym_name}"
+                    msg += f" needed for {ast.Module.get_href_path(node)}"
+                    self.__debug_print(msg)
+                    continue
+                base_class_symbol_table = base_class_symbol.fetch_sym_tab
+                if (
+                    base_class_symbol_table is None
+                    and base_class_symbol.defn[0]
+                    .parent_of_type(ast.Module)
+                    .py_info.is_raised_from_py
+                ):
+                    msg = "Missing symbol table for python base class "
+                    msg += f"{ast.Module.get_href_path(item)}.{item.sym_name}"
+                    msg += f" needed for {ast.Module.get_href_path(node)}"
+                    self.__debug_print(msg)
+                    continue
+                assert base_class_symbol_table is not None
+                node.sym_tab.inherit_sym_tab(base_class_symbol_table)
+
+            # In case of atom trailer, unwind it and use each name node to
+            # as the code above to lookup for the base class
+            elif isinstance(item, ast.AtomTrailer):
+                current_sym_table = node.sym_tab.parent
+                not_found: bool = False
+                assert current_sym_table is not None
+                for name in item.as_attr_list:
+                    sym = self.__lookup(name.sym_name, current_sym_table)
+                    if sym is None:
+                        msg = "Missing symbol for base class "
+                        msg += f"{ast.Module.get_href_path(name)}.{name.sym_name}"
+                        msg += f" needed for {ast.Module.get_href_path(node)}"
+                        self.__debug_print(msg)
+                        not_found = True
+                        break
+                    current_sym_table = sym.fetch_sym_tab
+
+                    # In case of python nodes, the base class may not be
+                    # raised so ignore these classes for now
+                    # TODO Do we need to import these classes?
+                    if (
+                        sym.defn[0].parent_of_type(ast.Module).py_info.is_raised_from_py
+                        and current_sym_table is None
+                    ):
+                        msg = "Missing symbol table for python base class "
+                        msg += f"{ast.Module.get_href_path(name)}.{name.sym_name}"
+                        msg += f" needed for {ast.Module.get_href_path(node)}"
+                        self.__debug_print(msg)
+                        not_found = True
+                        break
+
+                    assert current_sym_table is not None
+
+                if not_found:
+                    continue
+
+                assert current_sym_table is not None
+                node.sym_tab.inherit_sym_tab(current_sym_table)

jaclang/compiler/passes/main/py_collect_dep_pass.py

@@ -35,7 +35,7 @@ class PyCollectDepsPass(Pass):
         if isinstance(node, ast.ModulePath):
             if node.path:
                 path = ".".join([i.value for i in node.path])
-            node.abs_path = self.ir.py_mod_dep_map.get(path)
+            node.abs_path = self.ir.py_info.py_mod_dep_map.get(path)
             if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
                 node.abs_path = node.abs_path.replace(".pyi", ".py")
 
@@ -45,7 +45,7 @@ class PyCollectDepsPass(Pass):
             if mod_path_node.path:
                 path = ".".join([i.value for i in mod_path_node.path])
             path += f".{node.name.value}"
-            node.abs_path = self.ir.py_mod_dep_map.get(path)
+            node.abs_path = self.ir.py_info.py_mod_dep_map.get(path)
             if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
                 node.abs_path = node.abs_path.replace(".pyi", ".py")
 
@@ -61,17 +61,17 @@ class PyCollectDepsPass(Pass):
             else:
                 mod_name = node_full_name
 
-            if mod_name not in self.ir.py_mod_dep_map:
+            if mod_name not in self.ir.py_info.py_mod_dep_map:
                 self.__debug_print(
                     f"Can't find a python file associated with {type(node)}::{node.loc}"
                 )
                 return
 
-            mode_path = self.ir.py_mod_dep_map[mod_name]
+            mode_path = self.ir.py_info.py_mod_dep_map[mod_name]
             if mode_path.endswith(".jac"):
                 return
 
-            self.ir.py_raise_map[mod_name] = mode_path
+            self.ir.py_info.py_raise_map[mod_name] = mode_path
         else:
             self.__debug_print(
                 f"Collect python dependencies is not supported in {type(node)}::{node.loc}"

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -129,7 +129,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             is_imported=False,
             kid=valid,
         )
-        ret.is_raised_from_py = True
+        ret.py_info.is_raised_from_py = True
         return self.nu(ret)
 
     def proc_function_def(

jaclang/compiler/passes/main/schedules.py

@@ -20,6 +20,7 @@ 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
+from .inheritance_pass import InheritancePass  # noqa: I100
 
 py_code_gen = [
     SubNodeTabPass,
@@ -38,6 +39,7 @@ type_checker_sched = [
     PyCollectDepsPass,
     PyImportPass,
     DefUsePass,
+    InheritancePass,
     FuseTypeInfoPass,
     AccessCheckPass,
 ]

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,6 +4,8 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
+from typing import TypeVar
+
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
@@ -19,6 +21,7 @@ class SymTabBuildPass(Pass):
     def push_scope(self, name: str, key_node: ast.AstNode) -> None:
         """Push scope."""
         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:
@@ -1284,3 +1287,17 @@ class SymTabBuildPass(Pass):
     def enter_comment_token(self, node: ast.CommentToken) -> None:
         """Sub objects."""
         self.sync_node_to_scope(node)
+
+
+T = TypeVar("T", bound=ast.AstNode)
+
+
+class PyInspectSymTabBuildPass(SymTabBuildPass):
+    """Jac Symbol table build pass."""
+
+    def push_scope(self, name: str, key_node: ast.AstNode) -> None:
+        """Push scope."""
+        if not len(self.cur_sym_tab):
+            self.cur_sym_tab.append(SymbolTable(name, key_node))
+        else:
+            self.cur_sym_tab.append(self.cur_scope.push_kid_scope(name, key_node))

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

@@ -0,0 +1,130 @@
+node NodeA {
+    has value: int = 10;
+}
+
+node NodeC {
+    has value: int = 10;
+}
+
+edge EdgeB {
+    has value: int = 20;
+}
+
+with entry {
+    node_1 = a(value=5);
+    node_2 = a();
+    node_3 = a(value=15);
+    node_4 = a(value=20);
+    node_5 = c(value=25);
+    print(type(root ++> node_1));
+    node_1 +:edge_1 := b(value=5):+> node_2;
+    node_1 +:edge_2 := b(value=10):+> node_3;
+    node_1 +:edge_3 := b(value=15):+> node_4;
+    node_1 +:edge_4 := b():+> node_5;
+    node_1 del--> node_2;
+    del node_3;
+}
+
+
+node A {
+    has val: int = 0;
+}
+
+edge a {}
+
+walker W {
+    can create with `root entry;
+}
+
+:walker:W:can:create {
+    Start = A(5);
+    here +:a:+> Start;
+    Start +:a:+> A(10) +:a:+> A(15);
+    Start +:a:+> A(20) +:a:+> A(25);
+}
+
+with entry {
+    root spawn W();
+    print([root-->-->(`?A)]);
+    print([root-->-->-->(`?A)]);
+}
+
+"""Bubble sort using DS Features of Jac (somparision and swapping happens in inner nodes)."""
+glob list1 = [80, 79, 60, 59, 40, 35, 19, 1];
+
+node main_node {
+    has no: int = 0;
+}
+
+node inner_node {
+    has main: int = 0,
+        sub: int = 0;
+}
+
+walker walker1 {
+    can create_main_node with `root entry;
+}
+
+:walker:walker1:can:create_main_node {
+    end = here;
+    for i=0 to i<len(list1)+1 by i+=1  {
+        end ++> (end := main_node(no=i + 1));
+        visit [-->];
+    }
+}
+
+walker walker2 {
+    can skip_root with `root entry {
+        visit [-->];
+    }
+
+    can process with main_node entry;
+}
+
+:walker:walker2:can:process {
+    :g: list1 ;
+
+    for j in range(0, len(list1) - (here.no)) {
+        here ++> inner_node(main=here.no, sub=j + 1);
+    }
+    visit [-->];
+}
+
+walker walker3 {
+    can skiproot with `root entry {
+        visit [-->];
+    }
+
+    can adjust with main_node entry;
+}
+
+:walker:walker3:can:adjust {
+    here spawn walker4();
+}
+
+walker walker4 {
+    can skipmain with main_node entry {
+        visit [-->];#  print(f"iteration {here.no} started  {list1}");
+    }
+
+    can skipin with inner_node entry {
+        :g: list1 ;
+
+        j = here.sub - 1;
+        if list1[j] > list1[j + 1] {
+            x = list1[j];
+            list1[j] = list1[j + 1];
+            list1[j + 1] = x;
+        }
+        #uncomment below to see the swap in each inner nodes
+        # print(list1);
+
+    }
+}
+
+with entry {
+    root spawn walker1();
+    root spawn walker2();
+    root spawn walker3();
+    print(Jac.node_dot(root));
+}

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

@@ -1,3 +1,3 @@
-from .display import *
-from .color import *
-from .constants import *
+from .display import set_mode
+from .color import Color
+from .constants import CONST_VALUE, CL

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

@@ -1,3 +1,3 @@
-from .display import *
-from .color import *
-from .constants import *
+from .display import set_mode
+from .color import Color
+from .constants import CONST_VALUE, CL

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

@@ -81,39 +81,35 @@ class ImportPassPassTests(TestCase):
             "genericpath": r"jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi$",
         }
         for i in p:
-            self.assertIn(i, build.ir.py_raise_map)
-            self.assertRegex(re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]), p[i])
+            self.assertIn(i, build.ir.py_info.py_raise_map)
+            self.assertRegex(
+                re.sub(r".*fixtures/", "", build.ir.py_info.py_raise_map[i]), p[i]
+            )
 
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""
         state = jac_file_to_pass(
             self.fixture_abs_path("py_imp_test.jac"), schedule=py_code_gen_typed
         )
+        for i in list(
+            filter(
+                lambda x: x.py_info.is_raised_from_py,
+                state.ir.get_all_sub_nodes(ast.Module),
+            )
+        ):
+            print(ast.Module.get_href_path(i))
         self.assertEqual(
             len(
                 list(
                     filter(
-                        lambda x: x.is_raised_from_py,
+                        lambda x: x.py_info.is_raised_from_py,
                         state.ir.get_all_sub_nodes(ast.Module),
                     )
                 )
             ),
-            7,
+            11,  # TODO: Need to only link the modules one time
         )
 
-    # 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()

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

@@ -62,3 +62,27 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertEqual(out.count("Type: builtins.str"), 35)
         for i in lis:
             self.assertNotIn(i, out)
+
+    def test_data_spatial_type_info(self) -> None:
+        """Testing for type info for dataspatial constructs."""
+        out = AstTool().ir(
+            ["ast", f"{self.fixture_abs_path('data_spatial_types.jac')}"]
+        )
+        self.assertRegex(
+            out,
+            r"129:24 - 129:28.*SpecialVarRef - _Jac.get_root\(\) \- Type\: jaclang.runtimelib.architype.Root",
+        )
+        self.assertRegex(out, r"129:11 - 129:29.*FuncCall \- Type\: builtins\.str")
+        self.assertRegex(
+            out,
+            r"129:15 - 129:23.*Name \- node_dot \- Type\: builtins.str,  SymbolTable\: str",
+        )
+        self.assertRegex(
+            out,
+            r"128:5 - 128:25.*BinaryExpr \- Type\: jaclang.runtimelib.architype.WalkerArchitype",
+        )
+        self.assertRegex(
+            out,
+            r"48:11 - 48:28.*EdgeRefTrailer \- Type\: builtins.list\[data_spatial_types.A\]",
+        )
+        self.assertRegex(out, r"24:5 - 24:25.*BinaryExpr \- Type\: builtins.bool", out)

jaclang/compiler/passes/main/type_check_pass.py

@@ -115,13 +115,14 @@ class JacTypeCheckPass(Pass):
             for k, v in mypy_graph.items()
             if (
                 k.startswith("jaclang.plugin")
+                or k.startswith("jaclang.runtimelib")
                 or not (k.startswith("jaclang.") or k.startswith("mypy."))
             )
         }
         for i in mypy_graph:
-            self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
+            self.ir.py_info.py_mod_dep_map[i] = mypy_graph[i].xpath
             for j in mypy_graph[i].dependencies:
-                self.ir.py_mod_dep_map[j] = str(
+                self.ir.py_info.py_mod_dep_map[j] = str(
                     myab.find_module_with_reason(j, manager)
                 )
         myab.process_graph(mypy_graph, manager)

jaclang/compiler/py_info.py

@@ -0,0 +1,22 @@
+"""Code location info for AST nodes."""
+
+from __future__ import annotations
+
+
+class PyInfo:
+    """Python info related to python imports."""
+
+    def __init__(self) -> None:
+        """Object Initialization."""
+        # Module dependacy map used to store all module dependacies detected
+        # by mypy. The dependacies are computed using the mypy graph in
+        # TypeCheck pass
+        self.py_mod_dep_map: dict[str, str] = {}
+
+        # Get all the modules that we really need to raise inorder to make
+        # all Jac types correct (FuseTypeInfo works). This is computed using
+        # PyCollectDepsPass.
+        self.py_raise_map: dict[str, str] = {}
+
+        # Flag for python modules raised into jac
+        self.is_raised_from_py: bool = False

jaclang/compiler/symtable.py

@@ -115,6 +115,7 @@ class SymbolTable:
         node: ast.AstSymbolNode,
         access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
         single: bool = False,
+        force_overwrite: bool = False,
     ) -> Optional[ast.AstNode]:
         """Set a variable in the symbol table.
 
@@ -126,7 +127,7 @@ class SymbolTable:
             if single and node.sym_name in self.tab
             else None
         )
-        if node.sym_name not in self.tab:
+        if force_overwrite or node.sym_name not in self.tab:
             self.tab[node.sym_name] = Symbol(
                 defn=node.name_spec,
                 access=(
@@ -163,11 +164,17 @@ class SymbolTable:
         node: ast.AstSymbolNode,
         access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
         single_decl: Optional[str] = None,
+        force_overwrite: bool = False,
     ) -> Optional[Symbol]:
         """Insert into symbol table."""
         if node.sym and self == node.sym.parent_tab:
             return node.sym
-        self.insert(node=node, single=single_decl is not None, access_spec=access_spec)
+        self.insert(
+            node=node,
+            single=single_decl is not None,
+            access_spec=access_spec,
+            force_overwrite=force_overwrite,
+        )
         self.update_py_ctx_for_def(node)
         return node.sym
 

jaclang/langserve/tests/test_server.py

@@ -330,7 +330,7 @@ class TestJacLangServer(TestCase):
                     "doubleinner",
                     "apply_red",
                 ],
-                8,
+                11,
             ),
             (
                 lspt.Position(65, 23),
@@ -359,7 +359,7 @@ class TestJacLangServer(TestCase):
                     "doubleinner",
                     "apply_red",
                 ],
-                8,
+                11,
             ),
             (
                 lspt.Position(73, 22),

jaclang/plugin/default.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as ast3
 import fnmatch
 import html
+import inspect
 import os
 import types
 from collections import OrderedDict
@@ -818,12 +819,14 @@ class JacFeatureImpl(
     @hookimpl
     def create_test(test_fun: Callable) -> Callable:
         """Create a new test."""
+        file_path = inspect.getfile(test_fun)
+        func_name = test_fun.__name__
 
         def test_deco() -> None:
             test_fun(JacTestCheck())
 
         test_deco.__name__ = test_fun.__name__
-        JacTestCheck.add_test(test_deco)
+        JacTestCheck.add_test(file_path, func_name, test_deco)
 
         return test_deco
 
@@ -831,6 +834,7 @@ class JacFeatureImpl(
     @hookimpl
     def run_test(
         filepath: str,
+        func_name: Optional[str],
         filter: Optional[str],
         xit: bool,
         maxfail: Optional[int],
@@ -849,7 +853,9 @@ class JacFeatureImpl(
                     mod_name = mod_name[:-5]
                 JacTestCheck.reset()
                 Jac.jac_import(target=mod_name, base_path=base, cachable=False)
-                JacTestCheck.run_test(xit, maxfail, verbose)
+                JacTestCheck.run_test(
+                    xit, maxfail, verbose, os.path.abspath(filepath), func_name
+                )
                 ret_count = JacTestCheck.failcount
             else:
                 print("Not a .jac file.")
@@ -875,7 +881,9 @@ class JacFeatureImpl(
                         print(f"\n\n\t\t* Inside {root_dir}" + "/" + f"{file} *")
                         JacTestCheck.reset()
                         Jac.jac_import(target=file[:-4], base_path=root_dir)
-                        JacTestCheck.run_test(xit, maxfail, verbose)
+                        JacTestCheck.run_test(
+                            xit, maxfail, verbose, os.path.abspath(file), func_name
+                        )
 
                     if JacTestCheck.breaker and (xit or maxfail):
                         break

jaclang/plugin/feature.py

@@ -359,6 +359,7 @@ class JacFeature(
     @staticmethod
     def run_test(
         filepath: str,
+        func_name: Optional[str] = None,
         filter: Optional[str] = None,
         xit: bool = False,
         maxfail: Optional[int] = None,
@@ -368,6 +369,7 @@ class JacFeature(
         """Run the test suite in the specified .jac file."""
         return plugin_manager.hook.run_test(
             filepath=filepath,
+            func_name=func_name,
             filter=filter,
             xit=xit,
             maxfail=maxfail,

jaclang/plugin/spec.py

@@ -345,6 +345,7 @@ class JacFeatureSpec(
     @hookspec(firstresult=True)
     def run_test(
         filepath: str,
+        func_name: Optional[str],
         filter: Optional[str],
         xit: bool,
         maxfail: Optional[int],