python-delphi-lsp 2.0.3__py3-none-any.whl → 2.0.4__py3-none-any.whl

delphi_lsp/__init__.py

@@ -48,6 +48,7 @@ from .semantic_builder import SemanticBuilder, SemanticModel, SemanticProblem
 from .workspace import WorkspaceSemanticResult, build_workspace_semantics
 from .lsp_server import LspWorkspaceState, create_server
 from .project_discovery import DelphiProjectDiscovery, DiscoveryProblem, discover_delphi_project
+from .progress import ProgressCallback, ProgressEvent
 from .project_indexer import (
     GetUnitSyntaxHook,
     IncludeFileInfo,
@@ -136,6 +137,8 @@ __all__ = [
     'DelphiProjectDiscovery',
     'DiscoveryProblem',
     'discover_delphi_project',
+    'ProgressCallback',
+    'ProgressEvent',
     'ProjectIndexer',
     'ProjectIndexResult',
     'ProjectProblemType',

delphi_lsp/_version.py

@@ -1 +1 @@
-__version__ = "2.0.3"
+__version__ = "2.0.4"

delphi_lsp/agent_context.py

@@ -695,7 +695,14 @@ def _build_registry(workspace: AgentWorkspace, project_id: str, revision: str) -
             include_paths=workspace.include_paths,
         )
         sources[source_path] = document
-        model = build_outline_semantic_model(text, str(source_path))
+        if workspace.defines:
+            model = build_outline_semantic_model(
+                text,
+                str(source_path),
+                defines=workspace.defines,
+            )
+        else:
+            model = build_outline_semantic_model(text, str(source_path))
         unit_symbols = _collect_raw_symbols(model.unit_scope, unit, source_path, document)
         raw_symbols.extend(_exclude_routine_locals(unit_symbols, document))
 

delphi_lsp/agent_layers.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Any, Iterable
 import json
 
-from .lsp_server import build_outline_semantic_model, outline_source
+from .lsp_server import build_outline_semantic_model
 from .metrics import analyze_project
 from .project_discovery import DelphiProjectDiscovery, discover_delphi_project
 from .project_indexer import ProjectIndexResult, ProjectIndexer
+from .progress import ProgressCallback, ProgressEvent
 from .semantic import Scope, SourceRange, Symbol, SymbolIndex, SymbolKind
 from .semantic_builder import SemanticModel
 from .source_reader import read_source_text
@@ -28,10 +29,14 @@ def build_codebase_index(
     *,
     project_file: str | Path | None = None,
     index_projects: bool = False,
+    on_progress: ProgressCallback | None = None,
 ) -> CodebaseIndex:
-    discovery = discover_delphi_project(root, project_file=project_file)
+    progress = _MonotonicProgress(on_progress)
+    discovery = discover_delphi_project(root, project_file=project_file, on_progress=progress)
     models: dict[str, SemanticModel] = {}
-    for source in discovery.source_files:
+    lines_processed = 0
+    symbols_discovered = 0
+    for completed, source in enumerate(discovery.source_files, start=1):
         path = Path(source)
         if path.suffix.casefold() not in {".pas", ".dpr", ".dpk", ".inc"}:
             continue
@@ -39,7 +44,25 @@ def build_codebase_index(
             text = read_source_text(path)
         except (OSError, UnicodeError):
             continue
-        models[source] = build_outline_semantic_model(outline_source(text), source)
+        model = build_outline_semantic_model(
+            text,
+            source,
+            defines=discovery.defines,
+        )
+        models[source] = model
+        lines_processed += text.count("\n") + (0 if not text or text.endswith("\n") else 1)
+        symbols_discovered += sum(len(items) for items in model.index.name_index.values())
+        _emit_progress(
+            progress,
+            "outline",
+            source,
+            len(discovery.source_files),
+            completed,
+            len(discovery.source_files),
+            "source outlined",
+            lines_processed=lines_processed,
+            symbols_discovered=symbols_discovered,
+        )
 
     symbol_index = SymbolIndex()
     for model in models.values():
@@ -47,6 +70,18 @@ def build_codebase_index(
     for model in models.values():
         model.index = symbol_index
 
+    _emit_progress(
+        progress,
+        "relations",
+        str(Path(root).expanduser().resolve()),
+        len(discovery.source_files),
+        len(discovery.source_files),
+        len(discovery.source_files),
+        "semantic relations indexed",
+        lines_processed=lines_processed,
+        symbols_discovered=sum(len(items) for items in symbol_index.name_index.values()),
+    )
+
     project_results: dict[str, ProjectIndexResult] = {}
     if index_projects:
         for project in discovery.project_files:
@@ -54,16 +89,90 @@ def build_codebase_index(
                 search_paths=discovery.search_paths,
                 include_paths=discovery.include_paths,
                 defines=discovery.defines,
+                on_progress=progress,
             )
             project_results[project] = indexer.index(project)
 
-    return CodebaseIndex(
+    index = CodebaseIndex(
         root=str(Path(root).expanduser().resolve()),
         discovery=discovery,
         models=models,
         symbol_index=symbol_index,
         project_results=project_results,
     )
+    _emit_progress(
+        progress,
+        "complete",
+        str(Path(root).expanduser().resolve()),
+        len(discovery.source_files),
+        len(discovery.source_files),
+        len(discovery.source_files),
+        "codebase index complete",
+        lines_processed=lines_processed,
+        symbols_discovered=sum(len(items) for items in symbol_index.name_index.values()),
+    )
+    return index
+
+
+def _emit_progress(
+    callback: ProgressCallback | None,
+    phase: str,
+    path: str,
+    files_discovered: int,
+    files_completed: int,
+    files_total: int | None,
+    detail: str,
+    *,
+    lines_processed: int = 0,
+    symbols_discovered: int = 0,
+) -> None:
+    if callback is not None:
+        callback(
+            ProgressEvent(
+                phase,
+                "delphi",
+                path,
+                files_discovered,
+                files_completed,
+                files_total,
+                lines_processed,
+                symbols_discovered,
+                0,
+                detail,
+            )
+        )
+
+
+class _MonotonicProgress:
+    def __init__(self, callback: ProgressCallback | None) -> None:
+        self._callback = callback
+        self._files_discovered = 0
+        self._files_completed = 0
+        self._files_total: int | None = None
+        self._lines_processed = 0
+        self._symbols_discovered = 0
+        self._cached_files = 0
+
+    def __call__(self, event: ProgressEvent) -> None:
+        self._files_discovered = max(self._files_discovered, event.files_discovered)
+        self._files_completed = max(self._files_completed, event.files_completed)
+        if event.files_total is not None:
+            self._files_total = max(self._files_total or 0, event.files_total)
+        self._lines_processed = max(self._lines_processed, event.lines_processed)
+        self._symbols_discovered = max(self._symbols_discovered, event.symbols_discovered)
+        self._cached_files = max(self._cached_files, event.cached_files)
+        if self._callback is not None:
+            self._callback(
+                replace(
+                    event,
+                    files_discovered=self._files_discovered,
+                    files_completed=self._files_completed,
+                    files_total=self._files_total,
+                    lines_processed=self._lines_processed,
+                    symbols_discovered=self._symbols_discovered,
+                    cached_files=self._cached_files,
+                )
+            )
 
 
 def render_layer(

delphi_lsp/lsp_server.py

@@ -7,6 +7,7 @@ from urllib.parse import unquote, urlparse
 import os
 import re
 
+from .preprocessor import Preprocessor
 from .semantic import (
     ReferenceKind,
     Scope,
@@ -249,7 +250,11 @@ class LspWorkspaceState:
             text = read_source_text(path)
         except (OSError, UnicodeError):
             return None
-        return build_outline_semantic_model(text, file_name)
+        return build_outline_semantic_model(
+            text,
+            file_name,
+            defines=self.config.defines,
+        )
 
     def full_semantic_for_uri(self, uri: str) -> Optional[SemanticModel]:
         file_name = uri_to_path(uri)
@@ -267,7 +272,11 @@ class LspWorkspaceState:
         text = self.text_for_uri(uri)
         if text is None:
             return None
-        return build_outline_semantic_model(text, uri_to_path(uri))
+        return build_outline_semantic_model(
+            text,
+            uri_to_path(uri),
+            defines=self.config.defines,
+        )
 
     def text_for_uri(self, uri: str) -> Optional[str]:
         doc = self.documents.get(uri)
@@ -293,7 +302,14 @@ class LspWorkspaceState:
     ) -> Optional[WorkspaceSemanticResult]:
         if not sources:
             return None
-        models = {file_name: build_outline_semantic_model(text, file_name) for file_name, text in sources.items()}
+        models = {
+            file_name: build_outline_semantic_model(
+                text,
+                file_name,
+                defines=self.config.defines,
+            )
+            for file_name, text in sources.items()
+        }
         index = SymbolIndex()
         for model in models.values():
             index.register_unit(model.unit_scope.name, model.unit_scope)
@@ -343,8 +359,51 @@ def uri_to_path(uri: str) -> str:
     return path or uri
 
 
-def outline_source(text: str) -> str:
-    return _blank_compound_statement_bodies(text)
+def outline_source(text: str, *, defines: Iterable[str] | None = None) -> str:
+    scan_text = (
+        text
+        if defines is None
+        else _conditional_outline_scan_text(text, defines=defines)
+    )
+    return _blank_compound_statement_bodies(
+        text,
+        scan_text=scan_text,
+    )
+
+
+def _conditional_outline_scan_text(
+    text: str,
+    *,
+    defines: Iterable[str],
+) -> str:
+    if '{$' not in text and '(*$' not in text:
+        return text
+    selected = Preprocessor(
+        defines=defines,
+        include_loader=lambda _name, _current: None,
+        preserve_active_directives=True,
+    ).process(text, '<outline>').text
+    original_lines = text.splitlines(keepends=True)
+    selected_lines = selected.splitlines(keepends=True)
+    if len(original_lines) != len(selected_lines):
+        return text
+    restored: list[str] = []
+    for original_line, selected_line in zip(original_lines, selected_lines, strict=True):
+        original_body, original_ending = _split_line_ending(original_line)
+        selected_body, _selected_ending = _split_line_ending(selected_line)
+        if len(original_body) != len(selected_body):
+            return text
+        restored.append(selected_body + original_ending)
+    result = ''.join(restored)
+    return result if len(result) == len(text) else text
+
+
+def _split_line_ending(line: str) -> tuple[str, str]:
+    if line.endswith('\r\n'):
+        return line[:-2], '\r\n'
+    if line.endswith(('\r', '\n')):
+        return line[:-1], line[-1]
+    return line, ''
 
 
 def multiline_string_block_end(text: str, start: int) -> int | None:
@@ -406,11 +465,29 @@ _CLASS_MEMBER_BOUNDARIES = frozenset(
 _GENERIC_ROUTINE_HEADINGS = frozenset(
     {'constructor', 'destructor', 'function', 'operator', 'procedure'}
 )
+_CONDITIONAL_DIRECTIVE_OPENERS = frozenset({'if', 'ifdef', 'ifndef', 'ifopt'})
+_CONDITIONAL_DIRECTIVE_ALTERNATIVES = frozenset({'else', 'elseif'})
+_CONDITIONAL_DIRECTIVE_CLOSERS = frozenset({'endif', 'ifend'})
+
+
+@dataclass
+class _ConditionalOutlineFrame:
+    base_stack: tuple[str, ...]
+    branch_stacks: list[tuple[str, ...]] = field(default_factory=list)
+    has_alternative: bool = False
 
 
-def _blank_compound_statement_bodies(text: str) -> str:
-    chars = list(text)
+def _blank_compound_statement_bodies(
+    text: str,
+    *,
+    scan_text: str | None = None,
+) -> str:
+    scanned = scan_text if scan_text is not None else text
+    if len(scanned) != len(text):
+        return text
+    chars = list(scanned)
     end_stack: list[str] = []
+    conditional_frames: list[_ConditionalOutlineFrame] = []
     body_start: int | None = None
     previous_token: str | None = None
     previous_token_is_identifier = False
@@ -421,26 +498,48 @@ def _blank_compound_statement_bodies(text: str) -> str:
     routine_heading_active = False
     type_constructors: dict[tuple[int, int], str] = {}
     i = 0
-    n = len(text)
+    n = len(scanned)
     while i < n:
-        ch = text[i]
-        nxt = text[i + 1] if i + 1 < n else ''
-
-        if end_stack and (
-            (ch == '{' and nxt == '$')
-            or (ch == '(' and nxt == '*' and i + 2 < n and text[i + 2] == '$')
-        ):
-            # Raw conditional branches can disagree on END nesting, so keep the file all-or-safe.
-            return text
+        ch = scanned[i]
+        nxt = scanned[i + 1] if i + 1 < n else ''
+
+        directive = _compiler_directive_at(scanned, i)
+        if directive is not None and (end_stack or conditional_frames):
+            directive_name, directive_end = directive
+            if directive_name in _CONDITIONAL_DIRECTIVE_OPENERS:
+                conditional_frames.append(
+                    _ConditionalOutlineFrame(base_stack=tuple(end_stack))
+                )
+            elif directive_name in _CONDITIONAL_DIRECTIVE_ALTERNATIVES:
+                if not conditional_frames:
+                    return scanned
+                frame = conditional_frames[-1]
+                frame.branch_stacks.append(tuple(end_stack))
+                frame.has_alternative = True
+                end_stack[:] = frame.base_stack
+            elif directive_name in _CONDITIONAL_DIRECTIVE_CLOSERS:
+                if not conditional_frames:
+                    return scanned
+                frame = conditional_frames.pop()
+                frame.branch_stacks.append(tuple(end_stack))
+                if not frame.has_alternative:
+                    frame.branch_stacks.append(frame.base_stack)
+                merged_stack = _merge_conditional_outline_stacks(frame)
+                if merged_stack is None:
+                    merged_stack = _common_conditional_outline_stack(frame)
+                    body_start = None
+                end_stack[:] = merged_stack
+            i = directive_end
+            continue
 
         if ch.isspace():
             i += 1
-            while i < n and text[i].isspace():
+            while i < n and scanned[i].isspace():
                 i += 1
             continue
 
         if ch == "'":
-            block_end = multiline_string_block_end(text, i)
+            block_end = multiline_string_block_end(scanned, i)
             if block_end is not None:
                 i = block_end
                 previous_token = 'literal'
@@ -449,8 +548,8 @@ def _blank_compound_statement_bodies(text: str) -> str:
                 continue
             i += 1
             while i < n:
-                if text[i] == "'":
-                    if i + 1 < n and text[i + 1] == "'":
+                if scanned[i] == "'":
+                    if i + 1 < n and scanned[i + 1] == "'":
                         i += 2
                         continue
                     i += 1
@@ -463,13 +562,13 @@ def _blank_compound_statement_bodies(text: str) -> str:
 
         if ch == '/' and nxt == '/':
             i += 2
-            while i < n and text[i] not in {'\n', '\r'}:
+            while i < n and scanned[i] not in {'\n', '\r'}:
                 i += 1
             continue
 
         if ch == '{':
             i += 1
-            while i < n and text[i] != '}':
+            while i < n and scanned[i] != '}':
                 i += 1
             if i < n:
                 i += 1
@@ -477,7 +576,7 @@ def _blank_compound_statement_bodies(text: str) -> str:
 
         if ch == '(' and nxt == '*':
             i += 2
-            while i + 1 < n and not (text[i] == '*' and text[i + 1] == ')'):
+            while i + 1 < n and not (scanned[i] == '*' and scanned[i + 1] == ')'):
                 i += 1
             if i + 1 < n:
                 i += 2
@@ -486,9 +585,9 @@ def _blank_compound_statement_bodies(text: str) -> str:
         if ch == '&' and (nxt.isalpha() or nxt == '_'):
             start = i
             i += 2
-            while i < n and (text[i].isalnum() or text[i] == '_'):
+            while i < n and (scanned[i].isalnum() or scanned[i] == '_'):
                 i += 1
-            previous_token = text[start:i].casefold()
+            previous_token = scanned[start:i].casefold()
             previous_token_is_identifier = True
             generic_owner_ready = False
             continue
@@ -496,9 +595,9 @@ def _blank_compound_statement_bodies(text: str) -> str:
         if ch.isalpha() or ch == '_':
             start = i
             i += 1
-            while i < n and (text[i].isalnum() or text[i] == '_'):
+            while i < n and (scanned[i].isalnum() or scanned[i] == '_'):
                 i += 1
-            word = text[start:i].casefold()
+            word = scanned[start:i].casefold()
             generic_owner_ready = False
             opens_construct: bool | None = False
             if not end_stack:
@@ -517,14 +616,14 @@ def _blank_compound_statement_bodies(text: str) -> str:
                 else:
                     opens_construct = _opens_end_terminated_construct(
                         word,
-                        text=text,
+                        text=scanned,
                         word_end=i,
                         previous_token=previous_token,
                         end_stack=end_stack,
                         type_constructor=type_constructors.get((paren_depth, bracket_depth)),
                     )
                 if opens_construct is None:
-                    return text
+                    return scanned
                 if opens_construct:
                     end_stack.append(word)
             if word == 'class' and opens_construct:
@@ -546,7 +645,7 @@ def _blank_compound_statement_bodies(text: str) -> str:
         if ch == '<' and nxt not in {'=', '>'}:
             if angle_depth > 0:
                 if not previous_token_is_identifier:
-                    return text
+                    return scanned
                 angle_depth += 1
             elif generic_owner_ready or (
                 routine_heading_active
@@ -582,7 +681,64 @@ def _blank_compound_statement_bodies(text: str) -> str:
         previous_token = ch
         previous_token_is_identifier = False
         i += 1
-    return text if angle_depth > 0 else ''.join(chars)
+    return scanned if angle_depth > 0 or conditional_frames else ''.join(chars)
+
+
+def _compiler_directive_at(text: str, start: int) -> tuple[str, int] | None:
+    if text.startswith('{$', start):
+        content_start = start + 2
+        close = text.find('}', content_start)
+        if close < 0:
+            return None
+        end = close + 1
+    elif text.startswith('(*$', start):
+        content_start = start + 3
+        close = text.find('*)', content_start)
+        if close < 0:
+            return None
+        end = close + 2
+    else:
+        return None
+    match = re.match(r'\s*([A-Za-z]+)', text[content_start:close])
+    return ((match.group(1).casefold() if match else ''), end)
+
+
+def _merge_conditional_outline_stacks(
+    frame: _ConditionalOutlineFrame,
+) -> list[str] | None:
+    base = frame.base_stack
+    branches = frame.branch_stacks
+    if not branches or any(
+        len(branch) < len(base) or branch[:len(base)] != base
+        for branch in branches
+    ):
+        return None
+    tails = [branch[len(base):] for branch in branches]
+    shapes = [tuple(_outline_block_shape(item) for item in tail) for tail in tails]
+    if any(shape != shapes[0] for shape in shapes[1:]):
+        return None
+    merged = list(base)
+    for values in zip(*tails, strict=True):
+        merged.append(values[0] if all(value == values[0] for value in values) else 'begin')
+    return merged
+
+
+def _outline_block_shape(value: str) -> str:
+    return 'statement' if value in _END_TERMINATED_STATEMENTS else value
+
+
+def _common_conditional_outline_stack(
+    frame: _ConditionalOutlineFrame,
+) -> list[str]:
+    common: list[str] = []
+    for values in zip(*frame.branch_stacks):
+        shapes = {_outline_block_shape(value) for value in values}
+        if len(shapes) != 1:
+            break
+        common.append(
+            values[0] if all(value == values[0] for value in values) else 'begin'
+        )
+    return common
 
 
 def _opens_end_terminated_construct(
@@ -684,7 +840,13 @@ _TYPE_REF_STOP_RE = re.compile(
 )
 
 
-def build_outline_semantic_model(text: str, file_name: str) -> SemanticModel:
+def build_outline_semantic_model(
+    text: str,
+    file_name: str,
+    *,
+    defines: Iterable[str] = (),
+) -> SemanticModel:
+    text = outline_source(text, defines=defines)
     unit_name = _outline_unit_name(text, file_name)
     unit_scope = Scope(kind=ScopeKind.UNIT, name=unit_name)
     unit_range = SourceRange(file_name, 1, 1, 1, max(2, len(unit_name) + 1))

delphi_lsp/preprocessor.py

@@ -136,11 +136,13 @@ class Preprocessor:
         include_paths: Iterable[str] = (),
         include_loader: Optional[IncludeLoader] = None,
         options: Optional[PreprocessorOptions] = None,
+        preserve_active_directives: bool = False,
     ) -> None:
         self.defines: set[str] = {self._normalize_define(d) for d in defines if d}
         self.include_paths = [Path(p) for p in include_paths]
         self.include_loader = include_loader or self._default_include_loader
         self.options = options or PreprocessorOptions()
+        self.preserve_active_directives = preserve_active_directives
         self._apply_default_compiler_defines()
         self.scoped_enums = self.options.scoped_enums
         self._option_values: dict[str, str] = {}
@@ -191,7 +193,9 @@ class Preprocessor:
             if ch == "'":
                 start_line = ctx.line
                 active = self._is_active()
-                literal = self._consume_string(ctx)
+                literal = self._consume_multiline_string(ctx)
+                if literal is None:
+                    literal = self._consume_string(ctx)
                 self._emit_text(output, literal, ctx.file_name, start_line, active=active)
                 continue
 
@@ -273,6 +277,19 @@ class Preprocessor:
             version_define = int(round(self.options.compiler_version * 10))
             self.defines.add(f'VER{version_define}')
 
+    def _consume_multiline_string(self, ctx: _FileContext) -> str | None:
+        for quote_count in (5, 3):
+            delimiter = "'" * quote_count
+            if not ctx.text.startswith(delimiter, ctx.index):
+                continue
+            content_start = ctx.index + quote_count
+            if content_start >= len(ctx.text) or ctx.text[content_start] != '\n':
+                continue
+            close = ctx.text.find(delimiter, content_start + 1)
+            end = len(ctx.text) if close < 0 else close + quote_count
+            return ctx.advance(end - ctx.index)
+        return None
+
     def _emit_text(
         self,
         output: _OutputBuffer,
@@ -310,9 +327,14 @@ class Preprocessor:
     ) -> None:
         name, param = self._parse_directive(directive_content)
         replacement = self._replace_with_spaces(directive_raw)
+        active_replacement = (
+            directive_raw
+            if self.preserve_active_directives and self._is_active()
+            else replacement
+        )
 
         if not name:
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
         if name in {'IFDEF', 'IFNDEF', 'IF', 'IFOPT'}:
@@ -378,14 +400,14 @@ class Preprocessor:
                         self.defines.add(define_name)
                     else:
                         self.defines.discard(define_name)
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
         if name in {'SCOPEDENUMS'}:
             if self._is_active():
                 self.scoped_enums = self._parse_on_off(param)
                 self._set_option('SCOPEDENUMS', 'ON' if self.scoped_enums else 'OFF')
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
         if name in {'PUSHOPT', 'POPOPT'}:
@@ -405,13 +427,13 @@ class Preprocessor:
                                 col=ctx.col,
                             )
                         )
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
         if name == 'OPT':
             if self._is_active():
                 self._apply_opt_directive(param)
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
         if name in {'I', 'INCLUDE'}:
@@ -443,21 +465,21 @@ class Preprocessor:
                             )
                         else:
                             include_stack.append(resolved_path)
-                            ctx.pending_output = replacement
+                            ctx.pending_output = active_replacement
                             ctx.pending_line = start_line
                             normalized = self._normalize_newlines(content)
                             if not normalized.endswith('\n'):
                                 normalized += '\n'
                             contexts.append(_FileContext(text=normalized, file_name=resolved_path))
                             return
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
         if self._is_active() and self._apply_named_option(name, param):
-            self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+            self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
             return
 
-        self._emit_text(output, replacement, ctx.file_name, start_line, active=True)
+        self._emit_text(output, active_replacement, ctx.file_name, start_line, active=True)
 
     def _parse_directive(self, directive_text: str) -> tuple[str, str]:
         text = directive_text.strip()

delphi_lsp/progress.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+
+@dataclass(frozen=True)
+class ProgressEvent:
+    """A package-controlled snapshot of Delphi indexing progress."""
+
+    phase: str
+    language: str
+    path: str
+    files_discovered: int
+    files_completed: int
+    files_total: int | None
+    lines_processed: int
+    symbols_discovered: int
+    cached_files: int
+    detail: str
+
+
+ProgressCallback = Callable[[ProgressEvent], None]
+
+
+__all__ = ["ProgressCallback", "ProgressEvent"]

delphi_lsp/project_discovery.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
+import errno
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Iterable
+from typing import Iterable, Iterator
 import os
 import re
 import xml.etree.ElementTree as ET
 
+from .progress import ProgressCallback, ProgressEvent
+
 
 SOURCE_EXTENSIONS = (".pas", ".dpr", ".dpk", ".inc")
 PROJECT_EXTENSIONS = (".dpr", ".dpk")
@@ -69,10 +72,12 @@ def discover_delphi_project(
     search_paths: Iterable[str | os.PathLike[str]] = (),
     defines: Iterable[str] = (),
     scan_workspace_sources: bool = True,
+    on_progress: ProgressCallback | None = None,
 ) -> DelphiProjectDiscovery:
     root_path = Path(root).expanduser().resolve()
     project_path = Path(project_file).expanduser().resolve() if project_file is not None else None
     discovery = DelphiProjectDiscovery(root=str(root_path))
+    _emit_progress(on_progress, "discovery", str(root_path), 0, 0, None, "project discovery started")
 
     seen_search: set[str] = set()
     seen_include: set[str] = set()
@@ -185,18 +190,42 @@ def discover_delphi_project(
                     discovery.config_files.append(str(cfg))
 
     if scan_workspace_sources:
-        populate_workspace_sources(discovery)
+        populate_workspace_sources(discovery, on_progress=on_progress)
+
+    _emit_progress(
+        on_progress,
+        "inventory",
+        str(root_path),
+        len(discovery.source_files),
+        0,
+        len(discovery.source_files),
+        "project discovery complete",
+    )
 
     return discovery
 
 
-def populate_workspace_sources(discovery: DelphiProjectDiscovery) -> DelphiProjectDiscovery:
+def populate_workspace_sources(
+    discovery: DelphiProjectDiscovery,
+    *,
+    on_progress: ProgressCallback | None = None,
+) -> DelphiProjectDiscovery:
     root_path = Path(discovery.root).expanduser().resolve()
     seen_sources = {source.casefold() for source in discovery.source_files}
     seen_search = {path.casefold() for path in discovery.search_paths}
     seen_include = {path.casefold() for path in discovery.include_paths}
 
-    _scan_sources(root_path, discovery, seen_sources)
+    _scan_sources(root_path, discovery, seen_sources, on_progress=on_progress)
+    total_sources = len(discovery.source_files)
+    _emit_progress(
+        on_progress,
+        "inventory",
+        str(root_path),
+        total_sources,
+        0,
+        total_sources,
+        "workspace source inventory complete",
+    )
     for source in discovery.source_files:
         path = Path(source)
         unit_key = path.stem.casefold()
@@ -227,10 +256,51 @@ def populate_workspace_sources(discovery: DelphiProjectDiscovery) -> DelphiProje
     return discovery
 
 
-def discover_workspace_sources(root: str | os.PathLike[str]) -> DelphiProjectDiscovery:
+def discover_workspace_sources(
+    root: str | os.PathLike[str],
+    *,
+    on_progress: ProgressCallback | None = None,
+) -> DelphiProjectDiscovery:
     root_path = Path(root).expanduser().resolve()
     discovery = DelphiProjectDiscovery(root=str(root_path))
-    return populate_workspace_sources(discovery)
+    _emit_progress(on_progress, "discovery", str(root_path), 0, 0, None, "workspace discovery started")
+    populate_workspace_sources(discovery, on_progress=on_progress)
+    _emit_progress(
+        on_progress,
+        "complete",
+        str(root_path),
+        len(discovery.source_files),
+        len(discovery.source_files),
+        len(discovery.source_files),
+        "workspace discovery complete",
+    )
+    return discovery
+
+
+def _emit_progress(
+    callback: ProgressCallback | None,
+    phase: str,
+    path: str,
+    files_discovered: int,
+    files_completed: int,
+    files_total: int | None,
+    detail: str,
+) -> None:
+    if callback is not None:
+        callback(
+            ProgressEvent(
+                phase=phase,
+                language="delphi",
+                path=path,
+                files_discovered=files_discovered,
+                files_completed=files_completed,
+                files_total=files_total,
+                lines_processed=0,
+                symbols_discovered=0,
+                cached_files=0,
+                detail=detail,
+            )
+        )
 
 
 def _project_candidates(root: Path, explicit: Path | None) -> list[Path]:
@@ -409,33 +479,72 @@ def _main_source_from_dproj(path: Path) -> str | None:
     return None
 
 
-def _scan_sources(root: Path, discovery: DelphiProjectDiscovery, seen_sources: set[str]) -> None:
-    for path in root.rglob("*"):
+def _scan_sources(
+    root: Path,
+    discovery: DelphiProjectDiscovery,
+    seen_sources: set[str],
+    *,
+    on_progress: ProgressCallback | None = None,
+) -> None:
+    for path in _walk_files(root):
         if path.suffix.casefold() not in SOURCE_EXTENSIONS:
             continue
-        if any(part in SKIP_DIRS for part in path.parts):
-            continue
-        if not path.is_file():
-            continue
         resolved = path.resolve()
         key = str(resolved).casefold()
         if key in seen_sources:
             continue
         seen_sources.add(key)
         discovery.source_files.append(str(resolved))
+        _emit_progress(
+            on_progress,
+            "discovery",
+            str(resolved),
+            len(discovery.source_files),
+            0,
+            None,
+            "source file discovered",
+        )
     discovery.source_files.sort(key=lambda item: (item.casefold(), item))
 
 
 def _walk_sources(root: Path, pattern: str) -> list[Path]:
     results: list[Path] = []
-    for path in root.rglob(pattern):
-        if any(part in SKIP_DIRS for part in path.parts):
-            continue
-        if path.is_file():
+    for path in _walk_files(root):
+        if path.match(pattern):
             results.append(path.resolve())
     return results
 
 
+def _walk_files(root: Path) -> Iterator[Path]:
+    def handle_error(error: OSError) -> None:
+        if _is_path_too_long(error):
+            return
+        raise error
+
+    for directory, directory_names, file_names in os.walk(
+        root,
+        followlinks=False,
+        onerror=handle_error,
+    ):
+        directory_names[:] = sorted(
+            name for name in directory_names if name not in SKIP_DIRS
+        )
+        current = Path(directory)
+        for name in sorted(file_names):
+            path = current / name
+            try:
+                if path.is_file():
+                    yield path
+            except OSError as error:
+                if _is_path_too_long(error):
+                    continue
+                raise
+
+
+def _is_path_too_long(error: OSError) -> bool:
+    return getattr(error, "winerror", None) == 206 or error.errno == errno.ENAMETOOLONG
+
+
 def _add_resolved_path(
     target: list[str],
     seen: set[str],

delphi_lsp/project_indexer.py

@@ -9,6 +9,7 @@ from .consts import AttributeName, SyntaxNodeType
 from .nodes import SyntaxNode
 from .parser import DelphiParser
 from .preprocessor import IncludeLoader
+from .progress import ProgressCallback, ProgressEvent
 from .source_reader import read_source_text
 
 
@@ -71,6 +72,7 @@ class ProjectIndexer:
         on_get_unit_syntax: GetUnitSyntaxHook | None = None,
         on_unit_parsed: UnitParsedHook | None = None,
         source_transform: SourceTransform | None = None,
+        on_progress: ProgressCallback | None = None,
     ) -> None:
         self.search_paths = [Path(path) for path in search_paths]
         self.include_paths = [Path(path) for path in include_paths]
@@ -79,6 +81,7 @@ class ProjectIndexer:
         self.on_get_unit_syntax = on_get_unit_syntax
         self.on_unit_parsed = on_unit_parsed
         self.source_transform = source_transform
+        self.on_progress = on_progress
 
         self._parsed_units: dict[str, UnitInfo] = {}
         self._problems: list[ProjectProblem] = []
@@ -86,6 +89,9 @@ class ProjectIndexer:
         self._include_files: dict[str, IncludeFileInfo] = {}
         self._project_folder: Path = Path('.')
         self._aborting: bool = False
+        self._files_discovered = 0
+        self._files_completed = 0
+        self._lines_processed = 0
 
     def index(self, file_name: str) -> ProjectIndexResult:
         self._parsed_units = {}
@@ -93,9 +99,13 @@ class ProjectIndexer:
         self._not_found_units = set()
         self._include_files = {}
         self._aborting = False
+        self._files_discovered = 0
+        self._files_completed = 0
+        self._lines_processed = 0
 
         entry = Path(file_name).expanduser().resolve()
         self._project_folder = entry.parent
+        self._emit_progress("discovery", str(entry), "project index started")
 
         is_project = entry.suffix.casefold() in {'.dpr', '.dpk'}
         self._parse_unit(entry.stem, entry, is_project=is_project)
@@ -105,12 +115,14 @@ class ProjectIndexer:
         problems = list(self._problems)
         not_found = sorted(self._not_found_units, key=str.casefold)
 
-        return ProjectIndexResult(
+        result = ProjectIndexResult(
             parsed_units=parsed_units,
             include_files=include_files,
             problems=problems,
             not_found_units=not_found,
         )
+        self._emit_progress("complete", str(entry), "project index complete")
+        return result
 
     def _parse_unit(self, unit_name: str, file_path: Path, *, is_project: bool) -> None:
         if self._aborting:
@@ -119,6 +131,8 @@ class ProjectIndexer:
         normalized_name = unit_name.casefold()
         if normalized_name in self._parsed_units:
             return
+        self._files_discovered += 1
+        self._emit_progress("inventory", str(file_path), "unit discovered")
 
         hook_tree: Optional[SyntaxNode] = None
         do_parse_unit = True
@@ -134,7 +148,12 @@ class ProjectIndexer:
         if syntax_tree is None and do_parse_unit:
             source = self._read_file(file_path)
             if source is None:
+                self._files_completed += 1
+                self._emit_progress("detail", str(file_path), "unit unavailable")
                 return
+            self._lines_processed += source.count("\n") + (
+                0 if not source or source.endswith("\n") else 1
+            )
             parser = DelphiParser(
                 include_paths=[str(path) for path in self.include_paths],
                 defines=self.defines,
@@ -161,15 +180,21 @@ class ProjectIndexer:
                     has_error=True,
                     error_info=UnitErrorInfo(error=str(exc)),
                 )
+                self._files_completed += 1
+                self._emit_progress("detail", str(file_path), "unit parse failed")
                 return
 
         if syntax_tree is None:
+            self._files_completed += 1
+            self._emit_progress("detail", str(file_path), "unit skipped")
             return
 
         actual_name = syntax_tree.get_attribute(AttributeName.anName) or unit_name
         normalized_name = actual_name.casefold()
         unit_info = UnitInfo(name=actual_name, path=str(file_path), syntax_tree=syntax_tree)
         self._parsed_units[normalized_name] = unit_info
+        self._files_completed += 1
+        self._emit_progress("detail", str(file_path), "unit parsed")
 
         if self.on_unit_parsed is not None:
             do_abort = self.on_unit_parsed(actual_name, str(file_path), syntax_tree, from_parser)
@@ -290,6 +315,23 @@ class ProjectIndexer:
 
         return wrapped
 
+    def _emit_progress(self, phase: str, path: str, detail: str) -> None:
+        if self.on_progress is not None:
+            self.on_progress(
+                ProgressEvent(
+                    phase=phase,
+                    language="delphi",
+                    path=path,
+                    files_discovered=self._files_discovered,
+                    files_completed=self._files_completed,
+                    files_total=self._files_discovered,
+                    lines_processed=self._lines_processed,
+                    symbols_discovered=0,
+                    cached_files=0,
+                    detail=detail,
+                )
+            )
+
     def _default_include_loader(self, parent_file: str, include_name: str) -> Optional[tuple[str, str]]:
         parent = Path(parent_file).resolve().parent
         include_path = Path(include_name.replace('\\', '/'))

{python_delphi_lsp-2.0.3.dist-info → python_delphi_lsp-2.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 2.0.3
+Version: 2.0.4
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -41,7 +41,7 @@ Dynamic: license-file
 
 `python-delphi-lsp` parses Delphi/Object Pascal, builds semantic and project
 indexes, serves LSP, and provides bounded codebase navigation for agents.
-Version 2.0.3 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 2.0.4 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -82,6 +82,19 @@ project = ProjectIndexer(
 print(project.parsed_units)
 ```
 
+Long-running discovery and indexing accept a keyword-only `on_progress`
+callback. It receives an immutable `ProgressEvent` with package-controlled
+phase, path, and monotonic counters; callback exceptions are not suppressed.
+
+```python
+from delphi_lsp import ProjectIndexer, ProgressEvent
+
+def report(event: ProgressEvent) -> None:
+    print(event.phase, event.files_completed, event.path)
+
+ProjectIndexer(on_progress=report).index("Main.dpr")
+```
+
 ## Architecture metrics
 
 The public metrics API analyzes a single unit or aggregates a complete project:

{python_delphi_lsp-2.0.3.dist-info → python_delphi_lsp-2.0.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
-delphi_lsp/__init__.py,sha256=Gtoeg_D3hLGCFi34wdYiKrIByAbkWe1zS84v6_KJ6_4,3768
-delphi_lsp/_version.py,sha256=_GEKEa6BYjBV34SZkSlAR87aCM5Y9G0aSI0LXL52iJg,22
+delphi_lsp/__init__.py,sha256=mq3tF0NrXDgbkJXDuf5HhW6sOnmP7DQxs3zl8fGoAmo,3867
+delphi_lsp/_version.py,sha256=ZOg41aCgKEuObK5WhegikXektFWPJaeZ-TMDh0Ke95M,22
 delphi_lsp/agent_cli.py,sha256=Mma4C1Ca_Hd_9dl0mePT7uIypw6j6gDWdKu9XxIMXQQ,9226
-delphi_lsp/agent_context.py,sha256=FdRQ2MFGDcqBDGMnD0w2X8p1kB3YwyTPDm_4cdCmwbA,77504
-delphi_lsp/agent_layers.py,sha256=7TmplTL7m_riS8BxZCD-3j1p8iOGiD9QWHay5ZcDYiw,21369
+delphi_lsp/agent_context.py,sha256=BfmsCbTIWSaMNFkPuyC31yh7wkzCzBI5xt3BE8vsIa4,77715
+delphi_lsp/agent_layers.py,sha256=ngFn-zH2Jv6CBjOhd3UkoyVgsrdXW0BChnQxSVmkRRc,25131
 delphi_lsp/agent_metrics.py,sha256=6y9DrSnKitZbwRFQrofanw6k89YGqbvEacqgSKHgh2c,2695
 delphi_lsp/agent_protocol.py,sha256=cZ1LIMhrkOb5CqiGcjSH1eZUNqtJCYySUc54h-PCyOs,12551
 delphi_lsp/agent_relations.py,sha256=pXhuCjfwmicG3VG7lYtGvKKv-mFPQ_hJ3w0eavqMoV0,32900
@@ -14,21 +14,22 @@ delphi_lsp/consts.py,sha256=qM40iwxXmvEileWHJVLMYlQSkLoLyQaqM-Zscz3VJbs,5958
 delphi_lsp/grammar.py,sha256=QWEMSUKr0e1xlJOveZtp7K-MvhlkvDgxkD0iUKIyxKU,18577
 delphi_lsp/lark_builder.py,sha256=c0_kFB_o3U64fwsC2BnsFibAojnqxjaZSrzASg6sTSM,119202
 delphi_lsp/lark_tokens.py,sha256=xT_GES2z6p1IdN3EnoKE9RcUM6suu1RV3J-0FEJN2r8,4176
-delphi_lsp/lsp_server.py,sha256=CCR9FwtZ6oOlEdy8FU-1kFlLawQS3PJ7XyBf2KG5Ijo,65950
+delphi_lsp/lsp_server.py,sha256=kxm0A-VNDkkNZKb6TSqFxur6wNcvh1m34EKIKfOr2LU,71514
 delphi_lsp/metrics.py,sha256=f70B1awypqVWZIW_SNpFHdShoS8OzDW5DWX5ftQMI0c,26166
 delphi_lsp/nodes.py,sha256=LW8KUgNCg9MHK_2NmzrgCMMJNcBwa4C76XwKoS7kt4E,13556
 delphi_lsp/parser.py,sha256=4hckHD_fsiiUe3oeSRJwqbY8bDWqJaYLsU10NYDIW6E,6025
-delphi_lsp/preprocessor.py,sha256=X58ZUfI7Hifg-7KYomOF0BZEp-jl1NFGyNl9VCu6wtU,29935
-delphi_lsp/project_discovery.py,sha256=ei7Iy19EMpTWjOFpKPc9hDG2oH1MUGxKwCLnibJp_TM,17336
-delphi_lsp/project_indexer.py,sha256=R5oD4sYsIi2nAlOCr-Mq3-CFkINeC19t0vtKkciCRmg,11227
+delphi_lsp/preprocessor.py,sha256=aXJiabmCvWoUdrxYAA4EVVxDDQXl_IeFUezoDdMlFyU,30984
+delphi_lsp/progress.py,sha256=FF3lqdDKLvq3b7cOhuSc3P0FDzVnX0miD8U8_3xt5iY,535
+delphi_lsp/project_discovery.py,sha256=UpezFlNJDaF5sW8tkG_HUxHpAULSf1GSWXJTlUF8vMM,20230
+delphi_lsp/project_indexer.py,sha256=J_GA1GlLrmxAajS7zHeeVHbVH7MEcf8278Yd9hcIh7o,13137
 delphi_lsp/semantic.py,sha256=egQ-_AjmnAATvL1hRUfjd4FDapFxdwi5rt8QExb0POc,9818
 delphi_lsp/semantic_builder.py,sha256=ulA7xHJpltjc6cTo5wh9yTcYazuIykM-YLMXD1h-wzk,58680
 delphi_lsp/source_reader.py,sha256=HWiw25sLVZ6s1GGpMl17uZ-o68HoxTEd3Z0__m1vsSE,520
 delphi_lsp/workspace.py,sha256=TU__SujItRlW8hB2kuYC7ZJx1WQVOj7frYxvo7rDqeI,2137
 delphi_lsp/writer.py,sha256=j-cnyiHFNOTFECL7Ehm-m43ye7ev7qFeCCscFMjrAOY,2503
-python_delphi_lsp-2.0.3.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
-python_delphi_lsp-2.0.3.dist-info/METADATA,sha256=Dw8iQ0nH5GwHL2eIbYPEMXpVcoMp0Mc0tkGltO7iUMo,14942
-python_delphi_lsp-2.0.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_delphi_lsp-2.0.3.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
-python_delphi_lsp-2.0.3.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
-python_delphi_lsp-2.0.3.dist-info/RECORD,,
+python_delphi_lsp-2.0.4.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+python_delphi_lsp-2.0.4.dist-info/METADATA,sha256=y1GTsjlMI2yUCd5Z9ZmGOHiiuRxQlf2IIQEmM5G1TyY,15390
+python_delphi_lsp-2.0.4.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_delphi_lsp-2.0.4.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
+python_delphi_lsp-2.0.4.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
+python_delphi_lsp-2.0.4.dist-info/RECORD,,