python-delphi-lsp 3.6.0__cp310-abi3-win_amd64.whl

delphi_lsp/semantic_builder.py

@@ -0,0 +1,2302 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+
+from .consts import ATTRIBUTE_NAME_STRINGS, AttributeName, SyntaxNodeType
+from .delphiast_parser import _without_cyclic_gc
+from .nodes import CompoundSyntaxNode, SyntaxNode, ValuedSyntaxNode
+from .preprocessor import PreprocessedSource
+from .semantic import (
+    ArrayTypeRef,
+    ClassOfTypeRef,
+    ClassTypeRef,
+    EnumTypeRef,
+    FileTypeRef,
+    GenericInstanceTypeRef,
+    InterfaceTypeRef,
+    Modifier,
+    NamedTypeRef,
+    PointerTypeRef,
+    ProcTypeRef,
+    RecordTypeRef,
+    ReferenceKind,
+    ReferenceTypeRef,
+    Scope,
+    ScopeKind,
+    SetTypeRef,
+    SourceRange,
+    SubrangeTypeRef,
+    Symbol,
+    SymbolIndex,
+    SymbolKind,
+    SymbolReference,
+    TypeParameterRef,
+    TypeRef,
+    UnknownTypeRef,
+    Visibility,
+)
+
+
+@dataclass
+class SemanticProblem:
+    message: str
+    range: SourceRange
+
+
+@dataclass
+class SemanticModel:
+    unit_scope: Scope
+    index: SymbolIndex
+    problems: list[SemanticProblem] = field(default_factory=list)
+    references: list[SymbolReference] = field(default_factory=list)
+
+
+class SemanticBuilder:
+    def __init__(
+        self,
+        *,
+        collect_references: bool = True,
+        source_maps: Mapping[str, PreprocessedSource] | None = None,
+    ) -> None:
+        self._collect_references_enabled = collect_references
+        self._source_maps = source_maps or {}
+        self._problems: list[SemanticProblem] = []
+        self._references: list[SymbolReference] = []
+        self._index: SymbolIndex = SymbolIndex()
+        self._node_scopes: dict[int, Scope] = {}
+        self._builtin_types = {
+            'string', 'ansistring', 'widestring', 'unicodestring',
+            'char', 'widechar',
+            'integer', 'smallint', 'shortint', 'longint', 'int64', 'uint64',
+            'byte', 'word', 'cardinal', 'nativeint', 'nativeuint',
+            'boolean', 'bytebool', 'wordbool', 'longbool',
+            'single', 'double', 'extended', 'currency', 'real', 'real48',
+            'variant', 'olevariant', 'pointer', 'pchar', 'tobject', 'tclass',
+        }
+
+    @_without_cyclic_gc
+    def build(self, root: SyntaxNode, *, index: SymbolIndex | None = None) -> SemanticModel:
+        self._reset_state(index=index, clear_scopes=True)
+        unit_scope = self.declare(root, index=self._index)
+        return self.resolve(root, unit_scope)
+
+    def declare(
+        self,
+        root: SyntaxNode,
+        *,
+        index: SymbolIndex | None = None,
+        unit_scope: Scope | None = None,
+        reset_state: bool = False,
+    ) -> Scope:
+        if reset_state:
+            self._reset_state(index=index, clear_scopes=True)
+        elif index is not None:
+            self._index = index
+
+        unit_name = self._attr(root, AttributeName.anName) or 'unit'
+        if unit_scope is None:
+            unit_scope = Scope(kind=ScopeKind.UNIT, name=unit_name)
+        if unit_scope.owner is None:
+            unit_symbol = Symbol(
+                name=unit_name,
+                kind=SymbolKind.UNIT,
+                decl_range=self._node_range(root),
+                name_range=self._node_range(root),
+                scope=unit_scope,
+            )
+            unit_scope.owner = unit_symbol
+            self._define_symbol(unit_scope, unit_symbol)
+
+        self._declare_symbols(root, unit_scope, Visibility.PUBLIC)
+        self._index.register_unit(unit_name, unit_scope)
+        return unit_scope
+
+    def resolve(self, root: SyntaxNode, unit_scope: Scope) -> SemanticModel:
+        self._references = []
+        self._resolve_type_refs(unit_scope)
+
+        if self._collect_references_enabled:
+            self._collect_references_pass(root, unit_scope, Visibility.PUBLIC)
+
+        return SemanticModel(
+            unit_scope=unit_scope,
+            index=self._index,
+            problems=list(self._problems),
+            references=list(self._references),
+        )
+
+    def _reset_state(self, *, index: SymbolIndex | None, clear_scopes: bool) -> None:
+        self._problems = []
+        self._references = []
+        if clear_scopes:
+            self._node_scopes = {}
+        if index is not None:
+            self._index = index
+        elif self._index is None:
+            self._index = SymbolIndex()
+
+    def _declare_symbols(self, node: SyntaxNode, scope: Scope, visibility: Visibility) -> None:
+        pending = [(node, scope, visibility)]
+        while pending:
+            current, current_scope, current_visibility = pending.pop()
+            if current.typ == SyntaxNodeType.ntUses:
+                self._handle_uses(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntTypeSection:
+                self._handle_type_section(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntVariables:
+                self._handle_variable_section(
+                    current,
+                    current_scope,
+                    current_visibility,
+                )
+                continue
+            if current.typ == SyntaxNodeType.ntVariable:
+                self._handle_inline_variable(
+                    current,
+                    current_scope,
+                    current_visibility,
+                )
+                continue
+            if current.typ == SyntaxNodeType.ntConstants:
+                self._handle_constant_section(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntMethod:
+                routine_scope = self._handle_method(
+                    current,
+                    current_scope,
+                    current_visibility,
+                )
+                if routine_scope is not None:
+                    excluded = {
+                        SyntaxNodeType.ntParameters,
+                        SyntaxNodeType.ntReturnType,
+                        SyntaxNodeType.ntTypeParams,
+                    }
+                    pending.extend(
+                        (child, routine_scope, current_visibility)
+                        for child in reversed(current.child_nodes)
+                        if child.typ not in excluded
+                    )
+                continue
+            if current.typ == SyntaxNodeType.ntProperty:
+                self._handle_property(
+                    current,
+                    current_scope,
+                    current_visibility,
+                )
+                continue
+            if current.typ == SyntaxNodeType.ntField:
+                self._handle_field(
+                    current,
+                    current_scope,
+                    current_visibility,
+                )
+                continue
+            if current.typ == SyntaxNodeType.ntLabel:
+                self._handle_label(current, current_scope)
+                continue
+
+            pending.extend(
+                (child, current_scope, current_visibility)
+                for child in reversed(current.child_nodes)
+            )
+
+    def _handle_uses(self, node: SyntaxNode, scope: Scope) -> None:
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntUnit:
+                continue
+            name = self._attr(child, AttributeName.anName)
+            if not name:
+                continue
+            imported_scope = self._index.lookup_unit(name)
+            if imported_scope is None:
+                imported_scope = Scope(kind=ScopeKind.UNIT, name=name)
+                self._add_problem(f'Unresolved unit {name}', child)
+            scope.add_import(imported_scope)
+
+    def _handle_type_section(self, node: SyntaxNode, scope: Scope) -> None:
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntTypeDecl:
+                continue
+            self._handle_type_decl(child, scope)
+
+    def _handle_type_decl(self, node: SyntaxNode, scope: Scope) -> None:
+        name = self._attr(node, AttributeName.anName)
+        if not name:
+            return
+        type_node = node.find_node(SyntaxNodeType.ntType)
+        type_ref, kind = self._infer_type_ref_and_kind(name, type_node)
+        type_symbol = Symbol(
+            name=name,
+            kind=kind,
+            decl_range=self._node_range(node),
+            name_range=self._node_name_range(node, name),
+            scope=scope,
+            type_ref=type_ref,
+        )
+        type_scope = Scope(kind=ScopeKind.TYPE, name=name, parent=scope, owner=type_symbol)
+        type_symbol.member_scope = type_scope
+        type_symbol.base_types = self._type_bases(type_node)
+        self._define_symbol(scope, type_symbol)
+        self._node_scopes[id(node)] = type_scope
+
+        type_params = node.find_node(SyntaxNodeType.ntTypeParams)
+        if type_params is not None:
+            self._define_type_parameters(type_params, type_scope)
+
+        if kind == SymbolKind.ENUM and type_node is not None:
+            self._define_enum_values(type_node, scope, type_symbol)
+
+        if type_node is not None:
+            self._visit_type_members(type_node, type_scope)
+
+    def _define_enum_values(self, type_node: SyntaxNode, scope: Scope, type_symbol: Symbol) -> None:
+        for child in type_node.child_nodes:
+            if child.typ != SyntaxNodeType.ntEnum:
+                continue
+            name = self._child_name(child)
+            if not name:
+                continue
+            symbol = Symbol(
+                name=name,
+                kind=SymbolKind.ENUM_VALUE,
+                decl_range=self._node_range(child),
+                name_range=self._node_range(child),
+                scope=scope,
+                type_ref=NamedTypeRef(name=type_symbol.name),
+            )
+            self._define_symbol(scope, symbol)
+
+    def _visit_type_members(self, node: SyntaxNode, scope: Scope) -> None:
+        visibility = Visibility.PUBLIC
+        visibility_map = self._visibility_map()
+        for child in node.child_nodes:
+            if child.typ in visibility_map:
+                visibility = visibility_map[child.typ]
+                for member in child.child_nodes:
+                    self._declare_symbols(member, scope, visibility)
+                continue
+            self._declare_symbols(child, scope, visibility)
+
+    def _handle_variable_section(self, node: SyntaxNode, scope: Scope, visibility: Visibility) -> None:
+        section_kind = self._attr(node, AttributeName.anKind)
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntVariable:
+                continue
+            name = self._child_name(child)
+            if not name:
+                continue
+            type_ref = self._type_from_node(child.find_node(SyntaxNodeType.ntType))
+            symbol = Symbol(
+                name=name,
+                kind=SymbolKind.VARIABLE,
+                decl_range=self._node_range(child),
+                name_range=self._node_range(child),
+                scope=scope,
+                visibility=visibility,
+                type_ref=type_ref,
+            )
+            if section_kind:
+                symbol.attributes['section'] = section_kind
+            self._bind_anonymous_structured_type(child, symbol)
+            self._define_symbol(scope, symbol)
+
+    def _handle_constant_section(self, node: SyntaxNode, scope: Scope) -> None:
+        section_kind = self._attr(node, AttributeName.anKind)
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntConstant:
+                continue
+            name = self._child_name(child)
+            if not name:
+                continue
+            type_ref = self._type_from_node(child.find_node(SyntaxNodeType.ntType))
+            symbol = Symbol(
+                name=name,
+                kind=SymbolKind.CONSTANT,
+                decl_range=self._node_range(child),
+                name_range=self._node_range(child),
+                scope=scope,
+                type_ref=type_ref,
+            )
+            if section_kind:
+                symbol.attributes['section'] = section_kind
+            self._define_symbol(scope, symbol)
+
+    def _handle_field(self, node: SyntaxNode, scope: Scope, visibility: Visibility) -> None:
+        name = self._child_name(node)
+        if not name:
+            return
+        type_ref = self._type_from_node(node.find_node(SyntaxNodeType.ntType))
+        symbol = Symbol(
+            name=name,
+            kind=SymbolKind.FIELD,
+            decl_range=self._node_range(node),
+            name_range=self._node_range(node),
+            scope=scope,
+            visibility=visibility,
+            type_ref=type_ref,
+        )
+        self._bind_anonymous_structured_type(node, symbol)
+        self._define_symbol(scope, symbol)
+
+    def _handle_inline_variable(self, node: SyntaxNode, scope: Scope, visibility: Visibility) -> None:
+        name = self._child_name(node)
+        if not name:
+            return
+        type_ref = self._type_from_node(node.find_node(SyntaxNodeType.ntType))
+        if isinstance(type_ref, UnknownTypeRef):
+            type_ref = UnknownTypeRef('inferred')
+        symbol = Symbol(
+            name=name,
+            kind=SymbolKind.VARIABLE,
+            decl_range=self._node_range(node),
+            name_range=self._node_range(node),
+            scope=scope,
+            visibility=visibility,
+            type_ref=type_ref,
+        )
+        symbol.attributes['section'] = 'inline'
+        self._bind_anonymous_structured_type(node, symbol)
+        self._define_symbol(scope, symbol)
+
+    def _bind_anonymous_structured_type(
+        self,
+        declaration: SyntaxNode,
+        symbol: Symbol,
+    ) -> None:
+        type_node = declaration.find_node(SyntaxNodeType.ntType)
+        structured = self._anonymous_structured_type_node(type_node)
+        if structured is None:
+            return
+        member_scope = Scope(
+            kind=ScopeKind.TYPE,
+            name=symbol.name,
+            parent=symbol.scope,
+            owner=symbol,
+        )
+        symbol.member_scope = member_scope
+        self._node_scopes[id(declaration)] = member_scope
+        self._node_scopes[id(structured)] = member_scope
+        type_tag = self._attr(structured, AttributeName.anType)
+        packed = self._type_wrapper_contains(type_node, {'packed', 'bitpacked'})
+        if type_tag == 'record':
+            replacement: TypeRef = RecordTypeRef(
+                name='',
+                scope=member_scope,
+                packed=packed,
+            )
+        elif type_tag == 'class':
+            replacement = ClassTypeRef(
+                name='',
+                scope=member_scope,
+                bases=self._type_bases(structured),
+            )
+        else:
+            replacement = InterfaceTypeRef(
+                name='',
+                scope=member_scope,
+                bases=self._type_bases(structured),
+            )
+        symbol.type_ref = self._replace_unknown_type_ref(
+            symbol.type_ref,
+            replacement,
+        )
+        self._visit_type_members(structured, member_scope)
+
+    def _anonymous_structured_type_node(
+        self,
+        node: SyntaxNode | None,
+    ) -> SyntaxNode | None:
+        if node is None:
+            return None
+        if self._attr(node, AttributeName.anType) in {
+            'record',
+            'class',
+            'interface',
+            'dispinterface',
+        }:
+            return node
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntType:
+                continue
+            structured = self._anonymous_structured_type_node(child)
+            if structured is not None:
+                return structured
+        return None
+
+    def _type_wrapper_contains(
+        self,
+        node: SyntaxNode | None,
+        wrappers: set[str],
+    ) -> bool:
+        current = node
+        while current is not None:
+            if self._attr(current, AttributeName.anType) in wrappers:
+                return True
+            current = next(
+                (
+                    child
+                    for child in current.child_nodes
+                    if child.typ == SyntaxNodeType.ntType
+                ),
+                None,
+            )
+        return False
+
+    def _replace_unknown_type_ref(
+        self,
+        type_ref: TypeRef,
+        replacement: TypeRef,
+    ) -> TypeRef:
+        if isinstance(type_ref, UnknownTypeRef):
+            return replacement
+        if isinstance(type_ref, ArrayTypeRef):
+            return ArrayTypeRef(
+                element_type=self._replace_unknown_type_ref(
+                    type_ref.element_type,
+                    replacement,
+                ),
+                dimensions=type_ref.dimensions,
+                is_dynamic=type_ref.is_dynamic,
+            )
+        if isinstance(type_ref, PointerTypeRef):
+            return PointerTypeRef(
+                self._replace_unknown_type_ref(type_ref.target, replacement)
+            )
+        if isinstance(type_ref, SetTypeRef):
+            return SetTypeRef(
+                self._replace_unknown_type_ref(
+                    type_ref.element_type,
+                    replacement,
+                )
+            )
+        if isinstance(type_ref, ClassOfTypeRef):
+            return ClassOfTypeRef(
+                self._replace_unknown_type_ref(type_ref.target, replacement)
+            )
+        if isinstance(type_ref, ReferenceTypeRef):
+            return ReferenceTypeRef(
+                self._replace_unknown_type_ref(type_ref.target, replacement)
+            )
+        if isinstance(type_ref, FileTypeRef) and type_ref.element_type is not None:
+            return FileTypeRef(
+                self._replace_unknown_type_ref(
+                    type_ref.element_type,
+                    replacement,
+                )
+            )
+        return type_ref
+
+    def _handle_label(self, node: SyntaxNode, scope: Scope) -> None:
+        name = self._attr(node, AttributeName.anName)
+        if not name and isinstance(node, ValuedSyntaxNode):
+            name = node.value
+        if not name:
+            return
+        symbol = Symbol(
+            name=name,
+            kind=SymbolKind.LABEL,
+            decl_range=self._node_range(node),
+            name_range=self._node_range(node),
+            scope=scope,
+        )
+        self._define_symbol(scope, symbol)
+
+    def _handle_method(
+        self,
+        node: SyntaxNode,
+        scope: Scope,
+        visibility: Visibility,
+    ) -> Scope | None:
+        name = self._attr(node, AttributeName.anName)
+        if not name:
+            return None
+        kind = self._method_kind(node)
+        type_ref = self._method_type_ref(node, name)
+        symbol = Symbol(
+            name=name,
+            kind=kind,
+            decl_range=self._node_tree_range(node),
+            name_range=self._node_range(node),
+            scope=scope,
+            visibility=visibility,
+            type_ref=type_ref,
+            modifiers=self._method_modifiers(node),
+            attributes=self._symbol_attributes(node),
+        )
+        routine_parent = scope
+        name_parts = self._normalized_reference_parts(name)
+        if len(name_parts) > 1 and scope.kind == ScopeKind.UNIT:
+            declaring_type = self._declaring_type_for_method(name_parts, scope)
+            if declaring_type is not None and declaring_type.member_scope is not None:
+                routine_parent = declaring_type.member_scope
+        routine_scope = Scope(
+            kind=ScopeKind.ROUTINE,
+            name=name,
+            parent=routine_parent,
+            owner=symbol,
+        )
+        symbol.member_scope = routine_scope
+        self._define_symbol(scope, symbol)
+        self._node_scopes[id(node)] = routine_scope
+
+        params = node.find_node(SyntaxNodeType.ntParameters)
+        if params is not None:
+            self._define_parameters(params, routine_scope)
+
+        type_params = node.find_node(SyntaxNodeType.ntTypeParams)
+        if type_params is not None:
+            self._define_type_parameters(type_params, routine_scope)
+
+        return routine_scope
+
+    def _declaring_type_for_method(
+        self,
+        name_parts: list[str],
+        scope: Scope,
+    ) -> Symbol | None:
+        type_name = '.'.join(name_parts[:-1])
+        if len(name_parts) == 2:
+            candidates = scope.resolve(type_name)
+        else:
+            resolved = self._resolve_reference(
+                type_name,
+                ReferenceKind.TYPE,
+                scope,
+            )
+            candidates = [resolved] if resolved is not None else []
+        type_kinds = {
+            SymbolKind.CLASS,
+            SymbolKind.INTERFACE,
+            SymbolKind.RECORD,
+            SymbolKind.TYPE,
+        }
+        candidates = [
+            candidate
+            for candidate in candidates
+            if candidate.kind in type_kinds and candidate.member_scope is not None
+        ]
+        member_name = name_parts[-1]
+        member_matches = [
+            candidate
+            for candidate in candidates
+            if candidate.member_scope is not None
+            and candidate.member_scope.lookup_local(member_name)
+        ]
+        if len(member_matches) == 1:
+            return member_matches[0]
+        populated = [
+            candidate
+            for candidate in candidates
+            if candidate.member_scope is not None and candidate.member_scope.symbols
+        ]
+        if len(populated) == 1:
+            return populated[0]
+        return candidates[0] if len(candidates) == 1 else None
+
+    def _handle_property(self, node: SyntaxNode, scope: Scope, visibility: Visibility) -> None:
+        name = self._attr(node, AttributeName.anName)
+        if not name:
+            return
+        type_ref = self._type_from_node(node.find_node(SyntaxNodeType.ntType))
+        symbol = Symbol(
+            name=name,
+            kind=SymbolKind.PROPERTY,
+            decl_range=self._node_range(node),
+            name_range=self._node_range(node),
+            scope=scope,
+            visibility=visibility,
+            type_ref=type_ref,
+            attributes=self._symbol_attributes(node),
+        )
+        self._define_symbol(scope, symbol)
+
+    def _define_parameters(self, node: SyntaxNode, scope: Scope) -> None:
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntParameter:
+                continue
+            name = self._child_name(child)
+            if not name:
+                continue
+            type_ref = self._type_from_node(child.find_node(SyntaxNodeType.ntType))
+            symbol = Symbol(
+                name=name,
+                kind=SymbolKind.PARAMETER,
+                decl_range=self._node_range(child),
+                name_range=self._node_range(child),
+                scope=scope,
+                type_ref=type_ref,
+            )
+            kind = self._attr(child, AttributeName.anKind)
+            if kind:
+                symbol.attributes['modifier'] = kind
+            self._define_symbol(scope, symbol)
+
+    def _define_type_parameters(self, node: SyntaxNode, scope: Scope) -> None:
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntTypeParam:
+                continue
+            name = self._child_name(child)
+            if not name:
+                continue
+            symbol = Symbol(
+                name=name,
+                kind=SymbolKind.TYPE_PARAMETER,
+                decl_range=self._node_range(child),
+                name_range=self._node_range(child),
+                scope=scope,
+                type_ref=TypeParameterRef(name=name),
+            )
+            constraints = self._constraint_names(child)
+            if constraints:
+                symbol.attributes['constraints'] = ', '.join(constraints)
+            self._define_symbol(scope, symbol)
+
+    def _method_kind(self, node: SyntaxNode) -> SymbolKind:
+        kind = self._attr(node, AttributeName.anKind)
+        if kind == 'function':
+            return SymbolKind.FUNCTION
+        if kind == 'procedure':
+            return SymbolKind.PROCEDURE
+        if kind == 'constructor':
+            return SymbolKind.CONSTRUCTOR
+        if kind == 'destructor':
+            return SymbolKind.DESTRUCTOR
+        return SymbolKind.METHOD
+
+    def _method_modifiers(self, node: SyntaxNode) -> set[Modifier]:
+        modifiers: set[Modifier] = set()
+        if self._attr(node, AttributeName.anClass) == 'true':
+            modifiers.add(Modifier.CLASS)
+        binding = self._attr(node, AttributeName.anMethodBinding)
+        if binding in {'virtual', 'dynamic'}:
+            modifiers.add(Modifier.VIRTUAL)
+        if binding == 'override':
+            modifiers.add(Modifier.OVERRIDE)
+        if self._attr(node, AttributeName.anReintroduce) == 'true':
+            modifiers.add(Modifier.REINTRODUCE)
+        if self._attr(node, AttributeName.anOverload) == 'true':
+            modifiers.add(Modifier.OVERLOAD)
+        if self._attr(node, AttributeName.anAbstract) == 'true':
+            modifiers.add(Modifier.ABSTRACT)
+        if self._attr(node, AttributeName.anInline) == 'true':
+            modifiers.add(Modifier.INLINE)
+        if self._attr(node, AttributeName.anExternal) == 'true':
+            modifiers.add(Modifier.EXTERNAL)
+        if self._attr(node, AttributeName.anForwarded) == 'true':
+            modifiers.add(Modifier.FORWARD)
+        if self._attr(node, AttributeName.anDeprecated):
+            modifiers.add(Modifier.DEPRECATED)
+        if self._attr(node, AttributeName.anNoReturn) == 'true':
+            modifiers.add(Modifier.NORETURN)
+        if self._attr(node, AttributeName.anStatic) == 'true':
+            modifiers.add(Modifier.STATIC)
+        if self._attr(node, AttributeName.anFinal) == 'true':
+            modifiers.add(Modifier.FINAL)
+        if self._attr(node, AttributeName.anSealed) == 'true':
+            modifiers.add(Modifier.SEALED)
+        return modifiers
+
+    def _method_type_ref(self, node: SyntaxNode, name: str) -> TypeRef:
+        params = node.find_node(SyntaxNodeType.ntParameters)
+        param_types = tuple(
+            self._type_from_node(p.find_node(SyntaxNodeType.ntType))
+            for p in params.child_nodes
+            if p.typ == SyntaxNodeType.ntParameter
+        ) if params else ()
+        return_type_node = node.find_node(SyntaxNodeType.ntReturnType)
+        return_type = None
+        if return_type_node is not None:
+            return_type = self._type_from_node(return_type_node.find_node(SyntaxNodeType.ntType))
+        return ProcTypeRef(name=name, params=param_types, return_type=return_type)
+
+    def _infer_type_ref_and_kind(self, name: str, type_node: SyntaxNode | None) -> tuple[TypeRef, SymbolKind]:
+        if type_node is None:
+            return UnknownTypeRef('missing type'), SymbolKind.TYPE
+        while self._attr(type_node, AttributeName.anType) in {'packed', 'bitpacked'}:
+            nested_type = next(
+                (
+                    child
+                    for child in type_node.child_nodes
+                    if child.typ == SyntaxNodeType.ntType
+                ),
+                None,
+            )
+            if nested_type is None:
+                break
+            type_node = nested_type
+        type_tag = self._attr(type_node, AttributeName.anType)
+        name_tag = self._attr(type_node, AttributeName.anName)
+        if type_tag in {'class', 'objcclass'}:
+            return ClassTypeRef(name=name), SymbolKind.CLASS
+        if type_tag == 'record':
+            return RecordTypeRef(name=name), SymbolKind.RECORD
+        if type_tag in {'interface', 'dispinterface'}:
+            return InterfaceTypeRef(name=name), SymbolKind.INTERFACE
+        if name_tag == 'enum':
+            members = tuple(self._enum_members(type_node))
+            return EnumTypeRef(name=name, members=members), SymbolKind.ENUM
+        if type_tag == 'set':
+            elem = self._type_from_node(type_node.find_node(SyntaxNodeType.ntType))
+            return SetTypeRef(element_type=elem), SymbolKind.TYPE
+        if type_tag == 'array':
+            return self._type_from_node(type_node), SymbolKind.TYPE
+        if type_tag == 'distinct':
+            return self._type_from_node(type_node), SymbolKind.TYPE
+        if name_tag == 'subrange':
+            lower, upper = self._subrange_bounds(type_node)
+            return SubrangeTypeRef(lower=lower, upper=upper), SymbolKind.TYPE
+        if name_tag:
+            return NamedTypeRef(name=name_tag), SymbolKind.TYPE
+        return UnknownTypeRef('unresolved type'), SymbolKind.TYPE
+
+    def _type_bases(self, type_node: SyntaxNode | None) -> tuple[TypeRef, ...]:
+        if type_node is None:
+            return ()
+        bases = []
+        for child in type_node.child_nodes:
+            if child.typ == SyntaxNodeType.ntType:
+                bases.append(self._type_from_node(child))
+        return tuple(bases)
+
+    def _resolve_type_refs(self, scope: Scope) -> None:
+        pending = [scope]
+        while pending:
+            current = pending.pop()
+            member_scopes: list[Scope] = []
+            for symbols in current.symbols.values():
+                for symbol in symbols:
+                    symbol.type_ref = self._resolve_type_ref(
+                        symbol.type_ref,
+                        current,
+                    )
+                    if symbol.member_scope is not None:
+                        member_scopes.append(symbol.member_scope)
+            pending.extend(reversed(member_scopes))
+
+    def _resolve_type_ref(self, type_ref: TypeRef, scope: Scope) -> TypeRef:
+        if isinstance(type_ref, GenericInstanceTypeRef):
+            base = self._resolve_type_ref(type_ref.base, scope)
+            args = tuple(self._resolve_type_ref(arg, scope) for arg in type_ref.args)
+            if isinstance(base, NamedTypeRef):
+                return GenericInstanceTypeRef(base=base, args=args)
+            return GenericInstanceTypeRef(base=NamedTypeRef(name=type_ref.base.name), args=args)
+        if isinstance(type_ref, ArrayTypeRef):
+            elem = self._resolve_type_ref(type_ref.element_type, scope)
+            dims = tuple(self._resolve_type_ref(dim, scope) for dim in type_ref.dimensions)
+            return ArrayTypeRef(element_type=elem, dimensions=dims, is_dynamic=type_ref.is_dynamic)
+        if isinstance(type_ref, SetTypeRef):
+            elem = self._resolve_type_ref(type_ref.element_type, scope)
+            return SetTypeRef(element_type=elem)
+        if isinstance(type_ref, PointerTypeRef):
+            return PointerTypeRef(self._resolve_type_ref(type_ref.target, scope))
+        if isinstance(type_ref, ClassOfTypeRef):
+            return ClassOfTypeRef(self._resolve_type_ref(type_ref.target, scope))
+        if isinstance(type_ref, ReferenceTypeRef):
+            return ReferenceTypeRef(self._resolve_type_ref(type_ref.target, scope))
+        if isinstance(type_ref, FileTypeRef) and type_ref.element_type is not None:
+            return FileTypeRef(self._resolve_type_ref(type_ref.element_type, scope))
+        if isinstance(type_ref, ProcTypeRef):
+            return ProcTypeRef(
+                name=type_ref.name,
+                params=tuple(
+                    self._resolve_type_ref(parameter, scope)
+                    for parameter in type_ref.params
+                ),
+                return_type=(
+                    self._resolve_type_ref(type_ref.return_type, scope)
+                    if type_ref.return_type is not None
+                    else None
+                ),
+            )
+        if isinstance(type_ref, NamedTypeRef):
+            return self._normalize_named_type(type_ref, scope)
+        return type_ref
+
+    def _normalize_named_type(self, type_ref: NamedTypeRef, scope: Scope) -> NamedTypeRef:
+        if type_ref.unit_name:
+            return type_ref
+        if '.' in type_ref.name:
+            unit_name, name = self._split_qualified_name(type_ref.name)
+            return NamedTypeRef(name=name, unit_name=unit_name)
+        resolved = scope.resolve(type_ref.name)
+        if resolved:
+            symbol = resolved[0]
+            unit_scope = self._unit_scope_for_symbol(symbol)
+            if unit_scope is not None and unit_scope.name != scope.name:
+                return NamedTypeRef(name=type_ref.name, unit_name=unit_scope.name)
+        return type_ref
+
+    def _type_from_node(self, node: SyntaxNode | None) -> TypeRef:
+        if node is None:
+            return UnknownTypeRef('missing type')
+        name = self._attr(node, AttributeName.anName)
+        type_tag = self._attr(node, AttributeName.anType)
+        if type_tag == 'pointer':
+            target = node.find_node(SyntaxNodeType.ntType)
+            return PointerTypeRef(self._type_from_node(target))
+        if type_tag == 'array':
+            element = self._type_from_node(node.find_node(SyntaxNodeType.ntType))
+            bounds_node = node.find_node(SyntaxNodeType.ntBounds)
+            if bounds_node is None or not bounds_node.child_nodes:
+                return ArrayTypeRef(element_type=element, is_dynamic=True)
+            dims = tuple(self._bound_type_ref(child) for child in bounds_node.child_nodes)
+            return ArrayTypeRef(element_type=element, dimensions=dims, is_dynamic=False)
+        if type_tag == 'set':
+            elem = self._type_from_node(node.find_node(SyntaxNodeType.ntType))
+            return SetTypeRef(element_type=elem)
+        if type_tag == 'class of':
+            target = node.find_node(SyntaxNodeType.ntType)
+            return ClassOfTypeRef(self._type_from_node(target))
+        if type_tag == 'reference':
+            target = node.find_node(SyntaxNodeType.ntType)
+            return ReferenceTypeRef(self._type_from_node(target))
+        if type_tag == 'file':
+            target = node.find_node(SyntaxNodeType.ntType)
+            if target is None:
+                return FileTypeRef(None)
+            return FileTypeRef(self._type_from_node(target))
+        if type_tag in {'packed', 'bitpacked'}:
+            target = node.find_node(SyntaxNodeType.ntType)
+            return self._type_from_node(target)
+        if type_tag == 'distinct':
+            target = node.find_node(SyntaxNodeType.ntType)
+            return self._type_from_node(target)
+        if type_tag in {'procedure', 'function'}:
+            return self._proc_type_from_node(node, type_tag)
+        if name == 'subrange':
+            lower, upper = self._subrange_bounds(node)
+            return SubrangeTypeRef(lower=lower, upper=upper)
+
+        type_args_node = node.find_node(SyntaxNodeType.ntTypeArgs)
+        if name:
+            base = self._type_ref_from_name(name)
+            if type_args_node is not None:
+                args = tuple(
+                    self._type_from_node(child)
+                    for child in type_args_node.child_nodes
+                    if child.typ == SyntaxNodeType.ntType
+                )
+                if isinstance(base, NamedTypeRef):
+                    return GenericInstanceTypeRef(base=base, args=args)
+            return base
+        return UnknownTypeRef('unresolved type')
+
+    def _type_ref_from_name(self, name: str) -> TypeRef:
+        generic = self._generic_name_parts(name)
+        if generic is None:
+            return self._named_type_ref(name)
+        base_name, arg_names = generic
+        base = self._named_type_ref(base_name)
+        args = tuple(self._type_ref_from_name(arg_name) for arg_name in arg_names)
+        if isinstance(base, NamedTypeRef):
+            return GenericInstanceTypeRef(base=base, args=args)
+        return self._named_type_ref(name)
+
+    def _generic_name_parts(self, name: str) -> tuple[str, tuple[str, ...]] | None:
+        text = name.strip()
+        open_index = text.find('<')
+        if open_index <= 0 or not text.endswith('>'):
+            return None
+        depth = 0
+        for index, ch in enumerate(text[open_index:], start=open_index):
+            if ch == '<':
+                depth += 1
+            elif ch == '>':
+                depth -= 1
+                if depth == 0 and index != len(text) - 1:
+                    return None
+                if depth < 0:
+                    return None
+        if depth != 0:
+            return None
+        base_name = text[:open_index].strip()
+        if not base_name:
+            return None
+        args = self._split_top_level_type_args(text[open_index + 1 : -1])
+        if not args:
+            return None
+        return base_name, tuple(args)
+
+    def _split_top_level_type_args(self, text: str) -> list[str]:
+        args: list[str] = []
+        current: list[str] = []
+        angle = 0
+        square = 0
+        round_ = 0
+        in_string = False
+        index = 0
+        while index < len(text):
+            ch = text[index]
+            if ch == "'":
+                current.append(ch)
+                if in_string and index + 1 < len(text) and text[index + 1] == "'":
+                    current.append(text[index + 1])
+                    index += 2
+                    continue
+                in_string = not in_string
+                index += 1
+                continue
+            if not in_string:
+                if ch == '<':
+                    angle += 1
+                elif ch == '>':
+                    angle = max(0, angle - 1)
+                elif ch == '[':
+                    square += 1
+                elif ch == ']':
+                    square = max(0, square - 1)
+                elif ch == '(':
+                    round_ += 1
+                elif ch == ')':
+                    round_ = max(0, round_ - 1)
+                elif ch == ',' and angle == 0 and square == 0 and round_ == 0:
+                    arg = ''.join(current).strip()
+                    if arg:
+                        args.append(arg)
+                    current = []
+                    index += 1
+                    continue
+            current.append(ch)
+            index += 1
+        arg = ''.join(current).strip()
+        if arg:
+            args.append(arg)
+        return args
+
+    def _proc_type_from_node(self, node: SyntaxNode, kind: str) -> TypeRef:
+        params = node.find_node(SyntaxNodeType.ntParameters)
+        param_types = tuple(
+            self._type_from_node(p.find_node(SyntaxNodeType.ntType))
+            for p in params.child_nodes
+            if p.typ == SyntaxNodeType.ntParameter
+        ) if params else ()
+        return_type = None
+        return_type_node = node.find_node(SyntaxNodeType.ntReturnType)
+        if return_type_node is not None:
+            return_type = self._type_from_node(return_type_node.find_node(SyntaxNodeType.ntType))
+        return ProcTypeRef(name=kind, params=param_types, return_type=return_type)
+
+    def _bound_type_ref(self, node: SyntaxNode) -> TypeRef:
+        if node.typ == SyntaxNodeType.ntSubrange:
+            lower, upper = self._subrange_bounds(node)
+            return SubrangeTypeRef(lower=lower, upper=upper)
+        text = self._expr_to_text(node)
+        if text:
+            return NamedTypeRef(name=text)
+        return UnknownTypeRef('bound')
+
+    def _subrange_bounds(self, node: SyntaxNode) -> tuple[str, str]:
+        bounds = node.find_node(SyntaxNodeType.ntBounds)
+        if bounds is None:
+            children = node.child_nodes
+        else:
+            children = bounds.child_nodes
+        values = [self._expr_to_text(child) for child in children if self._expr_to_text(child)]
+        if len(values) >= 2:
+            return (values[0], values[1])
+        return ('', '')
+
+    def _enum_members(self, node: SyntaxNode) -> Iterable[str]:
+        for child in node.child_nodes:
+            if child.typ == SyntaxNodeType.ntEnum:
+                name = self._child_name(child)
+                if name:
+                    yield name
+
+    def _collect_references_pass(self, node: SyntaxNode, scope: Scope, visibility: Visibility) -> None:
+        pending = [(node, scope, visibility)]
+        while pending:
+            current, current_scope, current_visibility = pending.pop()
+            if current.typ in {
+                SyntaxNodeType.ntCall,
+                SyntaxNodeType.ntDot,
+                SyntaxNodeType.ntIdentifier,
+            }:
+                self._collect_expr_references(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntUses:
+                self._collect_uses_references(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntTypeSection:
+                for child in current.child_nodes:
+                    if child.typ == SyntaxNodeType.ntTypeDecl:
+                        self._collect_type_decl_references(
+                            child,
+                            current_scope,
+                        )
+                continue
+            if current.typ == SyntaxNodeType.ntVariables:
+                for child in current.child_nodes:
+                    if child.typ == SyntaxNodeType.ntVariable:
+                        self._collect_variable_references(
+                            child,
+                            current_scope,
+                        )
+                continue
+            if current.typ == SyntaxNodeType.ntVariable:
+                self._collect_variable_references(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntConstants:
+                for child in current.child_nodes:
+                    if child.typ == SyntaxNodeType.ntConstant:
+                        self._collect_constant_references(
+                            child,
+                            current_scope,
+                        )
+                continue
+            if current.typ == SyntaxNodeType.ntMethod:
+                method_scope, body = self._collect_method_references(
+                    current,
+                    current_scope,
+                )
+                pending.extend(
+                    (child, method_scope, current_visibility)
+                    for child in reversed(body)
+                )
+                continue
+            if current.typ == SyntaxNodeType.ntResolutionClause:
+                self._add_method_resolution_reference(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntProperty:
+                self._collect_property_references(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntField:
+                self._collect_field_references(current, current_scope)
+                continue
+            if current.typ == SyntaxNodeType.ntWith:
+                with_scope, body = self._collect_with_references(
+                    current,
+                    current_scope,
+                )
+                pending.extend(
+                    (child, with_scope, current_visibility)
+                    for child in reversed(body)
+                )
+                continue
+            if current.typ == SyntaxNodeType.ntGoto:
+                label_name = self._attr(current, AttributeName.anName)
+                self._add_reference(
+                    label_name,
+                    ReferenceKind.LABEL,
+                    current,
+                    current_scope,
+                )
+                continue
+
+            pending.extend(
+                (child, current_scope, current_visibility)
+                for child in reversed(current.child_nodes)
+            )
+
+    def _collect_uses_references(self, node: SyntaxNode, scope: Scope) -> None:
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntUnit:
+                continue
+            name = self._attr(child, AttributeName.anName)
+            if name:
+                self._add_reference(name, ReferenceKind.UNIT, child, scope)
+
+    def _collect_type_decl_references(self, node: SyntaxNode, scope: Scope) -> None:
+        type_node = node.find_node(SyntaxNodeType.ntType)
+        type_scope = self._node_scopes.get(id(node), scope)
+        type_params = node.find_node(SyntaxNodeType.ntTypeParams)
+        if type_params is not None:
+            self._collect_type_param_references(type_params, scope)
+        if type_node is not None:
+            type_name = self._attr(type_node, AttributeName.anName).strip()
+            type_kind = self._attr(type_node, AttributeName.anType)
+            direct_alias = (
+                bool(type_name)
+                and type_name.casefold() != 'enum'
+                and '..' not in type_name
+            )
+            if type_kind in {'array', 'procedure', 'function'} or direct_alias:
+                self._record_type_reference(type_node, type_scope)
+            else:
+                for child in type_node.child_nodes:
+                    if child.typ == SyntaxNodeType.ntType:
+                        self._record_type_reference(child, type_scope)
+            self._collect_type_members_references(type_node, type_scope)
+
+    def _collect_type_members_references(self, node: SyntaxNode, scope: Scope) -> None:
+        visibility = Visibility.PUBLIC
+        visibility_map = self._visibility_map()
+        for child in node.child_nodes:
+            if child.typ == SyntaxNodeType.ntBounds:
+                continue
+            if child.typ in visibility_map:
+                visibility = visibility_map[child.typ]
+                for member in child.child_nodes:
+                    self._collect_references_pass(member, scope, visibility)
+                continue
+            self._collect_references_pass(child, scope, visibility)
+
+    def _collect_variable_references(self, node: SyntaxNode, scope: Scope) -> None:
+        type_node = node.find_node(SyntaxNodeType.ntType)
+        if type_node is not None:
+            self._record_type_reference(type_node, scope)
+            self._collect_anonymous_type_member_references(node, type_node)
+        value_node = node.find_node(SyntaxNodeType.ntValue)
+        if value_node is not None:
+            self._collect_expr_references(value_node, scope)
+
+    def _collect_constant_references(self, node: SyntaxNode, scope: Scope) -> None:
+        type_node = node.find_node(SyntaxNodeType.ntType)
+        if type_node is not None:
+            self._record_type_reference(type_node, scope)
+        value_node = node.find_node(SyntaxNodeType.ntValue)
+        if value_node is not None:
+            self._collect_expr_references(value_node, scope)
+
+    def _collect_field_references(self, node: SyntaxNode, scope: Scope) -> None:
+        type_node = node.find_node(SyntaxNodeType.ntType)
+        if type_node is not None:
+            self._record_type_reference(type_node, scope)
+            self._collect_anonymous_type_member_references(node, type_node)
+
+    def _collect_anonymous_type_member_references(
+        self,
+        declaration: SyntaxNode,
+        type_node: SyntaxNode,
+    ) -> None:
+        structured = self._anonymous_structured_type_node(type_node)
+        member_scope = self._node_scopes.get(id(declaration))
+        if structured is None or member_scope is None:
+            return
+        self._collect_type_members_references(structured, member_scope)
+
+    def _collect_with_references(
+        self,
+        node: SyntaxNode,
+        scope: Scope,
+    ) -> tuple[Scope, list[SyntaxNode]]:
+        expr_nodes: list[SyntaxNode] = []
+        body_nodes: list[SyntaxNode] = []
+        for child in node.child_nodes:
+            if child.typ == SyntaxNodeType.ntExpressions:
+                expr_nodes.extend(child.child_nodes)
+            else:
+                body_nodes.append(child)
+
+        for expr in expr_nodes:
+            self._collect_expr_references(expr, scope)
+
+        with_scopes: list[Scope] = []
+        for expr in expr_nodes:
+            with_scopes.extend(self._with_scopes_for_expr(expr, scope))
+
+        target_scope = scope
+        if with_scopes:
+            target_scope = Scope(kind=ScopeKind.WITH, name='with', parent=scope)
+            for with_scope in with_scopes:
+                target_scope.add_with_scope(with_scope)
+
+        return target_scope, body_nodes
+
+    def _with_scopes_for_expr(self, node: SyntaxNode, scope: Scope) -> list[Scope]:
+        name = self._expr_name(node)
+        if not name:
+            return []
+        symbol = self._resolve_reference(name, ReferenceKind.VALUE, scope)
+        if symbol is None:
+            return []
+        return list(self._iter_member_scopes(symbol, scope))
+
+    def _collect_method_references(
+        self,
+        node: SyntaxNode,
+        scope: Scope,
+    ) -> tuple[Scope, list[SyntaxNode]]:
+        method_scope = self._node_scopes.get(id(node), scope)
+        params = node.find_node(SyntaxNodeType.ntParameters)
+        if params is not None:
+            for param in params.child_nodes:
+                if param.typ != SyntaxNodeType.ntParameter:
+                    continue
+                type_node = param.find_node(SyntaxNodeType.ntType)
+                if type_node is not None:
+                    self._record_type_reference(type_node, method_scope)
+                value_node = param.find_node(SyntaxNodeType.ntValue)
+                if value_node is not None:
+                    self._collect_expr_references(value_node, method_scope)
+        type_params = node.find_node(SyntaxNodeType.ntTypeParams)
+        if type_params is not None:
+            self._collect_type_param_references(type_params, method_scope)
+        return_type_node = node.find_node(SyntaxNodeType.ntReturnType)
+        if return_type_node is not None:
+            type_node = return_type_node.find_node(SyntaxNodeType.ntType)
+            if type_node is not None:
+                self._record_type_reference(type_node, method_scope)
+        excluded = {
+            SyntaxNodeType.ntParameters,
+            SyntaxNodeType.ntReturnType,
+            SyntaxNodeType.ntTypeParams,
+        }
+        return (
+            method_scope,
+            [child for child in node.child_nodes if child.typ not in excluded],
+        )
+
+    def _collect_property_references(self, node: SyntaxNode, scope: Scope) -> None:
+        type_node = node.find_node(SyntaxNodeType.ntType)
+        if type_node is not None:
+            self._record_type_reference(type_node, scope)
+        params = node.find_node(SyntaxNodeType.ntParameters)
+        if params is not None:
+            for param in params.child_nodes:
+                if param.typ != SyntaxNodeType.ntParameter:
+                    continue
+                type_node = param.find_node(SyntaxNodeType.ntType)
+                if type_node is not None:
+                    self._record_type_reference(type_node, scope)
+        for child in node.child_nodes:
+            if child.typ in {SyntaxNodeType.ntRead, SyntaxNodeType.ntWrite, SyntaxNodeType.ntImplements}:
+                self._collect_expr_references(child, scope)
+            if child.typ == SyntaxNodeType.ntUnknown and self._attr(child, AttributeName.anKind) in {'add', 'remove', 'stored'}:
+                self._collect_expr_references(child, scope)
+
+    def _collect_type_param_references(self, node: SyntaxNode, scope: Scope) -> None:
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntTypeParam:
+                continue
+            constraints = child.find_node(SyntaxNodeType.ntConstraints)
+            if constraints is None:
+                continue
+            for constraint in constraints.child_nodes:
+                if constraint.typ == SyntaxNodeType.ntType:
+                    self._record_type_reference(constraint, scope)
+
+    def _record_type_reference(self, node: SyntaxNode, scope: Scope) -> None:
+        name = self._attr(node, AttributeName.anName)
+        if name:
+            self._record_type_text_reference(name, node, scope)
+
+        if self._attr(node, AttributeName.anType) == 'array':
+            bounds_node = node.find_node(SyntaxNodeType.ntBounds)
+            if bounds_node is not None:
+                for bound in bounds_node.child_nodes:
+                    self._record_array_bound_references(bound, scope)
+
+        for child in node.child_nodes:
+            if child.typ == SyntaxNodeType.ntType:
+                self._record_type_reference(child, scope)
+            elif child.typ == SyntaxNodeType.ntTypeArgs:
+                for type_arg in child.child_nodes:
+                    if type_arg.typ == SyntaxNodeType.ntType:
+                        self._record_type_reference(type_arg, scope)
+            elif child.typ in {
+                SyntaxNodeType.ntParameters,
+                SyntaxNodeType.ntReturnType,
+            }:
+                self._record_nested_type_references(child, scope)
+
+    def _record_nested_type_references(self, node: SyntaxNode, scope: Scope) -> None:
+        pending = list(reversed(node.child_nodes))
+        while pending:
+            child = pending.pop()
+            if child.typ == SyntaxNodeType.ntType:
+                self._record_type_reference(child, scope)
+            else:
+                pending.extend(reversed(child.child_nodes))
+
+    def _record_type_text_reference(
+        self,
+        text: str,
+        node: SyntaxNode,
+        scope: Scope,
+        *,
+        column_offset: int = 0,
+    ) -> None:
+        leading = len(text) - len(text.lstrip())
+        column_offset += leading
+        name = text.strip()
+        if name.casefold().startswith('specialize '):
+            column_offset += len('specialize ')
+            name = name[len('specialize '):].strip()
+        while name.startswith('^'):
+            column_offset += 1
+            name = name[1:].lstrip()
+        short_string = re.fullmatch(r'(?P<name>[A-Za-z_][A-Za-z0-9_.]*)\s*\[[^]]+\]', name)
+        if short_string is not None:
+            name = short_string.group('name')
+        codepage_string = re.fullmatch(
+            r'(?P<name>[A-Za-z_][A-Za-z0-9_.]*)\s*\([^()]*\)',
+            name,
+        )
+        if codepage_string is not None:
+            name = codepage_string.group('name')
+        lowered = name.casefold()
+        if lowered in {
+            'const',
+            'file',
+            'procedure',
+            'function',
+            'reference to procedure',
+            'reference to function',
+        }:
+            return
+        if lowered.startswith(('procedure', 'function')):
+            for type_match in re.finditer(
+                r':\s*(?:\^\s*)?([A-Za-z_][A-Za-z0-9_.]*(?:\s*<[^;()]+>)?)',
+                name,
+            ):
+                self._record_type_text_reference(
+                    type_match.group(1),
+                    node,
+                    scope,
+                    column_offset=column_offset + type_match.start(1),
+                )
+            return
+        for prefix in ('file of ', 'class of ', 'reference to ', 'set of '):
+            if lowered.startswith(prefix):
+                self._record_type_text_reference(
+                    name[len(prefix):].strip(),
+                    node,
+                    scope,
+                    column_offset=column_offset + len(prefix),
+                )
+                return
+        if lowered.startswith('array'):
+            array_match = re.fullmatch(
+                r'array(?:\s*\[(?P<bounds>[^]]*)\])?\s+of\s+(?P<element>.+)',
+                name,
+                re.IGNORECASE,
+            )
+            if array_match is None:
+                return
+            bounds = array_match.group('bounds')
+            if bounds:
+                bounds_start = array_match.start('bounds')
+                search_start = 0
+                for bound_text in bounds.split(','):
+                    bound_start = bounds.find(bound_text, search_start)
+                    self._record_array_bound_text(
+                        bound_text,
+                        node,
+                        scope,
+                        column_offset=column_offset + bounds_start + bound_start,
+                    )
+                    search_start = bound_start + len(bound_text) + 1
+            self._record_type_text_reference(
+                array_match.group('element'),
+                node,
+                scope,
+                column_offset=column_offset + array_match.start('element'),
+            )
+            return
+        if not name:
+            return
+        generic = self._generic_name_parts(name)
+        reference_name = generic[0] if generic is not None else name
+        self._add_reference(
+            reference_name,
+            ReferenceKind.TYPE,
+            node,
+            scope,
+            column_offset=column_offset,
+        )
+        if generic is not None:
+            _, args = generic
+            search_start = name.find('<') + 1
+            for argument in args:
+                argument_start = name.find(argument, search_start)
+                self._record_type_text_reference(
+                    argument,
+                    node,
+                    scope,
+                    column_offset=column_offset + argument_start,
+                )
+                search_start = argument_start + len(argument)
+
+    def _record_array_bound_references(self, node: SyntaxNode, scope: Scope) -> None:
+        name = self._expr_name(node)
+        if name and node.typ in {SyntaxNodeType.ntIdentifier, SyntaxNodeType.ntDot}:
+            self._add_reference(name, ReferenceKind.TYPE, node, scope)
+            return
+        text = self._expr_to_text(node)
+        if text:
+            self._record_array_bound_text(text, node, scope)
+            return
+        self._record_array_bound_expression(node, scope)
+
+    def _record_array_bound_expression(self, node: SyntaxNode, scope: Scope) -> None:
+        if node.typ == SyntaxNodeType.ntCall and node.child_nodes:
+            target = node.child_nodes[0]
+            target_name = self._expr_name(target)
+            if target_name.casefold() in {'low', 'high', 'pred', 'succ', 'sizeof'}:
+                self._add_reference(target_name, ReferenceKind.CALL, target, scope)
+                arguments = [*target.child_nodes, *node.child_nodes[1:]]
+                for argument in arguments:
+                    self._record_array_operator_argument(argument, scope)
+                return
+        if node.typ == SyntaxNodeType.ntIdentifier:
+            self._add_reference(
+                self._attr(node, AttributeName.anName),
+                ReferenceKind.VALUE,
+                node,
+                scope,
+            )
+            return
+        for child in node.child_nodes:
+            self._record_array_bound_expression(child, scope)
+
+    def _record_array_operator_argument(self, node: SyntaxNode, scope: Scope) -> None:
+        name = self._expr_name(node)
+        if name:
+            resolved_type = self._resolve_reference(name, ReferenceKind.TYPE, scope)
+            kind = (
+                ReferenceKind.TYPE
+                if self._is_type_symbol(resolved_type)
+                else ReferenceKind.VALUE
+            )
+            self._add_reference(name, kind, node, scope)
+            return
+        for child in node.child_nodes:
+            self._record_array_operator_argument(child, scope)
+
+    def _record_array_bound_text(
+        self,
+        text: str,
+        node: SyntaxNode,
+        scope: Scope,
+        *,
+        column_offset: int = 0,
+    ) -> None:
+        leading = len(text) - len(text.lstrip())
+        column_offset += leading
+        candidate = text.strip()
+        if self._simple_type_name(candidate):
+            self._add_reference(
+                candidate,
+                ReferenceKind.TYPE,
+                node,
+                scope,
+                column_offset=column_offset,
+            )
+            return
+        candidate = re.sub(
+            r"'(?:''|[^'])*'",
+            lambda match: ' ' * len(match.group()),
+            candidate,
+        )
+        candidate = re.sub(
+            r'\$[0-9A-Fa-f]+|%[01]+|&[0-7]+|#[0-9]+|#\$[0-9A-Fa-f]+',
+            lambda match: ' ' * len(match.group()),
+            candidate,
+        )
+        for identifier_match in re.finditer(
+            r'&?[^\W\d]\w*(?:\.&?[^\W\d]\w*)*',
+            candidate,
+        ):
+            identifier = identifier_match.group()
+            following = candidate[identifier_match.end():]
+            if (
+                identifier.casefold() in {'low', 'high', 'pred', 'succ', 'sizeof'}
+                and re.match(r'\s*\(', following) is not None
+            ):
+                self._add_reference(
+                    identifier,
+                    ReferenceKind.CALL,
+                    node,
+                    scope,
+                    column_offset=column_offset + identifier_match.start(),
+                )
+                continue
+            resolved_type = self._resolve_reference(identifier, ReferenceKind.TYPE, scope)
+            kind = (
+                ReferenceKind.TYPE
+                if self._is_type_symbol(resolved_type)
+                else ReferenceKind.VALUE
+            )
+            self._add_reference(
+                identifier,
+                kind,
+                node,
+                scope,
+                column_offset=column_offset + identifier_match.start(),
+            )
+
+    def _simple_type_name(self, text: str) -> str:
+        name = text.strip()
+        parts = name.split('.')
+        if parts and all(part.lstrip('&').isidentifier() for part in parts):
+            return name
+        return ''
+
+    def _is_type_symbol(self, symbol: Symbol | None) -> bool:
+        return symbol is not None and symbol.kind in {
+            SymbolKind.TYPE,
+            SymbolKind.TYPE_PARAMETER,
+            SymbolKind.CLASS,
+            SymbolKind.RECORD,
+            SymbolKind.INTERFACE,
+            SymbolKind.ENUM,
+        }
+
+    def _collect_expr_references(self, node: SyntaxNode, scope: Scope) -> None:
+        if node.typ == SyntaxNodeType.ntCall:
+            target = node.child_nodes[0] if node.child_nodes else None
+            if target is not None:
+                self._record_qualified_type_reference(target, scope)
+                self._record_value_qualifier_reference(target, scope)
+            name = self._expr_name(target) if target is not None else ''
+            if name:
+                self._add_reference(name, ReferenceKind.CALL, target or node, scope)
+            for child in node.child_nodes[1:]:
+                self._collect_expr_references(child, scope)
+            return
+        if node.typ == SyntaxNodeType.ntDot:
+            self._record_qualified_type_reference(node, scope)
+            self._record_value_qualifier_reference(node, scope)
+            name = self._expr_name(node)
+            if name:
+                self._add_reference(name, ReferenceKind.VALUE, node, scope)
+            return
+        if node.typ == SyntaxNodeType.ntIdentifier:
+            name = self._attr(node, AttributeName.anName)
+            self._add_reference(name, ReferenceKind.VALUE, node, scope)
+            return
+
+        for child in node.child_nodes:
+            self._collect_expr_references(child, scope)
+
+    def _record_value_qualifier_reference(
+        self,
+        node: SyntaxNode,
+        scope: Scope,
+    ) -> None:
+        if node.typ != SyntaxNodeType.ntDot or len(node.child_nodes) != 2:
+            return
+        qualifier = node.child_nodes[0]
+        self._record_value_qualifier_reference(qualifier, scope)
+        qualifier_name = self._expr_name(qualifier)
+        resolved = self._resolve_reference(
+            qualifier_name,
+            ReferenceKind.VALUE,
+            scope,
+        )
+        if resolved is None:
+            resolved = self._resolve_implicit_self_member(qualifier_name, scope)
+        if resolved is None or resolved.kind in {
+            SymbolKind.UNIT,
+            SymbolKind.MODULE,
+            SymbolKind.NAMESPACE,
+            SymbolKind.PACKAGE,
+            SymbolKind.TYPE,
+            SymbolKind.CLASS,
+            SymbolKind.RECORD,
+            SymbolKind.INTERFACE,
+            SymbolKind.ENUM,
+        }:
+            return
+        reference_node = (
+            qualifier.child_nodes[-1]
+            if qualifier.typ == SyntaxNodeType.ntDot and qualifier.child_nodes
+            else qualifier
+        )
+        self._references.append(
+            SymbolReference(
+                name=self._expr_name(reference_node),
+                kind=(
+                    ReferenceKind.CALL
+                    if resolved.kind
+                    in {
+                        SymbolKind.METHOD,
+                        SymbolKind.FUNCTION,
+                        SymbolKind.PROCEDURE,
+                        SymbolKind.CONSTRUCTOR,
+                        SymbolKind.DESTRUCTOR,
+                    }
+                    else ReferenceKind.VALUE
+                ),
+                ref_range=self._node_range(reference_node),
+                scope=scope,
+                resolved=resolved,
+            )
+        )
+
+    def _resolve_implicit_self_member(
+        self,
+        name: str,
+        scope: Scope,
+    ) -> Symbol | None:
+        parts = self._normalized_reference_parts(name)
+        if len(parts) != 2 or parts[0].casefold() != 'self':
+            return None
+        current: Scope | None = scope
+        while current is not None and current.kind != ScopeKind.TYPE:
+            current = current.parent
+        if current is None:
+            return None
+        if current.owner is None:
+            return None
+        return self._resolve_member_symbol(current.owner, parts[1], scope)
+
+    def _record_qualified_type_reference(
+        self,
+        node: SyntaxNode,
+        scope: Scope,
+    ) -> None:
+        if node.typ != SyntaxNodeType.ntDot or len(node.child_nodes) != 2:
+            return
+        qualifier = node.child_nodes[0]
+        qualifier_name = self._expr_name(qualifier)
+        qualifier_symbol = self._resolve_reference(
+            qualifier_name,
+            ReferenceKind.VALUE,
+            scope,
+        )
+        if qualifier_symbol is None or qualifier_symbol.kind not in {
+            SymbolKind.TYPE,
+            SymbolKind.CLASS,
+            SymbolKind.RECORD,
+            SymbolKind.INTERFACE,
+            SymbolKind.ENUM,
+        }:
+            return
+
+        member_name = self._expr_name(node.child_nodes[1])
+        qualified_name = self._expr_name(node)
+        member_symbol = self._resolve_reference(
+            qualified_name,
+            ReferenceKind.VALUE,
+            scope,
+        )
+        kind = ReferenceKind.TYPE_QUALIFIER
+        if (
+            member_symbol is not None
+            and member_symbol.kind == SymbolKind.CONSTRUCTOR
+        ) or (
+            qualifier_symbol.kind == SymbolKind.CLASS
+            and member_name.casefold() == 'create'
+        ):
+            # TObject's implicit Create is not present in every workspace index.
+            kind = ReferenceKind.CONSTRUCTOR_CALL
+        self._references.append(
+            SymbolReference(
+                name=qualifier_name,
+                kind=kind,
+                ref_range=self._node_range(qualifier),
+                scope=scope,
+                resolved=qualifier_symbol,
+            )
+        )
+
+    def _expr_name(self, node: SyntaxNode | None) -> str:
+        if node is None:
+            return ''
+        if node.typ == SyntaxNodeType.ntIdentifier:
+            name = self._attr(node, AttributeName.anName)
+            generic_args = self._attr(node, AttributeName.anGenericArgs)
+            if generic_args:
+                return f'{name}{generic_args}'
+            return name
+        if node.typ == SyntaxNodeType.ntDot and len(node.child_nodes) == 2:
+            left = self._expr_name(node.child_nodes[0])
+            right = self._expr_name(node.child_nodes[1])
+            if left and right:
+                return f'{left}.{right}'
+            return left or right
+        if node.typ == SyntaxNodeType.ntCall and node.child_nodes:
+            return self._expr_name(node.child_nodes[0])
+        if node.typ == SyntaxNodeType.ntIndexed and node.child_nodes:
+            return self._expr_name(node.child_nodes[0])
+        return ''
+
+    def _add_reference(
+        self,
+        name: str,
+        kind: ReferenceKind,
+        node: SyntaxNode,
+        scope: Scope,
+        *,
+        column_offset: int | None = None,
+    ) -> None:
+        if not name:
+            return
+        resolved = self._resolve_reference(name, kind, scope)
+        if column_offset is None:
+            reference_node = node
+            reference_name = name
+            if node.typ == SyntaxNodeType.ntDot and node.child_nodes:
+                reference_node = node.child_nodes[-1]
+                reference_name = self._expr_name(reference_node) or name
+            if reference_node.token_end_line:
+                start_file, start_line, start_col = self._map_position(
+                    reference_node.file_name,
+                    reference_node.line,
+                    reference_node.col,
+                )
+                end_file, end_line, end_col = self._map_position(
+                    reference_node.file_name,
+                    reference_node.token_end_line,
+                    reference_node.token_end_col,
+                )
+                if end_file != start_file:
+                    end_line, end_col = start_line, start_col + len(reference_name)
+                reference_range = SourceRange(
+                    file_name=start_file,
+                    start_line=start_line,
+                    start_col=start_col,
+                    end_line=end_line,
+                    end_col=end_col,
+                )
+            else:
+                reference_range = self._node_range(reference_node)
+            if (
+                reference_range.start_line == reference_range.end_line
+                and reference_range.start_col == reference_range.end_col
+            ):
+                reference_range = self._offset_range(
+                    reference_node,
+                    0,
+                    len(reference_name),
+                )
+        else:
+            reference_range = self._offset_range(node, column_offset, len(name))
+        if resolved is None and kind == ReferenceKind.TYPE and not self._is_builtin_type(name):
+            self._problems.append(
+                SemanticProblem(
+                    message=f'Unresolved type {name}',
+                    range=reference_range,
+                )
+            )
+        self._references.append(
+            SymbolReference(
+                name=name,
+                kind=kind,
+                ref_range=reference_range,
+                scope=scope,
+                resolved=resolved,
+            )
+        )
+
+    def _offset_range(
+        self,
+        node: SyntaxNode,
+        column_offset: int,
+        length: int,
+    ) -> SourceRange:
+        positions = node.source_positions
+        end_offset = column_offset + length
+        if (
+            positions
+            and length > 0
+            and column_offset < len(positions)
+            and end_offset <= len(positions)
+        ):
+            raw_start_line, raw_start_col = positions[column_offset]
+            raw_end_line, raw_end_col = positions[end_offset - 1]
+            raw_end_col += 1
+        else:
+            raw_start_line = node.line
+            raw_start_col = node.col + column_offset
+            raw_end_line = node.line
+            raw_end_col = node.col + end_offset
+        start_file, start_line, start_col = self._map_position(
+            node.file_name,
+            raw_start_line,
+            raw_start_col,
+        )
+        end_file, end_line, end_col = self._map_position(
+            node.file_name,
+            raw_end_line,
+            raw_end_col,
+        )
+        if end_file != start_file:
+            end_line, end_col = start_line, start_col + length
+        return SourceRange(
+            file_name=start_file,
+            start_line=start_line,
+            start_col=start_col,
+            end_line=end_line,
+            end_col=end_col,
+        )
+
+    def _add_method_resolution_reference(
+        self,
+        node: SyntaxNode,
+        scope: Scope,
+    ) -> None:
+        name = self._attr(node, AttributeName.anName)
+        if not name:
+            return
+        type_scope: Scope | None = scope
+        while type_scope is not None and type_scope.kind != ScopeKind.TYPE:
+            type_scope = type_scope.parent
+        routine_kinds = {
+            SymbolKind.METHOD,
+            SymbolKind.FUNCTION,
+            SymbolKind.PROCEDURE,
+            SymbolKind.CONSTRUCTOR,
+            SymbolKind.DESTRUCTOR,
+        }
+        candidates = (
+            [
+                symbol
+                for symbol in type_scope.lookup_local(name)
+                if symbol.kind in routine_kinds
+            ]
+            if type_scope is not None
+            else []
+        )
+        self._references.append(
+            SymbolReference(
+                name=name,
+                kind=ReferenceKind.VALUE,
+                ref_range=self._node_range(node),
+                scope=scope,
+                resolved=candidates[0] if candidates else None,
+            )
+        )
+
+    def _resolve_reference(self, name: str, kind: ReferenceKind, scope: Scope) -> Symbol | None:
+        parts = self._normalized_reference_parts(name)
+        if not parts:
+            return None
+        if len(parts) > 1:
+            resolved = self._resolve_qualified_reference(parts, scope)
+            if resolved is not None:
+                return resolved
+            symbols = self._index.resolve_qualified('.'.join(parts))
+            return symbols[0] if symbols else None
+        symbols = scope.resolve(parts[0])
+        if symbols:
+            return symbols[0]
+        return None
+
+    def _add_problem(self, message: str, node: SyntaxNode) -> None:
+        self._problems.append(
+            SemanticProblem(
+                message=message,
+                range=self._node_range(node),
+            )
+        )
+
+    def _is_builtin_type(self, name: str) -> bool:
+        base = name.split('.')[-1]
+        base = self._strip_generic_args(base)
+        return base.casefold() in self._builtin_types
+
+    def _normalized_reference_parts(self, name: str) -> list[str]:
+        if not name:
+            return []
+        parts = self._split_reference_parts(name)
+        normalized = [self._strip_generic_args(part) for part in parts]
+        return [part for part in normalized if part]
+
+    def _split_reference_parts(self, name: str) -> list[str]:
+        parts: list[str] = []
+        buf: list[str] = []
+        depth = 0
+        for ch in name:
+            if ch == '<':
+                depth += 1
+            elif ch == '>':
+                if depth:
+                    depth -= 1
+            elif ch == '.' and depth == 0:
+                part = ''.join(buf).strip()
+                if part:
+                    parts.append(part)
+                buf = []
+                continue
+            buf.append(ch)
+        part = ''.join(buf).strip()
+        if part:
+            parts.append(part)
+        return parts
+
+    def _strip_generic_args(self, name: str) -> str:
+        if '<' in name:
+            return name.split('<', 1)[0]
+        return name
+
+    def _resolve_qualified_reference(self, parts: list[str], scope: Scope) -> Symbol | None:
+        if parts[0].casefold() == 'self':
+            type_scope: Scope | None = scope
+            while type_scope is not None and type_scope.kind != ScopeKind.TYPE:
+                type_scope = type_scope.parent
+            if type_scope is not None and type_scope.owner is not None:
+                symbol = type_scope.owner
+                for part in parts[1:]:
+                    member = self._resolve_member_symbol(symbol, part, scope)
+                    if member is None:
+                        break
+                    symbol = member
+                else:
+                    return symbol
+        unit_scope, unit_len = self._match_unit_prefix(parts)
+        if unit_scope is not None and unit_len > 0:
+            unit_symbol = self._resolve_scope_chain(
+                unit_scope,
+                parts[unit_len:],
+                allow_imports=False,
+                origin_scope=scope,
+            )
+            if unit_symbol is not None:
+                return unit_symbol
+        return self._resolve_scope_chain(scope, parts, allow_imports=True, origin_scope=scope)
+
+    def _match_unit_prefix(self, parts: list[str]) -> tuple[Scope | None, int]:
+        if len(parts) < 2:
+            return None, 0
+        for idx in range(len(parts) - 1, 0, -1):
+            unit_name = '.'.join(parts[:idx])
+            unit_scope = self._index.lookup_unit(unit_name)
+            if unit_scope is not None:
+                return unit_scope, idx
+        return None, 0
+
+    def _resolve_scope_chain(
+        self,
+        scope: Scope,
+        parts: list[str],
+        *,
+        allow_imports: bool,
+        origin_scope: Scope,
+    ) -> Symbol | None:
+        if not parts:
+            return None
+        symbol = self._resolve_in_scope(scope, parts[0], allow_imports=allow_imports)
+        if symbol is None:
+            return None
+        for part in parts[1:]:
+            member_symbol = self._resolve_member_symbol(symbol, part, origin_scope)
+            if member_symbol is None:
+                return None
+            symbol = member_symbol
+        return symbol
+
+    def _resolve_in_scope(self, scope: Scope, name: str, *, allow_imports: bool) -> Symbol | None:
+        symbols = scope.resolve(name) if allow_imports else scope.lookup_local(name)
+        return symbols[0] if symbols else None
+
+    def _member_scope_for_symbol(self, symbol: Symbol, scope: Scope) -> Scope | None:
+        scopes = list(self._iter_member_scopes(symbol, scope))
+        return scopes[0] if scopes else None
+
+    def _resolve_member_symbol(self, symbol: Symbol, name: str, scope: Scope) -> Symbol | None:
+        for member_scope in self._iter_member_scopes(symbol, scope):
+            members = member_scope.lookup_local(name)
+            if members:
+                return members[0]
+        return None
+
+    def _iter_member_scopes(self, symbol: Symbol, scope: Scope) -> Iterable[Scope]:
+        type_symbol = self._type_owner_for_symbol(symbol, scope)
+        if type_symbol is None:
+            return
+        yield from self._iter_type_member_scopes(type_symbol, scope)
+
+    def _type_owner_for_symbol(self, symbol: Symbol, scope: Scope) -> Symbol | None:
+        if symbol.member_scope is not None and symbol.kind in {
+            SymbolKind.TYPE,
+            SymbolKind.CLASS,
+            SymbolKind.RECORD,
+            SymbolKind.INTERFACE,
+            SymbolKind.ENUM,
+        }:
+            return symbol
+        type_ref = symbol.type_ref
+        if isinstance(type_ref, ProcTypeRef) and type_ref.return_type is not None:
+            type_ref = type_ref.return_type
+        return self._type_symbol_from_ref(type_ref, scope)
+
+    def _iter_type_member_scopes(self, type_symbol: Symbol, scope: Scope) -> Iterable[Scope]:
+        seen: set[int] = set()
+        queue: list[Symbol] = [type_symbol]
+        while queue:
+            current = queue.pop(0)
+            current_id = id(current)
+            if current_id in seen:
+                continue
+            seen.add(current_id)
+            if current.member_scope is not None:
+                yield current.member_scope
+            for base_ref in current.base_types:
+                base_symbol = self._type_symbol_from_ref(base_ref, scope)
+                if base_symbol is not None:
+                    queue.append(base_symbol)
+
+    def _type_symbol_from_ref(self, type_ref: TypeRef, scope: Scope) -> Symbol | None:
+        if isinstance(type_ref, GenericInstanceTypeRef):
+            return self._type_symbol_from_ref(type_ref.base, scope)
+        if isinstance(type_ref, NamedTypeRef):
+            if type_ref.unit_name:
+                unit_scope = self._index.lookup_unit(type_ref.unit_name)
+                if unit_scope is not None:
+                    symbols = unit_scope.lookup_local(type_ref.name)
+                    return symbols[0] if symbols else None
+            if '.' in type_ref.name:
+                symbols = self._index.resolve_qualified(type_ref.name)
+                if symbols:
+                    return symbols[0]
+            symbols = scope.resolve(type_ref.name)
+            return symbols[0] if symbols else None
+        return None
+
+    def _define_symbol(self, scope: Scope, symbol: Symbol) -> None:
+        existing = scope.lookup_local(symbol.name)
+        scope.define(symbol)
+        for prev in existing:
+            if self._is_overloadable(prev, symbol):
+                prev.add_overload(symbol)
+                symbol.add_overload(prev)
+
+    def _is_overloadable(self, left: Symbol, right: Symbol) -> bool:
+        overload_kinds = {
+            SymbolKind.METHOD,
+            SymbolKind.FUNCTION,
+            SymbolKind.PROCEDURE,
+            SymbolKind.CONSTRUCTOR,
+            SymbolKind.DESTRUCTOR,
+        }
+        return left.kind in overload_kinds and right.kind in overload_kinds
+
+    def _symbol_attributes(self, node: SyntaxNode) -> dict[str, str]:
+        attrs: dict[str, str] = {}
+        skip = {
+            AttributeName.anName,
+            AttributeName.anKind,
+            AttributeName.anType,
+            AttributeName.anClass,
+            AttributeName.anVisibility,
+            AttributeName.anPath,
+        }
+        for key, value in node.attributes:
+            if key in skip:
+                continue
+            attrs[ATTRIBUTE_NAME_STRINGS[key]] = value
+        return attrs
+
+    def _constraint_names(self, node: SyntaxNode) -> tuple[str, ...]:
+        constraints_node = node.find_node(SyntaxNodeType.ntConstraints)
+        if constraints_node is None:
+            return ()
+        names: list[str] = []
+        for child in constraints_node.child_nodes:
+            if child.typ == SyntaxNodeType.ntClassConstraint:
+                names.append('class')
+            elif child.typ == SyntaxNodeType.ntRecordConstraint:
+                names.append('record')
+            elif child.typ == SyntaxNodeType.ntConstructorConstraint:
+                names.append('constructor')
+            elif child.typ == SyntaxNodeType.ntInterfaceConstraint:
+                names.append('interface')
+            elif child.typ == SyntaxNodeType.ntUnmanagedConstraint:
+                names.append('unmanaged')
+            elif child.typ == SyntaxNodeType.ntType:
+                names.append(self._type_from_node(child).display_name())
+        return tuple(names)
+
+    def _named_type_ref(self, name: str) -> NamedTypeRef:
+        if '.' in name:
+            unit_name, type_name = self._split_qualified_name(name)
+            return NamedTypeRef(name=type_name, unit_name=unit_name)
+        return NamedTypeRef(name=name)
+
+    def _split_qualified_name(self, name: str) -> tuple[str, str]:
+        parts = name.split('.')
+        return ('.'.join(parts[:-1]), parts[-1])
+
+    def _unit_scope_for_symbol(self, symbol: Symbol) -> Scope | None:
+        scope: Scope | None = symbol.scope
+        while scope is not None:
+            if scope.kind == ScopeKind.UNIT:
+                return scope
+            scope = scope.parent
+        return None
+
+    def _attr(self, node: SyntaxNode, name: AttributeName) -> str:
+        return node.get_attribute(name)
+
+    def _child_name(self, node: SyntaxNode | None) -> str:
+        if node is None:
+            return ''
+        if isinstance(node, ValuedSyntaxNode):
+            return node.value
+        name = self._attr(node, AttributeName.anName)
+        if name:
+            return name
+        for child in node.child_nodes:
+            if child.typ == SyntaxNodeType.ntName:
+                if isinstance(child, ValuedSyntaxNode):
+                    return child.value
+                return self._attr(child, AttributeName.anName)
+        return ''
+
+    def _expr_to_text(self, node: SyntaxNode) -> str:
+        if isinstance(node, ValuedSyntaxNode):
+            return node.value
+        name = node.get_attribute(AttributeName.anName)
+        if name:
+            return name
+        binary_ops = {
+            SyntaxNodeType.ntAdd: '+',
+            SyntaxNodeType.ntSub: '-',
+            SyntaxNodeType.ntMul: '*',
+            SyntaxNodeType.ntFDiv: '/',
+            SyntaxNodeType.ntDiv: 'div',
+            SyntaxNodeType.ntMod: 'mod',
+            SyntaxNodeType.ntShl: 'shl',
+            SyntaxNodeType.ntShr: 'shr',
+            SyntaxNodeType.ntAnd: 'and',
+            SyntaxNodeType.ntOr: 'or',
+            SyntaxNodeType.ntXor: 'xor',
+            SyntaxNodeType.ntEqual: '=',
+            SyntaxNodeType.ntNotEqual: '<>',
+            SyntaxNodeType.ntLower: '<',
+            SyntaxNodeType.ntLowerEqual: '<=',
+            SyntaxNodeType.ntGreater: '>',
+            SyntaxNodeType.ntGreaterEqual: '>=',
+            SyntaxNodeType.ntIn: 'in',
+            SyntaxNodeType.ntIs: 'is',
+            SyntaxNodeType.ntAs: 'as',
+            SyntaxNodeType.ntNotIn: 'not in',
+            SyntaxNodeType.ntIsNot: 'is not',
+        }
+        if node.typ in binary_ops and len(node.child_nodes) >= 2:
+            left = self._expr_to_text(node.child_nodes[0])
+            right = self._expr_to_text(node.child_nodes[1])
+            if left and right:
+                return f'{left} {binary_ops[node.typ]} {right}'
+        if node.typ == SyntaxNodeType.ntUnaryMinus and node.child_nodes:
+            inner = self._expr_to_text(node.child_nodes[0])
+            return f'-{inner}' if inner else ''
+        if node.typ == SyntaxNodeType.ntNot and node.child_nodes:
+            inner = self._expr_to_text(node.child_nodes[0])
+            return f'not {inner}' if inner else ''
+        if node.typ in {SyntaxNodeType.ntAddr, SyntaxNodeType.ntDeref} and node.child_nodes:
+            inner = self._expr_to_text(node.child_nodes[0])
+            if not inner:
+                return ''
+            return f'@{inner}' if node.typ == SyntaxNodeType.ntAddr else f'^{inner}'
+        if node.typ == SyntaxNodeType.ntCall and node.child_nodes:
+            callee = self._expr_to_text(node.child_nodes[0])
+            args_node = node.find_node(SyntaxNodeType.ntArguments)
+            args = []
+            if args_node is not None:
+                for child in args_node.child_nodes:
+                    text = self._expr_to_text(child)
+                    if text:
+                        args.append(text)
+            return f'{callee}({", ".join(args)})' if callee else ''
+        if node.typ == SyntaxNodeType.ntNamedArgument and node.child_nodes:
+            arg_name = self._attr(node, AttributeName.anName)
+            value = self._expr_to_text(node.child_nodes[0])
+            if arg_name and value:
+                return f'{arg_name}: {value}'
+        if node.typ == SyntaxNodeType.ntPositionalArgument and node.child_nodes:
+            return self._expr_to_text(node.child_nodes[0])
+        if node.typ == SyntaxNodeType.ntDot and len(node.child_nodes) >= 2:
+            left = self._expr_to_text(node.child_nodes[0])
+            right = self._expr_to_text(node.child_nodes[1])
+            if left and right:
+                return f'{left}.{right}'
+        if node.typ == SyntaxNodeType.ntIndexed and node.child_nodes:
+            base = self._expr_to_text(node.child_nodes[0])
+            exprs_node = node.find_node(SyntaxNodeType.ntExpressions)
+            parts = []
+            if exprs_node is not None:
+                for child in exprs_node.child_nodes:
+                    text = self._expr_to_text(child)
+                    if text:
+                        parts.append(text)
+            return f'{base}[{", ".join(parts)}]' if base else ''
+        if node.typ == SyntaxNodeType.ntExpression and self._attr(node, AttributeName.anKind) == 'format':
+            parts = []
+            for child in node.child_nodes:
+                text = self._expr_to_text(child)
+                if text:
+                    parts.append(text)
+            return ':'.join(parts)
+        return ''
+
+    def _node_range(self, node: SyntaxNode) -> SourceRange:
+        if isinstance(node, CompoundSyntaxNode):
+            end_line, end_col = node.end_line, node.end_col
+        else:
+            end_line, end_col = node.line, node.col
+        start_file, start_line, start_col = self._map_position(
+            node.file_name,
+            node.line,
+            node.col,
+        )
+        end_file, mapped_end_line, mapped_end_col = self._map_position(
+            node.file_name,
+            end_line,
+            end_col,
+        )
+        if end_file != start_file or (
+            mapped_end_line,
+            mapped_end_col,
+        ) < (start_line, start_col):
+            mapped_end_line, mapped_end_col = start_line, start_col
+        return SourceRange(
+            file_name=start_file,
+            start_line=start_line,
+            start_col=start_col,
+            end_line=mapped_end_line,
+            end_col=mapped_end_col,
+        )
+
+    def _node_name_range(self, node: SyntaxNode, name: str) -> SourceRange:
+        node_range = self._node_range(node)
+        return SourceRange(
+            file_name=node_range.file_name,
+            start_line=node_range.start_line,
+            start_col=node_range.start_col,
+            end_line=node_range.start_line,
+            end_col=node_range.start_col + len(name),
+        )
+
+    def _map_position(
+        self,
+        file_name: str,
+        line: int,
+        col: int,
+    ) -> tuple[str, int, int]:
+        preprocessed = self._source_maps.get(file_name)
+        if preprocessed is None:
+            return file_name, line, col
+        mapped_file, mapped_line, mapped_col = preprocessed.map_position(line, col)
+        if not mapped_file or mapped_line < 1 or mapped_col < 1:
+            return file_name, line, col
+        return mapped_file, mapped_line, mapped_col
+
+    def _node_tree_range(self, node: SyntaxNode) -> SourceRange:
+        result = self._node_range(node)
+        pending = list(reversed(node.child_nodes))
+        while pending:
+            child = pending.pop()
+            child_range = self._node_range(child)
+            if (
+                child_range.file_name == result.file_name
+                and (child_range.end_line, child_range.end_col)
+                > (result.end_line, result.end_col)
+            ):
+                result = SourceRange(
+                    file_name=result.file_name,
+                    start_line=result.start_line,
+                    start_col=result.start_col,
+                    end_line=child_range.end_line,
+                    end_col=child_range.end_col,
+                )
+            pending.extend(reversed(child.child_nodes))
+        return result
+
+    def _visibility_map(self) -> dict[SyntaxNodeType, Visibility]:
+        return {
+            SyntaxNodeType.ntPrivate: Visibility.PRIVATE,
+            SyntaxNodeType.ntProtected: Visibility.PROTECTED,
+            SyntaxNodeType.ntPublic: Visibility.PUBLIC,
+            SyntaxNodeType.ntPublished: Visibility.PUBLISHED,
+            SyntaxNodeType.ntStrictPrivate: Visibility.STRICT_PRIVATE,
+            SyntaxNodeType.ntStrictProtected: Visibility.STRICT_PROTECTED,
+        }