avrae-ls 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

avrae_ls/symbols.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import ast
+import logging
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Optional
+
+import draconic
+from lsprotocol import types
+
+from .argument_parsing import apply_argument_parsing
+from .parser import find_draconic_blocks
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class SymbolEntry:
+    name: str
+    kind: types.SymbolKind
+    range: types.Range
+    selection_range: types.Range
+
+
+class SymbolTable:
+    def __init__(self, entries: List[SymbolEntry]):
+        self._entries = entries
+        self._index: Dict[str, SymbolEntry] = {entry.name: entry for entry in entries}
+
+    @property
+    def entries(self) -> List[SymbolEntry]:
+        return self._entries
+
+    def lookup(self, name: str) -> Optional[SymbolEntry]:
+        return self._index.get(name)
+
+
+def build_symbol_table(source: str) -> SymbolTable:
+    entries: list[SymbolEntry] = []
+    parsed_source = apply_argument_parsing(source)
+    blocks = find_draconic_blocks(parsed_source)
+    if not blocks:
+        entries.extend(_symbols_from_code(parsed_source, 0, 0))
+    else:
+        for block in blocks:
+            entries.extend(_symbols_from_code(block.code, block.line_offset, block.char_offset))
+    return SymbolTable(entries)
+
+
+def document_symbols(source: str) -> List[types.DocumentSymbol]:
+    table = build_symbol_table(source)
+    return [
+        types.DocumentSymbol(
+            name=entry.name,
+            kind=entry.kind,
+            range=entry.range,
+            selection_range=entry.selection_range,
+        )
+        for entry in table.entries
+    ]
+
+
+def find_definition_range(table: SymbolTable, name: str) -> types.Range | None:
+    entry = table.lookup(name)
+    if entry:
+        return entry.selection_range
+    return None
+
+
+def find_references(
+    table: SymbolTable, source: str, name: str, include_declaration: bool = True
+) -> List[types.Range]:
+    parsed_source = apply_argument_parsing(source)
+    ranges: list[types.Range] = []
+    entry = table.lookup(name)
+    include_stores = include_declaration and entry is None
+    if include_declaration:
+        if entry:
+            ranges.append(entry.selection_range)
+
+    blocks = find_draconic_blocks(parsed_source)
+    if not blocks:
+        ranges.extend(_references_from_code(parsed_source, name, 0, 0, include_stores))
+    else:
+        for block in blocks:
+            ranges.extend(
+                _references_from_code(block.code, name, block.line_offset, block.char_offset, include_stores)
+            )
+    return _dedupe_ranges(ranges)
+
+
+def range_for_word(source: str, position: types.Position) -> types.Range | None:
+    lines = source.splitlines()
+    if position.line >= len(lines):
+        return None
+    line = lines[position.line]
+    if position.character > len(line):
+        return None
+
+    def _is_ident(ch: str) -> bool:
+        return ch.isalnum() or ch == "_"
+
+    start_idx = position.character
+    while start_idx > 0 and _is_ident(line[start_idx - 1]):
+        start_idx -= 1
+
+    end_idx = position.character
+    while end_idx < len(line) and _is_ident(line[end_idx]):
+        end_idx += 1
+
+    if start_idx == end_idx:
+        return None
+
+    return types.Range(
+        start=types.Position(line=position.line, character=start_idx),
+        end=types.Position(line=position.line, character=end_idx),
+    )
+
+
+def _symbols_from_code(code: str, line_offset: int, char_offset: int) -> List[SymbolEntry]:
+    body, offset_adjust = _parse_draconic(code)
+    if not body:
+        return []
+
+    local_offset = line_offset + offset_adjust
+
+    entries: list[SymbolEntry] = []
+    for node in body:
+        entry = _entry_from_node(node, local_offset, char_offset)
+        if entry:
+            entries.append(entry)
+    return entries
+
+
+def _entry_from_node(node: ast.AST, line_offset: int = 0, char_offset: int = 0) -> SymbolEntry | None:
+    if isinstance(node, ast.FunctionDef):
+        kind = types.SymbolKind.Function
+        name = node.name
+    elif isinstance(node, ast.ClassDef):
+        kind = types.SymbolKind.Class
+        name = node.name
+    elif isinstance(node, ast.Assign) and node.targets:
+        target = node.targets[0]
+        if isinstance(target, ast.Name):
+            kind = types.SymbolKind.Variable
+            name = target.id
+            node = target
+        else:
+            return None
+    elif isinstance(node, ast.AnnAssign):
+        target = node.target
+        if isinstance(target, ast.Name):
+            kind = types.SymbolKind.Variable
+            name = target.id
+            node = target
+        else:
+            return None
+    else:
+        return None
+
+    rng = _range_from_positions(
+        getattr(node, "lineno", 1),
+        getattr(node, "col_offset", 0),
+        getattr(node, "end_lineno", None),
+        getattr(node, "end_col_offset", None),
+    )
+    rng = _shift_range(rng, line_offset, char_offset)
+    return SymbolEntry(name=name, kind=kind, range=rng, selection_range=rng)
+
+
+class _ReferenceCollector(ast.NodeVisitor):
+    def __init__(self, target: str, include_stores: bool):
+        super().__init__()
+        self._target = target
+        self._include_stores = include_stores
+        self.ranges: list[types.Range] = []
+
+    def visit_Name(self, node: ast.Name):  # type: ignore[override]
+        if node.id == self._target:
+            if isinstance(node.ctx, ast.Store) and not self._include_stores:
+                return
+            rng = _range_from_positions(
+                getattr(node, "lineno", 1),
+                getattr(node, "col_offset", 0),
+                getattr(node, "end_lineno", None),
+                getattr(node, "end_col_offset", None),
+            )
+            self.ranges.append(rng)
+        self.generic_visit(node)
+
+
+def _references_from_code(
+    code: str,
+    name: str,
+    line_offset: int,
+    char_offset: int,
+    include_stores: bool,
+) -> List[types.Range]:
+    body, offset_adjust = _parse_draconic(code)
+    if not body:
+        return []
+
+    collector = _ReferenceCollector(name, include_stores)
+    for node in body:
+        collector.visit(node)
+
+    local_offset = line_offset + offset_adjust
+    return [_shift_range(rng, local_offset, char_offset) for rng in collector.ranges]
+
+
+def _parse_draconic(code: str) -> tuple[list[ast.AST], int]:
+    parser = draconic.DraconicInterpreter()
+    try:
+        return parser.parse(code), 0
+    except draconic.DraconicSyntaxError:
+        wrapped, added = _wrap_draconic(code)
+        try:
+            return parser.parse(wrapped), -added
+        except draconic.DraconicSyntaxError:
+            return [], 0
+    except Exception as exc:  # pragma: no cover - defensive
+        log.debug("Symbol extraction failed: %s", exc)
+        return [], 0
+
+
+def _range_from_positions(
+    lineno: int | None,
+    col_offset: int | None,
+    end_lineno: int | None,
+    end_col_offset: int | None,
+) -> types.Range:
+    start_line = max((lineno or 1) - 1, 0)
+    start_char = max(col_offset or 0, 0)
+    end_line = max(((end_lineno or lineno or 1) - 1), 0)
+    raw_end_char = end_col_offset if end_col_offset is not None else col_offset
+    end_char = max(raw_end_char or start_char, start_char)
+    if end_char <= start_char:
+        end_char = start_char + 1
+    return types.Range(
+        start=types.Position(line=start_line, character=start_char),
+        end=types.Position(line=end_line, character=end_char),
+    )
+
+
+def _shift_range(rng: types.Range, line_offset: int, char_offset: int = 0) -> types.Range:
+    start_char = rng.start.character + (char_offset if rng.start.line == 0 else 0)
+    end_char = rng.end.character + (char_offset if rng.end.line == 0 else 0)
+    if line_offset == 0:
+        return types.Range(
+            start=types.Position(line=rng.start.line, character=start_char),
+            end=types.Position(line=rng.end.line, character=end_char),
+        )
+    return types.Range(
+        start=types.Position(line=max(rng.start.line + line_offset, 0), character=max(start_char, 0)),
+        end=types.Position(line=max(rng.end.line + line_offset, 0), character=max(end_char, 0)),
+    )
+
+
+def _wrap_draconic(code: str) -> tuple[str, int]:
+    indented = "\n".join(f"    {line}" for line in code.splitlines())
+    wrapped = f"def __alias_main__():\n{indented}\n__alias_main__()"
+    return wrapped, 1
+
+
+def _dedupe_ranges(ranges: Iterable[types.Range]) -> List[types.Range]:
+    seen = set()
+    unique: list[types.Range] = []
+    for rng in ranges:
+        key = (rng.start.line, rng.start.character, rng.end.line, rng.end.character)
+        if key in seen:
+            continue
+        seen.add(key)
+        unique.append(rng)
+    return unique

