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

delphi_lsp/project_indexer.py

@@ -0,0 +1,470 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+
+from .consts import AttributeName, SyntaxNodeType
+from .nodes import SyntaxNode
+from .parser import DelphiParser
+from .parser_backend import ParserBackend, ParserMode, normalize_backend, normalize_mode
+from .preprocessor import IncludeLoader, PreprocessedSource
+from .progress import ProgressCallback, ProgressEvent
+from .project_config import ProjectPathConfig
+from .source_reader import read_source_text
+
+
+class ProjectProblemType(str, Enum):
+    CANT_FIND_FILE = 'cant_find_file'
+    CANT_OPEN_FILE = 'cant_open_file'
+    CANT_PARSE_FILE = 'cant_parse_file'
+
+
+@dataclass
+class ProjectProblem:
+    problem_type: ProjectProblemType
+    file_name: str
+    description: str
+
+
+@dataclass
+class UnitErrorInfo:
+    line: int = 0
+    col: int = 0
+    error: str = ''
+
+
+@dataclass
+class UnitInfo:
+    name: str
+    path: str
+    syntax_tree: SyntaxNode | None
+    preprocessed: PreprocessedSource | None = None
+    has_error: bool = False
+    error_info: UnitErrorInfo = field(default_factory=UnitErrorInfo)
+
+
+@dataclass
+class IncludeFileInfo:
+    name: str
+    path: str
+
+
+@dataclass
+class ProjectIndexResult:
+    parsed_units: list[UnitInfo]
+    include_files: list[IncludeFileInfo]
+    problems: list[ProjectProblem]
+    not_found_units: list[str]
+
+
+GetUnitSyntaxHook = Callable[[str], tuple[SyntaxNode | None, bool, bool]]
+UnitParsedHook = Callable[[str, str, SyntaxNode, bool], bool]
+SourceTransform = Callable[[str], str]
+
+
+class ProjectIndexer:
+    def __init__(
+        self,
+        *,
+        search_paths: Iterable[str] = (),
+        include_paths: Iterable[str] = (),
+        defines: Iterable[str] = (),
+        include_loader: IncludeLoader | None = None,
+        on_get_unit_syntax: GetUnitSyntaxHook | None = None,
+        on_unit_parsed: UnitParsedHook | None = None,
+        source_transform: SourceTransform | None = None,
+        retain_syntax: bool = True,
+        on_progress: ProgressCallback | None = None,
+        backend: ParserBackend | str = ParserBackend.DELPHIAST,
+        mode: ParserMode | str = ParserMode.STRICT,
+        source_roots: Iterable[str | Path] = (),
+        project_config: ProjectPathConfig | None = None,
+    ) -> None:
+        self.search_paths = [Path(path) for path in search_paths]
+        self.include_paths = [Path(path) for path in include_paths]
+        self.defines = list(defines)
+        self.include_loader = include_loader
+        self.on_get_unit_syntax = on_get_unit_syntax
+        self.on_unit_parsed = on_unit_parsed
+        self.source_transform = source_transform
+        self.retain_syntax = retain_syntax
+        self.on_progress = on_progress
+        self.backend = normalize_backend(backend)
+        self.mode = normalize_mode(mode)
+        self.source_roots = tuple(
+            Path(path).expanduser().resolve() for path in source_roots
+        )
+        self.project_config = project_config
+
+        self._parsed_units: dict[str, UnitInfo] = {}
+        self._problems: list[ProjectProblem] = []
+        self._not_found_units: set[str] = set()
+        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 = {}
+        self._problems = []
+        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)
+
+        parsed_units = sorted(
+            self._parsed_units.values(),
+            key=lambda item: (
+                item.name.casefold(),
+                item.name,
+                item.path.casefold(),
+                item.path,
+            ),
+        )
+        include_files = sorted(
+            self._include_files.values(),
+            key=lambda item: (
+                item.name.casefold(),
+                item.name,
+                item.path.casefold(),
+                item.path,
+            ),
+        )
+        problems = list(self._problems)
+        not_found = sorted(
+            self._not_found_units,
+            key=lambda value: (value.casefold(), value),
+        )
+
+        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:
+            return
+        if not self._source_is_allowed(file_path):
+            self._not_found_units.add(unit_name)
+            return
+
+        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: SyntaxNode | None = None
+        do_parse_unit = True
+        if self.on_get_unit_syntax is not None:
+            hook_tree, do_parse_unit, do_abort = self.on_get_unit_syntax(str(file_path))
+            if do_abort:
+                self._aborting = True
+                return
+
+        syntax_tree: SyntaxNode | None = hook_tree
+        preprocessed: PreprocessedSource | None = None
+        from_parser = False
+        parser_error = UnitErrorInfo()
+
+        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,
+                include_loader=self._build_include_loader(),
+                backend=self.backend,
+                mode=self.mode,
+            )
+            try:
+                if self.source_transform is not None:
+                    source = self.source_transform(source)
+                result = parser.parse(source, str(file_path), build_semantic=False)
+                syntax_tree = result.root
+                preprocessed = result.preprocessed
+                from_parser = True
+                if result.problems:
+                    first = result.problems[0]
+                    parser_error = UnitErrorInfo(
+                        line=first.line,
+                        col=first.column,
+                        error=first.message,
+                    )
+                    self._problems.append(
+                        ProjectProblem(
+                            problem_type=ProjectProblemType.CANT_PARSE_FILE,
+                            file_name=str(file_path),
+                            description=(
+                                f"Partial DelphiAST parse at {first.line}:{first.column}: "
+                                f"{first.message}"
+                            ),
+                        )
+                    )
+            except Exception as exc:  # pragma: no cover - parser error branch
+                self._problems.append(
+                    ProjectProblem(
+                        problem_type=ProjectProblemType.CANT_PARSE_FILE,
+                        file_name=str(file_path),
+                        description=str(exc),
+                    )
+                )
+                self._parsed_units[normalized_name] = UnitInfo(
+                    name=unit_name,
+                    path=str(file_path),
+                    syntax_tree=None,
+                    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 if self.retain_syntax else None,
+            preprocessed=preprocessed if self.retain_syntax else None,
+            has_error=bool(parser_error.error),
+            error_info=parser_error,
+        )
+        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)
+            if do_abort:
+                self._aborting = True
+                return
+
+        dependencies = self._collect_dependencies(
+            syntax_tree,
+            file_path,
+            is_project=is_project,
+        )
+        if not self.retain_syntax:
+            syntax_tree = None
+            preprocessed = None
+            hook_tree = None
+            if from_parser:
+                del result
+                del parser
+                source = ""
+
+        for dep_name, dep_path in dependencies:
+            if self._aborting:
+                return
+            resolved = self._resolve_unit_path(dep_name, dep_path, relative_to=file_path.parent)
+            if resolved is None:
+                self._not_found_units.add(dep_name)
+                self._problems.append(
+                    ProjectProblem(
+                        problem_type=ProjectProblemType.CANT_FIND_FILE,
+                        file_name=dep_name,
+                        description=f'Unit not found: {dep_name}',
+                    )
+                )
+                continue
+            self._parse_unit(dep_name, resolved, is_project=False)
+
+    def _read_file(self, file_path: Path) -> str | None:
+        try:
+            return read_source_text(file_path)
+        except (OSError, UnicodeError) as exc:
+            self._problems.append(
+                ProjectProblem(
+                    problem_type=ProjectProblemType.CANT_OPEN_FILE,
+                    file_name=str(file_path),
+                    description=str(exc),
+                )
+            )
+            return None
+
+    def _collect_dependencies(
+        self,
+        syntax_tree: SyntaxNode,
+        file_path: Path,
+        *,
+        is_project: bool,
+    ) -> list[tuple[str, str | None]]:
+        deps: list[tuple[str, str | None]] = []
+        if is_project:
+            self._append_units_from_node(syntax_tree, SyntaxNodeType.ntUses, deps)
+            self._append_units_from_node(syntax_tree, SyntaxNodeType.ntContains, deps)
+            return deps
+
+        intf = syntax_tree.find_node(SyntaxNodeType.ntInterface)
+        impl = syntax_tree.find_node(SyntaxNodeType.ntImplementation)
+        if intf is not None:
+            self._append_units_from_node(intf, SyntaxNodeType.ntUses, deps)
+        if impl is not None:
+            self._append_units_from_node(impl, SyntaxNodeType.ntUses, deps)
+        return deps
+
+    def _append_units_from_node(
+        self,
+        root: SyntaxNode,
+        node_type: SyntaxNodeType,
+        deps: list[tuple[str, str | None]],
+    ) -> None:
+        target = root.find_node(node_type)
+        if target is None:
+            return
+        for child in target.child_nodes:
+            if child.typ != SyntaxNodeType.ntUnit:
+                continue
+            name = child.get_attribute(AttributeName.anName)
+            if not name:
+                continue
+            dep_path = child.get_attribute(AttributeName.anPath) or None
+            deps.append((name, dep_path))
+
+    def _resolve_unit_path(self, unit_name: str, unit_path: str | None, *, relative_to: Path) -> Path | None:
+        candidates: list[Path] = []
+
+        if unit_path:
+            hint = Path(unit_path.replace('\\', '/'))
+            if hint.is_absolute():
+                candidates.append(hint)
+            else:
+                candidates.append((relative_to / hint).resolve())
+
+        unit_file_names: list[str]
+        normalized_unit_name = unit_name.replace('\\', '/')
+        if Path(normalized_unit_name).suffix.casefold() in {'.pas', '.dpr', '.dpk'}:
+            unit_file_names = [normalized_unit_name]
+        else:
+            unit_file_names = [
+                f'{normalized_unit_name}.pas',
+                f'{normalized_unit_name}.dpr',
+                f'{normalized_unit_name}.dpk',
+            ]
+
+        search_roots = [relative_to, self._project_folder, *self.search_paths, *self.include_paths]
+        for root in search_roots:
+            for file_name in unit_file_names:
+                candidates.append((root / file_name).resolve())
+
+        seen: set[str] = set()
+        for candidate in candidates:
+            key = str(candidate).casefold()
+            if key in seen:
+                continue
+            seen.add(key)
+            if (
+                candidate.exists()
+                and candidate.is_file()
+                and self._source_is_allowed(candidate)
+            ):
+                return candidate
+        return None
+
+    def _build_include_loader(self) -> IncludeLoader:
+        base_loader = self.include_loader or self._default_include_loader
+
+        def wrapped(parent_file: str, include_name: str) -> tuple[str, str] | None:
+            resolved = base_loader(parent_file, include_name)
+            if resolved is None:
+                return None
+            content, resolved_path = resolved
+            if not self._source_is_allowed(Path(resolved_path)):
+                return None
+            cache_key = f'{include_name.casefold()}::{resolved_path.casefold()}'
+            self._include_files[cache_key] = IncludeFileInfo(name=include_name, path=resolved_path)
+            return content, resolved_path
+
+        return wrapped
+
+    def _source_is_allowed(self, path: Path) -> bool:
+        try:
+            resolved = path.expanduser().resolve()
+        except OSError:
+            return False
+        if (
+            self.project_config is not None
+            and self.project_config.excludes_workspace_path(resolved)
+        ):
+            return False
+        if not self.source_roots:
+            return True
+        return any(resolved.is_relative_to(root) for root in self.source_roots)
+
+    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) -> tuple[str, str] | None:
+        parent = Path(parent_file).resolve().parent
+        include_path = Path(include_name.replace('\\', '/'))
+        search_roots = [parent, self._project_folder, *self.include_paths, *self.search_paths]
+        for root in search_roots:
+            candidate = (root / include_path).resolve()
+            if (
+                candidate.exists()
+                and candidate.is_file()
+                and self._source_is_allowed(candidate)
+            ):
+                try:
+                    content = read_source_text(candidate)
+                except OSError:
+                    continue
+                return content, str(candidate)
+        return None
+
+
+__all__ = [
+    'GetUnitSyntaxHook',
+    'IncludeFileInfo',
+    'ProjectIndexResult',
+    'ProjectIndexer',
+    'ProjectProblem',
+    'ProjectProblemType',
+    'SourceTransform',
+    'UnitErrorInfo',
+    'UnitInfo',
+    'UnitParsedHook',
+]

delphi_lsp/py.typed

@@ -0,0 +1 @@
+