jaclang 0.7.1__py3-none-any.whl → 0.7.5__py3-none-any.whl

jaclang/langserve/utils.py

@@ -1,12 +1,15 @@
 """Utility functions for the language server."""
 
 import asyncio
+import builtins
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.symtable import SymbolTable
+from jaclang.compiler.codeloc import CodeLocInfo
+from jaclang.compiler.symtable import Symbol, SymbolTable
 
+import lsprotocol.types as lspt
 
 T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
 P = ParamSpec("P")
@@ -55,17 +58,23 @@ def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]:
     return sym_tabs
 
 
-def find_deepest_node_at_pos(
+def find_deepest_symbol_node_at_pos(
     node: ast.AstNode, line: int, character: int
-) -> Optional[ast.AstNode]:
-    """Return the deepest node that contains the given position."""
+) -> Optional[ast.AstSymbolNode]:
+    """Return the deepest symbol node that contains the given position."""
+    last_symbol_node = None
+
     if position_within_node(node, line, character):
-        for i in node.kid:
-            if position_within_node(i, line, character):
-                return find_deepest_node_at_pos(i, line, character)
-        return node
-    else:
-        return None
+        if isinstance(node, ast.AstSymbolNode):
+            last_symbol_node = node
+
+        for child in node.kid:
+            if position_within_node(child, line, character):
+                deeper_node = find_deepest_symbol_node_at_pos(child, line, character)
+                if deeper_node is not None:
+                    last_symbol_node = deeper_node
+
+    return last_symbol_node
 
 
 def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
@@ -88,3 +97,88 @@ def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
     ):
         return True
     return False
+
+
+def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
+    """Recursively collect symbols from the AST."""
+    symbols = []
+    if node is None:
+        return symbols
+
+    for key, item in node.tab.items():
+        if (
+            key in dir(builtins)
+            or item in [owner_sym(tab) for tab in node.kid]
+            or item.decl.loc.mod_path != node.owner.loc.mod_path
+        ):
+            continue
+        else:
+
+            pos = create_range(item.decl.loc)
+            symbol = lspt.DocumentSymbol(
+                name=key,
+                kind=kind_map(item.decl),
+                range=pos,
+                selection_range=pos,
+                children=[],
+            )
+            symbols.append(symbol)
+
+    for sub_tab in [
+        i for i in node.kid if i.owner.loc.mod_path == node.owner.loc.mod_path
+    ]:
+        sub_symbols = collect_symbols(sub_tab)
+
+        if isinstance(
+            sub_tab.owner,
+            (ast.IfStmt, ast.ElseStmt, ast.WhileStmt, ast.IterForStmt, ast.InForStmt),
+        ):
+            symbols.extend(sub_symbols)
+        else:
+            sub_pos = create_range(sub_tab.owner.loc)
+            symbol = lspt.DocumentSymbol(
+                name=sub_tab.name,
+                kind=kind_map(sub_tab.owner),
+                range=sub_pos,
+                selection_range=sub_pos,
+                children=sub_symbols,
+            )
+            symbols.append(symbol)
+
+    return symbols
+
+
+def owner_sym(table: SymbolTable) -> Optional[Symbol]:
+    """Get owner sym."""
+    if table.has_parent() and isinstance(table.owner, ast.AstSymbolNode):
+        return table.parent.lookup(table.owner.sym_name)
+    return None
+
+
+def create_range(loc: CodeLocInfo) -> lspt.Range:
+    """Create an lspt.Range from a location object."""
+    return lspt.Range(
+        start=lspt.Position(line=loc.first_line - 1, character=loc.col_start - 1),
+        end=lspt.Position(line=loc.last_line - 1, character=loc.col_end - 1),
+    )
+
+
+def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
+    """Map the symbol node to an lspt.SymbolKind."""
+    return (
+        lspt.SymbolKind.Function
+        if isinstance(sub_tab, (ast.Ability, ast.AbilityDef))
+        else (
+            lspt.SymbolKind.Class
+            if isinstance(sub_tab, (ast.Architype, ast.ArchDef))
+            else (
+                lspt.SymbolKind.Module
+                if isinstance(sub_tab, ast.Module)
+                else (
+                    lspt.SymbolKind.Enum
+                    if isinstance(sub_tab, (ast.Enum, ast.EnumDef))
+                    else lspt.SymbolKind.Variable
+                )
+            )
+        )
+    )

