jaclang 0.7.18__py3-none-any.whl → 0.7.20__py3-none-any.whl

jaclang/langserve/engine.py

@@ -25,7 +25,6 @@ from jaclang.langserve.utils import (
     get_location_range,
     get_symbols_for_outline,
     parse_symbol_path,
-    resolve_completion_symbol_table,
 )
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
@@ -188,14 +187,73 @@ class JacLangServer(LanguageServer):
             if not node_selected
             else node_selected.sym_tab
         )
-        current_tab = self.modules[file_path].ir._sym_tab
         current_symbol_table = mod_tab
 
         if completion_trigger == ".":
             if current_symbol_path:
-                completion_items = resolve_completion_symbol_table(
-                    mod_tab, current_symbol_path, current_tab
-                )
+                temp_tab = mod_tab
+                for symbol in current_symbol_path:
+                    if symbol == "self":
+                        is_ability_def = (
+                            temp_tab.owner
+                            if isinstance(temp_tab.owner, ast.AbilityDef)
+                            else temp_tab.owner.find_parent_of_type(ast.AbilityDef)
+                        )
+                        if not is_ability_def:
+                            archi_owner = mod_tab.owner.find_parent_of_type(
+                                ast.Architype
+                            )
+                            temp_tab = (
+                                archi_owner._sym_tab
+                                if archi_owner and archi_owner._sym_tab
+                                else mod_tab
+                            )
+                            continue
+                        else:
+                            archi_owner = (
+                                (
+                                    is_ability_def.decl_link.find_parent_of_type(
+                                        ast.Architype
+                                    )
+                                )
+                                if is_ability_def.decl_link
+                                else None
+                            )
+                            temp_tab = (
+                                archi_owner.sym_tab
+                                if archi_owner and archi_owner.sym_tab
+                                else temp_tab
+                            )
+                            continue
+                    symb = temp_tab.lookup(symbol)
+                    if symb:
+                        fetc_tab = symb.fetch_sym_tab
+                        if fetc_tab:
+                            temp_tab = fetc_tab
+                        else:
+                            temp_tab = (
+                                symb.defn[0].type_sym_tab
+                                if symb.defn[0].type_sym_tab
+                                else temp_tab
+                            )
+                    else:
+                        break
+                completion_items = collect_all_symbols_in_scope(temp_tab, up_tree=False)
+                if (
+                    isinstance(temp_tab.owner, ast.Architype)
+                    and temp_tab.owner.base_classes
+                ):
+                    base = []
+                    for base_name in temp_tab.owner.base_classes.items:
+                        if isinstance(base_name, ast.Name) and base_name.sym:
+                            base.append(base_name.sym)
+                    for base_class_symbol in base:
+                        if base_class_symbol.fetch_sym_tab:
+                            completion_items += collect_all_symbols_in_scope(
+                                base_class_symbol.fetch_sym_tab,
+                                up_tree=False,
+                            )
+
             else:
                 completion_items = []
         else:
@@ -349,7 +407,10 @@ class JacLangServer(LanguageServer):
             elif node_selected.parent and isinstance(
                 node_selected.parent, ast.ModuleItem
             ):
-                path = node_selected.parent.from_mod_path.abs_path
+                path = (
+                    node_selected.parent.abs_path
+                    or node_selected.parent.from_mod_path.abs_path
+                )
                 try:  # TODO: Get rid of this when 'from' import is fixed
                     loc_range = tuple(
                         loc - 1 if loc > 0 else loc
@@ -371,7 +432,7 @@ class JacLangServer(LanguageServer):
                             ),
                         ),
                     )
-            elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+            elif isinstance(node_selected, ast.ElementStmt):
                 return None
             decl_node = (
                 node_selected.parent.body.target

jaclang/langserve/tests/test_server.py

@@ -218,9 +218,9 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (6, 39, "/pygame_mock/__init__.py:2:0-2:0"),
+            (6, 39, "/pygame_mock/__init__.pyi:2:0-2:0"),
             (6, 45, "/pygame_mock/constants.py:3:0-4:1"),
-            (7, 31, "/pygame_mock/__init__.py:2:0-2:0"),
+            (7, 31, "/pygame_mock/__init__.pyi:2:0-2:0"),
             (7, 35, "/pygame_mock/constants.py:3:0-4:1"),
             (20, 51, "/py_imp_test.jac:6:4-6:11"),
             (20, 64, "/pygame_mock/constants.py:4:3-4:15"),
@@ -282,7 +282,7 @@ class TestJacLangServer(TestCase):
             ),
             (
                 "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
-                6,
+                8,
             ),
             ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 6),
             ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 4),

jaclang/langserve/utils.py

@@ -332,119 +332,6 @@ def parse_symbol_path(text: str, dot_position: int) -> list[str]:
     return all_words
 
 
