agent-codinglanguage-mapper 1.0.0__py3-none-any.whl

agent_codinglanguage_mapper/lsp_service.py

@@ -0,0 +1,447 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import keyword
+from pathlib import Path
+import re
+from typing import Iterable
+from urllib.parse import unquote, urlparse
+
+from .indexer import build_workspace_snapshot
+from .models import Language, Problem, Resolution, SourceRange, Symbol
+from .workspace import WorkspaceSnapshot
+
+
+_IDENTIFIER_PATTERN = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+_DELPHI_LINKED_ROLES = frozenset({"declaration", "implementation"})
+_RUST_RESERVED_WORDS = frozenset(
+    """
+    Self _ abstract as async await become box break const continue crate do dyn else enum extern false final fn for gen
+    if impl in let loop macro match mod move mut override priv pub ref return self static struct super trait true try
+    type typeof unsafe unsized use virtual where while yield
+    """.split()
+)
+_CSHARP_RESERVED_WORDS = frozenset(
+    """
+    abstract as base bool break byte case catch char checked class const continue decimal default delegate do double
+    else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is
+    lock long namespace new null object operator out override params private protected public readonly ref return sbyte
+    sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe
+    ushort using virtual void volatile while
+    """.split()
+)
+_CPP_RESERVED_WORDS = frozenset(
+    """
+    alignas alignof and and_eq asm auto bitand bitor bool break case catch char char8_t char16_t char32_t class
+    compl concept const consteval constexpr constinit const_cast continue contract_assert co_await co_return co_yield
+    decltype default delete do double dynamic_cast else enum explicit export extern false float for friend goto if
+    inline int long mutable namespace new noexcept not not_eq nullptr operator or or_eq private protected public
+    register reinterpret_cast requires return short signed sizeof static static_assert static_cast struct switch template
+    this thread_local throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while
+    xor xor_eq
+    """.split()
+)
+_DELPHI_RESERVED_WORDS = frozenset(
+    """
+    and array as asm at automated begin case class const constructor destructor dispinterface div do downto else end
+    except exports file finalization finally for function goto if implementation in inherited initialization inline
+    interface is label library mod nil not object of on or packed private procedure program property protected public
+    published raise record repeat resourcestring set shl shr string then threadvar to try type unit until uses var while
+    with xor
+    """.split()
+)
+_RESERVED_WORDS = {
+    Language.RUST: _RUST_RESERVED_WORDS,
+    Language.CSHARP: _CSHARP_RESERVED_WORDS,
+    Language.CPP: _CPP_RESERVED_WORDS,
+    Language.DELPHI: _DELPHI_RESERVED_WORDS,
+}
+
+
+@dataclass(frozen=True)
+class TextEdit:
+    range: SourceRange
+    new_text: str
+
+
+class SafeRenameError(ValueError):
+    """Raised when a rename cannot be proven safe from indexed evidence."""
+
+
+class LanguageService:
+    def __init__(
+        self,
+        root: str | Path,
+        snapshot: WorkspaceSnapshot | None = None,
+        languages: Iterable[Language] | None = None,
+    ) -> None:
+        self.root = Path(root).expanduser().resolve()
+        self.languages = tuple(languages) if languages is not None else None
+        self._overrides: dict[str, str] = {}
+        self.snapshot = snapshot or build_workspace_snapshot(self.root, self.languages)
+
+    def update_document(self, path: str | Path, source: str) -> None:
+        relative = self.relative_path(path)
+        self._overrides[relative] = source
+        self.snapshot = build_workspace_snapshot(self.root, self.languages, self._overrides)
+
+    def close_document(self, path: str | Path) -> None:
+        relative = self.relative_path(path)
+        if relative in self._overrides:
+            del self._overrides[relative]
+            self.snapshot = build_workspace_snapshot(self.root, self.languages, self._overrides)
+
+    def definition(self, path: str | Path, line: int, character: int) -> SourceRange | None:
+        symbol = self.symbol_at(path, line, character)
+        return (symbol.name_range or symbol.range) if symbol is not None else None
+
+    def hover(self, path: str | Path, line: int, character: int) -> str | None:
+        symbol = self.symbol_at(path, line, character)
+        if symbol is None:
+            return None
+        signature = symbol.signature or symbol.qualified_name
+        return f"```{symbol.language.value}\n{signature}\n```\n{symbol.kind} in `{symbol.range.path}`"
+
+    def references(
+        self,
+        path: str | Path,
+        line: int,
+        character: int,
+        *,
+        include_declaration: bool = True,
+    ) -> tuple[SourceRange, ...]:
+        symbol = self.symbol_at(path, line, character)
+        if symbol is None:
+            return ()
+        linked_symbols = self._linked_rename_symbols(symbol, require_unique=False)
+        linked_target_ids = {item.target_id for item in linked_symbols}
+        ranges = [
+            item.range
+            for item in self.snapshot.references
+            if item.target_id in linked_target_ids
+        ]
+        if include_declaration:
+            ranges[0:0] = [item.name_range or item.range for item in linked_symbols]
+        return tuple(dict.fromkeys(ranges))
+
+    def rename(
+        self,
+        path: str | Path,
+        line: int,
+        character: int,
+        new_name: str,
+    ) -> dict[str, tuple[TextEdit, ...]]:
+        symbol = self.symbol_at(path, line, character)
+        if symbol is None:
+            raise SafeRenameError("no symbol at the requested position")
+        if symbol.name_range is None:
+            raise SafeRenameError("the declaration has no exact editable name range")
+        if not self._valid_identifier(symbol.language, new_name):
+            raise SafeRenameError(f"{new_name!r} is not a valid {symbol.language.value} identifier")
+        rename_symbols = self._linked_rename_symbols(symbol)
+        rename_target_ids = {item.target_id for item in rename_symbols}
+        rename_scopes = {(item.file_id, item.parent_id) for item in rename_symbols}
+        if any(
+            item.target_id not in rename_target_ids
+            and (item.file_id, item.parent_id) in rename_scopes
+            and item.language is symbol.language
+            and item.name.casefold() == new_name.casefold()
+            for item in self.snapshot.symbols
+        ):
+            raise SafeRenameError("the new name collides with a symbol in the same scope")
+
+        references = [item for item in self.snapshot.references if item.target_id in rename_target_ids]
+        matching_names = {self._simple_identifier(item.name).casefold() for item in rename_symbols}
+        uncertain = [
+            item
+            for item in self.snapshot.references
+            if item.language is symbol.language
+            and self._simple_identifier(item.name).casefold() in matching_names
+            and item.resolution is not Resolution.COMPLETE
+        ]
+        if uncertain or any(item.resolution is not Resolution.COMPLETE for item in references):
+            raise SafeRenameError("not every matching reference is uniquely resolved")
+
+        ranges: dict[SourceRange, str] = {}
+        for rename_symbol in rename_symbols:
+            if rename_symbol.name_range is None:
+                raise SafeRenameError("a linked declaration has no exact editable name range")
+            ranges[rename_symbol.name_range] = self._simple_identifier(rename_symbol.name)
+        for reference in references:
+            ranges[reference.range] = self._simple_identifier(reference.name)
+
+        edits: dict[str, list[TextEdit]] = {}
+        for source_range, expected_name in ranges.items():
+            if not self._identifier_text_matches(symbol.language, self._range_text(source_range), expected_name):
+                raise SafeRenameError("an indexed edit range no longer matches the symbol name")
+            edits.setdefault(source_range.path, []).append(TextEdit(source_range, new_name))
+        return {
+            file_name: tuple(sorted(values, key=lambda item: self._range_key(item.range), reverse=True))
+            for file_name, values in edits.items()
+        }
+
+    def document_symbols(self, path: str | Path) -> tuple[Symbol, ...]:
+        relative = self.relative_path(path)
+        selected: dict[tuple[object, ...], Symbol] = {}
+        for item in self.snapshot.symbols:
+            if item.kind == "module" or self.relative_path(item.range.path) != relative:
+                continue
+            anchor = item.name_range or item.range
+            key = (
+                item.qualified_name,
+                item.kind,
+                anchor.start_line,
+                anchor.start_character,
+                anchor.end_line,
+                anchor.end_character,
+            )
+            selected.setdefault(key, item)
+        return tuple(selected.values())
+
+    def workspace_symbols(self, query: str = "") -> tuple[Symbol, ...]:
+        folded = query.casefold().strip()
+        return tuple(
+            item
+            for item in self.snapshot.symbols
+            if item.kind != "module" and (not folded or folded in item.qualified_name.casefold())
+        )
+
+    def completions(self, path: str | Path, prefix: str = "") -> tuple[Symbol, ...]:
+        relative = self.relative_path(path)
+        source_file = next((item for item in self.snapshot.files if item.path == relative), None)
+        if source_file is None:
+            return ()
+        folded = prefix.casefold()
+        seen: set[str] = set()
+        result: list[Symbol] = []
+        for item in self.snapshot.symbols:
+            if item.project_id != source_file.project_id or item.language is not source_file.language:
+                continue
+            if item.kind == "module" or (folded and not item.name.casefold().startswith(folded)):
+                continue
+            key = item.name.casefold()
+            if key not in seen:
+                seen.add(key)
+                result.append(item)
+        return tuple(result)
+
+    def diagnostics(self, path: str | Path) -> tuple[Problem, ...]:
+        relative = self.relative_path(path)
+        return tuple(
+            item
+            for item in self.snapshot.problems
+            if (
+                item.range is not None and self.relative_path(item.range.path) == relative
+                or item.range is None and item.metadata.get("path") == relative
+            )
+        )
+
+    def symbol_at(self, path: str | Path, line: int, character: int) -> Symbol | None:
+        relative = self.relative_path(path)
+        references = [
+            item
+            for item in self.snapshot.references
+            if self.relative_path(item.range.path) == relative and self._contains(item.range, line, character)
+        ]
+        if references:
+            reference = min(references, key=lambda item: self._span(item.range))
+            return self.snapshot.symbols_by_id.get(reference.target_id) if reference.target_id else None
+        symbols = [
+            item
+            for item in self.snapshot.symbols
+            if self.relative_path(item.range.path) == relative
+            and self._contains(item.name_range or item.range, line, character)
+        ]
+        return min(symbols, key=lambda item: self._span(item.name_range or item.range)) if symbols else None
+
+    def relative_path(self, path: str | Path) -> str:
+        text = str(path)
+        parsed = urlparse(text)
+        if parsed.scheme == "file":
+            text = unquote(parsed.path)
+            if re.match(r"^/[A-Za-z]:/", text):
+                text = text[1:]
+        candidate = Path(text)
+        if candidate.is_absolute():
+            try:
+                return candidate.resolve().relative_to(self.root).as_posix()
+            except ValueError:
+                return candidate.as_posix()
+        return candidate.as_posix()
+
+    def path_uri(self, path: str) -> str:
+        candidate = Path(path)
+        return (candidate if candidate.is_absolute() else self.root / candidate).resolve().as_uri()
+
+    @staticmethod
+    def _contains(source_range: SourceRange, line: int, character: int) -> bool:
+        position = (line, character)
+        return (source_range.start_line, source_range.start_character) <= position < (
+            source_range.end_line,
+            source_range.end_character,
+        )
+
+    @staticmethod
+    def _span(source_range: SourceRange) -> tuple[int, int]:
+        return (
+            source_range.end_line - source_range.start_line,
+            source_range.end_character - source_range.start_character,
+        )
+
+    @staticmethod
+    def _range_key(source_range: SourceRange) -> tuple[int, int, int, int]:
+        return (
+            source_range.start_line,
+            source_range.start_character,
+            source_range.end_line,
+            source_range.end_character,
+        )
+
+    def _range_text(self, source_range: SourceRange) -> str:
+        source = self._overrides.get(source_range.path)
+        if source is None:
+            source = (self.root / source_range.path).read_text(encoding="utf-8", errors="replace")
+        lines = source.splitlines(keepends=True)
+        if not lines:
+            lines = [""]
+        elif source.endswith(("\r", "\n")):
+            lines.append("")
+        if (
+            source_range.start_line < 0
+            or source_range.end_line < source_range.start_line
+            or source_range.end_line >= len(lines)
+        ):
+            return ""
+
+        start_line = lines[source_range.start_line]
+        end_line = lines[source_range.end_line]
+        start_content = self._without_line_ending(start_line)
+        end_content = self._without_line_ending(end_line)
+        start = self._utf16_character_to_index(start_content, source_range.start_character)
+        end = self._utf16_character_to_index(end_content, source_range.end_character)
+        if start is None or end is None:
+            return ""
+        if source_range.start_line == source_range.end_line:
+            return start_content[start:end]
+        return "".join(
+            (
+                start_line[start:],
+                *lines[source_range.start_line + 1 : source_range.end_line],
+                end_content[:end],
+            )
+        )
+
+    @staticmethod
+    def _utf16_character_to_index(line: str, character: int) -> int | None:
+        if character < 0:
+            return None
+        utf16_character = 0
+        for index, value in enumerate(line):
+            if utf16_character == character:
+                return index
+            utf16_character += 2 if ord(value) > 0xFFFF else 1
+            if utf16_character > character:
+                return None
+        return len(line) if utf16_character == character else None
+
+    @staticmethod
+    def _without_line_ending(line: str) -> str:
+        if line.endswith("\r\n"):
+            return line[:-2]
+        if line.endswith(("\r", "\n")):
+            return line[:-1]
+        return line
+
+    def _linked_rename_symbols(
+        self,
+        symbol: Symbol,
+        *,
+        require_unique: bool = True,
+    ) -> tuple[Symbol, ...]:
+        if symbol.language is not Language.DELPHI:
+            return (symbol,)
+
+        simple_name = self._simple_identifier(symbol.name).casefold()
+        signature_key = self._normalized_delphi_signature(symbol)
+        selected_ids = {symbol.target_id}
+        while True:
+            expanded_ids = set(selected_ids)
+            for target_id in selected_ids:
+                expanded_ids.update(
+                    item.target_id
+                    for item in self.snapshot.symbol_aliases_by_id.get(target_id, ())
+                )
+            if symbol.role in _DELPHI_LINKED_ROLES:
+                context_file_ids = {
+                    item.file_id
+                    for item in self.snapshot.symbols
+                    if item.target_id in expanded_ids
+                }
+                expanded_ids.update(
+                    item.target_id
+                    for item in self.snapshot.symbols
+                    if item.language is Language.DELPHI
+                    and item.file_id in context_file_ids
+                    and item.qualified_name.casefold() == symbol.qualified_name.casefold()
+                    and item.kind == symbol.kind
+                    and item.role in _DELPHI_LINKED_ROLES
+                    and self._simple_identifier(item.name).casefold() == simple_name
+                    and self._normalized_delphi_signature(item) == signature_key
+                )
+            if expanded_ids == selected_ids:
+                break
+            selected_ids = expanded_ids
+
+        candidates = tuple(
+            item for item in self.snapshot.symbols if item.target_id in selected_ids
+        )
+        if require_unique:
+            role_counts: dict[tuple[str, str], int] = {}
+            for item in candidates:
+                if item.role not in _DELPHI_LINKED_ROLES:
+                    continue
+                key = (item.file_id, item.role)
+                role_counts[key] = role_counts.get(key, 0) + 1
+            if any(count > 1 for count in role_counts.values()):
+                raise SafeRenameError(
+                    "the Delphi declaration and implementation cannot be linked uniquely"
+                )
+        return candidates
+
+    @staticmethod
+    def _normalized_delphi_signature(symbol: Symbol) -> str:
+        signature = " ".join(symbol.signature.casefold().split())
+        indexed_name = symbol.name.casefold()
+        simple_name = symbol.qualified_name.rsplit(".", 1)[-1].casefold()
+        signature = signature.replace(indexed_name, simple_name, 1)
+
+        depth = 0
+        for index, character in enumerate(signature):
+            if character == "(":
+                depth += 1
+            elif character == ")" and depth:
+                depth -= 1
+            elif character == ";" and depth == 0:
+                signature = signature[:index]
+                break
+        return "".join(signature.split())
+
+    @staticmethod
+    def _simple_identifier(name: str) -> str:
+        return name.rsplit(".", 1)[-1]
+
+    @staticmethod
+    def _identifier_text_matches(language: Language, actual: str, expected: str) -> bool:
+        if language is Language.DELPHI:
+            return actual.casefold() == expected.casefold()
+        return actual == expected
+
+    @staticmethod
+    def _valid_identifier(language: Language, name: str) -> bool:
+        if language is Language.PYTHON:
+            return name.isidentifier() and not keyword.iskeyword(name)
+        if _IDENTIFIER_PATTERN.fullmatch(name) is None:
+            return False
+        if language is Language.DELPHI:
+            return name.casefold() not in _RESERVED_WORDS[language]
+        return name not in _RESERVED_WORDS[language]