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

agent_codinglanguage_mapper/adapters/tree_sitter.py

@@ -0,0 +1,1722 @@
+from __future__ import annotations
+
+import ast
+from bisect import bisect_right
+from collections import defaultdict
+from dataclasses import dataclass, replace
+from pathlib import Path
+import re
+from typing import Iterator, Protocol, cast
+
+from tree_sitter import Language as TreeSitterLanguage, Node, Parser, Query, QueryCursor, Tree
+import tree_sitter_c_sharp
+import tree_sitter_cpp
+import tree_sitter_python
+import tree_sitter_rust
+
+from ..models import Language, Problem, Reference, Relation, Resolution, SourceRange, Symbol
+from ..workspace import stable_id
+
+
+@dataclass(frozen=True)
+class ParsedDocument:
+    path: str
+    source: str
+    encoded: bytes
+    line_starts: tuple[int, ...]
+    tree: Tree
+    parse_count: int = 1
+    compatibility_edits: tuple[CompatibilityEdit, ...] = ()
+
+
+@dataclass(frozen=True)
+class CompatibilityEdit:
+    handler: str
+    start_byte: int
+    end_byte: int
+    is_error: bool = False
+
+
+@dataclass(frozen=True)
+class AdapterResult:
+    symbols: tuple[Symbol, ...] = ()
+    references: tuple[Reference, ...] = ()
+    relations: tuple[Relation, ...] = ()
+    problems: tuple[Problem, ...] = ()
+    document: object | None = None
+
+
+class LanguageAdapter(Protocol):
+    language: Language
+    extensions: tuple[str, ...]
+
+    def detect(self, path: str | Path) -> bool: ...
+
+    def parse_outline(self, path: str | Path, source: str) -> AdapterResult: ...
+
+    def parse_detail(self, path: str | Path, source: str, outline: AdapterResult) -> AdapterResult: ...
+
+    def resolve(self, result: AdapterResult) -> AdapterResult: ...
+
+
+_DEFINITIONS: dict[Language, dict[str, str]] = {
+    Language.PYTHON: {
+        "class_definition": "class",
+        "function_definition": "function",
+    },
+    Language.RUST: {
+        "const_item": "constant",
+        "enum_item": "enum",
+        "function_item": "function",
+        "function_signature_item": "function",
+        "impl_item": "implementation",
+        "macro_definition": "macro",
+        "mod_item": "module",
+        "static_item": "static",
+        "struct_item": "struct",
+        "trait_item": "trait",
+        "type_item": "type_alias",
+        "union_item": "union",
+    },
+    Language.CSHARP: {
+        "class_declaration": "class",
+        "constructor_declaration": "constructor",
+        "conversion_operator_declaration": "operator",
+        "delegate_declaration": "delegate",
+        "destructor_declaration": "destructor",
+        "enum_declaration": "enum",
+        "enum_member_declaration": "enum_member",
+        "event_declaration": "event",
+        "indexer_declaration": "indexer",
+        "interface_declaration": "interface",
+        "method_declaration": "method",
+        "namespace_declaration": "namespace",
+        "file_scoped_namespace_declaration": "namespace",
+        "operator_declaration": "operator",
+        "property_declaration": "property",
+        "record_declaration": "record",
+        "record_struct_declaration": "record_struct",
+        "struct_declaration": "struct",
+    },
+    Language.CPP: {
+        "alias_declaration": "type_alias",
+        "class_specifier": "class",
+        "concept_definition": "concept",
+        "enum_specifier": "enum",
+        "function_definition": "function",
+        "namespace_definition": "namespace",
+        "type_definition": "type_alias",
+        "union_specifier": "union",
+    },
+}
+
+_CALLS = {"call", "call_expression", "invocation_expression"}
+_IMPORTS = {
+    "import_statement",
+    "import_from_statement",
+    "use_declaration",
+    "using_directive",
+    "preproc_include",
+}
+_IDENTIFIERS = {
+    "field_identifier",
+    "identifier",
+    "namespace_identifier",
+    "type_identifier",
+}
+_PYTHON_COMPAT_ERROR = re.compile(
+    r"^\s*(?:print(?:\s|>>)|exec\s|except\s+[^:\n]+,\s*\w+\s*:|raise\s+\w+\s*,)",
+    re.MULTILINE,
+)
+
+_DETAIL_NODE_TYPES: dict[Language, tuple[str, ...]] = {
+    Language.PYTHON: ("call", "class_definition", "import_from_statement", "import_statement"),
+    Language.RUST: ("call_expression", "impl_item", "use_declaration"),
+    Language.CSHARP: (
+        "class_declaration",
+        "interface_declaration",
+        "invocation_expression",
+        "record_declaration",
+        "struct_declaration",
+        "using_directive",
+    ),
+    Language.CPP: ("call_expression", "class_specifier", "preproc_include"),
+}
+
+_FFI_NODE_TYPES: dict[Language, tuple[str, ...]] = {
+    Language.PYTHON: ("assignment", "call"),
+    Language.RUST: ("function_item", "function_signature_item"),
+    Language.CSHARP: ("method_declaration",),
+    Language.CPP: ("declaration", "function_definition"),
+}
+
+_FFI_MARKERS: dict[Language, tuple[bytes, ...]] = {
+    Language.PYTHON: (b"ctypes", b".dlopen", b"ffi.cdef"),
+    Language.RUST: (b"extern", b"export_name"),
+    Language.CSHARP: (b"DllImport", b"LibraryImport"),
+    Language.CPP: (b'extern "C"', b"__declspec(dllexport)", b"visibility"),
+}
+
+
+class TreeSitterAdapter:
+    def __init__(
+        self,
+        language: Language,
+        extensions: tuple[str, ...],
+        grammar: object,
+        *,
+        workspace_root: str | Path | None = None,
+        include_paths: tuple[str | Path, ...] = (),
+    ) -> None:
+        self.language = language
+        self.extensions = extensions
+        self._tree_language = TreeSitterLanguage(getattr(grammar, "language")())
+        self._parser = Parser(self._tree_language)
+        self._detail_query = self._node_query(_DETAIL_NODE_TYPES[language])
+        self._ffi_query = self._node_query(_FFI_NODE_TYPES[language])
+        self._workspace_root = (
+            Path(workspace_root).expanduser().resolve() if workspace_root is not None else None
+        )
+        self._include_paths = tuple(
+            (
+                (self._workspace_root / include_path).resolve()
+                if self._workspace_root is not None and not Path(include_path).is_absolute()
+                else Path(include_path).expanduser().resolve()
+            )
+            for include_path in include_paths
+        )
+
+    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:
+        document = self._parse(path, source)
+        module_name = Path(path).stem or "workspace"
+        module_id = stable_id("symbol", self.language.value, str(path), module_name, "0")
+        symbols: list[Symbol] = [
+            Symbol(
+                module_id,
+                module_name,
+                module_name,
+                "module",
+                self.language,
+                self._range(path, document.tree.root_node, document.encoded, document.line_starts),
+                "",
+                str(path),
+                "",
+                document.tree.root_node.type,
+                "",
+                None,
+            )
+        ]
+        problems = [self._compatibility_problem(document, edit) for edit in document.compatibility_edits]
+        self._collect(document.tree.root_node, document, (module_name,), module_id, symbols, problems)
+        return AdapterResult(tuple(symbols), problems=tuple(problems), document=document)
+
+    def parse_detail(self, path: str | Path, source: str, outline: AdapterResult) -> AdapterResult:
+        document = outline.document
+        if not isinstance(document, ParsedDocument) or document.path != str(path) or document.source != source:
+            document = self._parse(path, source)
+        references: list[Reference] = []
+        relations: list[Relation] = []
+        for node in self._query_nodes(self._detail_query, document.tree.root_node):
+            owner = self._owner(outline.symbols, node, document.encoded, document.line_starts)
+            if node.type in _CALLS:
+                target = node.child_by_field_name("function")
+                if owner is not None and target is not None:
+                    name = self._target_name(target, document.encoded)
+                    if name:
+                        references.append(
+                            Reference(
+                                owner.target_id,
+                                "",
+                                name,
+                                self.language,
+                                self._range(path, target, document.encoded, document.line_starts),
+                                Resolution.UNRESOLVED,
+                                "call",
+                                self._target_qualifier(target, document.encoded),
+                            )
+                        )
+            elif node.type in _IMPORTS:
+                references.extend(
+                    self._import_references(
+                        node,
+                        owner,
+                        path,
+                        document.encoded,
+                        document.line_starts,
+                    )
+                )
+            relations.extend(
+                self._base_relations(node, owner, path, document.encoded, document.line_starts)
+            )
+        relations.extend(
+            self._ffi_relations(
+                document.tree.root_node,
+                outline.symbols,
+                path,
+                document.encoded,
+                document.line_starts,
+            )
+        )
+        return AdapterResult(
+            outline.symbols,
+            tuple(references),
+            tuple(relations),
+            outline.problems,
+            document,
+        )
+
+    def resolve(self, result: AdapterResult) -> AdapterResult:
+        by_name: dict[str, list[Symbol]] = defaultdict(list)
+        for symbol in result.symbols:
+            if symbol.kind == "module":
+                continue
+            by_name[symbol.name].append(symbol)
+            if symbol.qualified_name != symbol.name:
+                by_name[symbol.qualified_name].append(symbol)
+
+        references = tuple(self._resolve_reference(item, by_name) for item in result.references)
+        relations = tuple(self._resolve_relation(item, by_name) for item in result.relations)
+        return replace(result, references=references, relations=relations)
+
+    def _node_query(self, node_types: tuple[str, ...]) -> Query:
+        patterns = " ".join(f"({node_type})" for node_type in node_types)
+        return Query(self._tree_language, f"[{patterns}] @node")
+
+    @staticmethod
+    def _query_nodes(query: Query, root: Node) -> tuple[Node, ...] | list[Node]:
+        return QueryCursor(query).captures(root).get("node", ())
+
+    def _parse(self, path: str | Path, source: str) -> ParsedDocument:
+        encoded = source.encode("utf-8")
+        line_starts = (0, *(match.end() for match in re.finditer(b"\n", encoded)))
+        parser_source, compatibility_edits = self._normalize_parser_source(path, encoded)
+        return ParsedDocument(
+            str(path),
+            source,
+            encoded,
+            line_starts,
+            self._parser.parse(parser_source),
+            compatibility_edits=compatibility_edits,
+        )
+
+    def _normalize_parser_source(
+        self,
+        path: str | Path,
+        source: bytes,
+    ) -> tuple[bytes, tuple[CompatibilityEdit, ...]]:
+        if self.language is Language.RUST:
+            return self._normalize_rust(source)
+        if self.language is Language.CSHARP:
+            return self._normalize_csharp(source)
+        if self.language is Language.CPP:
+            return self._normalize_cpp(path, source)
+        return source, ()
+
+    @staticmethod
+    def _masked(source: bytes, start: int, end: int, *, first: int | None = None) -> bytes:
+        replacement = bytearray(source[start:end])
+        for index, value in enumerate(replacement):
+            if value not in {10, 13}:
+                replacement[index] = 32
+        if first is not None and replacement:
+            replacement[0] = first
+        return bytes(replacement)
+
+    def _normalize_rust(self, source: bytes) -> tuple[bytes, tuple[CompatibilityEdit, ...]]:
+        normalized = bytearray(source)
+        edits: list[CompatibilityEdit] = []
+        for block in re.finditer(rb'\bunsafe\s+extern(?:\s+"[^"\r\n]*")?\s*\{', source):
+            end = self._balanced_end(source, block.end() - 1, 123, 125)
+            if end is None:
+                continue
+            for match in re.finditer(rb"\bsafe(?=[ \t]+fn\b)", source[block.end():end]):
+                start = block.end() + match.start()
+                stop = block.end() + match.end()
+                normalized[start:stop] = b" " * (stop - start)
+                edits.append(CompatibilityEdit("rust-2024-safe-extern-item", start, stop))
+        function_pointer = re.compile(
+            rb'\bas[ \t]+(?:unsafe[ \t]+)?(?:extern[ \t]+"[^"\r\n]+"[ \t]+)?fn[ \t]*\('
+        )
+        for declaration in function_pointer.finditer(source):
+            end = self._balanced_end(source, declaration.end() - 1, 40, 41)
+            if end is None:
+                continue
+            for match in re.finditer(rb"(?<=&)_\b", source[declaration.end():end]):
+                start = declaration.end() + match.start()
+                stop = declaration.end() + match.end()
+                normalized[start:stop] = b"T"
+                edits.append(CompatibilityEdit("rust-inferred-reference-type", start, stop))
+        for match in re.finditer(rb"(?<=::<)-(?=\d)", source):
+            normalized[match.start():match.end()] = b" "
+            edits.append(
+                CompatibilityEdit("rust-negative-const-generic-literal", match.start(), match.end())
+            )
+        return bytes(normalized), tuple(edits)
+
+    def _normalize_csharp(self, source: bytes) -> tuple[bytes, tuple[CompatibilityEdit, ...]]:
+        normalized = bytearray(source)
+        edits: list[CompatibilityEdit] = []
+        symbols: set[bytes] = set()
+        stack: list[tuple[bool, bool, bool]] = []
+        active = True
+        lexical_state = ("normal", 0)
+        first_conditional: tuple[int, int] | None = None
+        unbalanced: tuple[int, int] | None = None
+        lines = tuple(re.finditer(rb"[^\n]*(?:\n|$)", source))
+        for line in lines:
+            if line.start() == line.end():
+                continue
+            content = source[line.start():line.end()]
+            directive = (
+                re.match(rb"^[ \t]*#(if|elif|else|endif|define|undef)\b([^\r\n]*)", content)
+                if lexical_state[0] == "normal"
+                else None
+            )
+            if directive is not None:
+                kind, expression = directive.group(1), directive.group(2).strip()
+                if kind == b"if":
+                    condition = self._csharp_condition(expression, symbols)
+                    stack.append((active, condition, active and condition))
+                    active = active and condition
+                    if first_conditional is None:
+                        first_conditional = (line.start(), line.end())
+                elif kind == b"elif":
+                    if stack:
+                        parent_active, branch_taken, _ = stack[-1]
+                        condition = not branch_taken and self._csharp_condition(expression, symbols)
+                        active = parent_active and condition
+                        stack[-1] = (parent_active, branch_taken or condition, active)
+                    else:
+                        unbalanced = unbalanced or (line.start(), line.end())
+                elif kind == b"else":
+                    if stack:
+                        parent_active, branch_taken, _ = stack[-1]
+                        active = parent_active and not branch_taken
+                        stack[-1] = (parent_active, True, active)
+                    else:
+                        unbalanced = unbalanced or (line.start(), line.end())
+                elif kind == b"endif":
+                    if stack:
+                        parent_active, _, _ = stack.pop()
+                        active = parent_active
+                    else:
+                        unbalanced = unbalanced or (line.start(), line.end())
+                elif kind == b"define" and active and expression:
+                    symbols.add(expression.split(maxsplit=1)[0])
+                elif kind == b"undef" and active and expression:
+                    symbols.discard(expression.split(maxsplit=1)[0])
+                normalized[line.start():line.end()] = self._masked(source, line.start(), line.end())
+                continue
+            if not active:
+                normalized[line.start():line.end()] = self._masked(source, line.start(), line.end())
+                continue
+            lexical_state = self._csharp_lex_state(content, lexical_state)
+        if first_conditional is not None:
+            edits.append(CompatibilityEdit("csharp-conditional-compilation", *first_conditional))
+        if stack and first_conditional is not None:
+            unbalanced = unbalanced or first_conditional
+        if unbalanced is not None:
+            edits.append(CompatibilityEdit("csharp-unbalanced-conditional", *unbalanced, is_error=True))
+
+        parser_source = bytes(normalized)
+        cursor = 0
+        while True:
+            match = re.search(rb"\bis[ \t\r\n]*\[", parser_source[cursor:])
+            if match is None:
+                break
+            bracket = cursor + match.end() - 1
+            end = self._balanced_end(parser_source, bracket, 91, 93)
+            if end is None:
+                break
+            normalized[bracket:end] = self._masked(parser_source, bracket, end, first=95)
+            edits.append(CompatibilityEdit("csharp-list-pattern", bracket, end))
+            parser_source = bytes(normalized)
+            cursor = end
+        return bytes(normalized), tuple(edits)
+
+    @staticmethod
+    def _csharp_lex_state(line: bytes, initial: tuple[str, int]) -> tuple[str, int]:
+        state, delimiter = initial
+        index = 0
+        while index < len(line):
+            if state == "block_comment":
+                end = line.find(b"*/", index)
+                if end < 0:
+                    return state, delimiter
+                state = "normal"
+                index = end + 2
+                continue
+            if state == "verbatim_string":
+                quote = line.find(b'"', index)
+                if quote < 0:
+                    return state, delimiter
+                if quote + 1 < len(line) and line[quote + 1] == 34:
+                    index = quote + 2
+                    continue
+                state = "normal"
+                index = quote + 1
+                continue
+            if state == "raw_string":
+                end = line.find(b'"' * delimiter, index)
+                if end < 0:
+                    return state, delimiter
+                state = "normal"
+                index = end + delimiter
+                continue
+
+            if line[index:index + 2] == b"//":
+                return "normal", 0
+            if line[index:index + 2] == b"/*":
+                state = "block_comment"
+                index += 2
+                continue
+            if line[index:index + 2] == b'@"':
+                state = "verbatim_string"
+                index += 2
+                continue
+            if line[index] == 34:
+                quotes = 1
+                while index + quotes < len(line) and line[index + quotes] == 34:
+                    quotes += 1
+                if quotes >= 3:
+                    state = "raw_string"
+                    delimiter = quotes
+                    index += quotes
+                    continue
+                index += 1
+                escaped = False
+                while index < len(line) and line[index] not in {10, 13}:
+                    value = line[index]
+                    index += 1
+                    if escaped:
+                        escaped = False
+                    elif value == 92:
+                        escaped = True
+                    elif value == 34:
+                        break
+                continue
+            if line[index] == 39:
+                index += 1
+                escaped = False
+                while index < len(line) and line[index] not in {10, 13}:
+                    value = line[index]
+                    index += 1
+                    if escaped:
+                        escaped = False
+                    elif value == 92:
+                        escaped = True
+                    elif value == 39:
+                        break
+                continue
+            index += 1
+        return state, delimiter
+
+    @staticmethod
+    def _csharp_condition(expression: bytes, symbols: set[bytes]) -> bool:
+        tokens = re.findall(rb"true|false|[A-Za-z_]\w*|&&|\|\||==|!=|[!()]", expression)
+        position = 0
+
+        def primary() -> bool:
+            nonlocal position
+            if position >= len(tokens):
+                return False
+            token = tokens[position]
+            position += 1
+            if token == b"!":
+                return not primary()
+            if token == b"(":
+                value = disjunction()
+                if position < len(tokens) and tokens[position] == b")":
+                    position += 1
+                return value
+            if token == b"true":
+                return True
+            if token == b"false":
+                return False
+            return token in symbols
+
+        def equality() -> bool:
+            nonlocal position
+            value = primary()
+            while position < len(tokens) and tokens[position] in {b"==", b"!="}:
+                operator = tokens[position]
+                position += 1
+                right = primary()
+                value = value == right if operator == b"==" else value != right
+            return value
+
+        def conjunction() -> bool:
+            nonlocal position
+            value = equality()
+            while position < len(tokens) and tokens[position] == b"&&":
+                position += 1
+                right = equality()
+                value = value and right
+            return value
+
+        def disjunction() -> bool:
+            nonlocal position
+            value = conjunction()
+            while position < len(tokens) and tokens[position] == b"||":
+                position += 1
+                right = conjunction()
+                value = value or right
+            return value
+
+        return disjunction()
+
+    def _normalize_cpp(
+        self,
+        path: str | Path,
+        source: bytes,
+    ) -> tuple[bytes, tuple[CompatibilityEdit, ...]]:
+        normalized = bytearray(source)
+        edits: list[CompatibilityEdit] = []
+        defined_macros = set(
+            re.findall(rb"(?m)^[ \t]*#define[ \t]+([A-Z][A-Z0-9_]*)\b", source)
+        )
+        defined_macros.update(self._cpp_direct_include_macros(path, source))
+        lines = tuple(re.finditer(rb"[^\n]*(?:\n|$)", source))
+        depth = 0
+        index = 0
+        while index < len(lines):
+            line = lines[index]
+            content = source[line.start():line.end()]
+            stripped = content.strip(b" \t\r\n")
+            if stripped.startswith(b"#define") and content.rstrip(b" \t\r\n").endswith(b"\\"):
+                end_index = index
+                while end_index + 1 < len(lines) and source[lines[end_index].start():lines[end_index].end()].rstrip(
+                    b" \t\r\n"
+                ).endswith(b"\\"):
+                    end_index += 1
+                end = lines[end_index].end()
+                normalized[line.start():end] = self._masked(source, line.start(), end)
+                edits.append(CompatibilityEdit("cpp-multiline-macro-definition", line.start(), end))
+                index = end_index + 1
+                continue
+            if stripped.startswith((b"#define", b"#undef", b"#include")) and depth > 0:
+                normalized[line.start():line.end()] = self._masked(source, line.start(), line.end())
+                handler = self._cpp_preprocessor_handler(source, line.start())
+                edits.append(CompatibilityEdit(handler, line.start(), line.end()))
+                index += 1
+                continue
+            if depth > 0 and stripped in defined_macros:
+                normalized[line.start():line.end()] = self._masked(source, line.start(), line.end())
+                handler = self._cpp_preprocessor_handler(source, line.start())
+                edits.append(CompatibilityEdit(handler, line.start(), line.end()))
+                index += 1
+                continue
+            declaration_macro = re.fullmatch(
+                rb"([A-Z][A-Z0-9_]*)\s*\([^\r\n]*\)[ \t\r]*(?:\n)?",
+                content,
+            )
+            if declaration_macro is not None and declaration_macro.group(1) in defined_macros:
+                replacement = self._masked(source, line.start(), line.end(), first=59)
+                normalized[line.start():line.end()] = replacement
+                edits.append(CompatibilityEdit("cpp-declaration-macro", line.start(), line.end()))
+                index += 1
+                continue
+            depth += self._cpp_line_depth(bytes(normalized[line.start():line.end()]))
+            depth = max(0, depth)
+            index += 1
+        return bytes(normalized), tuple(edits)
+
+    def _cpp_direct_include_macros(self, path: str | Path, source: bytes) -> set[bytes]:
+        source_path = Path(path)
+        if not source_path.is_absolute() and self._workspace_root is not None:
+            source_path = self._workspace_root / source_path
+        macros: set[bytes] = set()
+        visited: set[Path] = set()
+
+        def collect(header: Path) -> None:
+            try:
+                resolved = header.resolve()
+                if self._workspace_root is not None:
+                    resolved.relative_to(self._workspace_root)
+                if resolved in visited:
+                    return
+                header_source = resolved.read_bytes()
+            except (OSError, ValueError):
+                return
+            visited.add(resolved)
+            macros.update(
+                re.findall(
+                    rb"(?m)^[ \t]*#define[ \t]+([A-Z][A-Z0-9_]*)\b",
+                    header_source,
+                )
+            )
+            for nested, quoted in self._cpp_includes(header_source):
+                candidates = ([resolved.parent / nested] if quoted else []) + [
+                    include_root / nested for include_root in self._include_paths
+                ]
+                for candidate in candidates:
+                    if candidate.is_file():
+                        collect(candidate)
+                        break
+
+        for relative, quoted in self._cpp_includes(source):
+            candidates = ([source_path.parent / relative] if quoted else []) + [
+                include_root / relative for include_root in self._include_paths
+            ]
+            for candidate in candidates:
+                if candidate.is_file():
+                    collect(candidate)
+                    break
+        return macros
+
+    @staticmethod
+    def _cpp_includes(source: bytes) -> tuple[tuple[str, bool], ...]:
+        includes: list[tuple[str, bool]] = []
+        pattern = re.compile(rb'(?m)^[ \t]*#include[ \t]+(?P<open>["<])(?P<path>[^">\r\n]+)[">]')
+        for match in pattern.finditer(source):
+            try:
+                includes.append((match.group("path").decode("utf-8"), match.group("open") == b'"'))
+            except UnicodeDecodeError:
+                continue
+        return tuple(includes)
+
+    @staticmethod
+    def _cpp_preprocessor_handler(source: bytes, start: int) -> str:
+        statement_start = max(source.rfind(b";", 0, start), source.rfind(b"}", 0, start)) + 1
+        context = source[statement_start:start]
+        if re.search(rb"=\s*\{[^}]*$", context, re.DOTALL) is not None:
+            return "cpp-preprocessor-in-initializer"
+        return "cpp-preprocessor-in-expression"
+
+    @staticmethod
+    def _cpp_line_depth(line: bytes) -> int:
+        line = re.sub(rb'"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|//.*', b"", line)
+        return line.count(b"(") + line.count(b"{") + line.count(b"[") - line.count(b")") - line.count(b"}") - line.count(b"]")
+
+    @staticmethod
+    def _balanced_end(source: bytes, start: int, opening: int, closing: int) -> int | None:
+        depth = 0
+        quote: int | None = None
+        escaped = False
+        for index in range(start, len(source)):
+            value = source[index]
+            if quote is not None:
+                if escaped:
+                    escaped = False
+                elif value == 92:
+                    escaped = True
+                elif value == quote:
+                    quote = None
+                continue
+            if value in {34, 39}:
+                quote = value
+            elif value == opening:
+                depth += 1
+            elif value == closing:
+                depth -= 1
+                if depth == 0:
+                    return index + 1
+        return None
+
+    def _compatibility_problem(self, document: ParsedDocument, edit: CompatibilityEdit) -> Problem:
+        start_line, start_character = TreeSitterAdapter._point_at(
+            document.encoded, edit.start_byte, document.line_starts
+        )
+        end_line, end_character = TreeSitterAdapter._point_at(
+            document.encoded, edit.end_byte, document.line_starts
+        )
+        return Problem(
+            "syntax-error" if edit.is_error else "syntax-compatibility",
+            (
+                f"Rejected malformed compatibility construct: {edit.handler}"
+                if edit.is_error
+                else f"Applied position-preserving compatibility handler: {edit.handler}"
+            ),
+            "error" if edit.is_error else "warning",
+            self.language,
+            SourceRange(document.path, start_line, start_character, end_line, end_character),
+            {"native_kind": "source-normalization", "handler": edit.handler},
+        )
+
+    def _collect(
+        self,
+        node: Node,
+        document: ParsedDocument,
+        parents: tuple[str, ...],
+        parent_id: str,
+        symbols: list[Symbol],
+        problems: list[Problem],
+    ) -> None:
+        compatibility_handler = self._compatibility_handler(node, document.encoded)
+        if compatibility_handler is not None:
+            problems.append(
+                Problem(
+                    "syntax-compatibility",
+                    f"Applied position-preserving compatibility handler: {compatibility_handler}",
+                    "warning",
+                    self.language,
+                    self._range(document.path, node, document.encoded, document.line_starts),
+                    {"native_kind": node.type, "handler": compatibility_handler},
+                )
+            )
+        elif node.type == "ERROR" or node.is_missing:
+            problems.append(
+                Problem(
+                    "syntax-error",
+                    f"Tree-sitter reported {node.type}",
+                    "error",
+                    self.language,
+                    self._range(document.path, node, document.encoded, document.line_starts),
+                    {"native_kind": node.type},
+                )
+            )
+
+        definitions = self._definitions(node, document.encoded)
+        next_parents = parents
+        next_parent_id = parent_id
+        for name, kind in definitions:
+            if not name:
+                continue
+            qualified = ".".join((*parents, name))
+            target_id = stable_id(
+                "symbol",
+                self.language.value,
+                document.path,
+                qualified,
+                str(node.start_byte),
+            )
+            symbol = Symbol(
+                target_id,
+                name,
+                qualified,
+                kind,
+                self.language,
+                self._range(document.path, node, document.encoded, document.line_starts),
+                "",
+                document.path,
+                self._signature(node, document.encoded),
+                node.type,
+                parent_id,
+                self._symbol_name_range(
+                    node,
+                    name,
+                    document.path,
+                    document.encoded,
+                    document.line_starts,
+                ),
+            )
+            symbols.append(symbol)
+            if kind in {
+                "class",
+                "extension_block",
+                "function",
+                "implementation",
+                "interface",
+                "method",
+                "module",
+                "namespace",
+                "record",
+                "record_struct",
+                "struct",
+                "trait",
+                "union",
+            }:
+                next_parents = (*parents, name)
+                next_parent_id = target_id
+                break
+
+        for child in node.children:
+            self._collect(child, document, next_parents, next_parent_id, symbols, problems)
+
+    def _definitions(self, node: Node, source: bytes) -> tuple[tuple[str, str], ...]:
+        if self.language is Language.CSHARP and self._csharp_extension_block(node, source):
+            return (("extension", "extension_block"),)
+        if self.language is Language.CSHARP and node.type == "local_function_statement" and any(
+            self._csharp_extension_block(ancestor, source) for ancestor in self._ancestors(node)
+        ):
+            name = node.child_by_field_name("name")
+            return ((self._text(name, source), "extension_member"),) if name is not None else ()
+        kind = _DEFINITIONS[self.language].get(node.type)
+        if kind is not None:
+            return ((self._definition_name(node, source), kind),)
+        if self.language is Language.CSHARP and node.type == "event_field_declaration":
+            names = [self._text(name, source) for name in self._descendants(node, "variable_declarator")]
+            return tuple((name, "event") for name in names)
+        if self.language is Language.CPP and node.type == "declaration":
+            declarator = self._first_descendant(node, "function_declarator")
+            if declarator is not None:
+                return ((self._declarator_name(declarator, source), "function"),)
+        return ()
+
+    def _definition_name(self, node: Node, source: bytes) -> str:
+        if self.language is Language.RUST and node.type == "impl_item":
+            implemented_type = node.child_by_field_name("type")
+            trait = node.child_by_field_name("trait")
+            type_name = self._target_name(implemented_type, source) if implemented_type is not None else ""
+            trait_name = self._target_name(trait, source) if trait is not None else ""
+            return f"impl<{trait_name}>:{type_name}" if trait_name else f"impl:{type_name}"
+        if self.language is Language.CSHARP and node.type == "indexer_declaration":
+            return "this[]"
+        field = node.child_by_field_name("name")
+        if field is not None:
+            return self._text(field, source)
+        if node.type in {"function_definition", "declaration"}:
+            declarator = node.child_by_field_name("declarator") or self._first_descendant(node, "function_declarator")
+            if declarator is not None:
+                return self._declarator_name(declarator, source)
+        for child in node.named_children:
+            if child.type in _IDENTIFIERS:
+                return self._text(child, source)
+        return ""
+
+    def _declarator_name(self, node: Node, source: bytes) -> str:
+        declarator = node.child_by_field_name("declarator")
+        if declarator is not None:
+            if declarator.type in _IDENTIFIERS:
+                return self._text(declarator, source)
+            return self._declarator_name(declarator, source)
+        identifiers = [item for item in self._walk(node) if item.type in _IDENTIFIERS]
+        return self._text(identifiers[-1], source) if identifiers else ""
+
+    def _signature(self, node: Node, source: bytes) -> str:
+        body = node.child_by_field_name("body")
+        end = body.start_byte if body is not None else node.end_byte
+        signature = source[node.start_byte:end].decode("utf-8", "replace").strip()
+        return " ".join(signature.split())[:2000]
+
+    def _symbol_name_range(
+        self,
+        node: Node,
+        name: str,
+        path: str,
+        source: bytes,
+        line_starts: tuple[int, ...],
+    ) -> SourceRange | None:
+        simple = name.rsplit(":", 1)[-1].rsplit(".", 1)[-1]
+        for candidate in self._walk(node):
+            if candidate.type in _IDENTIFIERS and self._text(candidate, source) == simple:
+                return self._range(path, candidate, source, line_starts)
+        return None
+
+    def _compatibility_handler(self, node: Node, source: bytes) -> str | None:
+        if self.language is Language.PYTHON:
+            if node.type in {"exec_statement", "print_statement"}:
+                return "python-2-compatibility"
+            if node.type != "ERROR":
+                return None
+            snippet = self._text(node, source)
+            if _PYTHON_COMPAT_ERROR.search(snippet) is not None:
+                return "python-2-compatibility"
+            parent = node.parent
+            if (
+                parent is not None
+                and parent.type == "type_parameter"
+                and re.fullmatch(r"[A-Za-z_]\w*\s*=", snippet.strip()) is not None
+            ):
+                return "python-type-parameter-default"
+
+        if self.language is Language.CSHARP:
+            return "csharp-14-extension-members" if self._csharp_extension_block(node, source) else None
+        if self.language is not Language.CPP:
+            return None
+        if node.type != "ERROR" and not node.is_missing:
+            return None
+        snippet = self._text(node, source)
+        parent = node.parent
+        if node.is_missing and node.type == "type_identifier" and parent is not None:
+            optional_parameter = parent.parent
+            if (
+                parent.type == "compound_literal_expression"
+                and optional_parameter is not None
+                and optional_parameter.type == "optional_parameter_declaration"
+                and self._text(parent, source).strip() == "{}"
+            ):
+                return "cpp-braced-default-parameter"
+        if node.type == "ERROR" and parent is not None and parent.type == "initializer_list":
+            parent_text = self._text(parent, source)
+            stripped = snippet.strip()
+            if re.search(r"(?m)^\s*#define\b", parent_text) is not None and (
+                stripped.startswith("#define")
+                or stripped.startswith("#undef")
+                or re.fullmatch(r"#[A-Za-z_]\w*", stripped) is not None
+            ):
+                return "cpp-preprocessor-in-initializer"
+        return None
+
+    def _csharp_extension_block(self, node: Node, source: bytes) -> bool:
+        if self.language is not Language.CSHARP or node.type != "constructor_declaration":
+            return False
+        name = node.child_by_field_name("name")
+        if name is None or self._text(name, source) != "extension":
+            return False
+        owner = next(
+            (ancestor for ancestor in self._ancestors(node) if ancestor.type == "class_declaration"),
+            None,
+        )
+        owner_name = owner.child_by_field_name("name") if owner is not None else None
+        return owner_name is not None and self._text(owner_name, source) != "extension"
+
+    def _base_relations(
+        self,
+        node: Node,
+        owner: Symbol | None,
+        path: str | Path,
+        source: bytes,
+        line_starts: tuple[int, ...],
+    ) -> tuple[Relation, ...]:
+        base_node: Node | None = None
+        kind = "inherits"
+        relation_owner = owner
+        if self.language is Language.PYTHON and node.type == "class_definition":
+            base_node = node.child_by_field_name("superclasses")
+            relation_owner = next((item for item in (owner,) if item and item.kind == "class"), owner)
+        elif self.language is Language.CSHARP and node.type in {
+            "class_declaration",
+            "interface_declaration",
+            "record_declaration",
+            "record_struct_declaration",
+            "struct_declaration",
+        }:
+            base_node = next((child for child in node.named_children if child.type == "base_list"), None)
+        elif self.language is Language.CPP and node.type in {"class_specifier", "struct_specifier"}:
+            base_node = next((child for child in node.named_children if child.type == "base_class_clause"), None)
+        elif self.language is Language.RUST and node.type == "impl_item":
+            base_node = node.child_by_field_name("trait")
+            kind = "implements"
+        if base_node is None or relation_owner is None:
+            return ()
+
+        names = self._type_names(base_node, source)
+        return tuple(
+            Relation(
+                relation_owner.target_id,
+                "",
+                kind,
+                Resolution.UNRESOLVED,
+                (self._range(path, base_node, source, line_starts),),
+                name,
+            )
+            for name in names
+            if name not in {"object", "System.Object"}
+        )
+
+    def _type_names(self, node: Node, source: bytes) -> tuple[str, ...]:
+        if node.type in _IDENTIFIERS or node.type in {"generic_name", "qualified_name", "scoped_type_identifier"}:
+            return (self._target_name(node, source),)
+        names: list[str] = []
+        for child in node.named_children:
+            if child.type in {"access_specifier", "type_argument_list"}:
+                continue
+            if child.type in _IDENTIFIERS or child.type in {
+                "attribute",
+                "generic_name",
+                "qualified_identifier",
+                "qualified_name",
+                "scoped_type_identifier",
+            }:
+                name = self._target_name(child, source)
+                if name:
+                    names.append(name)
+        return tuple(dict.fromkeys(names))
+
+    def _import_name(self, node: Node, source: bytes) -> str:
+        path = node.child_by_field_name("path") or node.child_by_field_name("module_name")
+        if path is not None:
+            return self._text(path, source).strip("<>\"")
+        text = self._text(node, source).strip()
+        for prefix in ("#include", "import", "from", "use", "using"):
+            if text.startswith(prefix):
+                return text[len(prefix):].strip().strip(";<>\"")
+        return text
+
+    def _import_references(
+        self,
+        node: Node,
+        owner: Symbol | None,
+        path: str | Path,
+        source: bytes,
+        line_starts: tuple[int, ...],
+    ) -> tuple[Reference, ...]:
+        text = self._text(node, source).strip()
+        source_id = owner.target_id if owner else ""
+        source_range = self._range(path, node, source, line_starts)
+
+        def reference(
+            name: str,
+            import_path: str,
+            *,
+            imported_symbols: tuple[tuple[str, str], ...] = (),
+            module_alias: str = "",
+            wildcard: bool = False,
+            project_wide: bool = False,
+        ) -> Reference:
+            return Reference(
+                source_id,
+                "",
+                name,
+                self.language,
+                source_range,
+                Resolution.UNRESOLVED,
+                "import",
+                "",
+                import_path,
+                imported_symbols,
+                module_alias,
+                wildcard,
+                project_wide,
+            )
+
+        if self.language is Language.PYTHON:
+            from_match = re.match(r"from\s+([.A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s+import\s+(.+)$", text, re.DOTALL)
+            if from_match is not None:
+                import_path = from_match.group(1)
+                body = from_match.group(2).strip().strip("()")
+                if body == "*":
+                    return (reference("*", import_path, wildcard=True),)
+                result: list[Reference] = []
+                for item in body.split(","):
+                    parts = re.split(r"\s+as\s+", item.strip(), maxsplit=1)
+                    original = parts[0].strip()
+                    alias = parts[1].strip() if len(parts) == 2 else original
+                    if original:
+                        result.append(
+                            reference(
+                                alias,
+                                import_path,
+                                imported_symbols=((original, alias),),
+                            )
+                        )
+                return tuple(result)
+            import_match = re.match(r"import\s+(.+)$", text, re.DOTALL)
+            if import_match is not None:
+                result = []
+                for item in import_match.group(1).split(","):
+                    parts = re.split(r"\s+as\s+", item.strip(), maxsplit=1)
+                    import_path = parts[0].strip()
+                    alias = parts[1].strip() if len(parts) == 2 else import_path.split(".", 1)[0]
+                    if import_path:
+                        result.append(reference(alias, import_path, module_alias=alias))
+                return tuple(result)
+
+        if self.language is Language.RUST:
+            body = re.sub(r"^use\s+|;$", "", text).strip()
+            if "::{" in body and body.endswith("}"):
+                prefix, members = body.split("::{", 1)
+                result = []
+                for item in members[:-1].split(","):
+                    member = item.strip()
+                    if member == "*":
+                        result.append(reference("*", prefix, wildcard=True))
+                        continue
+                    parts = re.split(r"\s+as\s+", member, maxsplit=1)
+                    original = parts[0].strip()
+                    alias = parts[1].strip() if len(parts) == 2 else original
+                    if original:
+                        result.append(
+                            reference(alias, prefix, imported_symbols=((original, alias),))
+                        )
+                return tuple(result)
+            if body.endswith("::*"):
+                return (reference("*", body[:-3], wildcard=True),)
+            parts = re.split(r"\s+as\s+", body, maxsplit=1)
+            qualified = parts[0].strip()
+            segments = qualified.split("::")
+            if len(segments) > 1:
+                original = segments[-1]
+                alias = parts[1].strip() if len(parts) == 2 else original
+                return (
+                    reference(
+                        alias,
+                        "::".join(segments[:-1]),
+                        imported_symbols=((original, alias),),
+                    ),
+                )
+            if qualified:
+                alias = parts[1].strip() if len(parts) == 2 else qualified
+                return (reference(alias, qualified, module_alias=alias),)
+
+        if self.language is Language.CSHARP:
+            body = text.rstrip(";").strip()
+            project_wide = body.startswith("global using ")
+            body = re.sub(r"^global\s+", "", body)
+            body = re.sub(r"^using\s+", "", body)
+            static = body.startswith("static ")
+            body = re.sub(r"^static\s+", "", body)
+            alias_match = re.match(r"([A-Za-z_]\w*)\s*=\s*(.+)$", body)
+            if alias_match is not None:
+                qualified = alias_match.group(2).strip()
+                segments = qualified.split(".")
+                return (
+                    reference(
+                        alias_match.group(1),
+                        ".".join(segments[:-1]),
+                        imported_symbols=((segments[-1], alias_match.group(1)),),
+                        project_wide=project_wide,
+                    ),
+                )
+            if body:
+                return (
+                    reference(
+                        body,
+                        body,
+                        wildcard=True,
+                        project_wide=project_wide,
+                        module_alias=body if static else "",
+                    ),
+                )
+
+        if self.language is Language.CPP:
+            import_path = self._import_name(node, source)
+            return (reference(import_path, import_path, wildcard=True),) if import_path else ()
+        return ()
+
+    def _ffi_relations(
+        self,
+        root: Node,
+        symbols: tuple[Symbol, ...],
+        path: str | Path,
+        source: bytes,
+        line_starts: tuple[int, ...],
+    ) -> tuple[Relation, ...]:
+        if not any(marker in source for marker in _FFI_MARKERS[self.language]):
+            return ()
+        relations: list[Relation] = []
+        seen: set[tuple[str, str, str]] = set()
+
+        def add(node: Node, target_name: str, target_library: str = "") -> None:
+            owner = self._owner(symbols, node, source, line_starts)
+            key = (owner.target_id if owner else "", target_name, target_library)
+            if owner is None or not target_name or key in seen:
+                return
+            seen.add(key)
+            relations.append(
+                Relation(
+                    owner.target_id,
+                    "",
+                    "ffi",
+                    Resolution.SOUND_PARTIAL,
+                    (self._range(path, node, source, line_starts),),
+                    target_name,
+                    target_library,
+                )
+            )
+
+        aliases: dict[str, str] = {}
+        python_loaders, python_prototypes = self._python_ffi_call_names(root, source)
+        ffi_nodes = sorted(
+            self._query_nodes(self._ffi_query, root),
+            key=lambda item: (item.start_byte, item.end_byte, item.type),
+        )
+        if self.language is Language.PYTHON:
+            for node in ffi_nodes:
+                if node.type != "assignment":
+                    continue
+                left = node.child_by_field_name("left")
+                right = node.child_by_field_name("right")
+                if left is None or right is None or right.type != "call":
+                    continue
+                function_name = self._python_call_name(right, source)
+                if function_name in python_loaders:
+                    aliases[self._target_name(left, source)] = self._python_literal_argument(
+                        right,
+                        source,
+                    )
+                if function_name in python_prototypes:
+                    add(node, self._target_name(left, source))
+
+        for node in ffi_nodes:
+            if self.language is Language.PYTHON and node.type == "assignment":
+                continue
+            elif self.language is Language.PYTHON and node.type == "call":
+                function = node.child_by_field_name("function")
+                if function is not None and function.type == "attribute":
+                    owner = function.child_by_field_name("object")
+                    attribute = function.child_by_field_name("attribute")
+                    target_name = self._target_name(attribute, source)
+                    if owner is not None and owner.type == "call":
+                        loader = self._python_call_name(owner, source)
+                        if loader in python_loaders:
+                            add(node, target_name, self._python_literal_argument(owner, source))
+                    elif owner is not None and owner.type == "identifier":
+                        owner_name = self._target_name(owner, source)
+                        if owner_name in aliases:
+                            add(node, target_name, aliases[owner_name])
+                        elif owner_name == "ffi" and target_name == "cdef":
+                            declaration = self._python_literal_argument(node, source)
+                            for declared in re.findall(r"\b([A-Za-z_]\w*)\s*\(", declaration):
+                                if declared not in {"cdef", "if", "while"}:
+                                    add(node, declared)
+            elif self.language is Language.CSHARP and node.type == "method_declaration":
+                attribute = self._csharp_ffi_attribute(node, source)
+                if attribute is not None:
+                    library, entry = self._csharp_ffi_attribute_arguments(attribute, source)
+                    name_node = node.child_by_field_name("name")
+                    add(
+                        node,
+                        entry or self._target_name(name_node, source),
+                        library,
+                    )
+            elif self.language is Language.RUST and node.type in {"function_item", "function_signature_item"}:
+                ancestors = tuple(self._ancestors(node))
+                parent_types = {item.type for item in ancestors}
+                local_attributes = self._preceding_attributes(node)
+                foreign = next(
+                    (item for item in ancestors if item.type == "foreign_mod_item"),
+                    None,
+                )
+                foreign_attributes = (
+                    self._preceding_attributes(foreign)
+                    if foreign is not None
+                    else ()
+                )
+                export = self._rust_attribute_value(
+                    local_attributes,
+                    "export_name",
+                    source,
+                )
+                if "foreign_mod_item" in parent_types:
+                    link_name = self._rust_attribute_value(
+                        local_attributes,
+                        "link_name",
+                        source,
+                    )
+                    library = self._rust_attribute_value(
+                        foreign_attributes,
+                        "name",
+                        source,
+                        container="link",
+                    )
+                    target = link_name or export or self._definition_name(node, source)
+                    add(
+                        node,
+                        target,
+                        library,
+                    )
+                elif (
+                    node.type == "function_item"
+                    and self._rust_function_abi(node, source) in {"C", "system"}
+                    and (export or self._rust_has_no_mangle(local_attributes, source))
+                ):
+                    add(
+                        node,
+                        export or self._definition_name(node, source),
+                    )
+            elif self.language is Language.CPP and node.type in {"declaration", "function_definition"}:
+                linkage = next(
+                    (item for item in self._ancestors(node) if item.type == "linkage_specification"),
+                    None,
+                )
+                linkage_value = linkage.child_by_field_name("value") if linkage is not None else None
+                declaration_prefix = self._cpp_declaration_prefix(node, source)
+                if (
+                    linkage_value is not None
+                    and self._text(linkage_value, source) == '"C"'
+                    or "__declspec(dllexport)" in declaration_prefix
+                    or re.search(
+                        r"__attribute__\s*\(\([^)]*visibility\s*\(\s*\"default\"",
+                        declaration_prefix,
+                    )
+                ):
+                    add(node, self._definition_name(node, source))
+        return tuple(relations)
+
+    def _python_ffi_call_names(self, root: Node, source: bytes) -> tuple[set[str], set[str]]:
+        loaders = {
+            "ctypes.CDLL",
+            "ctypes.OleDLL",
+            "ctypes.PyDLL",
+            "ctypes.WinDLL",
+            "ctypes.cdll.LoadLibrary",
+            "ctypes.oledll.LoadLibrary",
+            "ctypes.pydll.LoadLibrary",
+            "ctypes.windll.LoadLibrary",
+            "ffi.dlopen",
+        }
+        prototypes = {"ctypes.CFUNCTYPE", "ctypes.WINFUNCTYPE"}
+        if self.language is not Language.PYTHON:
+            return loaders, prototypes
+
+        imported_loaders = {"CDLL", "OleDLL", "PyDLL", "WinDLL"}
+        imported_prototypes = {"CFUNCTYPE", "WINFUNCTYPE"}
+        imported_libraries = {"cdll", "oledll", "pydll", "windll"}
+        for node in self._walk(root):
+            if node.type == "import_statement":
+                for item in node.named_children:
+                    original = item.child_by_field_name("name") if item.type == "aliased_import" else item
+                    alias = item.child_by_field_name("alias") if item.type == "aliased_import" else item
+                    if original is not None and alias is not None and self._text(original, source) == "ctypes":
+                        prefix = self._text(alias, source)
+                        loaders.update(
+                            {
+                                f"{prefix}.{name}"
+                                for name in imported_loaders
+                            }
+                        )
+                        loaders.update(
+                            f"{prefix}.{name}.LoadLibrary" for name in imported_libraries
+                        )
+                        prototypes.update(f"{prefix}.{name}" for name in imported_prototypes)
+            elif node.type == "import_from_statement":
+                module = node.child_by_field_name("module_name")
+                if module is None or self._text(module, source) != "ctypes":
+                    continue
+                for item in node.named_children:
+                    if item == module:
+                        continue
+                    original_node = item.child_by_field_name("name") if item.type == "aliased_import" else item
+                    alias_node = item.child_by_field_name("alias") if item.type == "aliased_import" else item
+                    if original_node is None or alias_node is None:
+                        continue
+                    original_name = self._text(original_node, source)
+                    alias_name = self._text(alias_node, source)
+                    if original_name in imported_loaders:
+                        loaders.add(alias_name)
+                    elif original_name in imported_libraries:
+                        loaders.add(f"{alias_name}.LoadLibrary")
+                    elif original_name in imported_prototypes:
+                        prototypes.add(alias_name)
+        return loaders, prototypes
+
+    def _csharp_ffi_attribute(self, node: Node, source: bytes) -> Node | None:
+        for child in node.named_children:
+            if child.type != "attribute_list":
+                continue
+            for item in self._walk(child):
+                if item.type != "attribute":
+                    continue
+                name = item.child_by_field_name("name")
+                if self._target_name(name, source) in {
+                    "DllImport",
+                    "DllImportAttribute",
+                    "LibraryImport",
+                    "LibraryImportAttribute",
+                }:
+                    return item
+        return None
+
+    def _csharp_ffi_attribute_arguments(self, attribute: Node, source: bytes) -> tuple[str, str]:
+        library = ""
+        entry = ""
+        arguments = next(
+            (item for item in attribute.named_children if item.type == "attribute_argument_list"),
+            None,
+        )
+        if arguments is None:
+            return library, entry
+        for argument in arguments.named_children:
+            if argument.type != "attribute_argument":
+                continue
+            literal = next(
+                (item for item in argument.named_children if item.type == "string_literal"),
+                None,
+            )
+            if literal is None:
+                continue
+            value = self._csharp_string_literal(literal, source)
+            name = argument.child_by_field_name("name")
+            if name is not None and self._text(name, source) == "EntryPoint":
+                entry = value
+            elif name is None and not library:
+                library = value
+        return library, entry
+
+    def _csharp_string_literal(self, node: Node, source: bytes) -> str:
+        text = self._text(node, source)
+        if text.startswith('@"') and text.endswith('"'):
+            return text[2:-1].replace('""', '"')
+        try:
+            value = ast.literal_eval(text)
+        except (SyntaxError, ValueError):
+            return ""
+        return value if isinstance(value, str) else ""
+
+    def _preceding_attributes(self, node: Node) -> tuple[Node, ...]:
+        attributes: list[Node] = []
+        sibling = node.prev_named_sibling
+        while sibling is not None and sibling.type == "attribute_item":
+            attribute = next(
+                (item for item in sibling.named_children if item.type == "attribute"),
+                None,
+            )
+            if attribute is not None:
+                attributes.append(attribute)
+            sibling = sibling.prev_named_sibling
+        return tuple(reversed(attributes))
+
+    def _rust_attribute_value(
+        self,
+        attributes: tuple[Node, ...],
+        key: str,
+        source: bytes,
+        *,
+        container: str = "",
+    ) -> str:
+        for attribute in attributes:
+            identifiers = [
+                item
+                for item in self._walk(attribute)
+                if item.type == "identifier"
+            ]
+            if not identifiers:
+                continue
+            attribute_name = self._text(identifiers[0], source)
+            if container and attribute_name != container:
+                continue
+            if not container and attribute_name != key:
+                continue
+            for index, identifier in enumerate(identifiers):
+                if self._text(identifier, source) != key:
+                    continue
+                after_identifier = identifier.end_byte
+                literal = next(
+                    (
+                        item
+                        for item in self._walk(attribute)
+                        if item.type == "string_literal" and item.start_byte >= after_identifier
+                    ),
+                    None,
+                )
+                if literal is not None:
+                    return self._text(literal, source).strip('"')
+                if index == 0 and not container:
+                    break
+        return ""
+
+    def _rust_has_no_mangle(self, attributes: tuple[Node, ...], source: bytes) -> bool:
+        for attribute in attributes:
+            identifiers = [
+                self._text(item, source)
+                for item in self._walk(attribute)
+                if item.type == "identifier"
+            ]
+            if identifiers[:1] == ["no_mangle"]:
+                return True
+            if identifiers[:2] == ["unsafe", "no_mangle"]:
+                return True
+        return False
+
+    def _rust_function_abi(self, node: Node, source: bytes) -> str:
+        for child in node.named_children:
+            if child.type != "function_modifiers":
+                continue
+            for item in self._walk(child):
+                if item.type != "extern_modifier":
+                    continue
+                literal = next(
+                    (candidate for candidate in item.named_children if candidate.type == "string_literal"),
+                    None,
+                )
+                if literal is not None:
+                    return self._text(literal, source).strip('"')
+        return ""
+
+    def _python_call_name(self, node: Node, source: bytes) -> str:
+        function = node.child_by_field_name("function")
+        return self._text(function, source).strip() if function is not None else ""
+
+    def _python_literal_argument(self, node: Node, source: bytes) -> str:
+        arguments = node.child_by_field_name("arguments")
+        if arguments is None or not arguments.named_children:
+            return ""
+        literal = arguments.named_children[0]
+        if literal.type != "string":
+            return ""
+        try:
+            value = ast.literal_eval(self._text(literal, source))
+        except (SyntaxError, ValueError):
+            return ""
+        return value if isinstance(value, str) else ""
+
+    def _cpp_declaration_prefix(self, node: Node, source: bytes) -> str:
+        body = node.child_by_field_name("body")
+        end_byte = body.start_byte if body is not None else node.end_byte
+        start_byte = node.start_byte
+        prefix = bytearray(source[start_byte:end_byte])
+        for item in self._walk(node):
+            if item.type != "comment" or item.start_byte >= end_byte:
+                continue
+            comment_start = max(item.start_byte, start_byte) - start_byte
+            comment_end = min(item.end_byte, end_byte) - start_byte
+            prefix[comment_start:comment_end] = b" " * (comment_end - comment_start)
+        return prefix.decode("utf-8", "replace")
+
+    def _target_name(self, node: Node | None, source: bytes) -> str:
+        if node is None:
+            return ""
+        text = self._text(node, source).strip()
+        text = re.sub(r"(?:::<[^>]+>|<[^>]+>)$", "", text)
+        parts = re.findall(r"[A-Za-z_]\w*", text)
+        return parts[-1] if parts else text
+
+    def _target_qualifier(self, node: Node, source: bytes) -> str:
+        parts = re.findall(r"[A-Za-z_]\w*", self._text(node, source))
+        return ".".join(parts[:-1]) if len(parts) > 1 else ""
+
+    @staticmethod
+    def _resolve_reference(item: Reference, by_name: dict[str, list[Symbol]]) -> Reference:
+        candidates = by_name.get(item.name, [])
+        if len(candidates) == 1:
+            return replace(item, target_id=candidates[0].target_id, resolution=Resolution.COMPLETE)
+        if len(candidates) > 1:
+            return replace(item, resolution=Resolution.AMBIGUOUS)
+        return replace(item, target_id="", resolution=Resolution.UNRESOLVED)
+
+    @staticmethod
+    def _resolve_relation(item: Relation, by_name: dict[str, list[Symbol]]) -> Relation:
+        candidates = by_name.get(item.target_name, [])
+        if len(candidates) == 1:
+            kind = "implements" if candidates[0].kind == "interface" else item.kind
+            return replace(item, target_id=candidates[0].target_id, kind=kind, resolution=Resolution.COMPLETE)
+        if len(candidates) > 1:
+            return replace(item, target_id="", resolution=Resolution.AMBIGUOUS)
+        return replace(item, target_id="", resolution=Resolution.UNRESOLVED)
+
+    @staticmethod
+    def _text(node: Node, source: bytes) -> str:
+        return source[node.start_byte:node.end_byte].decode("utf-8", "replace")
+
+    @staticmethod
+    def _range(
+        path: str | Path,
+        node: Node,
+        source: bytes,
+        line_starts: tuple[int, ...],
+    ) -> SourceRange:
+        start_line, start_character = TreeSitterAdapter._point_at(source, node.start_byte, line_starts)
+        end_line, end_character = TreeSitterAdapter._point_at(source, node.end_byte, line_starts)
+        return SourceRange(
+            str(path),
+            start_line,
+            start_character,
+            end_line,
+            end_character,
+        )
+
+    @staticmethod
+    def _point_at(source: bytes, byte_offset: int, line_starts: tuple[int, ...]) -> tuple[int, int]:
+        row = max(0, bisect_right(line_starts, byte_offset) - 1)
+        line_start = line_starts[row]
+        text = source[line_start:byte_offset].decode("utf-8", "replace")
+        return row, len(text.encode("utf-16-le")) // 2
+
+    @staticmethod
+    def _walk(node: Node) -> Iterator[Node]:
+        yield node
+        for child in node.named_children:
+            yield from TreeSitterAdapter._walk(child)
+
+    @staticmethod
+    def _ancestors(node: Node) -> Iterator[Node]:
+        current = node.parent
+        while current is not None:
+            yield current
+            current = current.parent
+
+    @staticmethod
+    def _descendants(node: Node, kind: str) -> Iterator[Node]:
+        for item in TreeSitterAdapter._walk(node):
+            if item.type == kind:
+                name = item.child_by_field_name("name")
+                yield name or item
+
+    @staticmethod
+    def _first_descendant(node: Node, kind: str) -> Node | None:
+        return next((item for item in TreeSitterAdapter._walk(node) if item.type == kind), None)
+
+    @staticmethod
+    def _owner(
+        symbols: tuple[Symbol, ...],
+        node: Node,
+        source: bytes,
+        line_starts: tuple[int, ...],
+    ) -> Symbol | None:
+        start = TreeSitterAdapter._point_at(source, node.start_byte, line_starts)
+        end = TreeSitterAdapter._point_at(source, node.end_byte, line_starts)
+        matching = [
+            item
+            for item in symbols
+            if (item.range.start_line, item.range.start_character) <= start
+            and end <= (item.range.end_line, item.range.end_character)
+        ]
+        if not matching:
+            return None
+        return min(
+            matching,
+            key=lambda item: (
+                item.range.end_line - item.range.start_line,
+                item.range.end_character - item.range.start_character,
+            ),
+        )
+
+
+class PythonAdapter(TreeSitterAdapter):
+    def __init__(self) -> None:
+        super().__init__(Language.PYTHON, (".py", ".pyi", ".pyw"), tree_sitter_python)
+
+
+class RustAdapter(TreeSitterAdapter):
+    def __init__(self) -> None:
+        super().__init__(Language.RUST, (".rs",), tree_sitter_rust)
+
+
+class CSharpAdapter(TreeSitterAdapter):
+    def __init__(self) -> None:
+        super().__init__(Language.CSHARP, (".cs", ".csx"), tree_sitter_c_sharp)
+
+
+class CppAdapter(TreeSitterAdapter):
+    def __init__(
+        self,
+        workspace_root: str | Path | None = None,
+        include_paths: tuple[str | Path, ...] = (),
+    ) -> None:
+        super().__init__(
+            Language.CPP,
+            (".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx", ".ixx", ".cppm"),
+            tree_sitter_cpp,
+            workspace_root=workspace_root,
+            include_paths=include_paths,
+        )
+
+
+_ADAPTERS = (PythonAdapter(), RustAdapter(), CSharpAdapter(), CppAdapter())
+
+
+def registered_adapters() -> tuple[LanguageAdapter, ...]:
+    # Import lazily so the heavier Delphi grammar is loaded only when registry access is needed.
+    from .delphi import DelphiAdapter
+
+    return cast(tuple[LanguageAdapter, ...], (*_ADAPTERS, DelphiAdapter()))
+
+
+def adapters_for(path: str | Path) -> tuple[Language, ...]:
+    return tuple(adapter.language for adapter in registered_adapters() if adapter.detect(path))
+
+
+def adapter_for(
+    language: Language,
+    *,
+    workspace_root: str | Path | None = None,
+    include_paths: tuple[str | Path, ...] = (),
+) -> LanguageAdapter:
+    if language is Language.CPP and (workspace_root is not None or include_paths):
+        return CppAdapter(workspace_root, include_paths)
+    return next(item for item in registered_adapters() if item.language is language)
+
+
+def parse_source(
+    language: Language,
+    path: str | Path,
+    source: str,
+    *,
+    include_detail: bool = True,
+    workspace_root: str | Path | None = None,
+    include_paths: tuple[str | Path, ...] = (),
+) -> AdapterResult:
+    adapter = adapter_for(
+        language,
+        workspace_root=workspace_root,
+        include_paths=include_paths,
+    )
+    outline = adapter.parse_outline(path, source)
+    if not include_detail:
+        return outline
+    return adapter.resolve(adapter.parse_detail(path, source, outline))