-def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str:
-    """Resolve symbol path."""
-    visited = set()
-    current_tab: Optional[SymbolTable] = node_tab
-
-    while current_tab is not None and current_tab not in visited:
-        visited.add(current_tab)
-        for name, symbol in current_tab.tab.items():
-            if name not in dir(builtins) and name == sym_name:
-                path = symbol.defn[0]._sym_type
-                if symbol.sym_type == SymbolType.ENUM_ARCH:
-                    if isinstance(current_tab.owner, ast.Module):
-                        return current_tab.owner.name + "." + sym_name
-                    elif isinstance(current_tab.owner, ast.AstSymbolNode):
-                        return current_tab.owner.name_spec._sym_type + "." + sym_name
-                return path
-        current_tab = current_tab.parent if current_tab.parent != current_tab else None
-    return ""
-
-
-def find_symbol_table(path: str, current_tab: Optional[SymbolTable]) -> SymbolTable:
-    """Find symbol table."""
-    path = path.lstrip(".")
-    current_table = current_tab
-    if current_table:
-        for segment in path.split("."):
-            current_table = next(
-                (
-                    child_table
-                    for child_table in current_table.kid
-                    if child_table.name == segment
-                ),
-                current_table,
-            )
-    if current_table:
-        return current_table
-    raise ValueError(f"Symbol table not found for path {path}")
-
-
-def resolve_completion_symbol_table(
-    mod_tab: SymbolTable,
-    current_symbol_path: list[str],
-    current_tab: Optional[SymbolTable],
-) -> list[lspt.CompletionItem]:
-    """Resolve symbol table for completion items."""
-    current_symbol_table = mod_tab
-    for obj in current_symbol_path:
-        if obj == "self":
-            try:
-                try:
-                    is_abilitydef = (
-                        mod_tab.owner
-                        if isinstance(mod_tab.owner, ast.AbilityDef)
-                        else mod_tab.owner.parent_of_type(ast.AbilityDef)
-                    )
-                    archi_owner = (
-                        (is_abilitydef.decl_link.parent_of_type(ast.Architype))
-                        if is_abilitydef.decl_link
-                        else None
-                    )
-                    current_symbol_table = (
-                        archi_owner._sym_tab
-                        if archi_owner and archi_owner._sym_tab
-                        else mod_tab
-                    )
-                    continue
-
-                except ValueError:
-                    pass
-                archi_owner = mod_tab.owner.parent_of_type(ast.Architype)
-                current_symbol_table = (
-                    archi_owner._sym_tab
-                    if archi_owner and archi_owner._sym_tab
-                    else mod_tab
-                )
-            except ValueError:
-                pass
-        else:
-            path: str = resolve_symbol_path(obj, current_symbol_table)
-            if path:
-                current_symbol_table = find_symbol_table(path, current_tab)
-            else:
-                if (
-                    isinstance(current_symbol_table.owner, ast.Architype)
-                    and current_symbol_table.owner.base_classes
-                ):
-                    for base_name in current_symbol_table.owner.base_classes.items:
-                        if isinstance(base_name, ast.Name) and base_name.sym:
-                            path = base_name.sym.sym_dotted_name + "." + obj
-                            current_symbol_table = find_symbol_table(path, current_tab)
-    if (
-        isinstance(current_symbol_table.owner, ast.Architype)
-        and current_symbol_table.owner.base_classes
-    ):
-        base = []
-        for base_name in current_symbol_table.owner.base_classes.items:
-            if isinstance(base_name, ast.Name) and base_name.sym:
-                base.append(base_name.sym.sym_dotted_name)
-        for base_ in base:
-            completion_items = collect_all_symbols_in_scope(
-                find_symbol_table(base_, current_tab),
-                up_tree=False,
-            )
-    else:
-        completion_items = []
-    if isinstance(current_symbol_table.owner, (ast.Ability, ast.AbilityDef)):
-        return completion_items
-    completion_items.extend(
-        collect_all_symbols_in_scope(current_symbol_table, up_tree=False)
-    )
-    return completion_items
-
-
 def get_token_start(
     token_index: int | None, sem_tokens: list[int]
 ) -> tuple[int, int, int]:

jaclang/plugin/tests/test_jaseci.py

