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

agent_codinglanguage_mapper/adapters/delphi.py

@@ -0,0 +1,822 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from pathlib import Path
+import re
+from typing import Iterable, Iterator
+
+from ..models import Language, Problem, Reference, Relation, Resolution, SourceRange, Symbol
+from ..workspace import stable_id
+from .delphi_frontend.lsp_server import (
+    _mask_delphi_comments_and_strings,
+    build_outline_semantic_model,
+    outline_source,
+)
+from .delphi_frontend.parser import DelphiParser
+from .delphi_frontend.preprocessor import PreprocessedSource, Preprocessor
+from .delphi_frontend.semantic import Modifier, ReferenceKind, Scope, Symbol as DelphiSymbol
+from .delphi_frontend.semantic_builder import SemanticModel
+from .delphi_frontend.source_reader import read_source_text
+from .tree_sitter import AdapterResult
+
+
+_DELPHI_SECTION = re.compile(r"\b(interface|implementation)\b", re.IGNORECASE)
+_DELPHI_IMPLEMENTABLE_KINDS = {"constructor", "destructor", "function", "method", "procedure"}
+_DELPHI_INCLUDE = re.compile(
+    r"\{\$\s*(?:I|INCLUDE)\b(?P<brace>[^}]*)\}|\(\*\$\s*(?:I|INCLUDE)\b(?P<paren>.*?)\*\)",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True)
+class DelphiDocument:
+    path: str
+    source: str
+    outline_model: SemanticModel
+    detail_model: SemanticModel | None = None
+    parse_count: int = 0
+    dependencies: tuple[str, ...] = ()
+
+
+class DelphiAdapter:
+    language = Language.DELPHI
+    extensions: tuple[str, ...] = (".pas", ".dpr", ".dpk", ".inc")
+
+    def __init__(
+        self,
+        *,
+        include_paths: Iterable[str] = (),
+        defines: Iterable[str] = (),
+        workspace_root: str | Path | None = None,
+    ) -> None:
+        self._include_paths = tuple(include_paths)
+        self._defines = tuple(defines)
+        self._workspace_root = (
+            Path(workspace_root).expanduser().resolve() if workspace_root is not None else None
+        )
+
+    def detect(self, path: str | Path) -> bool:
+        return Path(path).suffix.casefold() in self.extensions
+
+    def parse_outline(self, path: str | Path, source: str) -> AdapterResult:
+        path_text = str(path)
+        preprocessed: PreprocessedSource | None = None
+        outline_input = source
+        if "{$" in source or "(*$" in source:
+            preprocessed = Preprocessor(
+                defines=self._defines,
+                include_paths=self._include_paths,
+                workspace_root=self._workspace_root,
+            ).process(source, path_text)
+            outline_input = preprocessed.text
+        model = build_outline_semantic_model(outline_source(outline_input), path_text)
+        document = DelphiDocument(
+            path_text,
+            source,
+            model,
+            dependencies=preprocessed.included_files if preprocessed is not None else (),
+        )
+        symbols, _, _ = self._convert_model(model, source, path_text, preprocessed)
+        return AdapterResult(
+            symbols=symbols,
+            problems=self._preprocessor_problems(preprocessed) if preprocessed is not None else (),
+            document=document,
+        )
+
+    def parse_detail(self, path: str | Path, source: str, outline: AdapterResult) -> AdapterResult:
+        path_text = str(path)
+        current = outline.document
+        if not isinstance(current, DelphiDocument) or current.path != path_text or current.source != source:
+            current = DelphiDocument(path_text, source, build_outline_semantic_model(outline_source(source), path_text))
+        preprocessed = Preprocessor(
+            defines=self._defines,
+            include_paths=self._include_paths,
+            workspace_root=self._workspace_root,
+        ).process(source, path_text)
+        try:
+            parsed = DelphiParser(
+                include_paths=self._include_paths,
+                defines=self._defines,
+                workspace_root=self._workspace_root,
+            ).parse(
+                source,
+                path_text,
+                build_semantic=True,
+                preprocessed_source=preprocessed,
+            )
+            assert parsed.semantic is not None
+        except Exception as exc:
+            syntax_range = self._syntax_error_range(exc, preprocessed)
+            problem = Problem(
+                "syntax-error",
+                f"Delphi parser rejected the source: {exc}",
+                "error",
+                Language.DELPHI,
+                syntax_range,
+                metadata={
+                    "parser": "delphi_frontend",
+                    "error": type(exc).__name__,
+                    "path": syntax_range.path if syntax_range is not None else path_text,
+                },
+            )
+            problems = list(outline.problems)
+            for preprocessor_problem in self._preprocessor_problems(preprocessed):
+                if preprocessor_problem not in problems:
+                    problems.append(preprocessor_problem)
+            if problem not in problems:
+                problems.append(problem)
+            return replace(
+                outline,
+                problems=tuple(problems),
+                document=replace(current, dependencies=preprocessed.included_files),
+            )
+
+        document = replace(
+            current,
+            detail_model=parsed.semantic,
+            parse_count=current.parse_count + 1,
+            dependencies=parsed.preprocessed.included_files,
+        )
+        symbols, references, relations = self._convert_model(
+            parsed.semantic,
+            source,
+            path_text,
+            parsed.preprocessed,
+        )
+        problems = list(outline.problems)
+        for problem in self._preprocessor_problems(parsed.preprocessed):
+            if problem not in problems:
+                problems.append(problem)
+        for semantic_problem in parsed.semantic.problems:
+            problems.append(
+                Problem(
+                    "semantic-unresolved",
+                    semantic_problem.message,
+                    "warning",
+                    Language.DELPHI,
+                    self._mapped_range(semantic_problem.range, parsed.preprocessed),
+                )
+            )
+        return AdapterResult(symbols, references, relations, tuple(problems), document)
+
+    @staticmethod
+    def _preprocessor_problems(preprocessed: PreprocessedSource) -> tuple[Problem, ...]:
+        problems: list[Problem] = []
+        for item in preprocessed.problems:
+            start_line = max(0, item.line - 1)
+            start_character = max(0, item.col - 1)
+            problems.append(
+                Problem(
+                    f"preprocessor-{item.kind}",
+                    item.message,
+                    "warning",
+                    Language.DELPHI,
+                    SourceRange(
+                        item.file_name,
+                        start_line,
+                        start_character,
+                        start_line,
+                        start_character + 1,
+                    ),
+                    metadata={"parser": "delphi_frontend", "path": item.file_name},
+                )
+            )
+        return tuple(problems)
+
+    @staticmethod
+    def _syntax_error_range(
+        error: Exception,
+        preprocessed: PreprocessedSource,
+    ) -> SourceRange | None:
+        line = getattr(error, "line", None)
+        column = getattr(error, "column", None)
+        token = getattr(error, "token", None)
+        if not isinstance(line, int) and token is not None:
+            line = getattr(token, "line", None)
+        if not isinstance(column, int) and token is not None:
+            column = getattr(token, "column", None)
+        if not isinstance(line, int) or not isinstance(column, int):
+            return None
+        path, mapped_line, mapped_character = preprocessed.map_position(line, max(0, column - 1))
+        if not path:
+            return None
+        return SourceRange(
+            path,
+            max(0, mapped_line - 1),
+            max(0, mapped_character),
+            max(0, mapped_line - 1),
+            max(0, mapped_character) + 1,
+        )
+
+    def resolve(self, result: AdapterResult) -> AdapterResult:
+        return result
+
+    def _convert_model(
+        self,
+        model: SemanticModel,
+        source: str,
+        path: str,
+        preprocessed: PreprocessedSource | None = None,
+    ) -> tuple[tuple[Symbol, ...], tuple[Reference, ...], tuple[Relation, ...]]:
+        converted: list[Symbol] = []
+        source_symbols: dict[int, Symbol] = {}
+        parent_by_source: dict[int, str] = {}
+        seen: set[int] = set()
+        semantic_source = preprocessed.text if preprocessed is not None else source
+        interface_position, implementation_position = self._section_lines(semantic_source)
+
+        def visit(scope: Scope, prefix: tuple[str, ...], parent_id: str) -> None:
+            if id(scope) in seen:
+                return
+            seen.add(id(scope))
+            for values in scope.symbols.values():
+                for native in values:
+                    native_id = id(native)
+                    if native_id in source_symbols:
+                        continue
+                    name = native.name
+                    name_parts = tuple(part for part in name.split(".") if part)
+                    qualified_parts = name_parts if len(name_parts) > 1 else (*prefix, name)
+                    qualified = ".".join(qualified_parts)
+                    declared = self._mapped_range(native.decl_range, preprocessed)
+                    native_name_range = self._name_range(semantic_source, native)
+                    name_range = self._mapped_source_range(native_name_range, preprocessed)
+                    target_id = stable_id(
+                        "symbol",
+                        Language.DELPHI.value,
+                        declared.path,
+                        qualified,
+                        str(declared.start_line),
+                        str(declared.start_character),
+                    )
+                    item = Symbol(
+                        target_id,
+                        name,
+                        qualified,
+                        native.kind.value,
+                        Language.DELPHI,
+                        declared,
+                        "",
+                        declared.path,
+                        self._signature(semantic_source, native),
+                        native.kind.value,
+                        parent_id,
+                        name_range,
+                        self._symbol_role(
+                            native.kind.value,
+                            native.decl_range.start_line,
+                            native.decl_range.start_col,
+                            interface_position,
+                            implementation_position,
+                            native.modifiers,
+                            parent_id,
+                            self._routine_has_body(semantic_source, native),
+                        ),
+                    )
+                    converted.append(item)
+                    source_symbols[native_id] = item
+                    parent_by_source[native_id] = parent_id
+                    if native.member_scope is not None:
+                        visit(native.member_scope, (*prefix, name), target_id)
+
+        visit(model.unit_scope, (), "")
+
+        references = tuple(
+            self._reference(item, source_symbols, semantic_source, preprocessed)
+            for item in model.references
+        )
+        relations: list[Relation] = []
+        for native_id, item in source_symbols.items():
+            native = self._native_symbol(model.unit_scope, native_id)
+            if native is None:
+                continue
+            for base in native.base_types:
+                target_name = base.display_name()
+                target = self._unique_symbol(converted, target_name)
+                resolution = Resolution.COMPLETE if target is not None else Resolution.UNRESOLVED
+                kind = "implements" if target is not None and target.kind == "interface" else "inherits"
+                relations.append(
+                    Relation(
+                        item.target_id,
+                        target.target_id if target else "",
+                        kind,
+                        resolution,
+                        (item.range,),
+                        target_name,
+                    )
+                )
+            if Modifier.EXTERNAL in native.modifiers:
+                target_name, target_library = self._external_identity(
+                    semantic_source,
+                    replace(item, range=self._range(native.decl_range)),
+                    native.name.split(".")[-1],
+                )
+                relations.append(
+                    Relation(
+                        item.target_id,
+                        "",
+                        "ffi",
+                        Resolution.SOUND_PARTIAL,
+                        (item.range,),
+                        target_name,
+                        target_library,
+                    )
+                )
+        if preprocessed is not None:
+            relations.extend(self._export_relations(preprocessed, converted, path, source))
+        return tuple(converted), references, tuple(relations)
+
+    @staticmethod
+    def _section_lines(
+        source: str,
+    ) -> tuple[tuple[int, int] | None, tuple[int, int] | None]:
+        interface_position: tuple[int, int] | None = None
+        implementation_position: tuple[int, int] | None = None
+        comment_state: str | None = None
+        for line_number, raw_line in enumerate(source.splitlines(), start=1):
+            line, comment_state = _mask_delphi_comments_and_strings(raw_line, comment_state)
+            for match in _DELPHI_SECTION.finditer(line):
+                position = (line_number, match.start() + 1)
+                if match.group(1).casefold() == "interface" and interface_position is None:
+                    interface_position = position
+                elif match.group(1).casefold() == "implementation":
+                    implementation_position = position
+                    return interface_position, implementation_position
+        return interface_position, implementation_position
+
+    @staticmethod
+    def _symbol_role(
+        kind: str,
+        line_number: int,
+        column_number: int,
+        interface_position: tuple[int, int] | None,
+        implementation_position: tuple[int, int] | None,
+        modifiers: set[Modifier],
+        parent_id: str,
+        has_body: bool,
+    ) -> str:
+        if kind not in _DELPHI_IMPLEMENTABLE_KINDS:
+            return "definition"
+        if has_body:
+            return "implementation"
+        if parent_id or modifiers.intersection({Modifier.ABSTRACT, Modifier.EXTERNAL, Modifier.FORWARD}):
+            return "declaration"
+        position = (line_number, column_number)
+        if implementation_position is not None and position > implementation_position:
+            return "implementation"
+        if interface_position is not None and position > interface_position:
+            return "declaration"
+        return "definition"
+
+    @staticmethod
+    def _routine_has_body(source: str, symbol: DelphiSymbol) -> bool:
+        return re.search(
+            r"\b(?:begin|asm)\b",
+            DelphiAdapter._symbol_text(source, symbol, mask=True),
+            re.IGNORECASE,
+        ) is not None
+
+    def _export_relations(
+        self,
+        preprocessed: PreprocessedSource,
+        symbols: list[Symbol],
+        path: str,
+        original_source: str,
+    ) -> list[Relation]:
+        source = preprocessed.text
+        masked = self._masked_source(source)
+        library = re.search(
+            r"\blibrary\s+([A-Za-z_][A-Za-z0-9_]*)\s*;",
+            masked,
+            re.IGNORECASE,
+        )
+        target_library = library.group(1) if library is not None else ""
+        relations: list[Relation] = []
+        for exports in re.finditer(r"\bexports\b", masked, re.IGNORECASE):
+            statement_end = self._statement_end(masked, exports.end())
+            if statement_end is None:
+                continue
+            for start, end in self._comma_spans(masked, exports.end(), statement_end):
+                masked_item = masked[start:end]
+                name_match = re.search(r"\b([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\b", masked_item)
+                if name_match is None:
+                    continue
+                exported_name = name_match.group(1)
+                symbol = self._exported_symbol(symbols, exported_name)
+                if symbol is None:
+                    continue
+                target_name = exported_name.rsplit(".", 1)[-1]
+                alias_marker = re.search(r"\bname\b", masked_item, re.IGNORECASE)
+                if alias_marker is not None:
+                    original_tail = source[start + alias_marker.end():end]
+                    alias = re.match(r"\s*'((?:''|[^'])*)'", original_tail)
+                    if alias is not None:
+                        target_name = alias.group(1).replace("''", "'")
+                name_start = start + name_match.start(1)
+                evidence_path, evidence_line, character = self._map_export_position(
+                    preprocessed,
+                    original_source,
+                    path,
+                    name_start,
+                    exported_name,
+                )
+                evidence = SourceRange(
+                    evidence_path,
+                    evidence_line,
+                    character,
+                    evidence_line,
+                    character + len(exported_name),
+                )
+                relations.append(
+                    Relation(
+                        symbol.target_id,
+                        "",
+                        "ffi",
+                        Resolution.SOUND_PARTIAL,
+                        (evidence,),
+                        target_name,
+                        target_library,
+                    )
+                )
+        return relations
+
+    def _map_export_position(
+        self,
+        preprocessed: PreprocessedSource,
+        original_source: str,
+        path: str,
+        offset: int,
+        exported_name: str,
+    ) -> tuple[str, int, int]:
+        line = preprocessed.text.count("\n", 0, offset)
+        line_start = preprocessed.text.rfind("\n", 0, offset) + 1
+        character = offset - line_start
+        mapped_path, mapped_line, mapped_character = preprocessed.map_position(line + 1, character)
+        if not mapped_path:
+            return path, line, character
+        inline_origin = self._inline_include_origin(
+            mapped_path,
+            mapped_line,
+            mapped_character,
+            exported_name,
+            path,
+            original_source,
+        )
+        if inline_origin is not None:
+            return inline_origin
+        return mapped_path, max(0, mapped_line - 1), mapped_character
+
+    def _inline_include_origin(
+        self,
+        mapped_path: str,
+        mapped_line: int,
+        mapped_character: int,
+        exported_name: str,
+        main_path: str,
+        main_source: str,
+    ) -> tuple[str, int, int] | None:
+        source = main_source if mapped_path == main_path else self._read_source(mapped_path)
+        if source is None:
+            return None
+        lines = source.splitlines()
+        if mapped_line < 1 or mapped_line > len(lines):
+            return None
+        candidates: list[tuple[str, int, int]] = []
+        for include in _DELPHI_INCLUDE.finditer(lines[mapped_line - 1]):
+            include_character = mapped_character - include.start()
+            if include_character < 0:
+                continue
+            include_name = self._include_name(include.group("brace") or include.group("paren") or "")
+            resolved = self._read_include(mapped_path, include_name)
+            if resolved is None:
+                continue
+            include_source, include_path = resolved
+            first_line = include_source.removeprefix("\ufeff").split("\n", 1)[0]
+            end_character = include_character + len(exported_name)
+            if first_line[include_character:end_character].casefold() == exported_name.casefold():
+                candidates.append((include_path, 0, include_character))
+        return candidates[0] if len(candidates) == 1 else None
+
+    @staticmethod
+    def _include_name(parameter: str) -> str:
+        text = parameter.strip()
+        if not text:
+            return ""
+        if text[0] in {"'", '"'}:
+            end = text.find(text[0], 1)
+            return text[1:] if end == -1 else text[1:end]
+        return text.split(maxsplit=1)[0]
+
+    @staticmethod
+    def _read_source(path: str) -> str | None:
+        source_path = Path(path)
+        return read_source_text(source_path) if source_path.exists() else None
+
+    def _read_include(self, parent_file: str, include_name: str) -> tuple[str, str] | None:
+        if not include_name:
+            return None
+        workspace_root = self._workspace_root or Path(parent_file).expanduser().resolve().parent
+        include_path = Path(include_name.replace("\\", "/"))
+        parent_path = Path(parent_file).expanduser()
+        if not parent_path.is_absolute():
+            parent_path = workspace_root / parent_path
+        bases = [parent_path.parent]
+        for value in self._include_paths:
+            base = Path(value).expanduser()
+            bases.append(base if base.is_absolute() else workspace_root / base)
+        for base in bases:
+            candidate = (include_path if include_path.is_absolute() else base / include_path).resolve()
+            if candidate != workspace_root and not candidate.is_relative_to(workspace_root):
+                continue
+            if candidate.exists():
+                return read_source_text(candidate), str(candidate)
+        return None
+
+    @classmethod
+    def _external_identity(
+        cls,
+        source: str,
+        symbol: Symbol,
+        default_name: str,
+    ) -> tuple[str, str]:
+        lines = source.splitlines(keepends=True)
+        if symbol.range.start_line >= len(lines):
+            return default_name, ""
+        start = sum(len(line) for line in lines[: symbol.range.start_line])
+        start += symbol.range.start_character
+        segment = source[start:start + 4096]
+        masked = cls._masked_source(segment)
+        external = re.search(r"\bexternal\b", masked, re.IGNORECASE)
+        if external is None:
+            return default_name, ""
+        end = cls._statement_end(masked, external.end())
+        if end is None:
+            return default_name, ""
+        masked_tail = masked[external.end():end]
+        original_tail = segment[external.end():end]
+        library_match = re.match(r"\s*'((?:''|[^'])*)'", original_tail)
+        library = library_match.group(1).replace("''", "'") if library_match else ""
+        name = default_name
+        name_marker = re.search(r"\bname\b", masked_tail, re.IGNORECASE)
+        if name_marker is not None:
+            original_name = original_tail[name_marker.end():]
+            name_match = re.match(r"\s*'((?:''|[^'])*)'", original_name)
+            if name_match is not None:
+                name = name_match.group(1).replace("''", "'")
+        return name, library
+
+    @staticmethod
+    def _masked_source(source: str) -> str:
+        state: str | None = None
+        masked: list[str] = []
+        for raw_line in source.splitlines(keepends=True):
+            line = raw_line.rstrip("\r\n")
+            ending = raw_line[len(line):]
+            clean, state = _mask_delphi_comments_and_strings(line, state)
+            masked.append(clean + ending)
+        return "".join(masked)
+
+    @staticmethod
+    def _statement_end(source: str, start: int) -> int | None:
+        depth = 0
+        for index in range(start, len(source)):
+            character = source[index]
+            if character == "(":
+                depth += 1
+            elif character == ")" and depth:
+                depth -= 1
+            elif character == ";" and depth == 0:
+                return index
+        return None
+
+    @staticmethod
+    def _comma_spans(source: str, start: int, end: int) -> Iterator[tuple[int, int]]:
+        depth = 0
+        item_start = start
+        for index in range(start, end):
+            character = source[index]
+            if character == "(":
+                depth += 1
+            elif character == ")" and depth:
+                depth -= 1
+            elif character == "," and depth == 0:
+                yield item_start, index
+                item_start = index + 1
+        yield item_start, end
+
+    @staticmethod
+    def _exported_symbol(symbols: list[Symbol], name: str) -> Symbol | None:
+        folded = name.casefold()
+        exact = [
+            item
+            for item in symbols
+            if item.qualified_name.casefold() == folded or item.name.casefold() == folded
+        ]
+        candidates = exact or [
+            item
+            for item in symbols
+            if item.name.rsplit(".", 1)[-1].casefold() == name.rsplit(".", 1)[-1].casefold()
+        ]
+        for role in ("implementation", "definition", "declaration"):
+            preferred = [item for item in candidates if item.role == role]
+            if len(preferred) == 1:
+                return preferred[0]
+            if len(preferred) > 1:
+                return None
+        return None
+
+    def _reference(
+        self,
+        item: object,
+        symbols: dict[int, Symbol],
+        source_text: str,
+        preprocessed: PreprocessedSource | None,
+    ) -> Reference:
+        native = item
+        resolved = getattr(native, "resolved")
+        target = symbols.get(id(resolved)) if resolved is not None else None
+        owner = getattr(native, "scope").owner
+        source = symbols.get(id(owner)) if owner is not None else None
+        candidates = [value for value in symbols.values() if value.name.casefold() == getattr(native, "name").casefold()]
+        resolution = Resolution.COMPLETE if target is not None else (
+            Resolution.AMBIGUOUS if len(candidates) > 1 else Resolution.UNRESOLVED
+        )
+        kind = getattr(native, "kind")
+        original_name = getattr(native, "name")
+        name = original_name
+        qualifier = ""
+        if kind is ReferenceKind.CALL and "." in name:
+            qualifier = name.rsplit(".", 1)[0]
+            name = name.rsplit(".", 1)[-1]
+        ref_range = self._range(getattr(native, "ref_range"))
+        simple_name = name.rsplit(".", 1)[-1]
+        if ref_range.start_line == ref_range.end_line:
+            lines = source_text.splitlines()
+            if 0 <= ref_range.start_line < len(lines):
+                line_text = lines[ref_range.start_line]
+                if ref_range.end_character <= ref_range.start_character:
+                    segment = line_text[
+                        ref_range.start_character:ref_range.start_character + len(simple_name)
+                    ]
+                else:
+                    segment = line_text[ref_range.start_character:ref_range.end_character]
+                offset = segment.casefold().rfind(simple_name.casefold())
+                if offset >= 0:
+                    start_character = ref_range.start_character + offset
+                    ref_range = replace(
+                        ref_range,
+                        start_character=start_character,
+                        end_character=start_character + len(simple_name),
+                    )
+        mapped_ref_range = self._mapped_source_range(ref_range, preprocessed)
+        assert mapped_ref_range is not None
+        ref_range = mapped_ref_range
+        return Reference(
+            source.target_id if source else "",
+            target.target_id if target else "",
+            name,
+            Language.DELPHI,
+            ref_range,
+            resolution,
+            "import" if kind is ReferenceKind.UNIT else kind.value,
+            qualifier,
+            original_name if kind is ReferenceKind.UNIT else "",
+            (),
+            "",
+            kind is ReferenceKind.UNIT,
+        )
+
+    def _native_symbol(self, root: Scope, target_id: int) -> DelphiSymbol | None:
+        return next((item for item in self._iter_native_symbols(root) if id(item) == target_id), None)
+
+    def _iter_native_symbols(self, scope: Scope, seen: set[int] | None = None) -> Iterator[DelphiSymbol]:
+        if seen is None:
+            seen = set()
+        if id(scope) in seen:
+            return
+        seen.add(id(scope))
+        for values in scope.symbols.values():
+            for item in values:
+                yield item
+                if item.member_scope is not None:
+                    yield from self._iter_native_symbols(item.member_scope, seen)
+
+    @staticmethod
+    def _unique_symbol(symbols: list[Symbol], name: str) -> Symbol | None:
+        simple = name.rsplit(".", 1)[-1].casefold()
+        matches = [item for item in symbols if item.name.casefold() == simple]
+        return matches[0] if len(matches) == 1 else None
+
+    @staticmethod
+    def _range(value: object) -> SourceRange:
+        return SourceRange(
+            str(getattr(value, "file_name")),
+            max(0, int(getattr(value, "start_line")) - 1),
+            max(0, int(getattr(value, "start_col")) - 1),
+            max(0, int(getattr(value, "end_line")) - 1),
+            max(0, int(getattr(value, "end_col")) - 1),
+        )
+
+    @classmethod
+    def _mapped_range(
+        cls,
+        value: object,
+        preprocessed: PreprocessedSource | None,
+    ) -> SourceRange:
+        mapped = cls._mapped_source_range(cls._range(value), preprocessed)
+        assert mapped is not None
+        return mapped
+
+    @staticmethod
+    def _mapped_source_range(
+        value: SourceRange | None,
+        preprocessed: PreprocessedSource | None,
+    ) -> SourceRange | None:
+        if value is None or preprocessed is None:
+            return value
+        start_path, start_line, start_character = preprocessed.map_position(
+            value.start_line + 1,
+            value.start_character,
+        )
+        end_path, end_line, end_character = preprocessed.map_position(
+            value.end_line + 1,
+            value.end_character,
+        )
+        if not start_path:
+            return value
+        if end_path != start_path:
+            end_line = start_line
+            end_character = start_character
+        return SourceRange(
+            start_path,
+            max(0, start_line - 1),
+            max(0, start_character),
+            max(0, end_line - 1),
+            max(0, end_character),
+        )
+
+    @staticmethod
+    def _signature(source: str, symbol: DelphiSymbol) -> str:
+        text = DelphiAdapter._symbol_text(source, symbol).strip()
+        if (
+            symbol.kind.value in _DELPHI_IMPLEMENTABLE_KINDS
+            and re.search(
+                r"\b(?:constructor|destructor|function|procedure)\b",
+                text,
+                re.IGNORECASE,
+            )
+            is None
+        ):
+            lines = source.splitlines()
+            start = max(0, symbol.decl_range.start_line - 1)
+            end = min(len(lines), max(start + 1, symbol.decl_range.end_line))
+            text = "\n".join(lines[start:end]).strip()
+        if "begin" in text.casefold():
+            text = text[: text.casefold().find("begin")].rstrip()
+        return " ".join(text.split())[:2000]
+
+    @staticmethod
+    def _symbol_text(source: str, symbol: DelphiSymbol, *, mask: bool = False) -> str:
+        lines = source.splitlines()
+        if mask:
+            masked_lines: list[str] = []
+            comment_state: str | None = None
+            for line in lines:
+                clean, comment_state = _mask_delphi_comments_and_strings(line, comment_state)
+                masked_lines.append(clean)
+            lines = masked_lines
+        start_line = max(0, symbol.decl_range.start_line - 1)
+        end_line = min(len(lines) - 1, max(start_line, symbol.decl_range.end_line - 1))
+        if start_line >= len(lines) or end_line < start_line:
+            return ""
+        segments: list[str] = []
+        for line_number in range(start_line, end_line + 1):
+            start = max(0, symbol.decl_range.start_col - 1) if line_number == start_line else 0
+            end = (
+                max(start, symbol.decl_range.end_col - 1)
+                if line_number == end_line
+                else len(lines[line_number])
+            )
+            segments.append(lines[line_number][start:end])
+        return "\n".join(segments)
+
+    def _name_range(self, source: str, symbol: DelphiSymbol) -> SourceRange | None:
+        declared = self._range(symbol.decl_range)
+        lines = source.splitlines()
+        simple_name = symbol.name.rsplit(".", 1)[-1]
+        for line_number in range(declared.start_line, min(declared.end_line + 1, len(lines))):
+            start = declared.start_character if line_number == declared.start_line else 0
+            end = declared.end_character if line_number == declared.end_line else len(lines[line_number])
+            if end <= start:
+                end = len(lines[line_number])
+            segment = lines[line_number][start:end]
+            match = re.search(rf"\b{re.escape(simple_name)}\b", segment, re.IGNORECASE)
+            if match is not None:
+                return SourceRange(
+                    declared.path,
+                    line_number,
+                    start + match.start(),
+                    line_number,
+                    start + match.end(),
+                )
+        return None