jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/langserve/utils.jac

@@ -0,0 +1,438 @@
+"""Utility functions for the language server."""
+
+import asyncio;
+import builtins;
+import re;
+import from functools { wraps }
+import from typing {
+    Any,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Optional,
+    ParamSpec,
+    TypeVar
+}
+
+import jaclang.compiler.unitree as uni;
+import from jaclang.compiler.codeinfo { CodeLocInfo }
+import from jaclang.compiler.constant { SymbolType }
+import from jaclang.compiler.passes.transform { Alert }
+import from jaclang.compiler.unitree { Symbol, UniScopeNode }
+import from jaclang.vendor.pygls { uris }
+
+import lsprotocol.types as lspt;
+
+
+with entry {
+    P = ParamSpec('P');
+    T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
+}
+
+
+"""Return diagnostics."""
+def gen_diagnostics(
+    from_path: str,
+    errors: <>list[Alert],
+    warnings: <>list[Alert]
+) -> <>list[lspt.Diagnostic] {
+    return ([ lspt.Diagnostic(range=create_range(error.loc),
+    message=error.msg,
+    severity=lspt.DiagnosticSeverity.Error) for error in errors if error.loc.mod_path == uris.to_fs_path(from_path) ] + [ lspt.Diagnostic(range=create_range(warning.loc),
+    message=warning.msg,
+    severity=lspt.DiagnosticSeverity.Warning) for warning in warnings if warning.loc.mod_path == uris.to_fs_path(from_path) ]);
+}
+
+
+"""Debounce decorator for async functions."""
+def debounce(<>wait: float) -> Callable[[T], Callable[(..., Awaitable[None])]] {
+    def decorator(fn: T) -> Callable[P, Awaitable[None]] {
+        @wraps(fn)
+        async def debounced(*args: P.args, **kwargs: P.kwargs) -> None {
+            async def call_it() -> None {
+                await fn(*args, _=kwargs);
+            }
+            if hasattr(debounced, '_task') {
+                debounced._task.cancel();
+            }
+            async def debounced_coro() -> None {
+                try {
+                    await asyncio.sleep(<>wait);
+                    await call_it();
+                } except asyncio.CancelledError {
+                    ;
+                }
+
+            }
+            setattr(debounced, '_task', asyncio.create_task(debounced_coro()));
+        }
+        return debounced;
+    }
+    return decorator;
+}
+
+
+"""Iterate through symbol table."""
+def sym_tab_list(sym_tab: UniScopeNode, file_path: str) -> <>list[UniScopeNode] {
+    sym_tabs = [sym_tab]
+    if not (isinstance(sym_tab, uni.Module) and sym_tab.loc.mod_path != file_path )
+    else []
+    ;
+    for i in sym_tab.kid_scope {
+        sym_tabs += sym_tab_list(i, file_path=file_path);
+    }
+    return sym_tabs;
+}
+
+
+"""Return the deepest symbol node that contains the given position."""
+def find_deepest_symbol_node_at_pos(
+    <>node: uni.UniNode,
+    line: int,
+    character: int
+) -> Optional[uni.AstSymbolNode] {
+    last_symbol_node = None;
+    if position_within_node(<>node, line, character) {
+        if isinstance(<>node, uni.AstSymbolNode) {
+            last_symbol_node = <>node;
+        }
+        for child in [ i for i in <>node.kid if i.loc.mod_path == <>node.loc.mod_path ] {
+            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;
+}
+
+
+"""Check if the position falls within the node's location."""
+def position_within_node(<>node: uni.UniNode, line: int, character: int) -> bool {
+    if <>node.loc.first_line < (line + 1) < <>node.loc.last_line {
+        return True;
+    }
+    if <>node.loc.first_line == (line + 1)
+    and <>node.loc.col_start <= (character + 1)
+    and <>node.loc.last_line == (line + 1)
+    and <>node.loc.col_end >= (character + 1)
+
+    or <>node.loc.last_line > (line + 1)
+     {
+        return True;
+    }
+    if <>node.loc.last_line == (line + 1)
+    and <>node.loc.col_start <= (character + 1) <= <>node.loc.col_end
+     {
+        return True;
+    }
+    return False;
+}
+
+
+"""Find index."""
+def find_index(sem_tokens: <>list[int], line: int, char: int) -> Optional[int] {
+    index = None;
+    token_start_list = [ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ];
+    for (i, j) in enumerate(token_start_list) {
+        if j[0] == line and j[1] <= char <= j[2]  {
+            return i;
+        }
+    }
+    return index;
+}
+
+
+"""Recursively collect symbols from the AST."""
+def get_symbols_for_outline(<>node: UniScopeNode) -> <>list[lspt.DocumentSymbol] {
+    symbols = [];
+    for (key, item) in <>node.names_in_scope.items() {
+        if key in dir(builtins)
+        or item in [ owner_sym(tab) for tab in <>node.kid_scope ]
+        or item.decl.loc.mod_path != <>node.loc.mod_path
+         {
+            continue;
+        }
+        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_scope if i.loc.mod_path == <>node.loc.mod_path ] {
+        sub_symbols = get_symbols_for_outline(sub_tab);
+        if isinstance(sub_tab,
+        (uni.IfStmt, uni.ElseStmt, uni.WhileStmt, uni.IterForStmt, uni.InForStmt)) {
+            symbols.extend(sub_symbols);
+        } else {
+            sub_pos = create_range(sub_tab.loc);
+            symbol = lspt.DocumentSymbol(name=sub_tab.scope_name,
+            kind=kind_map(sub_tab),
+            range=sub_pos,
+            selection_range=sub_pos,
+            children=sub_symbols);
+            symbols.append(symbol);
+        }
+    }
+    return symbols;
+}
+
+
+"""Get owner sym."""
+def owner_sym(table: UniScopeNode) -> Optional[Symbol] {
+    if table.parent_scope and isinstance(table, uni.AstSymbolNode)  {
+        return table.parent_scope.lookup(table.sym_name);
+    }
+    return None;
+}
+
+
+"""Create an lspt.Range from a location object."""
+def create_range(loc: CodeLocInfo) -> lspt.Range {
+    return lspt.Range(start=lspt.Position(line=(loc.first_line - 1) if loc.first_line > 0 else 0 ,
+    character=(loc.col_start - 1) if loc.col_start > 0 else 0 ),
+    end=lspt.Position(line=(loc.last_line - 1) if loc.last_line > 0 else 0 ,
+    character=(loc.col_end - 1) if loc.col_end > 0 else 0 ));
+}
+
+
+"""Map the symbol node to an lspt.SymbolKind."""
+def kind_map(sub_tab: uni.UniNode) -> lspt.SymbolKind {
+    return lspt.SymbolKind.Function
+    if isinstance(sub_tab, (uni.Ability, uni.ImplDef))
+    else lspt.SymbolKind.Class
+    if isinstance(sub_tab, (uni.Archetype, uni.ImplDef))
+    else lspt.SymbolKind.Module
+    if isinstance(sub_tab, uni.Module)
+    else lspt.SymbolKind.Enum
+    if isinstance(sub_tab, (uni.Enum, uni.ImplDef))
+    else lspt.SymbolKind.Variable
+
+
+
+    ;
+}
+
+
+"""Map the symbol node to an lspt.CompletionItemKind."""
+def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind {
+    return lspt.CompletionItemKind.Function
+    if sub_tab in [SymbolType.ABILITY, SymbolType.TEST]
+    else lspt.CompletionItemKind.Class
+    if sub_tab in [SymbolType.OBJECT_ARCH,
+    SymbolType.NODE_ARCH,
+    SymbolType.EDGE_ARCH,
+    SymbolType.WALKER_ARCH]
+    else lspt.CompletionItemKind.Module
+    if sub_tab == SymbolType.MODULE
+    else lspt.CompletionItemKind.Enum
+    if sub_tab == SymbolType.ENUM_ARCH
+    else lspt.CompletionItemKind.Field
+    if sub_tab == SymbolType.HAS_VAR
+    else lspt.CompletionItemKind.Method
+    if sub_tab == SymbolType.METHOD
+    else lspt.CompletionItemKind.EnumMember
+    if sub_tab == SymbolType.ENUM_MEMBER
+    else lspt.CompletionItemKind.Interface
+    if sub_tab == SymbolType.IMPL
+    else lspt.CompletionItemKind.Variable
+
+
+
+
+
+
+
+    ;
+}
+
+
+"""Return all symbols in scope."""
+def collect_all_symbols_in_scope(
+    sym_tab: UniScopeNode,
+    up_tree: bool = True
+) -> <>list[lspt.CompletionItem] {
+    symbols = [];
+    visited = <>set();
+    current_tab : Optional[UniScopeNode] = sym_tab;
+    while current_tab is not None and current_tab not in visited  {
+        visited.add(current_tab);
+        for (name, symbol) in current_tab.names_in_scope.items() {
+            if name not in dir(builtins) and symbol.sym_type != SymbolType.IMPL  {
+                symbols.append(lspt.CompletionItem(label=name,
+                kind=label_map(symbol.sym_type)));
+            }
+        }
+        if not up_tree {
+            return symbols;
+        }
+        current_tab = current_tab.parent_scope
+        if current_tab.parent_scope != current_tab
+        else None
+        ;
+    }
+    return symbols;
+}
+
+
+"""Return all child tab's as completion items."""
+def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
+    symbols : <>list[lspt.CompletionItem] = [];
+    for tab in sym_tab.kid_scope {
+        if tab.scope_name not in [ i.label for i in symbols ] {
+            symbols.append(lspt.CompletionItem(label=tab.scope_name,
+            kind=label_map(tab.get_type())));
+        }
+    }
+    return symbols;
+}
+
+
+"""Parse text and return a list of symbols."""
+def parse_symbol_path(text: str, dot_position: int) -> <>list[str] {
+    text = text[ : dot_position ][ : -1 ].strip();
+    valid_character_pattern = re.compile('[a-zA-Z0-9_]');
+    reversed_text = text[ : : -1 ];
+    all_words = [];
+    current_word = [];
+    for char in reversed_text {
+        if valid_character_pattern.fullmatch(char) {
+            current_word.append(char);
+        } elif char == '.' {
+            if current_word {
+                all_words.append(''.join(current_word[ : : -1 ]));
+                current_word = [];
+            }
+        } elif current_word {
+            all_words.append(''.join(current_word[ : : -1 ]));
+            current_word = [];
+        }
+    }
+    all_words = all_words[ : : -1 ]
+    if not current_word
+    else ([''.join(current_word[ : : -1 ])] + all_words[ : : -1 ])
+    ;
+    return all_words;
+}
+
+
+"""Return the starting position of a token."""
+def get_token_start(
+    token_index: (int | None),
+    sem_tokens: <>list[int]
+) -> <>tuple[int, int, int] {
+    if token_index is None or token_index >= len(sem_tokens)  {
+        return (0, 0, 0);
+    }
+    current_line = 0;
+    current_char = 0;
+    current_tok_index = 0;
+    while current_tok_index < len(sem_tokens) {
+        token_line_delta = sem_tokens[current_tok_index];
+        token_start_char = sem_tokens[(current_tok_index + 1)];
+        if token_line_delta > 0 {
+            current_line += token_line_delta;
+            current_char = 0;
+        }
+        if current_tok_index == token_index {
+            if token_line_delta > 0 {
+                return (current_line,
+                token_start_char,
+                (token_start_char + sem_tokens[(current_tok_index + 2)]));
+            }
+            return (current_line,
+            (current_char + token_start_char),
+            ((current_char + token_start_char) + sem_tokens[(current_tok_index + 2)]));
+        }
+        current_char += token_start_char;
+        current_tok_index += 5;
+    }
+    return (current_line,
+    current_char,
+    (current_char + sem_tokens[(current_tok_index + 2)]));
+}
+
+
+"""Find the indices of the previous and next tokens surrounding the change."""
+def find_surrounding_tokens(
+    change_start_line: int,
+    change_start_char: int,
+    change_end_line: int,
+    change_end_char: int,
+    sem_tokens: <>list[int]
+) -> <>tuple[(int | None), (int | None), bool] {
+    prev_token_index = None;
+    next_token_index = None;
+    inside_tok = False;
+    for (i, tok) in enumerate([ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ][ 0 : ]) {
+        if (not (prev_token_index is None or next_token_index is None ))
+        and (tok[0] > change_end_line
+        or (tok[0] == change_end_line and tok[1] > change_end_char )
+        )
+         {
+            prev_token_index = (i * 5);
+            break;
+        } elif change_start_line == tok[0] == change_end_line
+        and tok[1] <= change_start_char
+        and tok[2] >= change_end_char
+         {
+            prev_token_index = (i * 5);
+            inside_tok = True;
+            break;
+        } elif tok[0] < change_start_line
+        or tok[0] == change_start_line and tok[1] < change_start_char
+         {
+            prev_token_index = (i * 5);
+        } elif tok[0] > change_end_line
+        or tok[0] == change_end_line and tok[1] > change_end_char
+         {
+            next_token_index = (i * 5);
+            break;
+        }
+    }
+    return (prev_token_index, next_token_index, inside_tok);
+}
+
+
+"""Get the line of code, and the first non-space character index."""
+def get_line_of_code(
+    line_number: int,
+    lines: <>list[str]
+) -> Optional[<>tuple[(str, int)]] {
+    if 0 <= line_number < len(lines) {
+        line = lines[line_number].rstrip('\n');
+        first_non_space = (len(line) - len(line.lstrip()));
+        return (line,
+        (first_non_space + 4)
+        if line.strip().endswith(('(', '{', '['))
+        else first_non_space
+        );
+    }
+    return None;
+}
+
+
+"""Add a new text edit to the changes dictionary if it is unique."""
+def add_unique_text_edit(
+    changes: <>dict[(str, <>list[lspt.TextEdit])],
+    key: str,
+    new_edit: lspt.TextEdit
+) -> None {
+    if key not in changes {
+        changes[key] = [new_edit];
+    } else {
+        for existing_edit in changes[key] {
+            if existing_edit.range.start == new_edit.range.start
+            and existing_edit.range.end == new_edit.range.end
+            and existing_edit.new_text == new_edit.new_text
+             {
+                return;
+            }
+        }
+        changes[key].append(new_edit);
+    }
+}

jaclang/runtimelib/{architype.py → archetype.py}

@@ -15,7 +15,7 @@ from uuid import UUID, uuid4
 
 logger = getLogger(__name__)
 
-TARCH = TypeVar("TARCH", bound="Architype")
+TARCH = TypeVar("TARCH", bound="Archetype")
 TANCH = TypeVar("TANCH", bound="Anchor")
 
 
@@ -70,7 +70,7 @@ class AnchorReport:
 class Anchor:
     """Object Anchor."""
 
-    architype: Architype
+    archetype: Archetype
     id: UUID = field(default_factory=uuid4)
     root: Optional[UUID] = None
     access: Permission = field(default_factory=Permission)
@@ -79,7 +79,7 @@ class Anchor:
 
     def is_populated(self) -> bool:
         """Check if state."""
-        return "architype" in self.__dict__
+        return "archetype" in self.__dict__
 
     def make_stub(self: TANCH) -> TANCH:
         """Return unsynced copy of anchor."""
@@ -90,8 +90,8 @@ class Anchor:
         return self
 
     def populate(self) -> None:
-        """Retrieve the Architype from db and return."""
-        from jaclang.plugin.feature import JacFeature as Jac
+        """Retrieve the Archetype from db and return."""
+        from jaclang.runtimelib.machine import JacMachineInterface as Jac
 
         jsrc = Jac.get_context().mem
 
@@ -117,13 +117,13 @@ class Anchor:
     def __getstate__(self) -> dict[str, Any]:  # NOTE: May be better type hinting
         """Serialize Anchor."""
         if self.is_populated():
-            unlinked = object.__new__(self.architype.__class__)
-            unlinked.__dict__.update(self.architype.__dict__)
+            unlinked = object.__new__(self.archetype.__class__)
+            unlinked.__dict__.update(self.archetype.__dict__)
             unlinked.__dict__.pop("__jac__", None)
 
             return {
                 "id": self.id,
-                "architype": unlinked,
+                "archetype": unlinked,
                 "root": self.root,
                 "access": self.access,
                 "persistent": self.persistent,
@@ -135,8 +135,8 @@ class Anchor:
         """Deserialize Anchor."""
         self.__dict__.update(state)
 
-        if self.is_populated() and self.architype:
-            self.architype.__jac__ = self
+        if self.is_populated() and self.archetype:
+            self.archetype.__jac__ = self
             self.hash = hash(dumps(self))
 
     def __repr__(self) -> str:
@@ -157,8 +157,8 @@ class Anchor:
         return AnchorReport(
             id=self.id.hex,
             context=(
-                asdict(self.architype)
-                if is_dataclass(self.architype) and not isinstance(self.architype, type)
+                asdict(self.archetype)
+                if is_dataclass(self.archetype) and not isinstance(self.archetype, type)
                 else {}
             ),
         )
@@ -179,7 +179,7 @@ class Anchor:
 class NodeAnchor(Anchor):
     """Node Anchor."""
 
-    architype: NodeArchitype
+    archetype: NodeArchetype
     edges: list[EdgeAnchor]
 
     def __getstate__(self) -> dict[str, object]:
@@ -196,7 +196,7 @@ class NodeAnchor(Anchor):
 class EdgeAnchor(Anchor):
     """Edge Anchor."""
 
-    architype: EdgeArchitype
+    archetype: EdgeArchetype
     source: NodeAnchor
     target: NodeAnchor
     is_undirected: bool
@@ -221,7 +221,7 @@ class EdgeAnchor(Anchor):
 class WalkerAnchor(Anchor):
     """Walker Anchor."""
 
-    architype: WalkerArchitype
+    archetype: WalkerArchetype
     path: list[NodeAnchor] = field(default_factory=list)
     next: list[NodeAnchor] = field(default_factory=list)
     ignores: list[NodeAnchor] = field(default_factory=list)
@@ -232,90 +232,114 @@ class WalkerAnchor(Anchor):
 class ObjectAnchor(Anchor):
     """Edge Anchor."""
 
-    architype: ObjectArchitype
+    archetype: ObjectArchetype
 
 
-class Architype:
-    """Architype Protocol."""
+@dataclass(eq=False, repr=False, kw_only=True)
+class Archetype:
+    """Archetype Protocol."""
+
+    _jac_entry_funcs_: ClassVar[list[DataSpatialFunction]] = []
+    _jac_exit_funcs_: ClassVar[list[DataSpatialFunction]] = []
 
-    _jac_entry_funcs_: ClassVar[list[DSFunc]]
-    _jac_exit_funcs_: ClassVar[list[DSFunc]]
+    @cached_property
+    def __jac__(self) -> Anchor:
+        """Create default anchor."""
+        return Anchor(archetype=self)
 
-    def __init__(self) -> None:
-        """Create default architype."""
-        self.__jac__ = Anchor(architype=self)
+    def __init_subclass__(cls) -> None:
+        """Configure subclasses."""
+        if not cls.__dict__.get("__jac_base__", False):
+            from jaclang import JacMachineInterface as _
+
+            _.make_archetype(cls)
 
     def __repr__(self) -> str:
-        """Override repr for architype."""
+        """Override repr for archetype."""
         return f"{self.__class__.__name__}"
 
 
-class NodeArchitype(Architype):
-    """Node Architype Protocol."""
+class NodeArchetype(Archetype):
+    """Node Archetype Protocol."""
 
-    __jac__: NodeAnchor
+    __jac_base__: ClassVar[bool] = True
 
-    def __init__(self) -> None:
-        """Create node architype."""
-        self.__jac__ = NodeAnchor(architype=self, edges=[])
+    @cached_property
+    def __jac__(self) -> NodeAnchor:
+        """Create default anchor."""
+        return NodeAnchor(archetype=self, edges=[])
 
 
-class EdgeArchitype(Architype):
-    """Edge Architype Protocol."""
+class EdgeArchetype(Archetype):
+    """Edge Archetype Protocol."""
 
+    __jac_base__: ClassVar[bool] = True
     __jac__: EdgeAnchor
 
 
-class WalkerArchitype(Architype):
-    """Walker Architype Protocol."""
+class WalkerArchetype(Archetype):
+    """Walker Archetype Protocol."""
 
-    __jac__: WalkerAnchor
+    __jac_async__: ClassVar[bool] = False
+    __jac_base__: ClassVar[bool] = True
 
-    def __init__(self) -> None:
-        """Create walker architype."""
-        self.__jac__ = WalkerAnchor(architype=self)
+    @cached_property
+    def __jac__(self) -> WalkerAnchor:
+        """Create default anchor."""
+        return WalkerAnchor(archetype=self)
 
 
-class ObjectArchitype(Architype):
-    """Walker Architype Protocol."""
+class ObjectArchetype(Archetype):
+    """Walker Archetype Protocol."""
 
-    __jac__: ObjectAnchor
+    __jac_base__: ClassVar[bool] = True
 
-    def __init__(self) -> None:
-        """Create walker architype."""
-        self.__jac__ = ObjectAnchor(architype=self)
+    @cached_property
+    def __jac__(self) -> ObjectAnchor:
+        """Create default anchor."""
+        return ObjectAnchor(archetype=self)
 
 
-class GenericEdge(EdgeArchitype):
+@dataclass(eq=False)
+class GenericEdge(EdgeArchetype):
     """Generic Edge."""
 
+    __jac_base__: ClassVar[bool] = True
 
-class Root(NodeArchitype):
+    def __repr__(self) -> str:
+        """Override repr for archetype."""
+        return f"{self.__class__.__name__}()"
+
+
+@dataclass(eq=False)
+class Root(NodeArchetype):
     """Generic Root Node."""
 
-    def __init__(self) -> None:
-        """Create root node."""
-        self.__jac__ = NodeAnchor(architype=self, persistent=True, edges=[])
+    __jac_base__: ClassVar[bool] = True
+
+    @cached_property
+    def __jac__(self) -> NodeAnchor:
+        """Create default anchor."""
+        return NodeAnchor(archetype=self, persistent=True, edges=[])
+
+    def __repr__(self) -> str:
+        """Override repr for archetype."""
+        return f"{self.__class__.__name__}()"
 
 
 @dataclass(eq=False)
-class DSFunc:
+class DataSpatialFunction:
     """Data Spatial Function."""
 
     name: str
-    func: Callable[[Any, Any], Any] | None = None
+    func: Callable[[Any, Any], Any]
 
     @cached_property
     def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
         """Get function parameter annotations."""
-        if self.func:
-            parameters = inspect.signature(self.func, eval_str=True).parameters
-            if len(parameters) >= 2:
-                second_param = list(parameters.values())[1]
-                ty = second_param.annotation
-                return ty if ty != inspect._empty else None
+        parameters = inspect.signature(self.func, eval_str=True).parameters
+        if len(parameters) >= 2:
+            second_param = list(parameters.values())[1]
+            ty = second_param.annotation
+            return ty if ty != inspect._empty else None
         return None
-
-    def resolve(self, cls: type) -> None:
-        """Resolve the function."""
-        self.func = getattr(cls, self.name)