@@ -337,8 +337,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- NO UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=2)")
-        self.assertTrue(archs[1], "A(val=1)")
+        self.assertEqual(archs[0], "A(val=2)")
+        self.assertEqual(archs[1], "A(val=1)")
 
         self._output2buffer()
         cli.enter(
@@ -435,8 +435,8 @@ class TestJaseciPlugin(TestCase):
 
         # --------- UPDATE SHOULD HAPPEN -------- #
 
-        self.assertTrue(archs[0], "A(val=20)")
-        self.assertTrue(archs[1], "A(val=10)")
+        self.assertEqual(archs[0], "A(val=20)")
+        self.assertEqual(archs[1], "A(val=10)")
 
         self._output2buffer()
         cli.enter(
@@ -474,6 +474,25 @@ class TestJaseciPlugin(TestCase):
         )
         self.assertFalse(self.capturedOutput.getvalue().strip())
 
+        # --------- ROOTS RESET OWN NODE -------- #
+
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[1],
+            session=session,
+            root=self.roots[0],
+            node=self.nodes[0],
+        )
+        cli.enter(
+            filename=self.fixture_abs_path("other_root_access.jac"),
+            entrypoint="update_node",
+            args=[2],
+            session=session,
+            root=self.roots[1],
+            node=self.nodes[1],
+        )
+
     def test_other_root_access(self) -> None:
         """Test filtering on node, then visit."""
         global session

jaclang/runtimelib/importer.py

@@ -195,6 +195,8 @@ class PythonImporter(Importer):
             loaded_items: list = []
             if spec.target.startswith("."):
                 spec.target = spec.target.lstrip(".")
+                if len(spec.target.split(".")) > 1:
+                    spec.target = spec.target.split(".")[-1]
                 full_target = path.normpath(path.join(spec.caller_dir, spec.target))
                 imp_spec = importlib.util.spec_from_file_location(
                     spec.target, full_target + ".py"
@@ -340,6 +342,7 @@ class JacImporter(Importer):
                     spec.full_target,
                     caller_dir=spec.caller_dir,
                     cachable=spec.cachable,
+                    reload=reload if reload else False,
                 )
                 try:
                     if not codeobj:

jaclang/runtimelib/machine.py

@@ -6,7 +6,7 @@ import os
 import sys
 import types
 from contextvars import ContextVar
-from typing import Optional
+from typing import Optional, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
@@ -55,11 +55,12 @@ class JacMachine:
         full_target: str,
         caller_dir: str,
         cachable: bool = True,
+        reload: bool = False,
     ) -> Optional[types.CodeType]:
         """Retrieve bytecode from the attached JacProgram."""
         if self.jac_program:
             return self.jac_program.get_bytecode(
-                module_name, full_target, caller_dir, cachable
+                module_name, full_target, caller_dir, cachable, reload=reload
             )
         return None
 
@@ -105,6 +106,46 @@ class JacMachine:
             return nodes
         return []
 
+    def update_walker(
+        self, module_name: str, items: Optional[dict[str, Union[str, Optional[str]]]]
+    ) -> tuple[types.ModuleType, ...]:
+        """Reimport the module."""
+        from .importer import JacImporter, ImportPathSpec
+
+        if module_name in self.loaded_modules:
+            try:
+                old_module = self.loaded_modules[module_name]
+                importer = JacImporter(self)
+                spec = ImportPathSpec(
+                    target=module_name,
+                    base_path=self.base_path,
+                    absorb=False,
+                    cachable=True,
+                    mdl_alias=None,
+                    override_name=None,
+                    lng="jac",
+                    items=items,
+                )
+                import_result = importer.run_import(spec, reload=True)
+                ret_items = []
+                if items:
+                    for item_name in items:
+                        if hasattr(old_module, item_name):
+                            new_attr = getattr(import_result.ret_mod, item_name, None)
+                            if new_attr:
+                                ret_items.append(new_attr)
+                                setattr(
+                                    old_module,
+                                    item_name,
+                                    new_attr,
+                                )
+                return (old_module,) if not items else tuple(ret_items)
+            except Exception as e:
+                logger.error(f"Failed to update module {module_name}: {e}")
+        else:
+            logger.warning(f"Module {module_name} not found in loaded modules.")
+        return ()
+
     @staticmethod
     def get(base_path: str = "") -> "JacMachine":
         """Get current jac machine."""
@@ -134,6 +175,7 @@ class JacProgram:
         full_target: str,
         caller_dir: str,
         cachable: bool = True,
+        reload: bool = False,
     ) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
         if self.mod_bundle and isinstance(self.mod_bundle, Module):
@@ -141,7 +183,7 @@ class JacProgram:
             return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
         gen_dir = os.path.join(caller_dir, Con.JAC_GEN_DIR)
         pyc_file_path = os.path.join(gen_dir, module_name + ".jbc")
-        if cachable and os.path.exists(pyc_file_path):
+        if cachable and os.path.exists(pyc_file_path) and not reload:
             with open(pyc_file_path, "rb") as f:
                 return marshal.load(f)
 

jaclang/runtimelib/memory.py

@@ -106,7 +106,7 @@ class ShelfStorage(Memory[UUID, Anchor]):
                         if root.has_write_access(d):
                             if hash(dumps(p_d.access)) != hash(dumps(d.access)):
                                 p_d.access = d.access
