@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/cpp/CppAdapter.js

@@ -1,707 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CppAdapter = void 0;
-const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
-const typia_1 = __importDefault(require("typia"));
-const EvidenceInventory_1 = require("../../graph/EvidenceInventory");
-const EvidenceParser_1 = require("../../parsers/EvidenceParser");
-const EvidenceParserError_1 = require("../../parsers/EvidenceParserError");
-const EvidenceTagParser_1 = require("../../parsers/EvidenceTagParser");
-const CppDocumentation_1 = require("./CppDocumentation");
-const CppFileScanner_1 = require("./CppFileScanner");
-/**
- * Reconciles C++ declaration families, public aliases, and documentation ownership.
- *
- * The scanner records lexical declarations and qualified definitions before the
- * snapshot-wide materializer decides which occurrences belong to one unit.
- * Alias resolution can then project public paths without changing canonical
- * identity. Documentation is attached only after those relationships are known.
- *
- * The pipeline carries conflicts and unsupported source forms into incomplete
- * output. It does not replace C++ lookup, preprocessing, or instantiation with
- * name-based guesses merely to produce a smaller public inventory.
- */
-class CppAdapter {
-    /**
-     * C++ artifact discriminator used by the public adapter.
-     *
-     * The configured type selects C++ grammar and ownership policy even for header
-     * extensions also accepted by C; extension overlap does not choose semantics.
-     */
-    type = "cpp";
-    /**
-     * Builds a C++ inventory from an owned copy of the source snapshot.
-     *
-     * Parsing precedes declaration and alias reconciliation, followed by annotation
-     * materialization and common inventory validation. Failures retain diagnostics,
-     * and the invocation's parser closes regardless of the extraction outcome.
-     */
-    async analyze(snapshot) {
-        const input = structuredClone((() => {
-            const _ip0 = input => "string" === typeof input["absolute"];
-            const _ip1 = input => "string" === typeof input["display"];
-            const _ip2 = input => "string" === typeof input["path"];
-            const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["absolute"] || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".absolute",
-                expected: "string",
-                value: input["absolute"]
-            }, _errorFactory);
-            const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["display"] || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".display",
-                expected: "string",
-                value: input["display"]
-            }, _errorFactory);
-            const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".path",
-                expected: "string",
-                value: input["path"]
-            }, _errorFactory);
-            const _ae0 = "(\"case-mismatch\" | \"invalid-encoding\" | \"not-file\" | \"path-unreadable\" | \"root-unreadable\" | \"source-changed\" | \"symlink-cycle\")";
-            const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.root && null !== input.root || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".root",
-                expected: "IEvidenceSourceRoot",
-                value: input.root
-            }, _errorFactory)) && _ao1(input.root, _path + ".root", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".root",
-                expected: "IEvidenceSourceRoot",
-                value: input.root
-            }, _errorFactory)) && ((Array.isArray(input.files) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".files",
-                expected: "Array<IEvidenceSourceFile>",
-                value: input.files
-            }, _errorFactory)) && input.files.every((elem, _index5) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".files[" + _index5 + "]",
-                expected: "IEvidenceSourceFile",
-                value: elem
-            }, _errorFactory)) && _ao2(elem, _path + ".files[" + _index5 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".files[" + _index5 + "]",
-                expected: "IEvidenceSourceFile",
-                value: elem
-            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".files",
-                expected: "Array<IEvidenceSourceFile>",
-                value: input.files
-            }, _errorFactory)) && ((Array.isArray(input.dependencies) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".dependencies",
-                expected: "Array<IEvidenceSourceDependency>",
-                value: input.dependencies
-            }, _errorFactory)) && input.dependencies.every((elem, _index6) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".dependencies[" + _index6 + "]",
-                expected: "IEvidenceSourceDependency",
-                value: elem
-            }, _errorFactory)) && _ao4(elem, _path + ".dependencies[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".dependencies[" + _index6 + "]",
-                expected: "IEvidenceSourceDependency",
-                value: elem
-            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".dependencies",
-                expected: "Array<IEvidenceSourceDependency>",
-                value: input.dependencies
-            }, _errorFactory)) && ((Array.isArray(input.diagnostics) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".diagnostics",
-                expected: "Array<IEvidenceSourceDiagnostic>",
-                value: input.diagnostics
-            }, _errorFactory)) && input.diagnostics.every((elem, _index7) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".diagnostics[" + _index7 + "]",
-                expected: "IEvidenceSourceDiagnostic",
-                value: elem
-            }, _errorFactory)) && _ao5(elem, _path + ".diagnostics[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".diagnostics[" + _index7 + "]",
-                expected: "IEvidenceSourceDiagnostic",
-                value: elem
-            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".diagnostics",
-                expected: "Array<IEvidenceSourceDiagnostic>",
-                value: input.diagnostics
-            }, _errorFactory)) && ("boolean" === typeof input.complete || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".complete",
-                expected: "boolean",
-                value: input.complete
-            }, _errorFactory));
-            const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.declared || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".declared",
-                expected: "string",
-                value: input.declared
-            }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.physical || "string" === typeof input.physical || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".physical",
-                expected: "(string | undefined)",
-                value: input.physical
-            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
-            const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".id",
-                expected: "string",
-                value: input.id
-            }, _errorFactory)) && ("string" === typeof input.physicalPath || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".physicalPath",
-                expected: "string",
-                value: input.physicalPath
-            }, _errorFactory)) && ("string" === typeof input.content || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".content",
-                expected: "string",
-                value: input.content
-            }, _errorFactory)) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".digest",
-                expected: "string",
-                value: input.digest
-            }, _errorFactory)) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".addresses",
-                expected: "Array<IEvidenceSourceAddress>",
-                value: input.addresses
-            }, _errorFactory)) && input.addresses.every((elem, _index8) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".addresses[" + _index8 + "]",
-                expected: "IEvidenceSourceAddress",
-                value: elem
-            }, _errorFactory)) && _ao3(elem, _path + ".addresses[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".addresses[" + _index8 + "]",
-                expected: "IEvidenceSourceAddress",
-                value: elem
-            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".addresses",
-                expected: "Array<IEvidenceSourceAddress>",
-                value: input.addresses
-            }, _errorFactory));
-            const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.relative || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".relative",
-                expected: "string",
-                value: input.relative
-            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.selected || "boolean" === typeof input.selected || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".selected",
-                expected: "(boolean | undefined)",
-                value: input.selected
-            }, _errorFactory));
-            const _ao4 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && ("boolean" === typeof input.recursive || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".recursive",
-                expected: "boolean",
-                value: input.recursive
-            }, _errorFactory));
-            const _ao5 = (input, _path, _exceptionable = true) => ("case-mismatch" === input.code || "invalid-encoding" === input.code || "not-file" === input.code || "path-unreadable" === input.code || "root-unreadable" === input.code || "source-changed" === input.code || "symlink-cycle" === input.code || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".code",
-                expected: _ae0,
-                value: input.code
-            }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
-                method: "typia.assert",
-                path: _path + ".message",
-                expected: "string",
-                value: input.message
-            }, _errorFactory));
-            const _io0 = input => "object" === typeof input.root && null !== input.root && _io1(input.root) && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && "boolean" === typeof input.complete;
-            const _io1 = input => "string" === typeof input.declared && _ip0(input) && (undefined === input.physical || "string" === typeof input.physical) && _ip1(input);
-            const _io2 = input => "string" === typeof input.id && "string" === typeof input.physicalPath && "string" === typeof input.content && "string" === typeof input.digest && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io3(elem)));
-            const _io3 = input => _ip0(input) && "string" === typeof input.relative && _ip1(input) && (undefined === input.selected || "boolean" === typeof input.selected);
-            const _io4 = input => _ip2(input) && "boolean" === typeof input.recursive;
-            const _io5 = input => ("case-mismatch" === input.code || "invalid-encoding" === input.code || "not-file" === input.code || "path-unreadable" === input.code || "root-unreadable" === input.code || "source-changed" === input.code || "symlink-cycle" === input.code) && _ip2(input) && "string" === typeof input.message;
-            const __is = input => "object" === typeof input && null !== input && _io0(input);
-            let _errorFactory;
-            return (input, errorFactory) => {
-                if (false === __is(input)) {
-                    _errorFactory = errorFactory;
-                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
-                        method: "typia.assert",
-                        path: _path + "",
-                        expected: "IEvidenceSourceSnapshot",
-                        value: input
-                    }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
-                        method: "typia.assert",
-                        path: _path + "",
-                        expected: "IEvidenceSourceSnapshot",
-                        value: input
-                    }, _errorFactory))(input, "$input", true);
-                }
-                return input;
-            };
-        })()(snapshot));
-        const inventory = {
-            schemaVersion: 1,
-            sources: input.files,
-            annotationRanges: [],
-            units: [],
-            addresses: [],
-            hosts: [],
-            declarations: [],
-            reviews: [],
-            diagnostics: input.diagnostics.map((diagnostic) => ({
-                code: `source-${diagnostic.code}`,
-                severity: "error",
-                message: diagnostic.message,
-                repair: "Restore access to the selected C++ source before evaluating coverage.",
-                location: { file: diagnostic.path },
-            })),
-            dependencies: input.dependencies,
-            complete: input.complete,
-        };
-        const parser = new EvidenceParser_1.EvidenceParser();
-        try {
-            const analyses = await Promise.all(input.files.map((source) => this.scan(parser, source)));
-            for (const analysis of analyses) {
-                inventory.diagnostics.push(...analysis.diagnostics);
-                inventory.complete &&= analysis.complete;
-            }
-            // Qualified definitions and aliases need the complete selected declaration
-            // set before a documentation position can be assigned its semantic owners.
-            const published = this.materializeUnits(inventory, analyses);
-            this.materializeDocumentation(inventory, analyses, published);
-            return new EvidenceInventory_1.EvidenceInventory([inventory]).snapshot();
-        }
-        finally {
-            await parser.close();
-        }
-    }
-    async scan(parser, source) {
-        const file = source.addresses[0]?.relative ?? source.physicalPath;
-        try {
-            return await parser.parse({ type: "cpp", file, content: source.content }, (session) => new CppFileScanner_1.CppFileScanner(session, source).scan());
-        }
-        catch (cause) {
-            const parserError = cause instanceof EvidenceParserError_1.EvidenceParserError ? cause : undefined;
-            return {
-                source,
-                declarations: [],
-                aliases: [],
-                documentation: [],
-                diagnostics: [
-                    {
-                        code: `cpp-${parserError?.code ?? "parse-failed"}`,
-                        severity: "error",
-                        message: parserError?.message ??
-                            `C++ parsing failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-                        repair: "Correct the source or add adapter support before evaluating coverage.",
-                        location: {
-                            file: source.physicalPath,
-                            ...(parserError?.range === undefined
-                                ? {}
-                                : { range: parserError.range }),
-                        },
-                    },
-                ],
-                complete: false,
-            };
-        }
-    }
-    materializeUnits(inventory, analyses) {
-        const declarationAnalysis = new Map();
-        const groups = new Map();
-        for (const analysis of analyses)
-            for (const declaration of analysis.declarations) {
-                declarationAnalysis.set(declaration.id, analysis);
-                const id = this.unitId(declaration);
-                let group = groups.get(id);
-                if (group === undefined) {
-                    group = { id, declarations: [] };
-                    groups.set(id, group);
-                }
-                group.declarations.push(declaration);
-            }
-        const publicGroups = new Set();
-        for (const group of groups.values()) {
-            if (group.declarations.some((declaration) => declaration.visibility === "public"))
-                publicGroups.add(group.id);
-        }
-        for (const group of groups.values()) {
-            const qualified = group.declarations.filter((declaration) => declaration.visibility === "qualified");
-            if (qualified.length === 0 || publicGroups.has(group.id))
-                continue;
-            if (group.declarations.some((declaration) => declaration.visibility === "non-public"))
-                continue;
-            const first = qualified[0];
-            const analysis = first === undefined ? undefined : declarationAnalysis.get(first.id);
-            const parent = first?.parentIdentity === undefined
-                ? undefined
-                : groups.get(this.typeId(first.parentIdentity));
-            if (parent !== undefined &&
-                parent.declarations.every((declaration) => declaration.form === "namespace") &&
-                publicGroups.has(parent.id)) {
-                publicGroups.add(group.id);
-                continue;
-            }
-            if (first !== undefined && analysis !== undefined)
-                this.problem(inventory, analysis, "cpp-qualified-owner", `C++ qualified declaration '${first.identity.join(".")}' has no selected public member declaration that establishes its owner and access.`, "Select the declaring class or namespace source, or add semantic owner resolution before evaluating this definition.");
-        }
-        for (const group of groups.values())
-            if (publicGroups.has(group.id))
-                this.checkGroup(inventory, group, declarationAnalysis);
-        const published = new Map();
-        for (const group of groups.values())
-            if (publicGroups.has(group.id))
-                for (const declaration of group.declarations)
-                    if (declaration.visibility !== "non-public")
-                        published.set(declaration.id, group.id);
-        const units = new Map();
-        for (const group of groups.values()) {
-            if (!publicGroups.has(group.id))
-                continue;
-            const declarations = group.declarations.filter((declaration) => declaration.visibility !== "non-public");
-            const first = declarations[0];
-            if (first === undefined)
-                continue;
-            const parentId = first.parentIdentity === undefined
-                ? undefined
-                : publicGroups.has(this.typeId(first.parentIdentity))
-                    ? this.typeId(first.parentIdentity)
-                    : undefined;
-            const unit = {
-                id: group.id,
-                type: "cpp",
-                symbol: first.symbol,
-                identity: first.identity,
-                name: first.name,
-                sites: [],
-                withdrawals: [],
-                ...(parentId === undefined ? {} : { parentId }),
-            };
-            for (const declaration of declarations)
-                if (!unit.sites.some((site) => site.id === declaration.site.id))
-                    unit.sites.push(structuredClone(declaration.site));
-            units.set(unit.id, unit);
-        }
-        inventory.units.push(...units.values());
-        const addressOwners = new Map();
-        for (const analysis of analyses)
-            for (const declaration of analysis.declarations) {
-                const unitId = published.get(declaration.id);
-                if (unitId === undefined)
-                    continue;
-                for (const sourceAddress of analysis.source.addresses)
-                    for (const segments of declaration.addresses)
-                        this.addAddress(inventory, analysis, addressOwners, unitId, sourceAddress.absolute, segments);
-            }
-        const resolvedAliases = this.resolveAliases(inventory, analyses, units, published);
-        for (const resolved of resolvedAliases) {
-            const unit = units.get(resolved.target.id);
-            if (unit !== undefined &&
-                !unit.sites.some((site) => site.id === resolved.alias.site.id))
-                unit.sites.push(structuredClone(resolved.alias.site));
-            for (const sourceAddress of resolved.analysis.source.addresses)
-                for (const candidate of units.values()) {
-                    if (!prefix(candidate.identity, resolved.target.identity))
-                        continue;
-                    this.addAddress(inventory, resolved.analysis, addressOwners, candidate.id, sourceAddress.absolute, [
-                        ...resolved.alias.scopeAddress,
-                        resolved.alias.name,
-                        ...candidate.identity.slice(resolved.target.identity.length),
-                    ]);
-                }
-        }
-        return published;
-    }
-    checkGroup(inventory, group, analyses) {
-        const callableForms = new Set([
-            "function",
-            "constructor",
-            "destructor",
-            "operator",
-            "conversion",
-        ]);
-        const declarations = group.declarations.filter((declaration) => declaration.visibility !== "non-public");
-        const first = declarations[0];
-        const analysis = first === undefined ? undefined : analyses.get(first.id);
-        if (first === undefined || analysis === undefined)
-            return;
-        const forms = new Set(declarations.map((declaration) => declaration.form));
-        const definitions = declarations.filter((declaration) => declaration.definition);
-        const callable = declarations.every((declaration) => callableForms.has(declaration.form));
-        const records = declarations.every((declaration) => ["class", "struct"].includes(declaration.form));
-        const staticData = declarations.every((declaration) => ["static-field", "variable"].includes(declaration.form));
-        const compatibleForms = forms.size === 1 || records || staticData;
-        const repeatedDefinition = !callable &&
-            first.form !== "namespace" &&
-            first.form !== "field" &&
-            first.form !== "enumerator" &&
-            definitions.length > 1;
-        const repeatedMember = (first.form === "field" || first.form === "enumerator") &&
-            declarations.length > 1;
-        const inaccessibleOverloads = group.declarations.some((declaration) => declaration.visibility === "non-public" &&
-            callableForms.has(declaration.form));
-        const qualifiedDefinitions = group.declarations.some((declaration) => declaration.visibility === "qualified" &&
-            callableForms.has(declaration.form));
-        if (!compatibleForms || repeatedDefinition || repeatedMember)
-            this.problem(inventory, analysis, "cpp-declaration-conflict", `C++ identity '${first.identity.join(".")}' has incompatible selected declarations.`, "Keep one compatible type or property definition, or one name-only callable overload family.");
-        if (callable && inaccessibleOverloads && qualifiedDefinitions)
-            this.problem(inventory, analysis, "cpp-overload-access", `C++ overload family '${first.identity.join(".")}' mixes public and inaccessible declarations with qualified definitions.`, "Keep access-specific definitions outside the selected snapshot or add signature-aware definition matching before evaluating this source.");
-    }
-    resolveAliases(inventory, analyses, units, published) {
-        const output = [];
-        const aliases = analyses.flatMap((analysis) => analysis.aliases.map((alias) => ({ analysis, alias })));
-        for (const entry of aliases) {
-            if (!entry.alias.public)
-                continue;
-            const candidates = this.aliasCandidates(entry.alias, units);
-            if (candidates.length !== 1) {
-                this.problem(inventory, entry.analysis, "cpp-alias-resolution", `C++ ${entry.alias.kind} alias '${entry.alias.name}' resolves to ${candidates.length} selected public units.`, "Select one explicit target or add semantic alias resolution before evaluating this source.");
-                continue;
-            }
-            const target = candidates[0];
-            if (target === undefined)
-                continue;
-            published.set(entry.alias.id, target.id);
-            output.push({ alias: entry.alias, analysis: entry.analysis, target });
-        }
-        return output;
-    }
-    aliasCandidates(alias, units) {
-        const paths = [alias.target, [...alias.scopeIdentity, ...alias.target]];
-        const keys = new Set(paths.map((path) => JSON.stringify(path)));
-        let candidates = Array.from(units.values()).filter((unit) => keys.has(JSON.stringify(unit.identity)));
-        if (candidates.length !== 0)
-            return candidates;
-        candidates = Array.from(units.values()).filter((unit) => paths.some((path) => path.length === unit.identity.length &&
-            path.every((part, index) => {
-                const actual = unit.identity[index];
-                return (actual !== undefined &&
-                    (part === actual || part === actual.replace(/`\d+$/u, "")));
-            })));
-        return candidates;
-    }
-    addAddress(inventory, analysis, owners, unitId, file, segments) {
-        const address = { unitId, file, segments };
-        const addressKey = JSON.stringify([file, segments]);
-        const owner = owners.get(addressKey);
-        if (owner !== undefined && owner !== unitId) {
-            this.problem(inventory, analysis, "cpp-address-conflict", `C++ address '${segments.join(".")}' selects more than one semantic unit.`, "Use distinct declarations or add an unambiguous address rule before evaluating this source.");
-            return;
-        }
-        owners.set(addressKey, unitId);
-        if (!inventory.addresses.some((candidate) => JSON.stringify(candidate) === JSON.stringify(address)))
-            inventory.addresses.push(address);
-    }
-    materializeDocumentation(inventory, analyses, published) {
-        const units = new Map(inventory.units.map((unit) => [unit.id, unit]));
-        for (const analysis of analyses)
-            for (const documentation of analysis.documentation) {
-                const groups = this.attachmentGroups(documentation, published);
-                if (groups.size === 0 && !this.annotation(analysis, documentation))
-                    continue;
-                inventory.annotationRanges.push({
-                    file: analysis.source.physicalPath,
-                    range: documentation.range,
-                });
-                for (const [siteId, unitIds] of groups) {
-                    const parsed = this.parse(analysis.source, documentation, this.host(analysis.source, documentation, siteId, unitIds));
-                    for (const unitId of unitIds) {
-                        const unit = units.get(unitId);
-                        if (unit !== undefined)
-                            unit.withdrawals.push(...parsed.withdrawals);
-                    }
-                }
-            }
-        const hidden = new Set();
-        for (const unit of inventory.units)
-            if (this.withdrawn(unit.id, units, new Set()))
-                hidden.add(unit.id);
-        for (const analysis of analyses) {
-            for (const documentation of analysis.documentation) {
-                const publishedGroups = this.attachmentGroups(documentation, published);
-                const groups = new Map();
-                for (const [siteId, unitIds] of publishedGroups) {
-                    const visible = unitIds.filter((unitId) => !hidden.has(unitId));
-                    if (visible.length !== 0)
-                        groups.set(siteId, visible);
-                }
-                if (groups.size === 0 &&
-                    publishedGroups.size !== 0 &&
-                    !this.claimAnnotation(analysis, documentation))
-                    continue;
-                if (groups.size === 0) {
-                    if (!this.annotation(analysis, documentation))
-                        continue;
-                    const host = this.host(analysis.source, documentation, undefined, []);
-                    inventory.hosts.push(host);
-                    const parsed = this.parse(analysis.source, documentation, host);
-                    inventory.declarations.push(...parsed.declarations);
-                    inventory.reviews.push(...parsed.reviews);
-                    inventory.diagnostics.push(...parsed.diagnostics);
-                    continue;
-                }
-                for (const [siteId, unitIds] of groups) {
-                    const host = this.host(analysis.source, documentation, siteId, unitIds);
-                    inventory.hosts.push(host);
-                    const parsed = this.parse(analysis.source, documentation, host);
-                    inventory.declarations.push(...parsed.declarations);
-                    inventory.reviews.push(...parsed.reviews);
-                    inventory.diagnostics.push(...parsed.diagnostics);
-                }
-            }
-            this.materializeUndocumentedHosts(inventory, analysis, published, hidden);
-        }
-    }
-    materializeUndocumentedHosts(inventory, analysis, published, hidden) {
-        const documented = new Set(analysis.documentation.flatMap((documentation) => documentation.attachments.flatMap((attachment) => {
-            const unitId = published.get(attachment.declarationId);
-            return unitId !== undefined && !hidden.has(unitId)
-                ? [attachment.declarationId]
-                : [];
-        })));
-        const sites = new Map();
-        const unitIds = new Map();
-        for (const declaration of [...analysis.declarations, ...analysis.aliases]) {
-            const unitId = published.get(declaration.id);
-            if (unitId === undefined ||
-                hidden.has(unitId) ||
-                documented.has(declaration.id))
-                continue;
-            sites.set(declaration.site.id, declaration.site);
-            const ids = unitIds.get(declaration.site.id) ?? [];
-            if (!ids.includes(unitId))
-                ids.push(unitId);
-            unitIds.set(declaration.site.id, ids);
-        }
-        for (const [siteId, site] of sites) {
-            inventory.hosts.push({
-                id: `${siteId}:host`,
-                file: analysis.source.physicalPath,
-                range: site.range,
-                origins: analysis.source.addresses.map((address) => address.absolute),
-                siteId,
-                unitIds: unitIds.get(siteId) ?? [],
-                attachment: "attached",
-            });
-        }
-    }
-    attachmentGroups(documentation, published) {
-        const groups = new Map();
-        for (const attachment of documentation.attachments) {
-            const unitId = published.get(attachment.declarationId);
-            if (unitId === undefined)
-                continue;
-            const unitIds = groups.get(attachment.siteId) ?? [];
-            if (!unitIds.includes(unitId))
-                unitIds.push(unitId);
-            groups.set(attachment.siteId, unitIds);
-        }
-        return groups;
-    }
-    host(source, documentation, siteId, unitIds) {
-        const attached = siteId !== undefined && unitIds.length !== 0;
-        return {
-            id: `${documentation.id}:host:${siteId ?? "unsupported"}`,
-            file: source.physicalPath,
-            range: documentation.range,
-            origins: source.addresses.map((address) => address.absolute),
-            unitIds,
-            attachment: attached ? "attached" : "unsupported",
-            ...(attached ? { siteId } : {}),
-            ...(attached
-                ? {}
-                : {
-                    problem: "Move the annotation into Doxygen attached to a supported public C++ declaration.",
-                }),
-        };
-    }
-    parse(source, documentation, host) {
-        return EvidenceTagParser_1.EvidenceTagParser.parse(source.content, host, CppDocumentation_1.CppDocumentation.read(source, documentation, host.id));
-    }
-    annotation(analysis, documentation) {
-        return this.annotationPattern(CppDocumentation_1.CppDocumentation.read(analysis.source, documentation, documentation.id)
-            .text, true);
-    }
-    claimAnnotation(analysis, documentation) {
-        return this.annotationPattern(CppDocumentation_1.CppDocumentation.read(analysis.source, documentation, documentation.id)
-            .text, false);
-    }
-    annotationPattern(raw, withdrawal) {
-        return withdrawal
-            ? /(?:^|[\r\n])[ \t]*@(evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link|internal|hidden|ignore)\b/u.test(raw)
-            : /(?:^|[\r\n])[ \t]*@(evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link)\b/u.test(raw);
-    }
-    withdrawn(id, units, visited) {
-        if (visited.has(id))
-            return false;
-        visited.add(id);
-        const unit = units.get(id);
-        if (unit === undefined)
-            return false;
-        if (unit.withdrawals.length !== 0)
-            return true;
-        return unit.parentId === undefined
-            ? false
-            : this.withdrawn(unit.parentId, units, visited);
-    }
-    unitId(declaration) {
-        return `cpp:${declaration.symbol}:${JSON.stringify(declaration.identity)}`;
-    }
-    typeId(identity) {
-        return `cpp:type:${JSON.stringify(identity)}`;
-    }
-    problem(inventory, analysis, code, message, repair) {
-        inventory.complete = false;
-        inventory.diagnostics.push({
-            code,
-            severity: "error",
-            message,
-            repair,
-            location: { file: analysis.source.physicalPath },
-        });
-    }
-}
-exports.CppAdapter = CppAdapter;
-function prefix(identity, parent) {
-    return (identity.length >= parent.length &&
-        parent.every((part, index) => identity[index] === part));
-}