{avrae_ls-0.6.0.dist-info → avrae_ls-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrae-ls
-Version: 0.6.0
+Version: 0.6.2
 Summary: Language server for Avrae draconic aliases
 Author: 1drturtle
 License: MIT License

avrae_ls-0.6.2.dist-info/RECORD

@@ -0,0 +1,34 @@
+avrae_ls/__init__.py,sha256=BmjrnksGkbG7TPqwbyQvgYj9uei8pFSFpfkRpaGVdJU,63
+avrae_ls/__main__.py,sha256=N0Q61dKDCPd8RK-DnviK-44b949GzNBYi3nDuS4xxLE,8668
+avrae_ls/alias_preview.py,sha256=pSDTZVmcZZbUqCxyCryVWFSGdN8p0fLkR4IqbHxgNMs,12376
+avrae_ls/alias_tests.py,sha256=JFaWApVqxsHoF4QDm98kbYZRPTy5_QhsmUJq2kWV_I4,11917
+avrae_ls/api.py,sha256=7QVJAmqgKkiS22qj39_aSVsDuO_kUkyl2Ho1IsD58yE,65110
+avrae_ls/argparser.py,sha256=DRptXGyK4f0r7NsuV1Sg4apG-qihIClOX408jgk4HH4,13762
+avrae_ls/argument_parsing.py,sha256=ezKl65VwuNEDxt6KlYwVQcpy1110UDvf4BqZqgZTcqk,2122
+avrae_ls/code_actions.py,sha256=CYl3nMzCaE9k35p5fWAmzsTOVfcv2RrkA3SbtyCdcsI,9423
+avrae_ls/codes.py,sha256=iPRPQ6i9DZheae4_ra1y29vCw3Y4SEu6Udf5WiZj_RY,136
+avrae_ls/completions.py,sha256=FO9LCT1E5upSr23j0lUa_h_J1QN7ET9Yl_jLcWE97m0,64023
+avrae_ls/config.py,sha256=B_WqsF2lWKsalWoEhogL9sxSym9r-XcPuo_Uyi27cl0,16984
+avrae_ls/context.py,sha256=c18vdkuxKlPjPIogtWhJjbuynKLmgybD-VUkG46ooKM,12205
+avrae_ls/cvars.py,sha256=0tcVbUHx_CKJ6aou3kEsKX37LRWAjkUWlqqIuSRFlXk,3197
+avrae_ls/diagnostics.py,sha256=x5sZmpgje3G6UfOub2nQFv10lfjTb_7Qn_2SjqiGfLY,28072
+avrae_ls/dice.py,sha256=DY7V7L-EwAXaCgddgVe9xU1s9lVtiw5Zc2reipNgdTk,874
+avrae_ls/parser.py,sha256=iwdITmiBqRTszxI5avjzD-P0nrRQb1Hv5AiWl603_DU,2201
+avrae_ls/runtime.py,sha256=2IbdZNZ7VCpjuU1lbbp8jTtroE6w7ii-r_erebJUl-A,26339
+avrae_ls/server.py,sha256=pY4kIYUWY1q-yks9GEaHvsZk8ObwZRFMLG9cHtiEP70,17025
+avrae_ls/signature_help.py,sha256=VSuLDExEEeNDc7yQZ_R6LXUcc95ErNCzoekiuMYEF6o,8654
+avrae_ls/symbols.py,sha256=9oKcAHeHq1_hx2waKsfT5EWrcngXJdjYXcImAE4ingg,8672
+draconic/LICENSE,sha256=Fzvu32_DafLKKn2mzxhEdlmrKZzAsigDZ87O7uoVqZI,1067
+draconic/__init__.py,sha256=YPH420Pcn_nTkfB62hJy_YqC5kpJdzSa78jP8n4z_xY,109
+draconic/exceptions.py,sha256=siahnHIsumbaUhKBDSrw_DmLZ-0oZks8L5oytPH8hD4,3753
+draconic/helpers.py,sha256=jY-f9KHWP0ey2q09g6QsbtVxxet8LoQoZ8mAfju1E5c,9470
+draconic/interpreter.py,sha256=ksL7qHwXmXsvSqf685xFEnzVLng6AZ2ewk1z7ymbKtc,42004
+draconic/string.py,sha256=kGrRc6wNHRq1y5xw8Os-fBhfINDtIY2nBWQWkyLSfQI,2858
+draconic/types.py,sha256=1Lsr6z8bW5agglGI4hLt_nPtYuZOIf_ueSpPDB4WDrs,13686
+draconic/utils.py,sha256=D4vJ-txqS2-rlqsEpXAC46_j1sZX4UjY-9zIgElo96k,3122
+draconic/versions.py,sha256=CUEsgUWjAmjez0432WwiBwZlIzWPIObwZUf8Yld18EE,84
+avrae_ls-0.6.2.dist-info/METADATA,sha256=R98dZGMitru9ZaX4XauObRgPA3G7sdOnHtvjmGOVkrI,7163
+avrae_ls-0.6.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+avrae_ls-0.6.2.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
+avrae_ls-0.6.2.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+avrae_ls-0.6.2.dist-info/RECORD,,

draconic/__init__.py

@@ -0,0 +1,4 @@
+from .exceptions import *
+from .helpers import DraconicConfig
+from .interpreter import *
+from . import utils

draconic/exceptions.py

@@ -0,0 +1,157 @@
+import abc
+import ast
+
+from .versions import PY_310
+
+__all__ = (
+    "DraconicException",
+    "DraconicSyntaxError",
+    "InvalidExpression",
+    "NotDefined",
+    "FeatureNotAvailable",
+    "DraconicValueError",
+    "LimitException",
+    "NumberTooHigh",
+    "IterableTooLong",
+    "TooManyStatements",
+    "TooMuchRecursion",
+    "WrappedException",
+    "AnnotatedException",
+    "NestedException",
+    "_PostponedRaise",
+    "_raise_in_context",
+)
+
+
+class DraconicException(Exception):
+    """Base exception for all exceptions in this library."""
+
+    __drac_context__: str = None
+
+    def __init__(self, msg):
+        super().__init__(msg)
+        self.msg = msg
+
+
+class DraconicSyntaxError(DraconicException):
+    """Bad syntax."""
+
+    def __init__(self, original: SyntaxError, expr):
+        super().__init__(original.msg)
+        self.lineno = original.lineno
+        self.offset = original.offset
+        self.end_lineno = None
+        self.end_offset = None
+        self.expr = expr
+
+        if PY_310:
+            self.end_lineno = original.end_lineno
+            self.end_offset = original.end_offset
+
+    @classmethod
+    def from_node(cls, node: ast.AST, msg: str, expr):
+        if PY_310:
+            inner = SyntaxError(
+                msg, ("<string>", node.lineno, node.col_offset + 1, expr, node.end_lineno, node.end_col_offset + 1)
+            )
+        else:
+            inner = SyntaxError(msg, ("<string>", node.lineno, node.col_offset + 1, expr))
+        return cls(inner, expr)
+
+
+class InvalidExpression(DraconicException):
+    """Base exception for all exceptions during run-time."""
+
+    def __init__(self, msg, node, expr):
+        super().__init__(msg)
+        self.node = node
+        self.expr = expr
+
+
+class NotDefined(InvalidExpression):
+    """Some name is not defined."""
+
+    pass
+
+
+class FeatureNotAvailable(InvalidExpression):
+    """What you're trying to do is not allowed."""
+
+    pass
+
+
+class DraconicValueError(InvalidExpression):
+    """Bad value passed to some function."""
+
+    pass
+
+
+class LimitException(InvalidExpression):
+    """
+    Something exceeded execution limits.
+    """
+
+    pass
+
+
+class NumberTooHigh(LimitException):
+    """Some number is way too big."""
+
+    pass
+
+
+class IterableTooLong(LimitException):
+    """Some iterable is way too big."""
+
+    pass
+
+
+class TooManyStatements(LimitException):
+    """Tried to execute too many statements."""
+
+    pass
+
+
+class TooMuchRecursion(LimitException):
+    """Too deep in recursion."""
+
+    pass
+
+
+class WrappedException(InvalidExpression, abc.ABC):
+    """abstract base exception for a lib exception that wraps some other exception"""
+
+    original: BaseException
+
+
+class AnnotatedException(WrappedException):
+    """A wrapper for another exception to handle lineno info."""
+
+    def __init__(self, original, node, expr):
+        super().__init__(str(original), node, expr)
+        self.original = original
+
+
+class NestedException(WrappedException):
+    """An exception occurred in a user-defined function call."""
+
+    def __init__(self, msg, node, expr, last_exc):
+        super().__init__(msg, node, expr)
+        self.last_exc = last_exc  # type: DraconicException  # used for tracebacking
+        # keep a reference to the end of the chain for easy comparison
+        if isinstance(last_exc, WrappedException):
+            self.original = last_exc.original
+        else:
+            self.original = last_exc
+
+
+# we need to raise some exception, but don't have the node context right now
+class _PostponedRaise(Exception):
+    def __init__(self, cls, *args, **kwargs):
+        self.cls = cls
+        self.args = args
+        self.kwargs = kwargs
+
+
+def _raise_in_context(cls, *args, **kwargs):
+    raise _PostponedRaise(cls, *args, **kwargs)