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

delphi_lsp/metrics.py

@@ -0,0 +1,1452 @@
+from __future__ import annotations
+
+import math
+import re
+from collections import Counter
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+
+from .consts import AttributeName, SyntaxNodeType
+from .lark_tokens import KEYWORDS
+from .nodes import SyntaxNode, ValuedSyntaxNode
+from .parser import DelphiParseError, DelphiParser
+from .parser_backend import ParserMode, normalize_mode
+from .preprocessor import IncludeLoader
+from .semantic import SymbolKind
+
+_KEYWORDS = frozenset(keyword.casefold() for keyword in KEYWORDS)
+_TWO_CHARACTER_OPERATORS = frozenset({":=", "<=", ">=", "<>", "..", "**"})
+_LINE_SCAN_SPECIAL_RE = re.compile(r"//|\{|\(\*|'|\r\n|\r|\n")
+_NON_WHITESPACE_RE = re.compile(r"\S")
+_WHITESPACE_RE = re.compile(r"\s+")
+_IDENTIFIER_PART_RE = re.compile(r"\w*")
+_NON_DECIMAL_DIGIT_CLASS = (
+    r"\u00B2-\u00B3\u00B9\u1369-\u1371\u19DA\u2070\u2074-\u2079"
+    r"\u2080-\u2089\u2460-\u2468\u2474-\u247C\u2488-\u2490\u24EA"
+    r"\u24F5-\u24FD\u24FF\u2776-\u277E\u2780-\u2788\u278A-\u2792"
+    r"\U00010A40-\U00010A43\U00010E60-\U00010E68"
+    r"\U00011052-\U0001105A\U0001F100-\U0001F10A"
+)
+_WORD_OPERATOR_CLASS = (
+    r"\u00BC-\u00BE\u09F4-\u09F9\u0B72-\u0B77\u0BF0-\u0BF2"
+    r"\u0C78-\u0C7E\u0D58-\u0D5E\u0D70-\u0D78\u0F2A-\u0F33"
+    r"\u1372-\u137C\u16EE-\u16F0\u17F0-\u17F9\u2150-\u2182"
+    r"\u2185-\u2189\u2469-\u2473\u247D-\u2487\u2491-\u249B"
+    r"\u24EB-\u24F4\u24FE\u277F\u2789\u2793\u2CFD\u3007"
+    r"\u3021-\u3029\u3038-\u303A\u3192-\u3195\u3220-\u3229"
+    r"\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF"
+    r"\uA6E6-\uA6EF\uA830-\uA835\U00010107-\U00010133"
+    r"\U00010140-\U00010178\U0001018A-\U0001018B"
+    r"\U000102E1-\U000102FB\U00010320-\U00010323\U00010341"
+    r"\U0001034A\U000103D1-\U000103D5\U00010858-\U0001085F"
+    r"\U00010879-\U0001087F\U000108A7-\U000108AF"
+    r"\U000108FB-\U000108FF\U00010916-\U0001091B"
+    r"\U000109BC-\U000109BD\U000109C0-\U000109CF"
+    r"\U000109D2-\U000109FF\U00010A44-\U00010A48"
+    r"\U00010A7D-\U00010A7E\U00010A9D-\U00010A9F"
+    r"\U00010AEB-\U00010AEF\U00010B58-\U00010B5F"
+    r"\U00010B78-\U00010B7F\U00010BA9-\U00010BAF"
+    r"\U00010CFA-\U00010CFF\U00010E69-\U00010E7E"
+    r"\U00010F1D-\U00010F26\U00010F51-\U00010F54"
+    r"\U00010FC5-\U00010FCB\U0001105B-\U00011065"
+    r"\U000111E1-\U000111F4\U0001173A-\U0001173B"
+    r"\U000118EA-\U000118F2\U00011C5A-\U00011C6C"
+    r"\U00011FC0-\U00011FD4\U00012400-\U0001246E"
+    r"\U00016B5B-\U00016B61\U00016E80-\U00016E96"
+    r"\U0001D2C0-\U0001D2D3\U0001D2E0-\U0001D2F3"
+    r"\U0001D360-\U0001D378\U0001E8C7-\U0001E8CF"
+    r"\U0001EC71-\U0001ECAB\U0001ECAD-\U0001ECAF"
+    r"\U0001ECB1-\U0001ECB4\U0001ED01-\U0001ED2D"
+    r"\U0001ED2F-\U0001ED3D\U0001F10B-\U0001F10C"
+)
+_METRIC_TOKEN_RE = re.compile(
+    r"//[^\r\n]*"
+    r"|\{[^}]*\}?"
+    r"|\(\*.*?(?:\*\)|\Z)"
+    r"|('(?:''|[^'])*(?:'|\Z)"
+    rf"|&(?=\d|[{_NON_DECIMAL_DIGIT_CLASS}{_WORD_OPERATOR_CLASS}])"
+    r"|[$%#](?=\w)(?:\w|\.(?!\.)|(?<=[eE])[+-])*"
+    r"|&?[A-Za-z_]\w*"
+    rf"|[{_NON_DECIMAL_DIGIT_CLASS}]"
+    r"(?:\w|\.(?!\.)|(?<=[eE])[+-])*"
+    r"|\d(?:\w|\.(?!\.)|(?<=[eE])[+-])*"
+    rf"|[{_WORD_OPERATOR_CLASS}]"
+    r"|&?\w+"
+    r"|:=|<=|>=|<>|\.\.|\*\*"
+    r"|\S)",
+    re.DOTALL,
+)
+_ASCII_METRIC_TOKEN_RE = re.compile(
+    r"//[^\r\n]*"
+    r"|\{[^}]*\}?"
+    r"|\(\*.*?(?:\*\)|\Z)"
+    r"|('(?:''|[^'])*(?:'|\Z)"
+    r"|&(?=\d)"
+    r"|[$%#](?=\w)(?:\w|\.(?!\.)|(?<=[eE])[+-])*"
+    r"|\d(?:\w|\.(?!\.)|(?<=[eE])[+-])*"
+    r"|&?[A-Za-z_]\w*"
+    r"|:=|<=|>=|<>|\.\.|\*\*"
+    r"|\S)",
+    re.DOTALL,
+)
+_DECISION_NODES = frozenset(
+    {
+        SyntaxNodeType.ntIf,
+        SyntaxNodeType.ntFor,
+        SyntaxNodeType.ntWhile,
+        SyntaxNodeType.ntRepeat,
+        SyntaxNodeType.ntCaseSelector,
+        SyntaxNodeType.ntExceptionHandler,
+    }
+)
+_DEPENDENCY_NODES = frozenset(
+    {
+        SyntaxNodeType.ntUses,
+        SyntaxNodeType.ntContains,
+        SyntaxNodeType.ntRequires,
+    }
+)
+_LARGE_PROJECT_UNIT_THRESHOLD = 256
+_LARGE_PROJECT_CHAR_THRESHOLD = 16 * 1024 * 1024
+_METRIC_TOKEN_CHUNK_TARGET = 590 * 1024
+_METRIC_TOKEN_FINDALL_LIMIT = 600 * 1024
+
+
+@dataclass(frozen=True)
+class MetricProblem:
+    kind: str
+    path: str
+    message: str
+
+    def to_mapping(self) -> dict[str, str]:
+        return {"kind": self.kind, "path": self.path, "message": self.message}
+
+
+@dataclass(frozen=True)
+class LineMetrics:
+    total_lines: int = 0
+    source_lines: int = 0
+    blank_lines: int = 0
+    comment_only_lines: int = 0
+    comment_lines: int = 0
+    directive_lines: int = 0
+
+    def to_mapping(self) -> dict[str, int]:
+        return {
+            "total_lines": self.total_lines,
+            "source_lines": self.source_lines,
+            "blank_lines": self.blank_lines,
+            "comment_only_lines": self.comment_only_lines,
+            "comment_lines": self.comment_lines,
+            "directive_lines": self.directive_lines,
+        }
+
+
+@dataclass(frozen=True)
+class HalsteadMetrics:
+    distinct_operators: int = 0
+    distinct_operands: int = 0
+    total_operators: int = 0
+    total_operands: int = 0
+    vocabulary: int = 0
+    length: int = 0
+    calculated_length: float = 0.0
+    volume: float = 0.0
+    difficulty: float = 0.0
+    effort: float = 0.0
+    estimated_time_seconds: float = 0.0
+    estimated_defects: float = 0.0
+
+    def to_mapping(self) -> dict[str, int | float]:
+        return {
+            "distinct_operators": self.distinct_operators,
+            "distinct_operands": self.distinct_operands,
+            "total_operators": self.total_operators,
+            "total_operands": self.total_operands,
+            "vocabulary": self.vocabulary,
+            "length": self.length,
+            "calculated_length": self.calculated_length,
+            "volume": self.volume,
+            "difficulty": self.difficulty,
+            "effort": self.effort,
+            "estimated_time_seconds": self.estimated_time_seconds,
+            "estimated_defects": self.estimated_defects,
+        }
+
+
+@dataclass(frozen=True)
+class RoutineComplexity:
+    name: str
+    value: int
+    line: int
+
+    def to_mapping(self) -> dict[str, str | int]:
+        return {"name": self.name, "value": self.value, "line": self.line}
+
+
+@dataclass(frozen=True)
+class CyclomaticMetrics:
+    routine_count: int = 0
+    total: int = 0
+    average: float = 0.0
+    maximum: int = 0
+    routines: tuple[RoutineComplexity, ...] = ()
+
+    @classmethod
+    def from_routines(cls, routines: Iterable[RoutineComplexity]) -> CyclomaticMetrics:
+        ordered = tuple(
+            sorted(
+                routines,
+                key=lambda item: (-item.value, item.name.casefold(), item.line, item.name),
+            )
+        )
+        total = sum(item.value for item in ordered)
+        count = len(ordered)
+        return cls(
+            routine_count=count,
+            total=total,
+            average=total / count if count else 0.0,
+            maximum=max((item.value for item in ordered), default=0),
+            routines=ordered,
+        )
+
+    def to_mapping(self, *, detail: bool = False) -> dict[str, object]:
+        result: dict[str, object] = {
+            "routine_count": self.routine_count,
+            "total": self.total,
+            "average": self.average,
+            "maximum": self.maximum,
+        }
+        if detail:
+            result["routines"] = [item.to_mapping() for item in self.routines]
+        return result
+
+
+@dataclass(frozen=True)
+class UnitMetrics:
+    name: str
+    path: str
+    lines: LineMetrics
+    cyclomatic: CyclomaticMetrics
+    halstead: HalsteadMetrics
+    maintainability_index: float
+    symbol_counts: Mapping[str, int]
+    dependencies: tuple[str, ...] = ()
+    internal_dependencies: tuple[str, ...] = ()
+    external_dependencies: tuple[str, ...] = ()
+    afferent_coupling: int = 0
+    efferent_coupling: int = 0
+    instability: float = 0.0
+    class_like_types: int = 0
+    abstract_types: int = 0
+    abstractness: float = 0.0
+    distance: float = 1.0
+    problems: tuple[MetricProblem, ...] = ()
+    unit_id: str = ""
+    _operator_vocabulary: frozenset[str] = field(default_factory=frozenset, repr=False)
+    _operand_vocabulary: frozenset[str] = field(default_factory=frozenset, repr=False)
+
+    def to_mapping(self, *, detail: bool = False) -> dict[str, object]:
+        result: dict[str, object] = {
+            "name": self.name,
+            "path": self.path,
+            "unit_id": self.unit_id,
+            "lines": self.lines.to_mapping(),
+            "cyclomatic": self.cyclomatic.to_mapping(detail=detail),
+            "maintainability_index": self.maintainability_index,
+            "afferent_coupling": self.afferent_coupling,
+            "efferent_coupling": self.efferent_coupling,
+            "instability": self.instability,
+            "abstractness": self.abstractness,
+            "distance": self.distance,
+            "class_like_types": self.class_like_types,
+            "abstract_types": self.abstract_types,
+            "problems": [problem.to_mapping() for problem in self.problems],
+        }
+        if detail:
+            result.update(
+                {
+                    "halstead": self.halstead.to_mapping(),
+                    "symbol_counts": dict(sorted(self.symbol_counts.items())),
+                    "dependencies": list(self.dependencies),
+                    "internal_dependencies": list(self.internal_dependencies),
+                    "external_dependencies": list(self.external_dependencies),
+                }
+            )
+        else:
+            result["halstead_volume"] = self.halstead.volume
+        return result
+
+
+@dataclass(frozen=True)
+class ProjectMetrics:
+    units: tuple[UnitMetrics, ...]
+    lines: LineMetrics
+    cyclomatic: CyclomaticMetrics
+    halstead: HalsteadMetrics
+    maintainability_index: float
+    total_loc: int
+    include_loc: int
+    total_loc_with_includes: int
+    dependency_edges: int
+    problems: tuple[MetricProblem, ...] = ()
+    project_id: str = ""
+    project_name: str = ""
+    include_metrics: tuple[UnitMetrics, ...] = ()
+
+    @property
+    def unit_count(self) -> int:
+        return len(self.units)
+
+    @property
+    def include_file_count(self) -> int:
+        return len(self.include_metrics)
+
+    @property
+    def file_metrics(self) -> tuple[UnitMetrics, ...]:
+        return tuple(
+            sorted(
+                (*self.units, *self.include_metrics),
+                key=lambda item: (
+                    item.name.casefold(),
+                    item.path.casefold(),
+                    item.name,
+                    item.path,
+                ),
+            )
+        )
+
+    def unit_by_name(self, name: str) -> UnitMetrics:
+        normalized = name.casefold()
+        for unit in self.units:
+            if unit.name.casefold() == normalized:
+                return unit
+        raise KeyError(name)
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "project_id": self.project_id,
+            "project_name": self.project_name,
+            "unit_count": self.unit_count,
+            "include_file_count": self.include_file_count,
+            "total_loc": self.total_loc,
+            "include_loc": self.include_loc,
+            "total_loc_with_includes": self.total_loc_with_includes,
+            "lines": self.lines.to_mapping(),
+            "cyclomatic": self.cyclomatic.to_mapping(),
+            "halstead": self.halstead.to_mapping(),
+            "maintainability_index": self.maintainability_index,
+            "dependency_edges": self.dependency_edges,
+            "problems": [problem.to_mapping() for problem in self.problems],
+        }
+
+
+@dataclass(frozen=True)
+class _ScanResult:
+    lines: LineMetrics
+    operator_vocabulary: frozenset[str]
+    operand_vocabulary: frozenset[str]
+    total_operators: int
+    total_operands: int
+
+
+def analyze_unit(
+    source: str,
+    path: str,
+    *,
+    defines: Iterable[str] = (),
+    include_paths: Iterable[str] = (),
+    include_loader: IncludeLoader | None = None,
+    parser_mode: ParserMode | str = ParserMode.STRICT,
+) -> UnitMetrics:
+    scan = _scan_source(source)
+    problems: list[MetricProblem] = []
+    root: SyntaxNode | None = None
+    try:
+        parsed = DelphiParser(
+            defines=tuple(defines),
+            include_paths=tuple(include_paths),
+            include_loader=include_loader,
+            mode=normalize_mode(parser_mode),
+        ).parse(
+            source,
+            path,
+            build_semantic=False,
+            build_source_map=False,
+            build_expressions=False,
+            build_node_positions=False,
+            build_comments=False,
+        )
+        root = parsed.root
+        if parsed.problems:
+            first = parsed.problems[0]
+            problems.append(
+                MetricProblem(
+                    kind="partial_parse",
+                    path=path,
+                    message=(
+                        f"Partial DelphiAST parse at {first.line}:{first.column}: "
+                        f"{first.message}"
+                    ),
+                )
+            )
+    except DelphiParseError as error:
+        problems.append(
+            MetricProblem(
+                kind="partial_parse",
+                path=path,
+                message=f"Recovered from strict parse failure: {error}",
+            )
+        )
+        try:
+            parsed = DelphiParser(
+                defines=tuple(defines),
+                include_paths=tuple(include_paths),
+                include_loader=include_loader,
+                mode=ParserMode.TOLERANT,
+                legacy_fallback_max_chars=0,
+            ).parse(
+                source,
+                path,
+                build_semantic=False,
+                build_source_map=False,
+                build_expressions=False,
+                build_node_positions=False,
+                build_comments=False,
+            )
+            root = parsed.root
+        except Exception as recovery_error:
+            problems.append(
+                MetricProblem(
+                    kind="parse_error",
+                    path=path,
+                    message=(
+                        "Could not recover source "
+                        f"({type(recovery_error).__name__})."
+                    ),
+                )
+            )
+    except Exception as error:
+        problems.append(
+            MetricProblem(
+                kind="parse_error",
+                path=path,
+                message=f"Could not parse source ({type(error).__name__}).",
+            )
+        )
+
+    name = Path(path).stem
+    dependencies: tuple[str, ...] = ()
+    cyclomatic = CyclomaticMetrics()
+    symbol_counts: Counter[str] = Counter()
+    class_like_types = 0
+    abstract_types = 0
+    if root is not None:
+        name = root.get_attribute(AttributeName.anName) or name
+        dependencies = _dependencies(root)
+        cyclomatic = _cyclomatic_metrics(root)
+        class_like_types, abstract_types = _abstract_type_counts(root)
+        symbol_counts = _syntax_symbol_counts(root)
+
+    halstead = _halstead_metrics(
+        operator_vocabulary=scan.operator_vocabulary,
+        operand_vocabulary=scan.operand_vocabulary,
+        total_operators=scan.total_operators,
+        total_operands=scan.total_operands,
+    )
+    abstractness = abstract_types / class_like_types if class_like_types else 0.0
+    maintainability = _maintainability_index(
+        volume=halstead.volume,
+        complexity=cyclomatic.total,
+        source_lines=scan.lines.source_lines,
+        routine_count=cyclomatic.routine_count,
+    )
+    return UnitMetrics(
+        name=name,
+        path=path,
+        lines=scan.lines,
+        cyclomatic=cyclomatic,
+        halstead=halstead,
+        maintainability_index=maintainability,
+        symbol_counts=dict(sorted(symbol_counts.items())),
+        dependencies=dependencies,
+        class_like_types=class_like_types,
+        abstract_types=abstract_types,
+        abstractness=abstractness,
+        distance=abs(abstractness - 1.0),
+        problems=tuple(problems),
+        _operator_vocabulary=scan.operator_vocabulary,
+        _operand_vocabulary=scan.operand_vocabulary,
+    )
+
+
+def analyze_include(source: str, path: str) -> UnitMetrics:
+    """Measure a standalone include fragment without invoking the parser."""
+
+    scan = _scan_source(source, collect_tokens=False)
+    halstead = HalsteadMetrics()
+    return UnitMetrics(
+        name=Path(path).name,
+        path=path,
+        lines=scan.lines,
+        cyclomatic=CyclomaticMetrics(),
+        halstead=halstead,
+        maintainability_index=_maintainability_index(
+            volume=halstead.volume,
+            complexity=0,
+            source_lines=scan.lines.source_lines,
+            routine_count=0,
+        ),
+        symbol_counts={},
+    )
+
+
+def analyze_project(
+    sources: Mapping[str, str],
+    *,
+    include_sources: Mapping[str, str] | None = None,
+    defines: Iterable[str] = (),
+    include_paths: Iterable[str] = (),
+    project_id: str = "",
+    project_name: str = "",
+    unit_ids: Mapping[str, str] | None = None,
+    parser_mode: ParserMode | str | None = None,
+) -> ProjectMetrics:
+    unique_sources = _unique_sources(sources)
+    if parser_mode is None:
+        source_chars = sum(len(source) for source in unique_sources.values())
+        selected_mode = (
+            ParserMode.TOLERANT
+            if len(unique_sources) >= _LARGE_PROJECT_UNIT_THRESHOLD
+            or source_chars >= _LARGE_PROJECT_CHAR_THRESHOLD
+            else ParserMode.STRICT
+        )
+    else:
+        selected_mode = normalize_mode(parser_mode)
+    units = [
+        analyze_unit(
+            source,
+            path,
+            defines=defines,
+            include_paths=include_paths,
+            parser_mode=selected_mode,
+        )
+        for path, source in unique_sources.items()
+    ]
+    unique_includes = _unique_sources(include_sources or {})
+    include_metrics = tuple(
+        analyze_include(source, path)
+        for path, source in unique_includes.items()
+    )
+    include_loc = sum(item.lines.total_lines for item in include_metrics)
+    return aggregate_project_metrics(
+        units,
+        include_loc=include_loc,
+        include_metrics=include_metrics,
+        project_id=project_id,
+        project_name=project_name,
+        unit_ids=unit_ids,
+    )
+
+
+def aggregate_project_metrics(
+    analyzed_units: Iterable[UnitMetrics],
+    *,
+    include_loc: int = 0,
+    include_metrics: Iterable[UnitMetrics] = (),
+    project_id: str = "",
+    project_name: str = "",
+    unit_ids: Mapping[str, str] | None = None,
+) -> ProjectMetrics:
+    units = list(analyzed_units)
+    include_items = tuple(
+        sorted(
+            include_metrics,
+            key=lambda item: (
+                item.name.casefold(),
+                item.path.casefold(),
+                item.name,
+                item.path,
+            ),
+        )
+    )
+    units.sort(
+        key=lambda item: (
+            item.name.casefold(),
+            item.path.casefold(),
+            item.name,
+            item.path,
+        )
+    )
+
+    canonical_units: dict[str, UnitMetrics] = {}
+    for unit in units:
+        canonical_units.setdefault(unit.name.casefold(), unit)
+
+    reverse_edges: dict[str, set[str]] = {name: set() for name in canonical_units}
+    dependencies_by_unit: dict[str, tuple[tuple[str, ...], tuple[str, ...]]] = {}
+    dependency_edges = 0
+    for unit in units:
+        internal: dict[str, str] = {}
+        external: dict[str, str] = {}
+        for dependency in unit.dependencies:
+            normalized_dependency = dependency.casefold()
+            if normalized_dependency == unit.name.casefold():
+                continue
+            if normalized_dependency in canonical_units:
+                canonical_name = canonical_units[normalized_dependency].name
+                internal.setdefault(normalized_dependency, canonical_name)
+                reverse_edges[normalized_dependency].add(unit.name.casefold())
+            else:
+                external.setdefault(normalized_dependency, dependency)
+        internal_values = tuple(sorted(internal.values(), key=lambda value: (value.casefold(), value)))
+        external_values = tuple(sorted(external.values(), key=lambda value: (value.casefold(), value)))
+        dependencies_by_unit[unit.path] = (internal_values, external_values)
+        dependency_edges += len(internal_values) + len(external_values)
+
+    operator_vocabulary = frozenset().union(
+        *(unit._operator_vocabulary for unit in units)
+    )
+    operand_vocabulary = frozenset().union(
+        *(unit._operand_vocabulary for unit in units)
+    )
+    total_operators = sum(unit.halstead.total_operators for unit in units)
+    total_operands = sum(unit.halstead.total_operands for unit in units)
+
+    enriched: list[UnitMetrics] = []
+    id_by_path = {path.casefold(): value for path, value in (unit_ids or {}).items()}
+    for unit in units:
+        internal, external = dependencies_by_unit[unit.path]
+        afferent = len(reverse_edges.get(unit.name.casefold(), ()))
+        efferent = len(internal) + len(external)
+        instability = efferent / (afferent + efferent) if afferent + efferent else 0.0
+        enriched.append(
+            replace(
+                unit,
+                internal_dependencies=internal,
+                external_dependencies=external,
+                afferent_coupling=afferent,
+                efferent_coupling=efferent,
+                instability=instability,
+                distance=abs(unit.abstractness + instability - 1.0),
+                unit_id=id_by_path.get(unit.path.casefold(), unit.unit_id),
+                _operator_vocabulary=frozenset(),
+                _operand_vocabulary=frozenset(),
+            )
+        )
+
+    line_metrics = _sum_line_metrics(unit.lines for unit in enriched)
+    routines = [routine for unit in enriched for routine in unit.cyclomatic.routines]
+    cyclomatic = CyclomaticMetrics.from_routines(routines)
+    halstead = _halstead_metrics(
+        operator_vocabulary=operator_vocabulary,
+        operand_vocabulary=operand_vocabulary,
+        total_operators=total_operators,
+        total_operands=total_operands,
+    )
+    maintainability = (
+        sum(
+            unit.maintainability_index * unit.lines.source_lines
+            for unit in enriched
+        )
+        / line_metrics.source_lines
+        if line_metrics.source_lines
+        else 100.0
+    )
+    problems = tuple(problem for unit in enriched for problem in unit.problems)
+    return ProjectMetrics(
+        units=tuple(enriched),
+        lines=line_metrics,
+        cyclomatic=cyclomatic,
+        halstead=halstead,
+        maintainability_index=maintainability,
+        total_loc=line_metrics.total_lines,
+        include_loc=include_loc,
+        total_loc_with_includes=line_metrics.total_lines + include_loc,
+        dependency_edges=dependency_edges,
+        problems=problems,
+        project_id=project_id,
+        project_name=project_name,
+        include_metrics=include_items,
+    )
+
+
+def _unique_sources(sources: Mapping[str, str]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    seen: set[str] = set()
+    for path, source in sorted(sources.items(), key=lambda item: (item[0].casefold(), item[0])):
+        normalized = str(Path(path)).replace("\\", "/").casefold()
+        if normalized in seen:
+            continue
+        seen.add(normalized)
+        result[path] = source
+    return result
+
+
+def _scan_source(source: str, *, collect_tokens: bool = True) -> _ScanResult:
+    if not collect_tokens:
+        return _scan_source_lines(source)
+
+    if len(source) <= _METRIC_TOKEN_FINDALL_LIMIT:
+        token_chunks = [(0, len(source))] if source else []
+        line_scan = _scan_source_lines(source)
+    else:
+        token_chunks = []
+        line_scan = _scan_source_lines(source, token_chunks=token_chunks)
+    token_pattern = _ASCII_METRIC_TOKEN_RE if source.isascii() else _METRIC_TOKEN_RE
+    operators: set[str] = set()
+    operands: set[str] = set()
+    total_operators = 0
+    total_operands = 0
+
+    def record_word(value: str, occurrences: int = 1) -> None:
+        nonlocal total_operators, total_operands
+        first = value[0]
+        if (
+            first == "&"
+            and len(value) > 1
+            and _identifier_start(value[1])
+            and "." not in value
+            and "+" not in value
+            and "-" not in value
+        ):
+            operands.add(value[1:].casefold())
+            total_operands += occurrences
+            return
+        if (
+            _identifier_start(first)
+            and "." not in value
+            and "+" not in value
+            and "-" not in value
+        ):
+            normalized = value.casefold()
+            if normalized in _KEYWORDS:
+                operators.add(normalized)
+                total_operators += occurrences
+            else:
+                operands.add(normalized)
+                total_operands += occurrences
+            return
+        if first.isdigit() or (
+            first in {"$", "%", "#"}
+            and len(value) > 1
+            and value[1].isalnum()
+        ):
+            operands.add(value.casefold())
+            total_operands += occurrences
+            return
+
+        index = 0
+        while index < len(value):
+            character = value[index]
+            if (
+                character == "&"
+                and index + 1 < len(value)
+                and _identifier_start(value[index + 1])
+            ):
+                identifier_tail = _IDENTIFIER_PART_RE.match(value, index + 2)
+                assert identifier_tail is not None
+                end = identifier_tail.end()
+                operands.add(value[index + 1 : end].casefold())
+                total_operands += occurrences
+                index = end
+                continue
+            if _identifier_start(character):
+                identifier_tail = _IDENTIFIER_PART_RE.match(value, index + 1)
+                assert identifier_tail is not None
+                end = identifier_tail.end()
+                record_word(value[index:end], occurrences)
+                index = end
+                continue
+            if character.isdigit() or (
+                character in {"$", "%", "#"}
+                and index + 1 < len(value)
+                and value[index + 1].isalnum()
+            ):
+                end = _number_end(value, index)
+                operands.add(value[index:end].casefold())
+                total_operands += occurrences
+                index = end
+                continue
+            pair = value[index : index + 2]
+            end = index + 2 if pair in _TWO_CHARACTER_OPERATORS else index + 1
+            operators.add(value[index:end].casefold())
+            total_operators += occurrences
+            index = end
+
+    token_counts: Counter[str] = Counter()
+    for start, end in token_chunks:
+        if end - start <= _METRIC_TOKEN_FINDALL_LIMIT:
+            token_counts.update(token_pattern.findall(source, start, end))
+        else:
+            token_counts.update(
+                match.group(1) or ""
+                for match in token_pattern.finditer(source, start, end)
+            )
+    token_counts.pop("", None)
+
+    for value, occurrences in token_counts.items():
+        if value.startswith("'"):
+            operands.add(value)
+            total_operands += occurrences
+            continue
+        first = value[0]
+        if first == "&" or first == "_" or first.isalnum() or first in {"$", "%", "#"}:
+            record_word(value, occurrences)
+            continue
+        operators.add(value.casefold())
+        total_operators += occurrences
+
+    return _ScanResult(
+        lines=line_scan.lines,
+        operator_vocabulary=frozenset(operators),
+        operand_vocabulary=frozenset(operands),
+        total_operators=total_operators,
+        total_operands=total_operands,
+    )
+
+
+def _scan_source_linear(source: str, *, collect_tokens: bool = True) -> _ScanResult:
+    if not collect_tokens:
+        return _scan_source_lines(source)
+    line_count = len(source.splitlines()) if source else 0
+    has_code = [False] * line_count
+    has_comment = [False] * line_count
+    has_directive = [False] * line_count
+    operators: set[str] = set()
+    operands: set[str] = set()
+    total_operators = 0
+    total_operands = 0
+    current_line = 0
+
+    def mark_line(flags: list[bool]) -> None:
+        if current_line < len(flags):
+            flags[current_line] = True
+
+    def mark_span(flags: list[bool], start: int, end: int) -> None:
+        nonlocal current_line
+        if not flags or end <= start:
+            return
+        newline_count = _line_break_count(source, start, end)
+        end_line = current_line + newline_count
+        if source[end - 1] in {"\r", "\n"}:
+            end_line -= 1
+        for line in range(current_line, min(end_line, len(flags) - 1) + 1):
+            flags[line] = True
+        current_line += newline_count
+
+    index = 0
+    length = len(source)
+    while index < length:
+        character = source[index]
+        if character.isspace():
+            whitespace = _WHITESPACE_RE.match(source, index)
+            assert whitespace is not None
+            end = whitespace.end()
+            current_line += _line_break_count(source, index, end)
+            index = end
+            continue
+        if source.startswith("//", index):
+            end = _line_ending_start(source, index + 2)
+            mark_span(has_comment, index, end)
+            index = end
+            continue
+        if character == "{":
+            close = source.find("}", index + 1)
+            end = length if close < 0 else close + 1
+            directive = index + 1 < length and source[index + 1] == "$"
+            mark_span(has_directive if directive else has_comment, index, end)
+            index = end
+            continue
+        if source.startswith("(*", index):
+            close = source.find("*)", index + 2)
+            end = length if close < 0 else close + 2
+            directive = index + 2 < length and source[index + 2] == "$"
+            mark_span(has_directive if directive else has_comment, index, end)
+            index = end
+            continue
+        if character == "'":
+            end = _quoted_end(source, index)
+            mark_span(has_code, index, end)
+            if collect_tokens:
+                operands.add(source[index:end])
+                total_operands += 1
+            index = end
+            continue
+        if character == "&" and index + 1 < length and _identifier_start(source[index + 1]):
+            end = index + 2
+            identifier_tail = _IDENTIFIER_PART_RE.match(source, end)
+            assert identifier_tail is not None
+            end = identifier_tail.end()
+            mark_line(has_code)
+            if collect_tokens:
+                operands.add(source[index + 1 : end].casefold())
+                total_operands += 1
+            index = end
+            continue
+        if _identifier_start(character):
+            end = index + 1
+            identifier_tail = _IDENTIFIER_PART_RE.match(source, end)
+            assert identifier_tail is not None
+            end = identifier_tail.end()
+            value = source[index:end].casefold()
+            mark_line(has_code)
+            if collect_tokens:
+                if value in _KEYWORDS:
+                    operators.add(value)
+                    total_operators += 1
+                else:
+                    operands.add(value)
+                    total_operands += 1
+            index = end
+            continue
+        if character.isdigit() or (
+            character in {"$", "%", "#"}
+            and index + 1 < length
+            and source[index + 1].isalnum()
+        ):
+            end = _number_end(source, index)
+            mark_line(has_code)
+            if collect_tokens:
+                operands.add(source[index:end].casefold())
+                total_operands += 1
+            index = end
+            continue
+        pair = source[index : index + 2]
+        end = index + 2 if pair in _TWO_CHARACTER_OPERATORS else index + 1
+        value = source[index:end]
+        mark_line(has_code)
+        if collect_tokens:
+            operators.add(value.casefold())
+            total_operators += 1
+        index = end
+
+    source_lines = 0
+    blank_lines = 0
+    comment_only_lines = 0
+    for line in range(line_count):
+        if has_code[line]:
+            source_lines += 1
+        elif has_directive[line]:
+            continue
+        elif has_comment[line]:
+            comment_only_lines += 1
+        else:
+            blank_lines += 1
+    lines = LineMetrics(
+        total_lines=line_count,
+        source_lines=source_lines,
+        blank_lines=blank_lines,
+        comment_only_lines=comment_only_lines,
+        comment_lines=sum(has_comment),
+        directive_lines=sum(has_directive),
+    )
+    return _ScanResult(
+        lines=lines,
+        operator_vocabulary=frozenset(operators),
+        operand_vocabulary=frozenset(operands),
+        total_operators=total_operators,
+        total_operands=total_operands,
+    )
+
+
+def _scan_source_lines(
+    source: str,
+    *,
+    token_chunks: list[tuple[int, int]] | None = None,
+) -> _ScanResult:
+    line_count = len(source.splitlines()) if source else 0
+    line_states = bytearray(line_count)
+    current_line = 0
+
+    def mark_span(flag: int, start: int, end: int) -> None:
+        nonlocal current_line
+        if not line_states or end <= start:
+            return
+        newline_count = _line_break_count(source, start, end)
+        end_line = current_line + newline_count
+        if source[end - 1] in {"\r", "\n"}:
+            end_line -= 1
+        for line in range(current_line, min(end_line, len(line_states) - 1) + 1):
+            line_states[line] |= flag
+        current_line += newline_count
+
+    index = 0
+    length = len(source)
+    chunk_start = 0
+    while index < length:
+        match = _LINE_SCAN_SPECIAL_RE.search(source, index)
+        special_start = match.start() if match is not None else length
+        if (
+            current_line < line_count
+            and _NON_WHITESPACE_RE.search(source, index, special_start) is not None
+        ):
+            line_states[current_line] |= 1
+        if match is None:
+            break
+        marker = match.group()
+        index = special_start
+        if marker in {"\r", "\n", "\r\n"}:
+            current_line += 1
+            index = match.end()
+            if (
+                token_chunks is not None
+                and index - chunk_start >= _METRIC_TOKEN_CHUNK_TARGET
+            ):
+                token_chunks.append((chunk_start, index))
+                chunk_start = index
+            continue
+        if marker == "//":
+            end = _line_ending_start(source, index + 2)
+            mark_span(2, index, end)
+            index = end
+            continue
+        if marker == "{":
+            close = source.find("}", index + 1)
+            end = length if close < 0 else close + 1
+            directive = index + 1 < length and source[index + 1] == "$"
+            mark_span(4 if directive else 2, index, end)
+            index = end
+            continue
+        if marker == "(*":
+            close = source.find("*)", index + 2)
+            end = length if close < 0 else close + 2
+            directive = index + 2 < length and source[index + 2] == "$"
+            mark_span(4 if directive else 2, index, end)
+            index = end
+            continue
+        end = _quoted_end(source, index)
+        mark_span(1, index, end)
+        index = end
+
+    if token_chunks is not None and chunk_start < length:
+        token_chunks.append((chunk_start, length))
+
+    source_lines = 0
+    blank_lines = 0
+    comment_only_lines = 0
+    for state in line_states:
+        if state & 1:
+            source_lines += 1
+        elif state & 4:
+            continue
+        elif state & 2:
+            comment_only_lines += 1
+        else:
+            blank_lines += 1
+    return _ScanResult(
+        lines=LineMetrics(
+            total_lines=line_count,
+            source_lines=source_lines,
+            blank_lines=blank_lines,
+            comment_only_lines=comment_only_lines,
+            comment_lines=sum(bool(state & 2) for state in line_states),
+            directive_lines=sum(bool(state & 4) for state in line_states),
+        ),
+        operator_vocabulary=frozenset(),
+        operand_vocabulary=frozenset(),
+        total_operators=0,
+        total_operands=0,
+    )
+
+
+def _line_break_count(source: str, start: int, end: int) -> int:
+    return (
+        source.count("\r", start, end)
+        + source.count("\n", start, end)
+        - source.count("\r\n", start, end)
+    )
+
+
+def _line_ending_start(source: str, start: int) -> int:
+    carriage_return = source.find("\r", start)
+    line_feed = source.find("\n", start)
+    candidates = [
+        position
+        for position in (carriage_return, line_feed)
+        if position >= 0
+    ]
+    return min(candidates, default=len(source))
+
+
+def _quoted_end(source: str, start: int) -> int:
+    index = start + 1
+    while index < len(source):
+        if source[index] != "'":
+            index += 1
+            continue
+        if index + 1 < len(source) and source[index + 1] == "'":
+            index += 2
+            continue
+        return index + 1
+    return len(source)
+
+
+def _number_end(source: str, start: int) -> int:
+    index = start + 1
+    while index < len(source):
+        character = source[index]
+        if character.isalnum() or character in {"_", "."}:
+            if source.startswith("..", index):
+                break
+            index += 1
+            continue
+        if character in {"+", "-"} and index > start and source[index - 1].casefold() == "e":
+            index += 1
+            continue
+        break
+    return index
+
+
+def _identifier_start(character: str) -> bool:
+    return character == "_" or character.isalpha()
+
+
+def _identifier_part(character: str) -> bool:
+    return character == "_" or character.isalnum()
+
+
+def _walk(node: SyntaxNode) -> Iterable[SyntaxNode]:
+    pending = [node]
+    while pending:
+        current = pending.pop()
+        yield current
+        pending.extend(reversed(current.child_nodes))
+
+
+def _dependencies(root: SyntaxNode) -> tuple[str, ...]:
+    dependencies: dict[str, str] = {}
+    for node in _walk(root):
+        if node.typ not in _DEPENDENCY_NODES:
+            continue
+        for child in node.child_nodes:
+            if child.typ != SyntaxNodeType.ntUnit:
+                continue
+            name = child.get_attribute(AttributeName.anName).strip()
+            if name:
+                dependencies.setdefault(name.casefold(), name)
+    return tuple(sorted(dependencies.values(), key=lambda value: (value.casefold(), value)))
+
+
+def _cyclomatic_metrics(root: SyntaxNode) -> CyclomaticMetrics:
+    routines: list[RoutineComplexity] = []
+    for node in _walk(root):
+        if node.typ != SyntaxNodeType.ntMethod:
+            continue
+        if not any(child.typ == SyntaxNodeType.ntStatements for child in node.child_nodes):
+            continue
+        name = node.get_attribute(AttributeName.anName) or f"anonymous@{node.line}"
+        routines.append(
+            RoutineComplexity(
+                name=name,
+                value=1 + _decision_count(node),
+                line=node.line,
+            )
+        )
+    return CyclomaticMetrics.from_routines(routines)
+
+
+def _decision_count(node: SyntaxNode) -> int:
+    count = 0
+    pending = list(reversed(node.child_nodes))
+    while pending:
+        child = pending.pop()
+        if child.typ == SyntaxNodeType.ntMethod:
+            continue
+        if child.typ in _DECISION_NODES:
+            count += 1
+        if child.typ == SyntaxNodeType.ntExcept and not any(
+            descendant.typ == SyntaxNodeType.ntExceptionHandler
+            for descendant in child.child_nodes
+        ):
+            count += 1
+        pending.extend(reversed(child.child_nodes))
+    return count
+
+
+def _syntax_symbol_counts(root: SyntaxNode) -> Counter[str]:
+    counts: Counter[str] = Counter()
+    pending = [root]
+    while pending:
+        node = pending.pop()
+        if node.typ == SyntaxNodeType.ntUses:
+            continue
+        if node.typ == SyntaxNodeType.ntTypeSection:
+            for child in node.child_nodes:
+                if child.typ == SyntaxNodeType.ntTypeDecl:
+                    _count_syntax_type_declaration(child, counts, pending)
+            continue
+        if node.typ == SyntaxNodeType.ntVariables:
+            _count_named_children(
+                node,
+                SyntaxNodeType.ntVariable,
+                SymbolKind.VARIABLE,
+                counts,
+            )
+            continue
+        if node.typ == SyntaxNodeType.ntVariable:
+            _count_named_declaration(node, SymbolKind.VARIABLE, counts)
+            continue
+        if node.typ == SyntaxNodeType.ntConstants:
+            _count_named_children(
+                node,
+                SyntaxNodeType.ntConstant,
+                SymbolKind.CONSTANT,
+                counts,
+            )
+            continue
+        if node.typ == SyntaxNodeType.ntMethod:
+            _count_syntax_method(node, counts, pending)
+            continue
+        if node.typ == SyntaxNodeType.ntProperty:
+            _count_named_declaration(node, SymbolKind.PROPERTY, counts)
+            continue
+        if node.typ == SyntaxNodeType.ntField:
+            _count_named_declaration(node, SymbolKind.FIELD, counts)
+            continue
+        if node.typ == SyntaxNodeType.ntLabel:
+            _count_named_declaration(node, SymbolKind.LABEL, counts)
+            continue
+        pending.extend(reversed(node.child_nodes))
+    return counts
+
+
+def _count_syntax_type_declaration(
+    node: SyntaxNode,
+    counts: Counter[str],
+    pending: list[SyntaxNode],
+) -> None:
+    if not _syntax_declaration_name(node):
+        return
+    type_node = node.find_node(SyntaxNodeType.ntType)
+    counts[_syntax_type_symbol_kind(node).value] += 1
+    type_parameters = node.find_node(SyntaxNodeType.ntTypeParams)
+    if type_parameters is not None:
+        _count_named_children(
+            type_parameters,
+            SyntaxNodeType.ntTypeParam,
+            SymbolKind.TYPE_PARAMETER,
+            counts,
+        )
+    if type_node is None:
+        return
+    if type_node.get_attribute(AttributeName.anName) == "enum":
+        _count_named_children(
+            type_node,
+            SyntaxNodeType.ntEnum,
+            SymbolKind.ENUM_VALUE,
+            counts,
+        )
+    pending.extend(reversed(type_node.child_nodes))
+
+
+def _count_syntax_method(
+    node: SyntaxNode,
+    counts: Counter[str],
+    pending: list[SyntaxNode],
+) -> None:
+    if not _syntax_declaration_name(node):
+        return
+    counts[_syntax_method_symbol_kind(node).value] += 1
+    parameters = node.find_node(SyntaxNodeType.ntParameters)
+    if parameters is not None:
+        _count_named_children(
+            parameters,
+            SyntaxNodeType.ntParameter,
+            SymbolKind.PARAMETER,
+            counts,
+        )
+    type_parameters = node.find_node(SyntaxNodeType.ntTypeParams)
+    if type_parameters is not None:
+        _count_named_children(
+            type_parameters,
+            SyntaxNodeType.ntTypeParam,
+            SymbolKind.TYPE_PARAMETER,
+            counts,
+        )
+    excluded = {
+        SyntaxNodeType.ntParameters,
+        SyntaxNodeType.ntReturnType,
+        SyntaxNodeType.ntTypeParams,
+    }
+    pending.extend(
+        child
+        for child in reversed(node.child_nodes)
+        if child.typ not in excluded
+    )
+
+
+def _count_named_children(
+    node: SyntaxNode,
+    child_type: SyntaxNodeType,
+    kind: SymbolKind,
+    counts: Counter[str],
+) -> None:
+    for child in node.child_nodes:
+        if child.typ == child_type:
+            _count_named_declaration(child, kind, counts)
+
+
+def _count_named_declaration(
+    node: SyntaxNode,
+    kind: SymbolKind,
+    counts: Counter[str],
+) -> None:
+    if _syntax_declaration_name(node):
+        counts[kind.value] += 1
+
+
+def _syntax_type_symbol_kind(node: SyntaxNode) -> SymbolKind:
+    type_node = node.find_node(SyntaxNodeType.ntType)
+    if type_node is None:
+        return SymbolKind.TYPE
+    type_tag = type_node.get_attribute(AttributeName.anType)
+    name_tag = type_node.get_attribute(AttributeName.anName)
+    if type_tag == "class":
+        return SymbolKind.CLASS
+    if type_tag == "record":
+        return SymbolKind.RECORD
+    if type_tag in {"interface", "dispinterface"}:
+        return SymbolKind.INTERFACE
+    if name_tag == "enum":
+        return SymbolKind.ENUM
+    return SymbolKind.TYPE
+
+
+def _syntax_method_symbol_kind(node: SyntaxNode) -> SymbolKind:
+    return {
+        "function": SymbolKind.FUNCTION,
+        "procedure": SymbolKind.PROCEDURE,
+        "constructor": SymbolKind.CONSTRUCTOR,
+        "destructor": SymbolKind.DESTRUCTOR,
+    }.get(node.get_attribute(AttributeName.anKind), SymbolKind.METHOD)
+
+
+def _syntax_declaration_name(node: SyntaxNode) -> str:
+    if isinstance(node, ValuedSyntaxNode):
+        return node.value
+    name = node.get_attribute(AttributeName.anName)
+    if name:
+        return name
+    for child in node.child_nodes:
+        if child.typ != SyntaxNodeType.ntName:
+            continue
+        if isinstance(child, ValuedSyntaxNode):
+            return child.value
+        return child.get_attribute(AttributeName.anName)
+    return ""
+
+
+def _abstract_type_counts(root: SyntaxNode) -> tuple[int, int]:
+    class_like = 0
+    abstract = 0
+    for node in _walk(root):
+        if node.typ != SyntaxNodeType.ntTypeDecl:
+            continue
+        type_node = next(
+            (child for child in node.child_nodes if child.typ == SyntaxNodeType.ntType),
+            None,
+        )
+        if type_node is None:
+            continue
+        kind = type_node.get_attribute(AttributeName.anType).casefold()
+        if kind not in {"class", "interface", "dispinterface"}:
+            continue
+        class_like += 1
+        has_abstract_method = any(
+            child.typ == SyntaxNodeType.ntMethod
+            and child.get_attribute(AttributeName.anAbstract) == "true"
+            for child in _walk(type_node)
+        )
+        if kind in {"interface", "dispinterface"} or (
+            type_node.get_attribute(AttributeName.anAbstract) == "true"
+            or has_abstract_method
+        ):
+            abstract += 1
+    return class_like, abstract
+
+
+def _halstead_metrics(
+    *,
+    operator_vocabulary: frozenset[str],
+    operand_vocabulary: frozenset[str],
+    total_operators: int,
+    total_operands: int,
+) -> HalsteadMetrics:
+    distinct_operators = len(operator_vocabulary)
+    distinct_operands = len(operand_vocabulary)
+    vocabulary = distinct_operators + distinct_operands
+    length = total_operators + total_operands
+    calculated_length = _halstead_term(distinct_operators) + _halstead_term(distinct_operands)
+    volume = length * math.log2(vocabulary) if vocabulary > 1 else 0.0
+    difficulty = (
+        (distinct_operators / 2.0) * (total_operands / distinct_operands)
+        if distinct_operands
+        else 0.0
+    )
+    effort = difficulty * volume
+    return HalsteadMetrics(
+        distinct_operators=distinct_operators,
+        distinct_operands=distinct_operands,
+        total_operators=total_operators,
+        total_operands=total_operands,
+        vocabulary=vocabulary,
+        length=length,
+        calculated_length=calculated_length,
+        volume=volume,
+        difficulty=difficulty,
+        effort=effort,
+        estimated_time_seconds=effort / 18.0,
+        estimated_defects=volume / 3000.0,
+    )
+
+
+def _halstead_term(value: int) -> float:
+    return value * math.log2(value) if value > 1 else 0.0
+
+
+def _maintainability_index(
+    *,
+    volume: float,
+    complexity: int,
+    source_lines: int,
+    routine_count: int,
+) -> float:
+    if source_lines == 0:
+        return 100.0
+    divisor = max(1, routine_count)
+    raw = (
+        171.0
+        - 5.2 * math.log10(max(volume / divisor, 1.0))
+        - 0.23 * complexity / divisor
+        - 16.2 * math.log10(max(source_lines / divisor, 1.0))
+    ) * 100.0 / 171.0
+    return min(100.0, max(0.0, raw))
+
+
+def _sum_line_metrics(metrics: Iterable[LineMetrics]) -> LineMetrics:
+    items = tuple(metrics)
+    return LineMetrics(
+        total_lines=sum(item.total_lines for item in items),
+        source_lines=sum(item.source_lines for item in items),
+        blank_lines=sum(item.blank_lines for item in items),
+        comment_only_lines=sum(item.comment_only_lines for item in items),
+        comment_lines=sum(item.comment_lines for item in items),
+        directive_lines=sum(item.directive_lines for item in items),
+    )
+
+
+__all__ = [
+    "CyclomaticMetrics",
+    "HalsteadMetrics",
+    "LineMetrics",
+    "MetricProblem",
+    "ProjectMetrics",
+    "RoutineComplexity",
+    "UnitMetrics",
+    "aggregate_project_metrics",
+    "analyze_include",
+    "analyze_project",
+    "analyze_unit",
+]