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

agent_codinglanguage_mapper/discovery.py

@@ -0,0 +1,1328 @@
+from __future__ import annotations
+
+import configparser
+import hashlib
+import json
+import os
+import re
+import shlex
+import sys
+import xml.etree.ElementTree as element_tree
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import Iterable, Iterator
+
+import pathspec
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover - Python 3.10 dependency fallback
+    import tomli as tomllib
+
+from .adapters import adapters_for
+from .models import Language, Problem, Project
+from .workspace import stable_id
+
+_IGNORED = {
+    ".git", ".hg", ".mypy_cache", ".pytest_cache", ".svn", ".tox", "__pycache__", "build", "dist", "node_modules",
+    "target", ".venv", "venv",
+}
+_MARKERS = {
+    "pyproject.toml": (Language.PYTHON, "python"), "setup.cfg": (Language.PYTHON, "python"),
+    "setup.py": (Language.PYTHON, "python"), "Cargo.toml": (Language.RUST, "rust"),
+    ".sln": (Language.CSHARP, "csharp-solution"), ".csproj": (Language.CSHARP, "csharp"),
+    ".dpr": (Language.DELPHI, "delphi"), ".dpk": (Language.DELPHI, "delphi-package"),
+    ".dproj": (Language.DELPHI, "delphi"),
+    ".groupproj": (Language.DELPHI, "delphi-group"), "compile_commands.json": (Language.CPP, "compile-commands"),
+    "CMakeLists.txt": (Language.CPP, "cmake"), ".vcxproj": (Language.CPP, "visual-cpp"),
+}
+_VARIABLE = re.compile(
+    r"\$\([^)]*\)|\$\{[^}]*\}|\$ENV\{[^}]*\}|\$(?![({<])[A-Za-z_][A-Za-z0-9_]*|%\([^)]*\)|%[^%]+%"
+)
+_GENERATOR_EXPRESSION = re.compile(r"\$<[^>]*>")
+_CMAKE_CALL = re.compile(r"\b([A-Za-z_][A-Za-z0-9_]*)\s*\(")
+_CMAKE_INCLUDE_MARKERS = {"AFTER", "BEFORE", "INTERFACE", "PRIVATE", "PUBLIC", "SYSTEM"}
+_CMAKE_BRACKET_COMMENT_START = re.compile(r"#\[(?P<equals>=*)\[")
+_CMAKE_ESCAPED_SEMICOLON = "\0"
+_CMAKE_LIBRARY_KINDS = {"SHARED", "MODULE"}
+_CMAKE_TARGET_MARKERS = {
+    "ALIAS", "EXCLUDE_FROM_ALL", "GLOBAL", "IMPORTED", "INTERFACE", "MODULE", "OBJECT", "SHARED", "STATIC", "UNKNOWN",
+}
+_DELPHI_IN = re.compile(r"\b(?:in|include)\s*['\"]([^'\"]+)['\"]", re.IGNORECASE)
+_SOLUTION_PROJECT = re.compile(
+    r'^Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+)"',
+    re.MULTILINE,
+)
+_NAMED_PROJECT_SUFFIXES = {".csproj", ".dpk", ".dpr", ".dproj", ".groupproj", ".sln", ".vcxproj"}
+_PROJECT_OWNERSHIP_PRIORITY = {
+    ".csproj": 3,
+    ".dpr": 3,
+    ".dpk": 3,
+    ".vcxproj": 3,
+    ".dproj": 2,
+    ".groupproj": 1,
+    ".sln": 1,
+}
+
+
+@dataclass(frozen=True)
+class DiscoveredFile:
+    path: Path
+    language: Language
+    project_id: str
+    include_paths: tuple[Path, ...] = ()
+    output_names: tuple[str, ...] = ()
+
+    @property
+    def name(self) -> str:
+        return self.path.name
+
+
+@dataclass(frozen=True)
+class DiscoveryResult:
+    projects: tuple[Project, ...]
+    files: tuple[DiscoveredFile, ...]
+    problems: tuple[Problem, ...] = ()
+
+
+@dataclass(frozen=True)
+class _Definition:
+    root: Path
+    language: Language
+    kind: str
+    metadata_path: Path
+    source_roots: tuple[Path, ...] = ()
+    source_files: tuple[Path, ...] = ()
+    include_paths: tuple[Path, ...] = ()
+    translation_unit_include_paths: tuple[tuple[Path, tuple[Path, ...]], ...] = ()
+    translation_unit_output_names: tuple[tuple[Path, tuple[str, ...]], ...] = ()
+
+
+@dataclass(frozen=True)
+class _MetadataPath:
+    value: str
+    base: Path
+
+
+@dataclass(frozen=True)
+class _CompileCommand:
+    source_file: str
+    include_paths: tuple[_MetadataPath, ...]
+
+
+@dataclass
+class _CMakeConditionalFrame:
+    parent_active: bool
+    parent_possible: bool
+    branch_taken: bool
+    uncertain: bool
+    active: bool
+    possible: bool
+
+
+def discover_workspace(root: str | Path, languages: Iterable[Language] | None = None) -> DiscoveryResult:
+    workspace = Path(root).expanduser().resolve()
+    allowed = set(languages) if languages is not None else set(Language)
+    paths = tuple(_walk(workspace))
+    definitions, problems = _definitions(workspace, paths)
+    projects: dict[str, Project] = {}
+    for definition in definitions:
+        if (
+            definition.language in allowed
+            and definition.metadata_path.suffix.casefold() in _NAMED_PROJECT_SUFFIXES
+        ):
+            project = _project_from_definition(definition, definitions)
+            projects[project.project_id] = _merge_project(projects.get(project.project_id), project)
+    files: list[DiscoveredFile] = []
+    for path in paths:
+        marker = _MARKERS.get(path.name) or _MARKERS.get(path.suffix.casefold())
+        if marker and path.suffix.casefold() not in {".dpk", ".dpr"}:
+            continue
+        detected = [language for language in _languages_for(path) if language in allowed]
+        if not detected:
+            continue
+        if _excluded_by_layout(path, definitions, detected[0]):
+            continue
+        project, ownership_problem = _owner(path, definitions, detected[0], workspace)
+        if ownership_problem is not None:
+            problems.append(ownership_problem)
+        project = _merge_project(projects.get(project.project_id), project)
+        projects[project.project_id] = project
+        files.append(
+            DiscoveredFile(
+                path,
+                detected[0],
+                project.project_id,
+                _source_include_paths(path, definitions, detected[0], project),
+                _source_output_names(path, definitions, detected[0], project),
+            )
+        )
+    return DiscoveryResult(
+        tuple(sorted(projects.values(), key=lambda item: (item.root, item.name, item.project_id))),
+        tuple(files),
+        tuple(problems),
+    )
+
+
+def workspace_inventory(root: str | Path) -> tuple[tuple[str, int, int, str], ...]:
+    workspace = Path(root).expanduser().resolve()
+    tracked: list[tuple[str, int, int, str]] = []
+    for path in _walk(workspace):
+        relative = path.relative_to(workspace).as_posix()
+        if path.name != ".gitignore" and not (
+            _MARKERS.get(path.name) or _MARKERS.get(path.suffix.casefold()) or _languages_for(path)
+        ):
+            continue
+        try:
+            stat = path.stat()
+            digest = (
+                ""
+                if _languages_for(path)
+                else hashlib.sha256(path.read_bytes()).hexdigest()
+            )
+        except OSError:
+            continue
+        tracked.append((relative, stat.st_mtime_ns, stat.st_size, digest))
+    return tuple(sorted(tracked))
+
+
+def workspace_directory_inventory(root: str | Path) -> tuple[tuple[str, int], ...]:
+    """Capture included directory mtimes without following directory symlinks."""
+    workspace = Path(root).expanduser().resolve()
+    tracked: list[tuple[str, int]] = []
+    pending: list[tuple[Path, tuple[tuple[Path, pathspec.GitIgnoreSpec], ...]]] = [
+        (workspace, ())
+    ]
+    while pending:
+        directory, inherited_rules = pending.pop()
+        try:
+            stat = directory.stat()
+            entries = sorted(directory.iterdir(), reverse=True)
+        except OSError:
+            continue
+        relative = directory.relative_to(workspace).as_posix()
+        tracked.append((relative or ".", stat.st_mtime_ns))
+        local_ignore = _gitignore(directory)
+        rules = inherited_rules + (((directory, local_ignore),) if local_ignore is not None else ())
+        for path in entries:
+            path_relative = path.relative_to(workspace)
+            if any(part in _IGNORED for part in path_relative.parts):
+                continue
+            if (
+                path.is_dir()
+                and not path.is_symlink()
+                and not _ignored_by_rules(path, rules, directory=True)
+            ):
+                pending.append((path, rules))
+    return tuple(sorted(tracked))
+
+
+def _walk(root: Path) -> Iterator[Path]:
+    """Yield included regular files without following directory symlinks."""
+    pending: list[tuple[Path, tuple[tuple[Path, pathspec.GitIgnoreSpec], ...]]] = [(root, ())]
+    while pending:
+        directory, inherited_rules = pending.pop()
+        try:
+            local_ignore = _gitignore(directory)
+            entries = sorted(directory.iterdir(), reverse=True)
+        except OSError:
+            continue
+        rules = inherited_rules + (((directory, local_ignore),) if local_ignore is not None else ())
+        for path in entries:
+            relative = path.relative_to(root)
+            if any(part in _IGNORED for part in relative.parts):
+                continue
+            if path.is_dir():
+                if not path.is_symlink() and not _ignored_by_rules(path, rules, directory=True):
+                    pending.append((path, rules))
+                continue
+            if _included(root, path, rules):
+                yield path
+
+
+def _included(
+    root: Path,
+    path: Path,
+    rules: tuple[tuple[Path, pathspec.GitIgnoreSpec], ...],
+) -> bool:
+    if not path.is_file():
+        return False
+    try:
+        path.resolve().relative_to(root)
+    except ValueError:
+        return False
+    if path.name == ".gitignore":
+        return True
+    return not _ignored_by_rules(path, rules)
+
+
+def _ignored_by_rules(
+    path: Path,
+    rules: tuple[tuple[Path, pathspec.GitIgnoreSpec], ...],
+    *,
+    directory: bool = False,
+) -> bool:
+    ignored = False
+    for base, rule in rules:
+        relative = path.relative_to(base).as_posix()
+        if directory:
+            relative += "/"
+        decision = rule.check_file(relative).include
+        if decision is not None:
+            ignored = decision
+    return ignored
+
+
+def _gitignore(root: Path) -> pathspec.GitIgnoreSpec | None:
+    path = root / ".gitignore"
+    return pathspec.GitIgnoreSpec.from_lines(path.read_text(errors="replace").splitlines()) if path.is_file() else None
+
+
+def _definitions(root: Path, paths: tuple[Path, ...]) -> tuple[list[_Definition], list[Problem]]:
+    definitions: list[_Definition] = []
+    problems: list[Problem] = []
+    for path in paths:
+        marker = _MARKERS.get(path.name) or _MARKERS.get(path.suffix.casefold())
+        if marker is None:
+            continue
+        language, kind = marker
+        definition, reported = _parse_definition(root, path, language, kind)
+        definitions.append(definition)
+        problems.extend(reported)
+    return definitions, problems
+
+
+def _parse_definition(workspace: Path, path: Path, language: Language, kind: str) -> tuple[_Definition, list[Problem]]:
+    root = path.parent
+    roots: list[str] = []
+    source_files: list[str] = []
+    include_paths: list[_MetadataPath] = []
+    compile_commands: list[_CompileCommand] = []
+    output_mappings: list[tuple[str, str]] = []
+    metadata_problems: list[Problem] = []
+    if path.name == "pyproject.toml":
+        roots = _pyproject_roots(path)
+    elif path.name == "setup.cfg":
+        roots = _setup_cfg_roots(path)
+    elif path.name == "Cargo.toml":
+        roots, source_files, output_mappings = _cargo_sources(path)
+    elif path.suffix.casefold() == ".sln":
+        source_files, metadata_problems = _solution_sources(workspace, path)
+    elif path.suffix.casefold() in {".csproj", ".vcxproj"}:
+        source_files = _xml_includes(path, {"Compile", "ClCompile", "ClInclude"})
+        if path.suffix.casefold() == ".vcxproj":
+            include_paths = _vcxproj_include_paths(path)
+    elif path.suffix.casefold() in {".dpk", ".dpr", ".dproj", ".groupproj"}:
+        roots, source_files = _delphi_sources(path)
+        if path.suffix.casefold() in {".dpk", ".dpr"}:
+            source_files.insert(0, path.name)
+    elif path.name == "compile_commands.json":
+        compile_commands = _compile_commands(path)
+    elif path.name == "CMakeLists.txt":
+        source_files, include_paths, output_mappings, uncertain_conditions = _cmake_metadata(path)
+        metadata_problems.extend(
+            _cmake_condition_problem(condition, path) for condition in uncertain_conditions
+        )
+    definition_roots, root_problems = _resolve_roots(workspace, root, language, path, roots)
+    translation_unit_includes: list[tuple[Path, tuple[Path, ...]]] = []
+    if compile_commands:
+        definition_files, translation_unit_includes, compile_problems = _resolve_compile_commands(
+            workspace,
+            language,
+            path,
+            compile_commands,
+        )
+        definition_includes: list[Path] = []
+        file_problems = compile_problems
+        include_problems: list[Problem] = []
+    else:
+        definition_files, file_problems = _resolve_files(workspace, root, language, path, source_files)
+        definition_includes, include_problems = _resolve_include_paths(workspace, language, path, include_paths)
+    output_names_by_file: dict[Path, list[str]] = {}
+    for output_name, source_file in output_mappings:
+        if _has_unresolved_static_value(output_name):
+            metadata_problems.append(_output_problem(output_name, language, path))
+            continue
+        expanded = _expand_project_variables(source_file, root)
+        if _has_unresolved_static_value(expanded):
+            continue
+        candidate = Path(expanded)
+        candidate = (candidate if candidate.is_absolute() else root / candidate).resolve()
+        if candidate not in definition_files and not any(
+            candidate.is_relative_to(source_root) for source_root in definition_roots
+        ):
+            continue
+        names = output_names_by_file.setdefault(candidate, [])
+        if output_name not in names:
+            names.append(output_name)
+    return (
+        _Definition(
+            root,
+            language,
+            kind,
+            path,
+            tuple(definition_roots),
+            tuple(definition_files),
+            tuple(definition_includes),
+            tuple(translation_unit_includes),
+            tuple((source_file, tuple(names)) for source_file, names in output_names_by_file.items()),
+        ),
+        root_problems + file_problems + include_problems + metadata_problems,
+    )
+
+
+def _pyproject_roots(path: Path) -> list[str]:
+    try:
+        data = tomllib.loads(path.read_text(errors="replace"))
+    except (OSError, ValueError):
+        return []
+    tool = data.get("tool", {})
+    setuptools = tool.get("setuptools", {}) if isinstance(tool, dict) else {}
+    result: list[str] = []
+    package_dir = setuptools.get("package-dir", {}) if isinstance(setuptools, dict) else {}
+    if isinstance(package_dir, dict):
+        result.extend(value for value in package_dir.values() if isinstance(value, str))
+    packages = setuptools.get("packages", {}) if isinstance(setuptools, dict) else {}
+    find = packages.get("find", {}) if isinstance(packages, dict) else {}
+    if isinstance(find, dict):
+        result.extend(value for value in find.get("where", []) if isinstance(value, str))
+    poetry = tool.get("poetry", {}) if isinstance(tool, dict) else {}
+    if isinstance(poetry, dict):
+        result.extend(item["from"] for item in poetry.get("packages", []) if isinstance(item, dict) and isinstance(item.get("from"), str))
+    return result
+
+
+def _setup_cfg_roots(path: Path) -> list[str]:
+    parser = configparser.ConfigParser()
+    try:
+        parser.read_string(path.read_text(errors="replace"))
+    except (configparser.Error, OSError):
+        return []
+    result: list[str] = []
+    if parser.has_option("options", "package_dir"):
+        result.extend(line.split("=", 1)[1].strip() for line in parser.get("options", "package_dir").splitlines() if "=" in line)
+    if parser.has_option("options.packages.find", "where"):
+        result.extend(value.strip() for value in parser.get("options.packages.find", "where").splitlines() if value.strip())
+    return result
+
+
+def _cargo_sources(path: Path) -> tuple[list[str], list[str], list[tuple[str, str]]]:
+    try:
+        data = tomllib.loads(path.read_text(errors="replace"))
+    except (OSError, ValueError):
+        return [], [], []
+    package = data.get("package")
+    if not isinstance(package, dict):
+        return [], [], []
+    files: list[str] = []
+    output_mappings: list[tuple[str, str]] = []
+    lib = data.get("lib", {})
+    if isinstance(lib, dict):
+        library_path = lib.get("path")
+        if isinstance(library_path, str):
+            files.append(library_path)
+        else:
+            library_path = "src/lib.rs"
+        crate_types = lib.get("crate-type", [])
+        if isinstance(crate_types, str):
+            crate_types = [crate_types]
+        if (
+            isinstance(crate_types, list)
+            and any(item in {"cdylib", "dylib"} for item in crate_types)
+            and isinstance(package.get("name"), str)
+        ):
+            library_name = lib.get("name", package["name"])
+            if isinstance(library_name, str):
+                output_mappings.append((library_name.replace("-", "_"), library_path))
+    bins = data.get("bin", [])
+    if isinstance(bins, list):
+        files.extend(
+            item["path"]
+            for item in bins
+            if isinstance(item, dict) and isinstance(item.get("path"), str)
+        )
+    sources = ["src"] if (path.parent / "src").is_dir() or not files else []
+    return sources, files, output_mappings
+
+
+def _solution_sources(workspace: Path, path: Path) -> tuple[list[str], list[Problem]]:
+    try:
+        project_files = _SOLUTION_PROJECT.findall(path.read_text(errors="replace"))
+    except OSError:
+        return [], []
+    sources: list[str] = []
+    problems: list[Problem] = []
+    for project_file in project_files:
+        expanded = _expand_project_variables(project_file, path.parent)
+        if _has_unresolved_static_value(expanded):
+            problems.append(_project_file_problem("unresolved-project-file", project_file, path))
+            continue
+        candidate = Path(expanded)
+        candidate = candidate if candidate.is_absolute() else path.parent / candidate
+        candidate = candidate.resolve()
+        try:
+            candidate.relative_to(workspace)
+        except ValueError:
+            problems.append(_project_file_problem("workspace-escaping-project-file", project_file, path))
+            continue
+        if candidate.suffix.casefold() != ".csproj":
+            continue
+        if not candidate.is_file():
+            problems.append(_project_file_problem("missing-project-file", project_file, path))
+            continue
+        for source_file in _xml_includes(candidate, {"Compile"}):
+            expanded_source = _expand_project_variables(source_file, candidate.parent)
+            if _has_unresolved_static_value(expanded_source):
+                problems.append(_problem("unresolved-source-file", source_file, Language.CSHARP, candidate))
+                continue
+            source_path = Path(expanded_source)
+            source_path = source_path if source_path.is_absolute() else candidate.parent / source_path
+            normalized = str(source_path.resolve())
+            if normalized not in sources:
+                sources.append(normalized)
+    return sources, problems
+
+
+def _xml_includes(path: Path, names: set[str]) -> list[str]:
+    try:
+        tree = element_tree.parse(path)
+    except (OSError, element_tree.ParseError):
+        return []
+    return [element.attrib["Include"] for element in tree.iter() if element.tag.split("}")[-1] in names and "Include" in element.attrib]
+
+
+def _vcxproj_include_paths(path: Path) -> list[_MetadataPath]:
+    try:
+        tree = element_tree.parse(path)
+    except (OSError, element_tree.ParseError):
+        return []
+    result: list[_MetadataPath] = []
+    for element in tree.iter():
+        if element.tag.split("}")[-1] != "AdditionalIncludeDirectories" or not element.text:
+            continue
+        result.extend(
+            _MetadataPath(value.strip(), path.parent)
+            for value in element.text.split(";")
+            if value.strip()
+        )
+    return result
+
+
+def _delphi_sources(path: Path) -> tuple[list[str], list[str]]:
+    text = path.read_text(errors="replace")
+    source_files = (
+        _delphi_project_sources(text)
+        if path.suffix.casefold() in {".dpk", ".dpr"}
+        else _DELPHI_IN.findall(text)
+    )
+    roots: list[str] = []
+    if path.suffix.casefold() in {".dproj", ".groupproj"}:
+        try:
+            tree = element_tree.fromstring(text)
+        except element_tree.ParseError:
+            return roots, source_files
+        for element in tree.iter():
+            if element.tag.split("}")[-1] in {"DCC_UnitSearchPath", "DCC_IncludePath", "DCC_ObjPath", "DCC_SourcePath"} and element.text:
+                roots.extend(part.strip() for part in element.text.split(";") if part.strip())
+    return roots, source_files
+
+
+def _delphi_project_sources(text: str) -> list[str]:
+    sources: list[str] = []
+    position = 0
+    while position < len(text):
+        if text.startswith("//", position):
+            newline = text.find("\n", position + 2)
+            position = len(text) if newline < 0 else newline + 1
+            continue
+        if text.startswith("(*", position):
+            closing = text.find("*)", position + 2)
+            position = len(text) if closing < 0 else closing + 2
+            continue
+        if text[position] == "{":
+            closing = text.find("}", position + 1)
+            position = len(text) if closing < 0 else closing + 1
+            continue
+        if text[position] in {"'", '"'}:
+            _, position = _delphi_quoted_value(text, position)
+            continue
+        if text[position].isalpha() or text[position] == "_":
+            end = position + 1
+            while end < len(text) and (text[end].isalnum() or text[end] == "_"):
+                end += 1
+            keyword = text[position:end].casefold()
+            value_start = end
+            while value_start < len(text) and text[value_start].isspace():
+                value_start += 1
+            if keyword in {"in", "include"} and value_start < len(text) and text[value_start] in {"'", '"'}:
+                value, position = _delphi_quoted_value(text, value_start)
+                if value:
+                    sources.append(value)
+                continue
+            position = end
+            continue
+        position += 1
+    return sources
+
+
+def _delphi_quoted_value(text: str, position: int) -> tuple[str, int]:
+    quote = text[position]
+    value: list[str] = []
+    position += 1
+    while position < len(text):
+        character = text[position]
+        if character != quote:
+            value.append(character)
+            position += 1
+            continue
+        if position + 1 < len(text) and text[position + 1] == quote:
+            value.append(quote)
+            position += 2
+            continue
+        return "".join(value), position + 1
+    return "".join(value), position
+
+
+def _compile_commands(path: Path) -> list[_CompileCommand]:
+    try:
+        data = json.loads(path.read_text(errors="replace"))
+    except (OSError, ValueError):
+        return []
+    if not isinstance(data, list):
+        return []
+    commands: list[_CompileCommand] = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        directory_value = item.get("directory", str(path.parent))
+        directory = Path(directory_value) if isinstance(directory_value, str) else path.parent
+        directory = directory if directory.is_absolute() else path.parent / directory
+        source_file = item.get("file")
+        if not isinstance(source_file, str):
+            continue
+        source_path = Path(source_file)
+        source_path = source_path if source_path.is_absolute() else directory / source_path
+        commands.append(
+            _CompileCommand(
+                str(source_path),
+                tuple(_MetadataPath(value, directory) for value in _compile_include_paths(item)),
+            )
+        )
+    return commands
+
+
+def _compile_include_paths(
+    item: dict[str, object],
+    *,
+    windows: bool | None = None,
+) -> list[str]:
+    raw_arguments = item.get("arguments")
+    if isinstance(raw_arguments, list) and all(isinstance(value, str) for value in raw_arguments):
+        arguments = list(raw_arguments)
+    else:
+        command = item.get("command")
+        if not isinstance(command, str):
+            return []
+        try:
+            arguments = _split_command(command, windows=windows)
+        except ValueError:
+            return []
+    result: list[str] = []
+    index = 0
+    while index < len(arguments):
+        argument = _unquote_argument(arguments[index])
+        if argument in {"-I", "-isystem", "/I"}:
+            index += 1
+            if index < len(arguments):
+                value = _unquote_argument(arguments[index])
+                if value:
+                    result.append(value)
+        elif argument.startswith("-isystem") and len(argument) > len("-isystem"):
+            value = _unquote_argument(argument[len("-isystem"):])
+            if value:
+                result.append(value)
+        elif argument.startswith("-I") and len(argument) > 2:
+            value = _unquote_argument(argument[2:])
+            if value:
+                result.append(value)
+        elif argument.startswith("/I") and len(argument) > 2:
+            value = _unquote_argument(argument[2:])
+            if value:
+                result.append(value)
+        index += 1
+    return result
+
+
+def _split_command(command: str, *, windows: bool | None = None) -> list[str]:
+    use_windows_rules = os.name == "nt" if windows is None else windows
+    arguments = shlex.split(command, posix=not use_windows_rules)
+    if not use_windows_rules:
+        return arguments
+    result: list[str] = []
+    pending: list[str] = []
+    quoted = False
+    for argument in arguments:
+        pending.append(argument)
+        if argument.count('"') % 2:
+            quoted = not quoted
+        if not quoted:
+            result.append(" ".join(pending))
+            pending = []
+    result.extend(pending)
+    return result
+
+
+def _unquote_argument(value: str) -> str:
+    value = value.strip()
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+        return value[1:-1]
+    return value
+
+
+def _cmake_metadata(
+    path: Path,
+) -> tuple[list[str], list[_MetadataPath], list[tuple[str, str]], list[str]]:
+    sources: list[str] = []
+    include_paths: list[_MetadataPath] = []
+    loadable_targets: list[tuple[str, list[str]]] = []
+    output_names: dict[str, str] = {}
+    uncertain_conditions: list[str] = []
+    conditional_frames: list[_CMakeConditionalFrame] = []
+    opaque_blocks: list[str] = []
+    opaque_openers = {
+        "foreach": "endforeach",
+        "function": "endfunction",
+        "macro": "endmacro",
+        "while": "endwhile",
+    }
+    for name, arguments in _cmake_calls(path.read_text(errors="replace")):
+        try:
+            tokens = shlex.split(
+                arguments.replace(r"\;", _CMAKE_ESCAPED_SEMICOLON),
+                comments=False,
+                posix=True,
+            )
+        except ValueError:
+            continue
+        if opaque_blocks:
+            if name in opaque_openers:
+                opaque_blocks.append(opaque_openers[name])
+            elif name == opaque_blocks[-1]:
+                opaque_blocks.pop()
+            continue
+        if name in opaque_openers:
+            opaque_blocks.append(opaque_openers[name])
+            continue
+        if name == "if":
+            parent_active = all(frame.active for frame in conditional_frames)
+            parent_possible = all(frame.possible for frame in conditional_frames)
+            condition = _cmake_static_condition(tokens)
+            if parent_possible and condition is None and arguments.strip() not in uncertain_conditions:
+                uncertain_conditions.append(arguments.strip())
+            conditional_frames.append(
+                _CMakeConditionalFrame(
+                    parent_active,
+                    parent_possible,
+                    condition is True,
+                    condition is None,
+                    parent_active and condition is True,
+                    parent_possible and condition is not False,
+                )
+            )
+            continue
+        if name == "elseif":
+            if conditional_frames:
+                frame = conditional_frames[-1]
+                condition = _cmake_static_condition(tokens)
+                if (
+                    frame.parent_possible
+                    and not frame.branch_taken
+                    and condition is None
+                    and arguments.strip() not in uncertain_conditions
+                ):
+                    uncertain_conditions.append(arguments.strip())
+                frame.active = (
+                    frame.parent_active
+                    and not frame.branch_taken
+                    and not frame.uncertain
+                    and condition is True
+                )
+                frame.possible = (
+                    frame.parent_possible
+                    and not frame.branch_taken
+                    and condition is not False
+                )
+                frame.branch_taken = frame.branch_taken or condition is True
+                frame.uncertain = frame.uncertain or condition is None
+            continue
+        if name == "else":
+            if conditional_frames:
+                frame = conditional_frames[-1]
+                frame.active = frame.parent_active and not frame.branch_taken and not frame.uncertain
+                frame.possible = frame.parent_possible and not frame.branch_taken
+                frame.branch_taken = True
+            continue
+        if name == "endif":
+            if conditional_frames:
+                conditional_frames.pop()
+            continue
+        possible = all(frame.possible for frame in conditional_frames)
+        if not possible:
+            continue
+        active = all(frame.active for frame in conditional_frames)
+        if name in {"add_executable", "add_library"}:
+            output_name = tokens[0].replace(_CMAKE_ESCAPED_SEMICOLON, ";") if tokens else ""
+            target_kind = next(
+                (
+                    item.upper()
+                    for item in tokens[1:]
+                    if item.upper() in _CMAKE_TARGET_MARKERS
+                ),
+                "",
+            )
+            target_sources = [
+                item
+                for item in _cmake_list_items(tokens[1:])
+                if item.upper() not in _CMAKE_TARGET_MARKERS
+                and (
+                    _has_unresolved_static_value(item)
+                    or Path(item).suffix.casefold()
+                    in {".c", ".cc", ".cpp", ".cxx", ".h", ".hpp"}
+                )
+            ]
+            sources.extend(target_sources)
+            if active and name == "add_library" and target_kind in _CMAKE_LIBRARY_KINDS:
+                loadable_targets.append((output_name, target_sources))
+        elif name == "set_target_properties":
+            properties_index = next(
+                (index for index, item in enumerate(tokens) if item.upper() == "PROPERTIES"),
+                -1,
+            )
+            if properties_index > 0:
+                targets = tokens[:properties_index]
+                properties = tokens[properties_index + 1 :]
+                for index in range(0, len(properties) - 1, 2):
+                    if properties[index].upper() == "OUTPUT_NAME":
+                        for target in targets:
+                            output_names[target] = (
+                                properties[index + 1]
+                                if active
+                                else "${OUTPUT_NAME_DEPENDS_ON_CMAKE_CONDITION}"
+                            )
+        elif name == "set_property":
+            property_index = next(
+                (index for index, item in enumerate(tokens) if item.upper() == "PROPERTY"),
+                -1,
+            )
+            if (
+                tokens
+                and tokens[0].upper() == "TARGET"
+                and property_index > 1
+                and len(tokens) > property_index + 2
+                and tokens[property_index + 1].upper() == "OUTPUT_NAME"
+            ):
+                targets = [
+                    target
+                    for target in tokens[1:property_index]
+                    if target.upper() not in {"APPEND", "APPEND_STRING"}
+                ]
+                modifiers = {item.upper() for item in tokens[1:property_index]}
+                values = tokens[property_index + 2 :]
+                for target in targets:
+                    if not active:
+                        output_names[target] = "${OUTPUT_NAME_DEPENDS_ON_CMAKE_CONDITION}"
+                    elif "APPEND_STRING" in modifiers:
+                        output_names[target] = output_names.get(target, "") + "".join(values)
+                    elif "APPEND" in modifiers:
+                        output_names[target] = "${OUTPUT_NAME_APPEND_REQUIRES_CMAKE}"
+                    else:
+                        output_names[target] = values[0]
+        elif name == "include_directories":
+            if not active:
+                continue
+            include_paths.extend(
+                _MetadataPath(item, path.parent)
+                for item in _cmake_list_items(tokens)
+                if item not in _CMAKE_INCLUDE_MARKERS
+            )
+        elif name == "target_include_directories":
+            if not active:
+                continue
+            include_paths.extend(
+                _MetadataPath(item, path.parent)
+                for item in _cmake_list_items(tokens[1:])
+                if item not in _CMAKE_INCLUDE_MARKERS
+            )
+    output_mappings = [
+        (output_names.get(target, target), source)
+        for target, target_sources in loadable_targets
+        if target
+        for source in target_sources
+    ]
+    return sources, include_paths, output_mappings, uncertain_conditions
+
+
+def _cmake_static_condition(tokens: list[str]) -> bool | None:
+    if len(tokens) == 2 and tokens[0].upper() == "NOT":
+        nested = _cmake_static_condition(tokens[1:])
+        return None if nested is None else not nested
+    if len(tokens) != 1:
+        return None
+    value = tokens[0].strip().upper()
+    if not value or value in {"0", "OFF", "NO", "FALSE", "N", "IGNORE", "NOTFOUND"}:
+        return False
+    if value.endswith("-NOTFOUND"):
+        return False
+    if value in {"1", "ON", "YES", "TRUE", "Y"}:
+        return True
+    try:
+        return float(value) != 0
+    except ValueError:
+        return None
+
+
+def _cmake_list_items(tokens: Iterable[str]) -> Iterator[str]:
+    for token in tokens:
+        yield from (
+            item.replace(_CMAKE_ESCAPED_SEMICOLON, ";")
+            for item in token.split(";")
+            if item
+        )
+
+
+def _cmake_calls(text: str) -> Iterator[tuple[str, str]]:
+    text = _strip_cmake_comments(text)
+    position = 0
+    while match := _CMAKE_CALL.search(text, position):
+        depth = 1
+        quote = ""
+        escaped = False
+        cursor = match.end()
+        while cursor < len(text) and depth:
+            character = text[cursor]
+            if escaped:
+                escaped = False
+            elif character == "\\":
+                escaped = True
+            elif quote:
+                if character == quote:
+                    quote = ""
+            elif character in {'"', "'"}:
+                quote = character
+            elif character == "(":
+                depth += 1
+            elif character == ")":
+                depth -= 1
+            cursor += 1
+        if depth:
+            return
+        yield match.group(1).casefold(), text[match.end():cursor - 1]
+        position = cursor
+
+
+def _strip_cmake_comments(text: str) -> str:
+    result: list[str] = []
+    quote = ""
+    escaped = False
+    position = 0
+    while position < len(text):
+        character = text[position]
+        if escaped:
+            escaped = False
+            result.append(character)
+        elif character == "\\":
+            escaped = True
+            result.append(character)
+        elif quote:
+            if character == quote:
+                quote = ""
+            result.append(character)
+        elif character in {'"', "'"}:
+            quote = character
+            result.append(character)
+        elif character == "#":
+            bracket = _CMAKE_BRACKET_COMMENT_START.match(text, position)
+            if bracket is not None:
+                closing = f"]{bracket.group('equals')}]"
+                closing_start = text.find(closing, bracket.end())
+                comment_end = len(text) if closing_start < 0 else closing_start + len(closing)
+                result.extend("\n" * text[position:comment_end].count("\n"))
+                position = comment_end
+                continue
+            newline = text.find("\n", position)
+            position = len(text) if newline < 0 else newline
+            continue
+        else:
+            result.append(character)
+        position += 1
+    return "".join(result)
+
+
+def _resolve_roots(workspace: Path, base: Path, language: Language, path: Path, roots: list[str]) -> tuple[list[Path], list[Problem]]:
+    resolved: list[Path] = []
+    problems: list[Problem] = []
+    for item in roots:
+        expanded = _expand_project_variables(item, base)
+        if _has_unresolved_static_value(expanded):
+            problems.append(_problem("unresolved-source-root", item, language, path))
+            continue
+        candidate = (base / expanded).resolve()
+        try:
+            candidate.relative_to(workspace)
+        except ValueError:
+            problems.append(_problem("workspace-escaping-source-root", item, language, path))
+            continue
+        if not candidate.is_dir():
+            problems.append(_problem("missing-source-root", item, language, path))
+            continue
+        resolved.append(candidate)
+    return resolved, problems
+
+
+def _resolve_files(workspace: Path, base: Path, language: Language, path: Path, files: list[str]) -> tuple[list[Path], list[Problem]]:
+    resolved: list[Path] = []
+    problems: list[Problem] = []
+    for item in files:
+        expanded = _expand_project_variables(item, base)
+        if _has_unresolved_static_value(expanded):
+            problems.append(_problem("unresolved-source-file", item, language, path))
+            continue
+        candidate = Path(expanded)
+        candidate = candidate if candidate.is_absolute() else base / candidate
+        candidate = candidate.resolve()
+        try:
+            candidate.relative_to(workspace)
+        except ValueError:
+            problems.append(_problem("workspace-escaping-source-file", item, language, path))
+            continue
+        if not candidate.is_file():
+            problems.append(_problem("missing-source-file", item, language, path))
+            continue
+        resolved.append(candidate)
+    return resolved, problems
+
+
+def _resolve_compile_commands(
+    workspace: Path,
+    language: Language,
+    path: Path,
+    commands: list[_CompileCommand],
+) -> tuple[list[Path], list[tuple[Path, tuple[Path, ...]]], list[Problem]]:
+    resolved_files: list[Path] = []
+    translation_unit_includes: list[tuple[Path, tuple[Path, ...]]] = []
+    problems: list[Problem] = []
+    seen_files: set[Path] = set()
+    mapped_files: set[Path] = set()
+    reported_include_problems: set[tuple[str, str]] = set()
+    for command in commands:
+        command_files, file_problems = _resolve_files(
+            workspace,
+            path.parent,
+            language,
+            path,
+            [command.source_file],
+        )
+        command_includes, include_problems = _resolve_include_paths(
+            workspace,
+            language,
+            path,
+            list(command.include_paths),
+            reported_include_problems,
+        )
+        problems.extend(file_problems)
+        problems.extend(include_problems)
+        if not command_files:
+            continue
+        source_file = command_files[0]
+        if source_file not in seen_files:
+            seen_files.add(source_file)
+            resolved_files.append(source_file)
+        if source_file not in mapped_files:
+            mapped_files.add(source_file)
+            translation_unit_includes.append((source_file, tuple(command_includes)))
+    return resolved_files, translation_unit_includes, problems
+
+
+def _resolve_include_paths(
+    workspace: Path,
+    language: Language,
+    path: Path,
+    include_paths: list[_MetadataPath],
+    reported_problems: set[tuple[str, str]] | None = None,
+) -> tuple[list[Path], list[Problem]]:
+    resolved: list[Path] = []
+    problems: list[Problem] = []
+    seen: set[Path] = set()
+    seen_problems = reported_problems if reported_problems is not None else set()
+
+    def report(code: str, identity: str, include_path: _MetadataPath) -> None:
+        key = (code, identity)
+        if key in seen_problems:
+            return
+        seen_problems.add(key)
+        problems.append(_include_problem(code, include_path.value, language, path))
+
+    for include_path in include_paths:
+        expanded = _expand_project_variables(include_path.value, include_path.base)
+        expanded_base = _expand_project_variables(str(include_path.base), path.parent)
+        if _has_unresolved_static_value(expanded) or _has_unresolved_static_value(expanded_base):
+            report("unresolved-include-path", f"{expanded_base}\0{expanded}", include_path)
+            continue
+        candidate = Path(expanded)
+        candidate = candidate if candidate.is_absolute() else Path(expanded_base) / candidate
+        candidate = candidate.resolve()
+        try:
+            candidate.relative_to(workspace)
+        except ValueError:
+            report("workspace-escaping-include-path", str(candidate), include_path)
+            continue
+        if not candidate.is_dir():
+            report("missing-include-path", str(candidate), include_path)
+            continue
+        if candidate not in seen:
+            seen.add(candidate)
+            resolved.append(candidate)
+    return resolved, problems
+
+
+def _has_unresolved_static_value(value: str) -> bool:
+    return _VARIABLE.search(value) is not None or _GENERATOR_EXPRESSION.search(value) is not None
+
+
+def _expand_project_variables(value: str, base: Path) -> str:
+    directory = f"{base}/"
+    replacements = {
+        "PROJECTDIR": directory,
+        "PROJECT_DIR": directory,
+        "MSBUILDPROJECTDIRECTORY": directory,
+        "MSBUILDTHISFILEDIRECTORY": directory,
+    }
+
+    def replace_variable(match: re.Match[str]) -> str:
+        token = match.group(0)
+        if not token.startswith("$("):
+            return token
+        return replacements.get(token[2:-1].upper(), token)
+
+    return _VARIABLE.sub(replace_variable, value).replace("\\", "/")
+
+
+def _problem(code: str, item: str, language: Language, path: Path) -> Problem:
+    return Problem(code, f"Could not resolve static metadata entry: {item}", language=language, metadata={"source_root": item, "metadata_path": str(path)})
+
+
+def _include_problem(code: str, item: str, language: Language, path: Path) -> Problem:
+    return Problem(
+        code,
+        f"Could not resolve static include path: {item}",
+        language=language,
+        metadata={"include_path": item, "metadata_path": str(path)},
+    )
+
+
+def _output_problem(item: str, language: Language, path: Path) -> Problem:
+    return Problem(
+        "unresolved-output-name",
+        f"Could not resolve static output name: {item}",
+        language=language,
+        metadata={"output_name": item, "metadata_path": str(path)},
+    )
+
+
+def _cmake_condition_problem(condition: str, path: Path) -> Problem:
+    return Problem(
+        "unresolved-cmake-condition",
+        f"Could not statically resolve CMake condition: {condition}",
+        language=Language.CPP,
+        metadata={"condition": condition, "metadata_path": str(path)},
+    )
+
+
+def _project_file_problem(code: str, item: str, path: Path) -> Problem:
+    return Problem(
+        code,
+        f"Could not resolve static solution project entry: {item}",
+        language=Language.CSHARP,
+        metadata={"project_file": item, "metadata_path": str(path)},
+    )
+
+
+def _languages_for(path: Path) -> tuple[Language, ...]:
+    detected = adapters_for(path)
+    return (Language.DELPHI,) if path.suffix.casefold() in {".pas", ".dpr", ".dpk"} else detected
+
+
+def _owner(
+    path: Path,
+    definitions: list[_Definition],
+    language: Language,
+    root: Path,
+) -> tuple[Project, Problem | None]:
+    candidates = [item for item in definitions if item.language is language and _owns(item, path)]
+    if not candidates:
+        return _synthetic_project(root, language), None
+    best_rank = max(_ownership_rank(item, path) for item in candidates)
+    winners = [item for item in candidates if _ownership_rank(item, path) == best_rank]
+    winner_ids = {_definition_project_id(item, definitions) for item in winners}
+    if len(winner_ids) > 1:
+        metadata_paths = sorted(str(item.metadata_path) for item in winners)
+        return (
+            _synthetic_project(root, language),
+            Problem(
+                "ambiguous-project-ownership",
+                f"Multiple project files can own {path}: {', '.join(metadata_paths)}",
+                "warning",
+                language,
+                metadata={"path": str(path.relative_to(root)), "project_files": metadata_paths},
+            ),
+        )
+    return _project_from_definition(winners[0], definitions), None
+
+
+def _synthetic_project(root: Path, language: Language) -> Project:
+    return Project(
+        stable_id("project", str(root), "synthetic"),
+        root.name,
+        str(root),
+        (language,),
+        "synthetic",
+    )
+
+
+def _project_from_definition(definition: _Definition, definitions: list[_Definition]) -> Project:
+    project_id = _definition_project_id(definition, definitions)
+    canonical = _canonical_project_definition(definition, definitions)
+    include_paths = tuple(
+        dict.fromkeys(
+            str(include_path)
+            for candidate in definitions
+            if candidate.language is definition.language
+            and _definition_project_id(candidate, definitions) == project_id
+            for include_path in candidate.include_paths
+        )
+    )
+    return Project(
+        project_id,
+        _definition_project_name(definition),
+        str(definition.root),
+        (definition.language,),
+        canonical.kind,
+        include_paths,
+    )
+
+
+def _merge_project(previous: Project | None, project: Project) -> Project:
+    if previous is None:
+        return project
+    selected_languages = {*previous.languages, *project.languages}
+    return replace(
+        previous,
+        languages=tuple(language for language in Language if language in selected_languages),
+        include_paths=tuple(dict.fromkeys((*previous.include_paths, *project.include_paths))),
+    )
+
+
+def _source_include_paths(
+    path: Path,
+    definitions: list[_Definition],
+    language: Language,
+    project: Project,
+) -> tuple[Path, ...]:
+    project_root = Path(project.root)
+    candidates = [
+        item
+        for item in definitions
+        if item.language is language
+        and item.root == project_root
+        and _definition_project_id(item, definitions) == project.project_id
+        and _owns(item, path)
+    ]
+    for candidate in candidates:
+        for source_file, include_paths in candidate.translation_unit_include_paths:
+            if source_file == path:
+                return include_paths
+    return tuple(Path(include_path) for include_path in project.include_paths)
+
+
+def _source_output_names(
+    path: Path,
+    definitions: list[_Definition],
+    language: Language,
+    project: Project,
+) -> tuple[str, ...]:
+    project_root = Path(project.root)
+    names: list[str] = []
+    for candidate in definitions:
+        if (
+            candidate.language is not language
+            or candidate.root != project_root
+            or _definition_project_id(candidate, definitions) != project.project_id
+            or not _owns(candidate, path)
+        ):
+            continue
+        for source_file, output_names in candidate.translation_unit_output_names:
+            if source_file == path:
+                names.extend(name for name in output_names if name not in names)
+    return tuple(names)
+
+
+def _excluded_by_layout(path: Path, definitions: list[_Definition], language: Language) -> bool:
+    scoped = [item for item in definitions if item.language is language and (item.source_roots or item.source_files)]
+    return any(path.is_relative_to(item.root) for item in scoped) and not any(_owns(item, path) for item in scoped)
+
+
+def _owns(definition: _Definition, path: Path) -> bool:
+    if path in definition.source_files:
+        return True
+    roots = definition.source_roots
+    if roots:
+        return any(path.is_relative_to(root) for root in roots)
+    return not definition.source_files and path.is_relative_to(definition.root)
+
+
+def _ownership_rank(definition: _Definition, path: Path) -> tuple[int, int, int, int, int]:
+    matching_root_depth = max(
+        (len(root.parts) for root in definition.source_roots if path.is_relative_to(root)),
+        default=-1,
+    )
+    return (
+        int(path in definition.source_files),
+        int(definition.metadata_path.stem.casefold() == path.stem.casefold()),
+        _PROJECT_OWNERSHIP_PRIORITY.get(definition.metadata_path.suffix.casefold(), 0),
+        matching_root_depth,
+        len(definition.root.parts),
+    )
+
+
+def _definition_project_id(definition: _Definition, definitions: list[_Definition]) -> str:
+    canonical = _canonical_project_definition(definition, definitions)
+    if canonical.metadata_path.suffix.casefold() in _NAMED_PROJECT_SUFFIXES:
+        return stable_id("project", str(canonical.metadata_path.with_suffix("")), canonical.kind)
+    return stable_id("project", str(definition.root), definition.language.value)
+
+
+def _canonical_project_definition(
+    definition: _Definition,
+    definitions: list[_Definition],
+) -> _Definition:
+    if definition.metadata_path.suffix.casefold() != ".dproj":
+        return definition
+    project_path = definition.metadata_path.with_suffix("")
+    companions = [
+        candidate
+        for candidate in definitions
+        if candidate.metadata_path.with_suffix("") == project_path
+        and candidate.metadata_path.suffix.casefold() in {".dpk", ".dpr"}
+    ]
+    if not companions:
+        return definition
+    return max(
+        companions,
+        key=lambda candidate: (candidate.metadata_path.suffix.casefold() == ".dpr", candidate.kind),
+    )
+
+
+def _definition_project_name(definition: _Definition) -> str:
+    if definition.metadata_path.suffix.casefold() in _NAMED_PROJECT_SUFFIXES:
+        return definition.metadata_path.stem
+    return definition.root.name