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

delphi_lsp/incremental.py

@@ -0,0 +1,1139 @@
+"""Conservative sub-unit reparsing for editor changes.
+
+The engine deliberately optimizes one case: edits wholly inside the statement
+body of a top-level implementation routine.  Every ambiguous edit is planned
+as a full reparse.
+"""
+
+from __future__ import annotations
+
+from bisect import bisect_right
+from dataclasses import dataclass, is_dataclass, replace
+from enum import Enum
+from hashlib import sha256
+from typing import TYPE_CHECKING, Any, cast
+
+from .consts import AttributeName, SyntaxNodeType
+from .semantic import SourceRange, Symbol, SymbolIndex, normalize_name
+from .semantic_builder import SemanticBuilder
+
+if TYPE_CHECKING:
+    from .nodes import SyntaxNode
+    from .parser import DelphiParser, ParseResult
+
+
+class EditKind(str, Enum):
+    INCREMENTAL = "incremental"
+    FULL_REPARSE = "full-reparse"
+
+
+FULL_REPARSE = EditKind.FULL_REPARSE
+
+
+@dataclass(frozen=True)
+class TextEdit:
+    """A Python-codepoint edit using half-open absolute source offsets."""
+
+    start: int
+    end: int
+    text: str
+
+    def __post_init__(self) -> None:
+        if self.start < 0 or self.end < self.start:
+            raise ValueError("edit offsets must satisfy 0 <= start <= end")
+
+
+@dataclass(frozen=True)
+class RoutineSpan:
+    name: str
+    start_line: int
+    end_line: int
+    body_start_line: int
+    body_end_line: int
+    start_offset: int
+    end_offset: int
+    body_start_offset: int
+    body_end_offset: int
+    context_hash: str
+
+
+@dataclass(frozen=True)
+class SectionSpan:
+    kind: str
+    start_line: int
+    end_line: int
+    start_offset: int
+    end_offset: int
+    context_hash: str
+
+
+@dataclass(frozen=True)
+class DeclarationSpan:
+    section: str
+    kind: str
+    start_line: int
+    end_line: int
+    start_offset: int
+    end_offset: int
+    context_hash: str
+
+
+@dataclass(frozen=True)
+class PathCounters:
+    incremental: int = 0
+    full_reparse: int = 0
+
+
+@dataclass(frozen=True)
+class SpanIndex:
+    source_hash: str
+    source_length: int
+    file_name: str
+    line_starts: tuple[int, ...]
+    sections: tuple[SectionSpan, ...]
+    declarations: tuple[DeclarationSpan, ...]
+    routines: tuple[RoutineSpan, ...]
+    result: ParseResult
+    parser: DelphiParser
+    counters: PathCounters = PathCounters()
+
+
+@dataclass(frozen=True)
+class EditPlan:
+    kind: EditKind
+    reason: str
+    edit: TextEdit
+    updated_source: str
+    origin_index: SpanIndex
+    updated_index: SpanIndex | None
+    counters: PathCounters
+    routine: RoutineSpan | None = None
+    previous_routine: RoutineSpan | None = None
+    line_delta: int = 0
+    character_delta: int = 0
+
+
+@dataclass(frozen=True)
+class SplicedModel:
+    result: ParseResult
+    span_index: SpanIndex
+    kind: EditKind
+    reason: str
+    counters: PathCounters
+
+
+def build_span_index(
+    source: str,
+    model: ParseResult,
+    *,
+    parser: DelphiParser | None = None,
+) -> SpanIndex:
+    """Build implementation-routine boundaries from a completed full parse."""
+
+    if parser is None:
+        from .parser import DelphiParser
+        from .parser_backend import ParserMode
+
+        parser = DelphiParser(mode=ParserMode.TOLERANT, legacy_fallback_max_chars=0)
+    _normalize_syntax_positions(model)
+    line_starts = _line_starts(source)
+    sections, declarations = _structural_spans(source, line_starts, model.root)
+    implementation = _implementation_node(model.root)
+    routines: list[RoutineSpan] = []
+    if implementation is not None:
+        for node in implementation.child_nodes:
+            if node.typ is not SyntaxNodeType.ntMethod:
+                continue
+            span = _routine_span(source, line_starts, node)
+            if span is not None:
+                routines.append(span)
+    return SpanIndex(
+        source_hash=_digest(source),
+        source_length=len(source),
+        file_name=model.root.file_name,
+        line_starts=line_starts,
+        sections=sections,
+        declarations=declarations,
+        routines=tuple(routines),
+        result=model,
+        parser=parser,
+    )
+
+
+def _normalize_syntax_positions(model: ParseResult) -> None:
+    root = model.root
+    if getattr(root, "_incremental_source_positions_normalized", False):
+        return
+    preprocessed = model.preprocessed
+    file_name = root.file_name
+
+    def mapped_position(line: int, col: int) -> tuple[int, int] | None:
+        if line < 1:
+            return None
+        mapped_file, mapped_line, mapped_col = preprocessed.map_position(line, col)
+        if mapped_file == file_name and mapped_line > 0:
+            return mapped_line, mapped_col
+        if line == len(preprocessed.source_map) + 1 and preprocessed.source_map:
+            last = preprocessed.source_map[-1]
+            if last.file_name == file_name:
+                return last.line + 1, col + last.col_offset
+        return None
+
+    def visit(node: SyntaxNode) -> None:
+        start = mapped_position(node.line, node.col)
+        if start is not None:
+            node.line, node.col = start
+        end_line = getattr(node, "end_line", 0)
+        end = mapped_position(end_line, getattr(node, "end_col", 0))
+        if end is not None:
+            cast(Any, node).end_line, cast(Any, node).end_col = end
+        token_end = mapped_position(node.token_end_line, node.token_end_col)
+        if token_end is not None:
+            node.token_end_line, node.token_end_col = token_end
+        if node.source_positions:
+            node.source_positions = (
+                mapped_position(line, col) or (line, col)
+                for line, col in node.source_positions
+            )
+        for child in node.child_nodes:
+            visit(child)
+
+    visit(root)
+    cast(Any, root)._incremental_source_positions_normalized = True
+
+
+def apply_edit(source: str, span_index: SpanIndex, edit: TextEdit) -> EditPlan:
+    """Apply *edit* and classify it as one routine span or a full reparse."""
+
+    if edit.end > len(source):
+        raise ValueError("edit end exceeds source length")
+    updated_source = source[: edit.start] + edit.text + source[edit.end :]
+    character_delta = len(edit.text) - (edit.end - edit.start)
+    removed = source[edit.start : edit.end]
+    line_delta = _newline_count(edit.text) - _newline_count(removed)
+    if _digest(source) != span_index.source_hash or len(source) != span_index.source_length:
+        return _full_plan(
+            span_index,
+            edit,
+            updated_source,
+            "stale-span-index",
+            line_delta,
+            character_delta,
+        )
+    if _touches_conditional_directive(source, edit) or _contains_conditional_directive(
+        edit.text
+    ):
+        return _full_plan(
+            span_index,
+            edit,
+            updated_source,
+            "conditional-directive",
+            line_delta,
+            character_delta,
+        )
+
+    routine = next(
+        (
+            candidate
+            for candidate in span_index.routines
+            if candidate.body_start_offset <= edit.start
+            and edit.end <= candidate.body_end_offset
+        ),
+        None,
+    )
+    if routine is None:
+        return _full_plan(
+            span_index,
+            edit,
+            updated_source,
+            "outside-routine-body",
+            line_delta,
+            character_delta,
+        )
+
+    updated_index = _shift_index(
+        span_index,
+        updated_source,
+        routine,
+        edit,
+        line_delta,
+        character_delta,
+        counters=PathCounters(
+            incremental=span_index.counters.incremental + 1,
+            full_reparse=span_index.counters.full_reparse,
+        ),
+    )
+    updated_routine = next(
+        candidate
+        for candidate in updated_index.routines
+        if candidate.start_offset == routine.start_offset
+    )
+    return EditPlan(
+        kind=EditKind.INCREMENTAL,
+        reason="routine-body",
+        edit=edit,
+        updated_source=updated_source,
+        origin_index=span_index,
+        updated_index=updated_index,
+        counters=updated_index.counters,
+        routine=updated_routine,
+        previous_routine=routine,
+        line_delta=line_delta,
+        character_delta=character_delta,
+    )
+
+
+def reparse_span(source: str, plan: EditPlan) -> SplicedModel:
+    """Execute an edit plan and return the updated parse result and span index."""
+
+    if source != plan.updated_source:
+        raise ValueError("source does not match the edit plan")
+    if plan.kind is EditKind.FULL_REPARSE:
+        return _execute_full_reparse(source, plan, plan.reason, plan.counters)
+    if (
+        plan.updated_index is None
+        or plan.routine is None
+        or plan.previous_routine is None
+    ):
+        return _execute_full_reparse(
+            source,
+            plan,
+            "incomplete-incremental-plan",
+            _escalated_counters(plan),
+        )
+    if _digest(source) != plan.updated_index.source_hash:
+        return _execute_full_reparse(
+            source,
+            plan,
+            "stale-updated-source",
+            _escalated_counters(plan),
+        )
+    routine = plan.routine
+    if _context_hash(source, routine.start_offset, routine.end_offset) != routine.context_hash:
+        return _execute_full_reparse(
+            source,
+            plan,
+            "routine-context-mismatch",
+            _escalated_counters(plan),
+        )
+
+    fragment_source = source[routine.start_offset : routine.end_offset]
+    wrapped = f"unit __Frag;\ninterface\nimplementation\n{fragment_source}\nend.\n"
+    fragment_result = plan.updated_index.parser.parse(
+        wrapped,
+        plan.updated_index.file_name,
+        build_semantic=False,
+    )
+    fragment_implementation = _implementation_node(fragment_result.root)
+    fragment_methods = (
+        [
+            child
+            for child in fragment_implementation.child_nodes
+            if child.typ is SyntaxNodeType.ntMethod
+        ]
+        if fragment_implementation is not None
+        else []
+    )
+    if len(fragment_methods) != 1:
+        return _execute_full_reparse(
+            source,
+            plan,
+            "fragment-resync-failed",
+            _escalated_counters(plan),
+        )
+    fragment_method = fragment_methods[0]
+    line_offset = routine.start_line - fragment_method.line
+    _shift_node(fragment_method, line_offset, plan.updated_index.file_name)
+    statements = next(
+        (
+            child
+            for child in fragment_method.child_nodes
+            if child.typ is SyntaxNodeType.ntStatements
+        ),
+        None,
+    )
+    if (
+        fragment_method.get_attribute(AttributeName.anName) != routine.name
+        or statements is None
+        or getattr(statements, "end_line", 0) != routine.end_line
+    ):
+        return _execute_full_reparse(
+            source,
+            plan,
+            "fragment-boundary-changed",
+            _escalated_counters(plan),
+        )
+
+    result = plan.updated_index.result
+    target_parent = _implementation_node(result.root)
+    target = _find_method_node(
+        target_parent,
+        plan.previous_routine.name,
+        plan.previous_routine.start_line,
+    )
+    if target_parent is None or target is None or fragment_implementation is None:
+        return _execute_full_reparse(
+            source,
+            plan,
+            "held-model-mismatch",
+            _escalated_counters(plan),
+        )
+
+    if result.semantic is not None and not _splice_semantic_model(
+            result,
+            fragment_result.root,
+            fragment_method,
+            plan.previous_routine,
+            routine,
+            plan.line_delta,
+        ):
+        return _execute_full_reparse(
+            source,
+            plan,
+            "semantic-splice-failed",
+            _escalated_counters(plan),
+        )
+
+    _shift_node_after(
+        result.root,
+        plan.previous_routine.end_line,
+        plan.line_delta,
+        skip=target,
+    )
+    target_index = target_parent.child_nodes.index(target)
+    target_parent.extract_child(target)
+    fragment_implementation.extract_child(fragment_method)
+    target_parent.add_child(fragment_method)
+    target_parent.child_nodes.insert(target_index, target_parent.child_nodes.pop())
+
+    shifted_fragment_problems = [
+        _shift_problem(problem, line_offset)
+        for problem in fragment_result.problems
+        if getattr(problem, "line", fragment_method.line) >= fragment_method.line - line_offset
+    ]
+    result.problems = [
+        shifted
+        for problem in result.problems
+        if (
+            shifted := _problem_after_edit(
+                problem,
+                plan.previous_routine,
+                plan.line_delta,
+            )
+        )
+        is not None
+    ]
+    result.problems.extend(shifted_fragment_problems)
+    result.comments = _splice_comments(
+        result.comments,
+        fragment_result.comments,
+        plan.previous_routine,
+        line_offset,
+        plan.line_delta,
+        routine,
+    )
+
+    updated_index = replace(
+        plan.updated_index,
+        result=result,
+        counters=plan.counters,
+    )
+    return SplicedModel(
+        result=result,
+        span_index=updated_index,
+        kind=EditKind.INCREMENTAL,
+        reason=plan.reason,
+        counters=plan.counters,
+    )
+
+
+def _execute_full_reparse(
+    source: str,
+    plan: EditPlan,
+    reason: str,
+    counters: PathCounters,
+) -> SplicedModel:
+    previous_index = plan.updated_index or plan.origin_index
+    result = previous_index.parser.parse(
+        source,
+        previous_index.file_name,
+        build_semantic=previous_index.result.semantic is not None,
+    )
+    span_index = replace(
+        build_span_index(
+            source,
+            result,
+            parser=previous_index.parser,
+        ),
+        counters=counters,
+    )
+    return SplicedModel(
+        result=result,
+        span_index=span_index,
+        kind=EditKind.FULL_REPARSE,
+        reason=reason,
+        counters=counters,
+    )
+
+
+def _escalated_counters(plan: EditPlan) -> PathCounters:
+    return PathCounters(
+        incremental=max(0, plan.counters.incremental - 1),
+        full_reparse=plan.counters.full_reparse + 1,
+    )
+
+
+def _implementation_node(root: SyntaxNode) -> SyntaxNode | None:
+    return next(
+        (
+            child
+            for child in root.child_nodes
+            if child.typ is SyntaxNodeType.ntImplementation
+        ),
+        None,
+    )
+
+
+def _find_method_node(
+    implementation: SyntaxNode | None,
+    name: str,
+    start_line: int,
+) -> SyntaxNode | None:
+    if implementation is None:
+        return None
+    return next(
+        (
+            child
+            for child in implementation.child_nodes
+            if child.typ is SyntaxNodeType.ntMethod
+            and child.line == start_line
+            and child.get_attribute(AttributeName.anName) == name
+        ),
+        None,
+    )
+
+
+def _shift_node(node: SyntaxNode, line_delta: int, file_name: str) -> None:
+    node.file_name = file_name
+    if node.line > 0:
+        node.line += line_delta
+    end_line = getattr(node, "end_line", 0)
+    if end_line > 0:
+        cast(Any, node).end_line = end_line + line_delta
+    if node.token_end_line > 0:
+        node.token_end_line += line_delta
+    if node.source_positions:
+        node.source_positions = (
+            (line + line_delta if line > 0 else line, column)
+            for line, column in node.source_positions
+        )
+    for child in node.child_nodes:
+        _shift_node(child, line_delta, file_name)
+
+
+def _shift_node_after(
+    node: SyntaxNode,
+    cutoff_line: int,
+    line_delta: int,
+    *,
+    skip: SyntaxNode,
+) -> None:
+    if line_delta == 0 or node is skip:
+        return
+    if node.line > cutoff_line:
+        _shift_node(node, line_delta, node.file_name)
+        return
+    end_line = getattr(node, "end_line", 0)
+    if end_line > cutoff_line:
+        cast(Any, node).end_line = end_line + line_delta
+    if node.token_end_line > cutoff_line:
+        node.token_end_line += line_delta
+    if node.source_positions:
+        node.source_positions = (
+            (line + line_delta if line > cutoff_line else line, column)
+            for line, column in node.source_positions
+        )
+    for child in node.child_nodes:
+        _shift_node_after(child, cutoff_line, line_delta, skip=skip)
+
+
+def _shift_problem(problem: Any, line_delta: int) -> Any:
+    line = getattr(problem, "line", None)
+    if not isinstance(line, int) or line < 1 or not is_dataclass(problem):
+        return problem
+    values: dict[str, Any] = {"line": line + line_delta}
+    if hasattr(problem, "file_name"):
+        values["file_name"] = problem.file_name
+    try:
+        return replace(cast(Any, problem), **values)
+    except TypeError:
+        values.pop("file_name", None)
+        return replace(cast(Any, problem), **values)
+
+
+def _problem_after_edit(
+    problem: Any,
+    previous: RoutineSpan,
+    line_delta: int,
+) -> Any | None:
+    line = getattr(problem, "line", None)
+    if not isinstance(line, int):
+        return problem
+    if previous.start_line <= line <= previous.end_line:
+        return None
+    if line > previous.end_line and line_delta:
+        return _shift_problem(problem, line_delta)
+    return problem
+
+
+def _splice_comments(
+    old_comments: list,
+    fragment_comments: list,
+    previous: RoutineSpan,
+    fragment_line_offset: int,
+    line_delta: int,
+    routine: RoutineSpan,
+) -> list:
+    kept = []
+    for comment in old_comments:
+        if previous.start_line <= comment.line <= previous.end_line:
+            continue
+        if comment.line > previous.end_line and line_delta:
+            _shift_node(comment, line_delta, comment.file_name)
+        kept.append(comment)
+    fragment_start = routine.start_line - fragment_line_offset
+    fragment_end = routine.end_line - fragment_line_offset
+    for comment in fragment_comments:
+        if fragment_start <= comment.line <= fragment_end:
+            _shift_node(comment, fragment_line_offset, comment.file_name)
+            kept.append(comment)
+    kept.sort(key=lambda comment: (comment.line, comment.col))
+    return kept
+
+
+def _splice_semantic_model(
+    result: ParseResult,
+    fragment_root: SyntaxNode,
+    fragment_method: SyntaxNode,
+    previous: RoutineSpan,
+    routine: RoutineSpan,
+    line_delta: int,
+) -> bool:
+    semantic = result.semantic
+    if semantic is None:
+        return True
+    unit_scope = semantic.unit_scope
+    key = normalize_name(previous.name)
+    candidates = unit_scope.symbols.get(key, [])
+    old_symbol = next(
+        (
+            symbol
+            for symbol in candidates
+            if symbol.name == previous.name
+            and symbol.decl_range.start_line == previous.start_line
+        ),
+        None,
+    )
+    if old_symbol is None:
+        return False
+    old_position = candidates.index(old_symbol)
+    candidates.remove(old_symbol)
+    if not candidates:
+        unit_scope.symbols.pop(key, None)
+    _remove_index_symbol(semantic.index, old_symbol)
+
+    _shift_scope_ranges(
+        unit_scope,
+        previous.end_line,
+        line_delta,
+        skip=old_symbol,
+    )
+    kept_references = []
+    for reference in semantic.references:
+        line = reference.ref_range.start_line
+        if previous.start_line <= line <= previous.end_line:
+            continue
+        reference.ref_range = _shift_source_range(
+            reference.ref_range,
+            previous.end_line,
+            line_delta,
+        )
+        kept_references.append(reference)
+    kept_problems = []
+    for problem in semantic.problems:
+        line = problem.range.start_line
+        if previous.start_line <= line <= previous.end_line:
+            continue
+        problem.range = _shift_source_range(
+            problem.range,
+            previous.end_line,
+            line_delta,
+        )
+        kept_problems.append(problem)
+
+    fragment_index = SymbolIndex(units=dict(semantic.index.units))
+    builder = SemanticBuilder()
+    builder.declare(
+        fragment_root,
+        index=fragment_index,
+        unit_scope=unit_scope,
+        reset_state=True,
+    )
+    fragment_model = builder.resolve(fragment_root, unit_scope)
+    new_candidates = unit_scope.symbols.get(normalize_name(routine.name), [])
+    new_symbol = next(
+        (
+            symbol
+            for symbol in reversed(new_candidates)
+            if symbol.name == routine.name
+            and symbol.decl_range.start_line == routine.start_line
+        ),
+        None,
+    )
+    if new_symbol is None:
+        return False
+    new_candidates.remove(new_symbol)
+    new_candidates.insert(min(old_position, len(new_candidates)), new_symbol)
+    _add_index_symbol(semantic.index, new_symbol)
+    semantic.references = [*kept_references, *fragment_model.references]
+    semantic.problems = [*kept_problems, *fragment_model.problems]
+    semantic.references.sort(
+        key=lambda reference: (
+            reference.ref_range.start_line,
+            reference.ref_range.start_col,
+            reference.name,
+        )
+    )
+    semantic.problems.sort(
+        key=lambda problem: (
+            problem.range.start_line,
+            problem.range.start_col,
+            problem.message,
+        )
+    )
+    return fragment_method.get_attribute(AttributeName.anName) == routine.name
+
+
+def _shift_scope_ranges(
+    scope: Any,
+    cutoff_line: int,
+    line_delta: int,
+    *,
+    skip: Symbol,
+) -> None:
+    if line_delta == 0:
+        return
+    pending = [scope]
+    seen_scopes: set[int] = set()
+    seen_symbols: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if id(current) in seen_scopes:
+            continue
+        seen_scopes.add(id(current))
+        if current.owner is not None and current.owner is not skip:
+            _shift_symbol_ranges(
+                current.owner,
+                cutoff_line,
+                line_delta,
+                seen_symbols,
+            )
+        for entries in current.symbols.values():
+            for symbol in entries:
+                if symbol is skip:
+                    continue
+                _shift_symbol_ranges(
+                    symbol,
+                    cutoff_line,
+                    line_delta,
+                    seen_symbols,
+                )
+                if symbol.member_scope is not None:
+                    pending.append(symbol.member_scope)
+
+
+def _shift_symbol_ranges(
+    symbol: Symbol,
+    cutoff_line: int,
+    line_delta: int,
+    seen: set[int],
+) -> None:
+    if id(symbol) in seen:
+        return
+    seen.add(id(symbol))
+    symbol.decl_range = _shift_source_range(symbol.decl_range, cutoff_line, line_delta)
+    symbol.name_range = _shift_source_range(symbol.name_range, cutoff_line, line_delta)
+    for overload in symbol.overloads:
+        _shift_symbol_ranges(overload, cutoff_line, line_delta, seen)
+
+
+def _shift_source_range(
+    value: SourceRange,
+    cutoff_line: int,
+    line_delta: int,
+) -> SourceRange:
+    if line_delta == 0:
+        return value
+    if value.start_line > cutoff_line:
+        return replace(
+            value,
+            start_line=value.start_line + line_delta,
+            end_line=value.end_line + line_delta,
+        )
+    if value.end_line > cutoff_line:
+        return replace(value, end_line=value.end_line + line_delta)
+    return value
+
+
+def _remove_index_symbol(index: SymbolIndex, symbol: Symbol) -> None:
+    key = normalize_name(symbol.name)
+    entries = index.name_index.get(key)
+    if entries is None:
+        return
+    index.name_index[key] = [candidate for candidate in entries if candidate is not symbol]
+    if not index.name_index[key]:
+        index.name_index.pop(key, None)
+
+
+def _add_index_symbol(index: SymbolIndex, symbol: Symbol) -> None:
+    key = normalize_name(symbol.name)
+    entries = index.name_index.setdefault(key, [])
+    if all(candidate is not symbol for candidate in entries):
+        entries.append(symbol)
+
+
+def _routine_span(
+    source: str,
+    line_starts: tuple[int, ...],
+    node: SyntaxNode,
+) -> RoutineSpan | None:
+    if node.line < 1:
+        return None
+    statements = next(
+        (
+            child
+            for child in node.child_nodes
+            if child.typ is SyntaxNodeType.ntStatements
+        ),
+        None,
+    )
+    statements_end_line = getattr(statements, "end_line", 0)
+    if (
+        statements is None
+        or statements.line < 1
+        or statements_end_line < 1
+        or statements_end_line > len(line_starts)
+    ):
+        return None
+    start_line = node.line
+    end_line = statements_end_line
+    body_start_line = statements.line + 1
+    body_end_line = statements_end_line - 1
+    if body_end_line < body_start_line:
+        return None
+    start_offset = _line_start(line_starts, start_line)
+    end_offset = _line_start(line_starts, end_line + 1, default=len(source))
+    body_start_offset = _line_start(line_starts, body_start_line)
+    body_end_offset = _line_start(
+        line_starts,
+        body_end_line + 1,
+        default=len(source),
+    )
+    name = node.get_attribute(AttributeName.anName)
+    if not name or end_offset <= start_offset:
+        return None
+    return RoutineSpan(
+        name=name,
+        start_line=start_line,
+        end_line=end_line,
+        body_start_line=body_start_line,
+        body_end_line=body_end_line,
+        start_offset=start_offset,
+        end_offset=end_offset,
+        body_start_offset=body_start_offset,
+        body_end_offset=body_end_offset,
+        context_hash=_context_hash(source, start_offset, end_offset),
+    )
+
+
+def _full_plan(
+    span_index: SpanIndex,
+    edit: TextEdit,
+    updated_source: str,
+    reason: str,
+    line_delta: int,
+    character_delta: int,
+) -> EditPlan:
+    counters = PathCounters(
+        incremental=span_index.counters.incremental,
+        full_reparse=span_index.counters.full_reparse + 1,
+    )
+    return EditPlan(
+        kind=EditKind.FULL_REPARSE,
+        reason=reason,
+        edit=edit,
+        updated_source=updated_source,
+        origin_index=span_index,
+        updated_index=None,
+        counters=counters,
+        line_delta=line_delta,
+        character_delta=character_delta,
+    )
+
+
+def _shift_index(
+    span_index: SpanIndex,
+    updated_source: str,
+    edited_routine: RoutineSpan,
+    edit: TextEdit,
+    line_delta: int,
+    character_delta: int,
+    *,
+    counters: PathCounters,
+) -> SpanIndex:
+    line_starts = _shift_line_starts(span_index.line_starts, edit)
+    routines: list[RoutineSpan] = []
+    for routine in span_index.routines:
+        if routine is edited_routine:
+            shifted = replace(
+                routine,
+                end_line=routine.end_line + line_delta,
+                body_end_line=routine.body_end_line + line_delta,
+                end_offset=routine.end_offset + character_delta,
+                body_end_offset=routine.body_end_offset + character_delta,
+            )
+        elif routine.start_offset >= edit.end:
+            shifted = replace(
+                routine,
+                start_line=routine.start_line + line_delta,
+                end_line=routine.end_line + line_delta,
+                body_start_line=routine.body_start_line + line_delta,
+                body_end_line=routine.body_end_line + line_delta,
+                start_offset=routine.start_offset + character_delta,
+                end_offset=routine.end_offset + character_delta,
+                body_start_offset=routine.body_start_offset + character_delta,
+                body_end_offset=routine.body_end_offset + character_delta,
+            )
+        else:
+            shifted = routine
+        routines.append(shifted)
+    return replace(
+        span_index,
+        source_hash=_digest(updated_source),
+        source_length=len(updated_source),
+        line_starts=line_starts,
+        sections=_shift_boundary_spans(
+            span_index.sections,
+            edit,
+            line_delta,
+            character_delta,
+        ),
+        declarations=_shift_boundary_spans(
+            span_index.declarations,
+            edit,
+            line_delta,
+            character_delta,
+        ),
+        routines=tuple(routines),
+        counters=counters,
+    )
+
+
+def _structural_spans(
+    source: str,
+    line_starts: tuple[int, ...],
+    root: SyntaxNode,
+) -> tuple[tuple[SectionSpan, ...], tuple[DeclarationSpan, ...]]:
+    section_kinds = {
+        SyntaxNodeType.ntInterface: "interface",
+        SyntaxNodeType.ntImplementation: "implementation",
+        SyntaxNodeType.ntInitialization: "initialization",
+        SyntaxNodeType.ntFinalization: "finalization",
+    }
+    declaration_kinds = {
+        SyntaxNodeType.ntTypeSection: "type",
+        SyntaxNodeType.ntConstants: "const",
+        SyntaxNodeType.ntVariables: "var",
+        SyntaxNodeType.ntUses: "uses",
+        SyntaxNodeType.ntExports: "exports",
+    }
+    section_nodes = [
+        child
+        for child in root.child_nodes
+        if child.typ in section_kinds and child.line > 0
+    ]
+    sections: list[SectionSpan] = []
+    declarations: list[DeclarationSpan] = []
+    source_end_line = len(line_starts) - (1 if line_starts[-1] == len(source) else 0)
+    root_end_line = min(
+        max(root.line, getattr(root, "end_line", 0)),
+        max(1, source_end_line),
+    )
+    for index, node in enumerate(section_nodes):
+        kind = section_kinds[node.typ]
+        end_line = (
+            section_nodes[index + 1].line - 1
+            if index + 1 < len(section_nodes)
+            else root_end_line
+        )
+        start_offset = _line_start(line_starts, node.line)
+        end_offset = _line_start(line_starts, end_line + 1, default=len(source))
+        sections.append(
+            SectionSpan(
+                kind=kind,
+                start_line=node.line,
+                end_line=end_line,
+                start_offset=start_offset,
+                end_offset=end_offset,
+                context_hash=_context_hash(source, start_offset, end_offset),
+            )
+        )
+        declaration_nodes = [
+            child
+            for child in node.child_nodes
+            if child.typ in declaration_kinds and child.line > 0
+        ]
+        for declaration_index, declaration in enumerate(declaration_nodes):
+            declaration_end_line = (
+                declaration_nodes[declaration_index + 1].line - 1
+                if declaration_index + 1 < len(declaration_nodes)
+                else end_line
+            )
+            declaration_start = _line_start(line_starts, declaration.line)
+            declaration_end = _line_start(
+                line_starts,
+                declaration_end_line + 1,
+                default=len(source),
+            )
+            declarations.append(
+                DeclarationSpan(
+                    section=kind,
+                    kind=declaration_kinds[declaration.typ],
+                    start_line=declaration.line,
+                    end_line=declaration_end_line,
+                    start_offset=declaration_start,
+                    end_offset=declaration_end,
+                    context_hash=_context_hash(
+                        source,
+                        declaration_start,
+                        declaration_end,
+                    ),
+                )
+            )
+    return tuple(sections), tuple(declarations)
+
+
+def _shift_boundary_spans(
+    spans: tuple,
+    edit: TextEdit,
+    line_delta: int,
+    character_delta: int,
+) -> tuple:
+    shifted_spans = []
+    for span in spans:
+        if span.start_offset >= edit.end:
+            shifted = replace(
+                span,
+                start_line=span.start_line + line_delta,
+                end_line=span.end_line + line_delta,
+                start_offset=span.start_offset + character_delta,
+                end_offset=span.end_offset + character_delta,
+            )
+        elif span.end_offset >= edit.end:
+            shifted = replace(
+                span,
+                end_line=span.end_line + line_delta,
+                end_offset=span.end_offset + character_delta,
+            )
+        else:
+            shifted = span
+        shifted_spans.append(shifted)
+    return tuple(shifted_spans)
+
+
+def _shift_line_starts(
+    line_starts: tuple[int, ...],
+    edit: TextEdit,
+) -> tuple[int, ...]:
+    prefix_end = bisect_right(line_starts, edit.start)
+    suffix_start = bisect_right(line_starts, edit.end)
+    character_delta = len(edit.text) - (edit.end - edit.start)
+    inserted = tuple(
+        edit.start + index + 1
+        for index, char in enumerate(edit.text)
+        if char == "\n"
+    )
+    shifted_suffix = tuple(
+        offset + character_delta
+        for offset in line_starts[suffix_start:]
+    )
+    return (*line_starts[:prefix_end], *inserted, *shifted_suffix)
+
+
+def _line_starts(source: str) -> tuple[int, ...]:
+    starts = [0]
+    starts.extend(index + 1 for index, char in enumerate(source) if char == "\n")
+    return tuple(starts)
+
+
+def _line_start(
+    line_starts: tuple[int, ...],
+    line: int,
+    *,
+    default: int | None = None,
+) -> int:
+    index = line - 1
+    if 0 <= index < len(line_starts):
+        return line_starts[index]
+    if default is not None and index == len(line_starts):
+        return default
+    raise ValueError(f"line {line} is outside the source")
+
+
+def _touches_conditional_directive(source: str, edit: TextEdit) -> bool:
+    line_start = source.rfind("\n", 0, edit.start) + 1
+    line_end = source.find("\n", edit.end)
+    if line_end < 0:
+        line_end = len(source)
+    return _contains_conditional_directive(source[line_start:line_end])
+
+
+def _contains_conditional_directive(text: str) -> bool:
+    folded = text.casefold()
+    return any(
+        marker in folded
+        for marker in ("{$if", "(*$if", "{$else", "{$endif")
+    )
+
+
+def _context_hash(source: str, start: int, end: int) -> str:
+    header_end = source.find("\n", start, end)
+    header = source[start : end if header_end < 0 else header_end]
+    closing_start = source.rfind("\n", start, max(start, end - 1)) + 1
+    closing = source[closing_start:end].rstrip("\r\n")
+    return _digest(f"{header}\n{closing}")
+
+
+def _newline_count(text: str) -> int:
+    return text.count("\n")
+
+
+def _digest(text: str) -> str:
+    return sha256(text.encode("utf-8")).hexdigest()
+
+
+__all__ = [
+    "FULL_REPARSE",
+    "DeclarationSpan",
+    "EditKind",
+    "EditPlan",
+    "PathCounters",
+    "RoutineSpan",
+    "SectionSpan",
+    "SpanIndex",
+    "SplicedModel",
+    "TextEdit",
+    "apply_edit",
+    "build_span_index",
+    "reparse_span",
+]