-                            if hash(dumps(d.architype)) != hash(dumps(d.architype)):
+                            if hash(dumps(p_d.architype)) != hash(dumps(d.architype)):
                                 p_d.architype = d.architype
 
                         self.__shelf__[_id] = p_d

jaclang/settings.py

@@ -17,6 +17,10 @@ class Settings:
     collect_py_dep_debug: bool = False
     print_py_raised_ast: bool = False
 
+    # Compiler configuration
+    disable_mtllm: bool = False
+    ignore_test_annex: bool = False
+
     # Formatter configuration
     max_line_length: int = 88
 

jaclang/stubs/jaclang/__init__.pyi

@@ -0,0 +1,5 @@
+from _typeshed import Incomplete
+
+__all__ = ["jac_import"]
+
+jac_import: Incomplete

jaclang/stubs/jaclang/cli/cli.pyi

@@ -0,0 +1,58 @@
+from jaclang import jac_import as jac_import
+from jaclang.cli.cmdreg import (
+    CommandShell as CommandShell,
+    cmd_registry as cmd_registry,
+)
+from jaclang.compiler.compile import jac_file_to_pass as jac_file_to_pass
+from jaclang.compiler.constant import Constants as Constants
+from jaclang.compiler.passes.main.pyast_load_pass import (
+    PyastBuildPass as PyastBuildPass,
+)
+from jaclang.compiler.passes.main.schedules import (
+    py_code_gen_typed as py_code_gen_typed,
+)
+from jaclang.compiler.passes.tool.schedules import format_pass as format_pass
+from jaclang.plugin.builtin import dotgen as dotgen
+from jaclang.runtimelib.constructs import Architype as Architype
+from jaclang.utils.lang_tools import AstTool as AstTool
+
+def format(path: str, outfile: str = "", debug: bool = False) -> None: ...
+def run(
+    filename: str,
+    session: str = "",
+    main: bool = True,
+    cache: bool = True,
+    walker: str = "",
+    node: str = "",
+) -> None: ...
+def get_object(id: str, session: str = "") -> dict: ...
+def build(filename: str) -> None: ...
+def check(filename: str, print_errs: bool = True) -> None: ...
+def lsp() -> None: ...
+def enter(filename: str, entrypoint: str, args: list) -> None: ...
+def test(
+    filepath: str,
+    filter: str = "",
+    xit: bool = False,
+    maxfail: int = None,
+    directory: str = "",
+    verbose: bool = False,
+) -> None: ...
+def tool(tool: str, args: list | None = None) -> None: ...
+def clean() -> None: ...
+def debug(filename: str, main: bool = True, cache: bool = False) -> None: ...
+def dot(
+    filename: str,
+    session: str = "",
+    initial: str = "",
+    depth: int = -1,
+    traverse: bool = False,
+    connection: list[str] = [],
+    bfs: bool = False,
+    edge_limit: int = 512,
+    node_limit: int = 512,
+    saveto: str = "",
+) -> None: ...
+def py2jac(filename: str) -> None: ...
+def jac2py(filename: str) -> None: ...
+def start_cli() -> None: ...

jaclang/stubs/jaclang/cli/cmdreg.pyi

@@ -0,0 +1,32 @@
+import argparse
+import cmd
+import inspect
+from _typeshed import Incomplete
+from typing import Callable
+
+class Command:
+    func: Callable
+    sig: inspect.Signature
+    def __init__(self, func: Callable) -> None: ...
+    def call(self, *args: list, **kwargs: dict) -> str: ...
+
+class CommandRegistry:
+    registry: dict[str, Command]
+    sub_parsers: argparse._SubParsersAction
+    parser: argparse.ArgumentParser
+    args: argparse.Namespace
+    def __init__(self) -> None: ...
+    def register(self, func: Callable) -> Callable: ...
+    def get(self, name: str) -> Command | None: ...
+    def get_all_commands(self) -> dict: ...
+
+cmd_registry: Incomplete
+
+class CommandShell(cmd.Cmd):
+    intro: str
+    prompt: str
+    cmd_reg: CommandRegistry
+    def __init__(self, cmd_reg: CommandRegistry) -> None: ...
+    def do_exit(self, arg: list) -> bool: ...
+    def default(self, line: str) -> None: ...
+    def do_help(self, arg: str) -> None: ...

jaclang/stubs/jaclang/compiler/__init__.pyi

@@ -0,0 +1,6 @@
+from _typeshed import Incomplete
+from jaclang.compiler.generated import jac_parser as jac_lark
+
+__all__ = ["jac_lark", "TOKEN_MAP"]
+
+TOKEN_MAP: Incomplete