jaclang/plugin/builtin.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional
-    from jaclang.core.construct import NodeArchitype
+    from jaclang.core.constructs import NodeArchitype
 
 
 def dotgen(

jaclang/plugin/default.py

@@ -7,40 +7,39 @@ import html
 import os
 import pickle
 import types
-from contextvars import ContextVar
+from collections import OrderedDict
 from dataclasses import field
 from functools import wraps
 from typing import Any, Callable, Optional, Type, Union
-from uuid import UUID
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
+from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
 from jaclang.core.aott import (
     aott_raise,
     extract_non_primary_type,
     get_all_type_explanations,
     get_info_types,
-    get_object_string,
-    get_type_annotation,
+    get_input_information,
 )
-from jaclang.core.construct import (
+from jaclang.core.constructs import (
     Architype,
     DSFunc,
     EdgeAnchor,
     EdgeArchitype,
+    ExecutionContext,
     GenericEdge,
     JacTestCheck,
+    Memory,
     NodeAnchor,
     NodeArchitype,
     ObjectAnchor,
     Root,
     WalkerAnchor,
     WalkerArchitype,
+    exec_context,
 )
 from jaclang.core.importer import jac_importer
-from jaclang.core.memory import Memory
-from jaclang.core.registry import SemInfo, SemRegistry, SemScope
-from jaclang.core.shelve_storage import ShelveStorage
 from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
@@ -70,65 +69,6 @@ __all__ = [
 hookimpl = pluggy.HookimplMarker("jac")
 
 
-class ExecutionContext:
-    """Default Execution Context implementation."""
-
-    mem: Optional[Memory]
-    root: Optional[Root]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.mem = ShelveStorage()
-        self.root = None
-
-    def init_memory(self, session: str = "") -> None:
-        if session:
-            self.mem = ShelveStorage(session)
-        else:
-            self.mem = Memory()
-
-    def get_root(self) -> Root:
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        if not self.root:
-            root = self.mem.get_obj(UUID(int=0))
-            if root is None:
-                self.root = Root()
-                self.mem.save_obj(self.root, persistent=self.root._jac_.persistent)
-            elif not isinstance(root, Root):
-                raise ValueError(f"Invalid root object: {root}")
-            else:
-                self.root = root
-        return self.root
-
-    def get_obj(self, obj_id: UUID) -> Architype | None:
-        """Get object from memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        return self.mem.get_obj(obj_id)
-
-    def save_obj(self, item: Architype, persistent: bool) -> None:
-        """Save object to memory."""
-        if self.mem is None:
-            raise ValueError("Memory not initialized")
-
-        self.mem.save_obj(item, persistent)
-
-    def reset(self) -> None:
-        """Reset the execution context."""
-        if self.mem:
-            self.mem.close()
-        self.mem = None
-        self.root = None
-
-
-ExecContext: ContextVar[ExecutionContext | None] = ContextVar(
-    "ExecutionContext", default=None
-)
-
-
 class JacFeatureDefaults:
     """Jac Feature."""
 
@@ -138,20 +78,20 @@ class JacFeatureDefaults:
     @hookimpl
     def context(session: str = "") -> ExecutionContext:
         """Get the execution context."""
-        ctx = ExecContext.get()
+        ctx = exec_context.get()
         if ctx is None:
             ctx = ExecutionContext()
-            ExecContext.set(ctx)
+            exec_context.set(ctx)
         return ctx
 
     @staticmethod
     @hookimpl
     def reset_context() -> None:
         """Reset the execution context."""
-        ctx = ExecContext.get()
+        ctx = exec_context.get()
         if ctx:
             ctx.reset()
-        ExecContext.set(None)
+        exec_context.set(None)
 
     @staticmethod
     @hookimpl
@@ -170,7 +110,9 @@ class JacFeatureDefaults:
         """Create a new architype."""
         for i in on_entry + on_exit:
             i.resolve(cls)
-        if not issubclass(cls, arch_base):
+        if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
+            cls, "_jac_exit_funcs_"
+        ):
             # Saving the module path and reassign it after creating cls
             # So the jac modules are part of the correct module
             cur_module = cls.__module__
@@ -179,12 +121,20 @@ class JacFeatureDefaults:
             cls._jac_entry_funcs_ = on_entry  # type: ignore
             cls._jac_exit_funcs_ = on_exit  # type: ignore
         else:
-            cls._jac_entry_funcs_ = cls._jac_entry_funcs_ + [
-                x for x in on_entry if x not in cls._jac_entry_funcs_
-            ]
-            cls._jac_exit_funcs_ = cls._jac_exit_funcs_ + [
-                x for x in on_exit if x not in cls._jac_exit_funcs_
-            ]
+            new_entry_funcs = OrderedDict(zip([i.name for i in on_entry], on_entry))
+            entry_funcs = OrderedDict(
+                zip([i.name for i in cls._jac_entry_funcs_], cls._jac_entry_funcs_)
+            )
+            entry_funcs.update(new_entry_funcs)
+            cls._jac_entry_funcs_ = list(entry_funcs.values())
+
+            new_exit_funcs = OrderedDict(zip([i.name for i in on_exit], on_exit))
+            exit_funcs = OrderedDict(
+                zip([i.name for i in cls._jac_exit_funcs_], cls._jac_exit_funcs_)
+            )
+            exit_funcs.update(new_exit_funcs)
+            cls._jac_exit_funcs_ = list(exit_funcs.values())
+
         inner_init = cls.__init__  # type: ignore
 
         @wraps(inner_init)
@@ -268,7 +218,7 @@ class JacFeatureDefaults:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -387,7 +337,13 @@ class JacFeatureDefaults:
     @hookimpl
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         return walker._jac_.ignore_node(expr)
@@ -396,7 +352,13 @@ class JacFeatureDefaults:
     @hookimpl
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's visit stmt feature."""
         if isinstance(walker, WalkerArchitype):
@@ -698,16 +660,10 @@ class JacFeatureDefaults:
         incl_info = [x for x in incl_info if not isinstance(x[1], type)]
         information, collected_types = get_info_types(_scope, mod_registry, incl_info)
         type_collector.extend(collected_types)
-        inputs_information_list = []
-        for i in inputs:
-            typ_anno = get_type_annotation(i[3])
-            type_collector.extend(extract_non_primary_type(typ_anno))
-            inputs_information_list.append(
-                f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}"
-            )
-        inputs_information = "\n".join(inputs_information_list)
 
-        output_information = f"{outputs[0]} ({outputs[1]})"
+        inputs_information = get_input_information(inputs, type_collector)
+
+        output_information = f"{outputs[0]} ({outputs[1]})".strip()
         type_collector.extend(extract_non_primary_type(outputs[1]))
         output_type_explanations = "\n".join(
             list(

jaclang/plugin/feature.py

@@ -3,22 +3,20 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, TYPE_CHECKING, Type, Union
+from typing import Any, Callable, Optional, Type, TypeAlias, Union
 
 from jaclang.compiler.absyntree import Module
+from jaclang.core.constructs import (
+    Architype,
+    EdgeArchitype,
+    Memory,
+    NodeArchitype,
+    Root,
+    WalkerArchitype,
+)
+from jaclang.plugin.default import ExecutionContext
 from jaclang.plugin.spec import JacBuiltin, JacCmdSpec, JacFeatureSpec, T
 
-if TYPE_CHECKING:
-    from jaclang.core.construct import (
-        Architype,
-        EdgeArchitype,
-        NodeArchitype,
-        WalkerArchitype,
-        Root,
-    )
-    from jaclang.plugin.default import ExecutionContext
-    from jaclang.core.memory import Memory
-
 
 import pluggy
 
@@ -33,7 +31,13 @@ class JacFeature:
 
     import abc
     from jaclang.compiler.constant import EdgeDir
-    from jaclang.plugin.spec import DSFunc
+    from jaclang.core.constructs import DSFunc
+
+    RootType: TypeAlias = Root
+    Obj: TypeAlias = Architype
+    Node: TypeAlias = NodeArchitype
+    Edge: TypeAlias = EdgeArchitype
+    Walker: TypeAlias = WalkerArchitype
 
     @staticmethod
     def context(session: str = "") -> ExecutionContext:
@@ -98,7 +102,7 @@ class JacFeature:
         cachable: bool = True,
         mdl_alias: Optional[str] = None,
         override_name: Optional[str] = None,
-        mod_bundle: Optional[Module] = None,
+        mod_bundle: Optional[Module | str] = None,
         lng: Optional[str] = "jac",
         items: Optional[dict[str, Union[str, bool]]] = None,
     ) -> Optional[types.ModuleType]:
@@ -162,7 +166,13 @@ class JacFeature:
     @staticmethod
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's ignore stmt feature."""
         return pm.hook.ignore(walker=walker, expr=expr)
@@ -170,7 +180,13 @@ class JacFeature:
     @staticmethod
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         return pm.hook.visit_node(walker=walker, expr=expr)

jaclang/plugin/spec.py

@@ -3,19 +3,19 @@
 from __future__ import annotations
 
 import types
-from dataclasses import dataclass
 from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
 
 from jaclang.compiler.absyntree import Module
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import EdgeArchitype, NodeArchitype
+    from jaclang.core.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
         ExecutionContext,
         WalkerArchitype,
         Root,
+        DSFunc,
     )
     from jaclang.core.memory import Memory
 
@@ -26,20 +26,6 @@ hookspec = pluggy.HookspecMarker("jac")
 T = TypeVar("T")
 
 
-# TODO: DSFunc should be moved into jaclang/core
-@dataclass(eq=False)
-class DSFunc:
-    """Data Spatial Function."""
-
-    name: str
-    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
-    func: Callable[[Any, Any], Any] | None = None
-
-    def resolve(self, cls: type) -> None:
-        """Resolve the function."""
-        self.func = getattr(cls, self.name)
-
-
 class JacFeatureSpec:
     """Jac Feature."""
 
@@ -113,7 +99,7 @@ class JacFeatureSpec:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -167,7 +153,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         raise NotImplementedError
@@ -176,7 +168,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         raise NotImplementedError

jaclang/plugin/tests/test_features.py

@@ -1,12 +1,8 @@
 """Tests for Jac parser."""
 
 import inspect
-import io
-import sys
-import traceback
 from typing import List, Type
 
-from jaclang.cli import cli
 from jaclang.plugin.default import JacFeatureDefaults
 from jaclang.plugin.feature import JacFeature
 from jaclang.plugin.spec import JacFeatureSpec
@@ -58,32 +54,3 @@ class TestFeatures(TestCase):
         self.assertEqual(jac_feature_spec_methods, jac_feature_defaults_methods)
         for i in jac_feature_spec_methods:
             self.assertIn(i, jac_feature_methods)
-
-    def test_impl_match_error_reporting(self) -> None:
-        """Basic test for error reporting."""
-        captured_output = io.StringIO()
-        original_stderr = sys.stderr
-        sys.stderr = captured_output
-
-        try:
-            # Execute the function that is expected to raise an exception
-            cli.run(self.fixture_abs_path("impl_match.jac"))  # type: ignore
-        except Exception:
-            # Print the full stack trace to the captured output
-            traceback.print_exc(file=captured_output)
-        finally:
-            # Restore the original stderr
-            sys.stderr = original_stderr
-
-        # Retrieve the captured output
-        stderr_val = captured_output.getvalue()
-        # Assertions or verifications
-        try:
-            self.assertIn("impl_match.jac", stderr_val)
-            self.assertIn("impl_match_impl.jac", stderr_val)
-            self.assertLess(
-                stderr_val.index("impl_match.jac"),
-                stderr_val.index("impl_match_impl.jac"),
-            )
-        except AssertionError:
-            self.skipTest("Error reporting not implemented yet")

jaclang/settings.py

@@ -12,11 +12,15 @@ class Settings:
     # Debug configuration
     fuse_type_info_debug: bool = False
     filter_sym_builtins: bool = True
+    ast_symbol_info_detailed: bool = False
 
     # Import configuration
     py_raise: bool = False
     py_raise_deep: bool = False
 
+    # LSP configuration
+    lsp_debug: bool = False
+
     def __post_init__(self) -> None:
         """Initialize settings."""
         home_dir = os.path.expanduser("~")

jaclang/tests/fixtures/abc.jac

@@ -18,9 +18,9 @@ Below we have the demonstration of a class to calculate the area of a circle.
 *#
 
 """Enum for shape types"""
-enum ShapeType  {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+enum ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Base class for a shape."""
@@ -50,24 +50,28 @@ with entry {
 # Global also works here
 
 with entry:__main__ {
-# To run the program functionality
-print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    # To run the program functionality
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }
 # Unit Tests!
 
 glob expected_area = 78.53981633974483;
 
-test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+test calc_area {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
-test circle_area   {
+test circle_area {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
-test circle_type   {
+test circle_type {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/tests/fixtures/byllmissue.jac

@@ -0,0 +1,12 @@
+class Foo {
+    '''
+    a doc string
+    '''
+    can bar() {
+        return 1;
+    }
+}
+
+with entry {
+    my_thing = YourThing(level=thingy by llm());
+}

jaclang/tests/fixtures/edgetypetest.jac

@@ -0,0 +1,16 @@
+
+# node x {}
+
+# edge edg {
+
+#     has name: str;
+
+# }
+
+# with entry {
+
+#     nodes = root +:edg:name="hello":+> x();
+
+#     print(nodes);
+
+# }