@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/rust/EvidenceRustModuleResolver.js

@@ -0,0 +1,717 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceRustModuleResolver = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const EvidenceSourcePath_1 = require("../../internal/EvidenceSourcePath");
+/**
+ * Resolves selected Rust file analyses into crate modules, public aliases, and
+ * impl ownership.
+ *
+ * The resolver joins node-free scan results, then materializes semantic units
+ * and every supported public address in the supplied Evidence inventory.
+ */
+class EvidenceRustModuleResolver {
+    analyses;
+    inventory;
+    declarations = new Map();
+    childModules = new Map();
+    exports = new Map();
+    externalTargets = new Map();
+    identities = new Map();
+    implMembers = new Map();
+    modules = new Map();
+    placements = new Map();
+    published = new Map();
+    reported = new Set();
+    unitDeclarations = new Map();
+    units = new Map();
+    addresses = new Set();
+    /**
+     * Creates a resolver that publishes into one inventory.
+     *
+     * The analyses remain read-only inputs; this instance owns all intermediate
+     * module, export, identity, and diagnostic state for the resolution pass.
+     */
+    constructor(analyses, inventory) {
+        this.analyses = analyses;
+        this.inventory = inventory;
+    }
+    /**
+     * Resolves all selected Rust analyses and publishes their public units.
+     *
+     * Resolution runs in dependency order: file-backed modules establish crate
+     * scope before exports and impl members can receive public addresses. The
+     * returned map links scanner declaration IDs to their published unit IDs.
+     */
+    publish() {
+        this.resolveExternalTargets();
+        this.placeFiles();
+        this.attachExternalInnerDocumentation();
+        this.buildModules();
+        this.buildExports();
+        this.resolveImplementations();
+        const occurrences = this.collectOccurrences();
+        this.materialize(occurrences);
+        this.inventory.units.push(...this.units.values());
+        return this.published;
+    }
+    resolveExternalTargets() {
+        const sources = new Map();
+        for (const analysis of this.analyses)
+            for (const location of this.sourceLocations(analysis)) {
+                const records = sources.get(location) ?? [];
+                records.push(analysis);
+                sources.set(location, records);
+            }
+        const claims = new Map();
+        for (const analysis of this.analyses)
+            for (const external of analysis.externalModules) {
+                if (external.pathOverride)
+                    continue;
+                const candidates = Array.from(new Map(this.sourceLocations(analysis)
+                    .flatMap((location) => {
+                    const directory = node_path_1.default.join(this.moduleDirectory(location), ...external.modulePath);
+                    return [
+                        EvidenceSourcePath_1.EvidenceSourcePath.slash(node_path_1.default.join(directory, `${external.name}.rs`)),
+                        EvidenceSourcePath_1.EvidenceSourcePath.slash(node_path_1.default.join(directory, external.name, "mod.rs")),
+                    ];
+                })
+                    .flatMap((candidate) => sources.get(candidate) ?? [])
+                    .map((candidate) => [candidate.source.id, candidate])).values());
+                if (candidates.length === 0) {
+                    this.problem("rust-module-missing", analysis, `Module '${[...external.modulePath, external.name].join("::")}' has no selected default source file.`, "Select its .rs or mod.rs source under the configured root, or inline the module.", external.declarationId);
+                    continue;
+                }
+                if (candidates.length > 1) {
+                    this.problem("rust-module-ambiguous", analysis, `Module '${[...external.modulePath, external.name].join("::")}' matches both supported source layouts.`, "Select exactly one of name.rs and name/mod.rs for this module.", external.declarationId);
+                    continue;
+                }
+                const target = candidates[0];
+                if (target === undefined)
+                    continue;
+                this.externalTargets.set(external.declarationId, target);
+                const owners = claims.get(target.source.id) ?? [];
+                owners.push(external.declarationId);
+                claims.set(target.source.id, owners);
+            }
+        for (const [sourceId, owners] of claims)
+            if (owners.length > 1) {
+                const target = this.analyses.find((analysis) => analysis.source.id === sourceId);
+                this.problem("rust-module-ownership", target, "One selected Rust file is claimed by more than one module declaration.", "Give every file-backed module one unambiguous declaration and default source path.", JSON.stringify([sourceId, owners]));
+            }
+    }
+    placeFiles() {
+        const claimed = new Set(Array.from(this.externalTargets.values()).map((analysis) => analysis.source.id));
+        const queue = [];
+        for (const analysis of this.analyses)
+            if (!claimed.has(analysis.source.id))
+                queue.push({
+                    analysis,
+                    rootKey: analysis.source.physicalPath,
+                    prefix: [],
+                });
+        if (queue.length === 0 && this.analyses.length !== 0) {
+            this.problem("rust-module-cycle", this.analyses[0], "Selected Rust module files form a declaration cycle with no crate root.", "Select a root file that is not owned by another mod declaration.", "root-cycle");
+            for (const analysis of this.analyses)
+                queue.push({
+                    analysis,
+                    rootKey: analysis.source.physicalPath,
+                    prefix: [],
+                });
+        }
+        for (let index = 0; index < queue.length; ++index) {
+            const placement = queue[index];
+            if (placement === undefined)
+                continue;
+            const previous = this.placements.get(placement.analysis.source.id);
+            if (previous !== undefined) {
+                if (previous.rootKey !== placement.rootKey ||
+                    JSON.stringify(previous.prefix) !== JSON.stringify(placement.prefix))
+                    this.problem("rust-module-ownership", placement.analysis, "One selected Rust file resolves to more than one crate/module identity.", "Select an acyclic module tree with one owner for each file.", placement.analysis.source.id);
+                continue;
+            }
+            this.placements.set(placement.analysis.source.id, placement);
+            for (const external of placement.analysis.externalModules) {
+                const target = this.externalTargets.get(external.declarationId);
+                if (target === undefined)
+                    continue;
+                queue.push({
+                    analysis: target,
+                    rootKey: placement.rootKey,
+                    prefix: [...placement.prefix, ...external.modulePath, external.name],
+                    moduleDeclarationId: external.declarationId,
+                });
+            }
+        }
+        for (const analysis of this.analyses)
+            if (!this.placements.has(analysis.source.id)) {
+                this.problem("rust-module-cycle", analysis, "A selected Rust file belongs to a disconnected module cycle.", "Break the cycle or select the containing crate root.", `disconnected:${analysis.source.id}`);
+                this.placements.set(analysis.source.id, {
+                    analysis,
+                    rootKey: analysis.source.physicalPath,
+                    prefix: [],
+                });
+            }
+    }
+    attachExternalInnerDocumentation() {
+        const sourceDeclarations = new Map();
+        for (const analysis of this.analyses)
+            for (const declaration of analysis.declarations)
+                sourceDeclarations.set(declaration.id, declaration);
+        for (const placement of this.placements.values()) {
+            if (placement.moduleDeclarationId === undefined)
+                continue;
+            const owner = sourceDeclarations.get(placement.moduleDeclarationId);
+            if (owner === undefined)
+                continue;
+            for (const documentation of placement.analysis.documentation) {
+                if (documentation.innerModulePath === undefined ||
+                    documentation.innerModulePath.length !== 0)
+                    continue;
+                if (!documentation.attachments.some((attachment) => attachment.declarationId === owner.id &&
+                    attachment.siteId === owner.site.id))
+                    documentation.attachments.push({
+                        declarationId: owner.id,
+                        siteId: owner.site.id,
+                    });
+            }
+        }
+    }
+    buildModules() {
+        for (const placement of this.placements.values()) {
+            const localPaths = new Map();
+            const remember = (value) => {
+                localPaths.set(JSON.stringify(value), value);
+            };
+            remember([]);
+            for (const declaration of placement.analysis.declarations) {
+                remember(declaration.modulePath);
+                if (declaration.form === "module" &&
+                    !placement.analysis.externalModules.some((external) => external.declarationId === declaration.id))
+                    remember([...declaration.modulePath, declaration.name]);
+            }
+            for (const use of placement.analysis.uses)
+                remember(use.modulePath);
+            for (const implementation of placement.analysis.implementations)
+                remember(implementation.modulePath);
+            for (const localPath of localPaths.values()) {
+                const modulePath = [...placement.prefix, ...localPath];
+                const key = this.moduleKey(placement.rootKey, modulePath);
+                this.modules.set(key, {
+                    key,
+                    rootKey: placement.rootKey,
+                    path: modulePath,
+                    localPath,
+                    placement,
+                    bindings: new Map(),
+                    uses: placement.analysis.uses.filter((use) => JSON.stringify(use.modulePath) === JSON.stringify(localPath)),
+                });
+            }
+        }
+        const rawDeclarations = new Map();
+        for (const analysis of this.analyses)
+            for (const declaration of analysis.declarations)
+                rawDeclarations.set(declaration.id, declaration);
+        for (const module of this.modules.values()) {
+            const declaration = module.localPath.length === 0
+                ? module.placement.moduleDeclarationId === undefined
+                    ? undefined
+                    : rawDeclarations.get(module.placement.moduleDeclarationId)
+                : this.findInlineModuleDeclaration(module);
+            if (declaration !== undefined)
+                module.declaration = declaration;
+        }
+        for (const placement of this.placements.values())
+            for (const declaration of placement.analysis.declarations) {
+                const module = this.modules.get(this.moduleKey(placement.rootKey, [
+                    ...placement.prefix,
+                    ...declaration.modulePath,
+                ]));
+                if (module === undefined)
+                    continue;
+                if (declaration.ownerDeclarationId === undefined &&
+                    declaration.implementationId === undefined) {
+                    const located = {
+                        declaration,
+                        placement,
+                        module,
+                        identity: [...module.path, declaration.name],
+                    };
+                    this.declarations.set(declaration.id, located);
+                    const bindings = module.bindings.get(declaration.name) ?? [];
+                    bindings.push(declaration);
+                    module.bindings.set(declaration.name, bindings);
+                }
+            }
+        for (const placement of this.placements.values())
+            for (const declaration of placement.analysis.declarations) {
+                if (this.declarations.has(declaration.id))
+                    continue;
+                const module = this.modules.get(this.moduleKey(placement.rootKey, [
+                    ...placement.prefix,
+                    ...declaration.modulePath,
+                ]));
+                if (module === undefined)
+                    continue;
+                const owner = declaration.ownerDeclarationId === undefined
+                    ? undefined
+                    : this.declarations.get(declaration.ownerDeclarationId);
+                this.declarations.set(declaration.id, {
+                    declaration,
+                    placement,
+                    module,
+                    identity: owner === undefined
+                        ? [...module.path, declaration.name]
+                        : [...owner.identity, declaration.name],
+                });
+            }
+        for (const located of this.declarations.values())
+            if (located.declaration.form === "module") {
+                const child = this.modules.get(this.moduleKey(located.module.rootKey, located.identity));
+                if (child !== undefined)
+                    this.childModules.set(located.declaration.id, child);
+            }
+    }
+    buildExports() {
+        for (const module of this.modules.values()) {
+            const entries = new Map();
+            this.exports.set(module.key, entries);
+            for (const declarations of module.bindings.values())
+                for (const declaration of declarations)
+                    if (declaration.visibility === "public")
+                        this.addExport(entries, {
+                            name: declaration.name,
+                            declaration,
+                            carrier: module.placement,
+                        });
+        }
+        const limit = Math.max(1, this.modules.size +
+            this.analyses.reduce((total, analysis) => total + analysis.uses.length, 0));
+        for (let pass = 0; pass < limit; ++pass) {
+            let changed = false;
+            for (const module of this.modules.values()) {
+                const entries = this.exports.get(module.key);
+                if (entries === undefined)
+                    continue;
+                for (const use of module.uses)
+                    for (const binding of use.bindings)
+                        if (binding.wildcard) {
+                            const target = this.resolveModulePath(module, binding.path);
+                            const exported = target === undefined ? undefined : this.exports.get(target.key);
+                            for (const records of exported === undefined
+                                ? []
+                                : exported.values())
+                                for (const record of records)
+                                    changed =
+                                        this.addExport(entries, {
+                                            name: record.name,
+                                            declaration: record.declaration,
+                                            carrier: module.placement,
+                                        }) || changed;
+                        }
+                        else {
+                            const records = this.resolveNamedPath(module, binding.path);
+                            const name = binding.alias ?? binding.path.at(-1);
+                            if (name === undefined)
+                                continue;
+                            for (const record of records)
+                                changed =
+                                    this.addExport(entries, {
+                                        name,
+                                        declaration: record.declaration,
+                                        carrier: module.placement,
+                                    }) || changed;
+                        }
+            }
+            if (!changed)
+                break;
+        }
+        for (const module of this.modules.values()) {
+            for (const use of module.uses)
+                for (const binding of use.bindings) {
+                    const resolved = binding.wildcard
+                        ? this.resolveModulePath(module, binding.path) !== undefined
+                        : this.resolveNamedPath(module, binding.path).length !== 0;
+                    if (!resolved)
+                        this.problem("rust-use-resolution", module.placement.analysis, `Public use target '${binding.path.join("::")}' cannot be resolved in the selected module graph.`, "Select its module sources or rewrite the reexport with a supported static local path.", `${use.id}:${JSON.stringify(binding)}`);
+                }
+            const exported = this.exports.get(module.key);
+            for (const [name, records] of exported ?? []) {
+                const identities = new Set(records.map((record) => record.declaration.id));
+                if (identities.size > 1)
+                    this.problem("rust-export-ambiguity", module.placement.analysis, `Rust public name '${[...module.path, name].join("::")}' resolves to more than one selected declaration.`, "Replace competing reexports or declarations with one unambiguous public binding.", `${module.key}:${name}:ambiguity`);
+            }
+        }
+    }
+    resolveImplementations() {
+        for (const placement of this.placements.values())
+            for (const implementation of placement.analysis.implementations) {
+                const module = this.modules.get(this.moduleKey(placement.rootKey, [
+                    ...placement.prefix,
+                    ...implementation.modulePath,
+                ]));
+                if (module === undefined)
+                    continue;
+                const members = placement.analysis.declarations.filter((declaration) => declaration.implementationId === implementation.id);
+                if (implementation.ownerPath.length === 1 &&
+                    implementation.typeParameters.includes(implementation.ownerPath[0] ?? "")) {
+                    this.implProblem(implementation, placement.analysis, "A generic blanket impl has no single selected nominal owner.", "Limit Evidence ownership to an impl for one selected local struct or enum.");
+                    continue;
+                }
+                const owners = this.resolveTypePath(module, implementation.ownerPath, new Set(["struct", "enum"]));
+                if (owners.length !== 1) {
+                    this.implProblem(implementation, placement.analysis, `Impl owner '${implementation.ownerPath.join("::")}' does not resolve to one selected local nominal type.`, "Select the owner's module source and use one unambiguous local struct or enum path.");
+                    continue;
+                }
+                const owner = owners[0];
+                if (owner === undefined)
+                    continue;
+                const trait = implementation.traitPath === undefined
+                    ? []
+                    : this.resolveTypePath(module, implementation.traitPath, new Set(["trait"]));
+                const explicitlyLocalTrait = implementation.traitPath?.[0] === "crate" ||
+                    implementation.traitPath?.[0] === "self" ||
+                    implementation.traitPath?.[0] === "super";
+                if (explicitlyLocalTrait &&
+                    implementation.traitPath !== undefined &&
+                    trait.length !== 1) {
+                    this.implProblem(implementation, placement.analysis, `Trait path '${implementation.traitPath.join("::")}' does not resolve to one selected local trait.`, "Select the trait module or use one supported unambiguous path.");
+                    continue;
+                }
+                const qualifier = implementation.traitPath === undefined
+                    ? undefined
+                    : `impl ${implementation.traitPath.join("::")}`;
+                for (const member of members) {
+                    const located = this.declarations.get(member.id);
+                    if (located === undefined)
+                        continue;
+                    located.identity = [
+                        ...owner.identity,
+                        ...(qualifier === undefined ? [] : [qualifier]),
+                        member.memberSegment ?? member.name,
+                    ];
+                    const resolved = {
+                        declaration: located,
+                        owner,
+                        ...(qualifier === undefined ? {} : { qualifier }),
+                        ...(trait[0] === undefined
+                            ? {}
+                            : { localTraitId: trait[0].declaration.id }),
+                    };
+                    const records = this.implMembers.get(owner.declaration.id) ?? [];
+                    records.push(resolved);
+                    this.implMembers.set(owner.declaration.id, records);
+                }
+            }
+    }
+    collectOccurrences() {
+        const output = [];
+        const roots = Array.from(this.modules.values()).filter((module) => module.path.length === 0 && module.placement.prefix.length === 0);
+        for (const root of roots)
+            this.collectModule(root, [], root.placement, new Set(), output);
+        return output;
+    }
+    collectModule(module, prefix, namespaceCarrier, ancestors, output) {
+        const entries = this.exports.get(module.key);
+        for (const [name, records] of entries ?? [])
+            for (const exported of records) {
+                const located = this.declarations.get(exported.declaration.id);
+                if (located === undefined)
+                    continue;
+                const publicPath = [...prefix, name];
+                output.push({ located, exported, namespaceCarrier, publicPath });
+                if (located.declaration.form !== "module")
+                    continue;
+                const child = this.childModules.get(located.declaration.id);
+                if (child === undefined)
+                    continue;
+                if (ancestors.has(located.declaration.id)) {
+                    this.problem("rust-reexport-cycle", located.placement.analysis, `Public module alias '${publicPath.join("::")}' forms a recursive reexport path.`, "Break the module reexport cycle or expose finite named items directly.", `${located.declaration.id}:${JSON.stringify(publicPath)}`);
+                    continue;
+                }
+                const nested = new Set(ancestors);
+                nested.add(located.declaration.id);
+                this.collectModule(child, publicPath, exported.carrier, nested, output);
+            }
+    }
+    materialize(occurrences) {
+        const reachable = new Set(occurrences.map((occurrence) => occurrence.located.declaration.id));
+        const roots = new Map(Array.from(this.placements.values())
+            .filter((placement) => placement.prefix.length === 0)
+            .map((placement) => [placement.rootKey, placement]));
+        for (const occurrence of occurrences) {
+            const located = occurrence.located;
+            const parent = located.module.declaration;
+            const parentDeclaration = parent !== undefined && reachable.has(parent.id)
+                ? this.declarations.get(parent.id)
+                : undefined;
+            const parentId = parentDeclaration === undefined
+                ? undefined
+                : this.unitId(parentDeclaration);
+            const unit = this.unit(located, parentId);
+            this.publishOccurrenceAddresses(unit, occurrence, roots.get(located.module.rootKey));
+            if (located.declaration.symbol !== "type")
+                continue;
+            this.materializeOwnedMembers(occurrence, unit, reachable, roots);
+        }
+    }
+    materializeOwnedMembers(occurrence, ownerUnit, reachable, roots) {
+        const owner = occurrence.located;
+        const direct = Array.from(this.declarations.values()).filter((located) => located.declaration.ownerDeclarationId === owner.declaration.id &&
+            (located.declaration.visibility === "public" ||
+                located.declaration.visibility === "implicit"));
+        for (const member of direct)
+            this.materializeMember(occurrence, ownerUnit, member, [member.declaration.name], roots.get(owner.module.rootKey));
+        for (const resolved of this.implMembers.get(owner.declaration.id) ?? []) {
+            if (resolved.declaration.declaration.visibility !== "public" &&
+                resolved.declaration.declaration.visibility !== "implicit")
+                continue;
+            if (resolved.localTraitId !== undefined &&
+                !reachable.has(resolved.localTraitId))
+                continue;
+            const suffix = [
+                ...(resolved.qualifier === undefined ? [] : [resolved.qualifier]),
+                resolved.declaration.declaration.name,
+            ];
+            this.materializeMember(occurrence, ownerUnit, resolved.declaration, suffix, roots.get(owner.module.rootKey));
+        }
+    }
+    materializeMember(occurrence, ownerUnit, member, suffix, root) {
+        const unit = this.unit(member, ownerUnit.id);
+        const publicPath = [...occurrence.publicPath, ...suffix];
+        if (root !== undefined)
+            this.publishAddress(unit.id, root, publicPath);
+        this.publishAddress(unit.id, occurrence.namespaceCarrier, this.relative(publicPath, occurrence.namespaceCarrier.prefix));
+        this.publishAddress(unit.id, occurrence.exported.carrier, this.relative(publicPath, occurrence.exported.carrier.prefix));
+        const origin = this.relative(member.identity, member.placement.prefix);
+        this.publishAddress(unit.id, member.placement, origin.length === member.identity.length &&
+            member.placement.prefix.length !== 0
+            ? [occurrence.publicPath.at(-1) ?? ownerUnit.name, ...suffix]
+            : origin);
+    }
+    publishOccurrenceAddresses(unit, occurrence, root) {
+        if (root !== undefined)
+            this.publishAddress(unit.id, root, occurrence.publicPath);
+        this.publishAddress(unit.id, occurrence.namespaceCarrier, this.relative(occurrence.publicPath, occurrence.namespaceCarrier.prefix));
+        this.publishAddress(unit.id, occurrence.exported.carrier, this.relative(occurrence.publicPath, occurrence.exported.carrier.prefix));
+        this.publishAddress(unit.id, occurrence.located.placement, this.relative(occurrence.located.identity, occurrence.located.placement.prefix));
+    }
+    unit(located, parentId) {
+        const id = this.unitId(located);
+        const declarationIds = this.unitDeclarations.get(id) ?? new Set();
+        if (declarationIds.size !== 0 &&
+            !declarationIds.has(located.declaration.id))
+            this.problem("rust-declaration-conflict", located.placement.analysis, `Rust public identity '${located.identity.join("::")}' has more than one selected declaration.`, "Select one declaration for this crate identity or resolve conditional alternatives before checking coverage.", `${id}:${located.declaration.id}:declaration`);
+        declarationIds.add(located.declaration.id);
+        this.unitDeclarations.set(id, declarationIds);
+        const identityKey = JSON.stringify([
+            located.module.rootKey,
+            located.identity,
+        ]);
+        const previousIdentity = this.identities.get(identityKey);
+        if (previousIdentity !== undefined && previousIdentity !== id)
+            this.problem("rust-identity-conflict", located.placement.analysis, `Rust public identity '${located.identity.join("::")}' has conflicting symbol kinds.`, "Rename one associated item or expose it through an unambiguous path.", `${identityKey}:kind`);
+        else
+            this.identities.set(identityKey, id);
+        let unit = this.units.get(id);
+        if (unit === undefined) {
+            unit = {
+                id,
+                type: "rust",
+                symbol: located.declaration.symbol,
+                identity: located.identity,
+                name: located.declaration.name,
+                sites: [structuredClone(located.declaration.site)],
+                withdrawals: [],
+                ...(parentId === undefined ? {} : { parentId }),
+            };
+            this.units.set(id, unit);
+        }
+        else if (!unit.sites.some((site) => site.id === located.declaration.site.id))
+            unit.sites.push(structuredClone(located.declaration.site));
+        this.published.set(located.declaration.id, id);
+        return unit;
+    }
+    unitId(located) {
+        return `rust:${located.module.rootKey}:${located.declaration.symbol}:${JSON.stringify(located.identity)}`;
+    }
+    resolveTypePath(module, sourcePath, forms) {
+        const candidates = this.resolvePathCandidates(module, sourcePath, true);
+        return this.uniqueLocated(candidates.flatMap((record) => {
+            const located = this.declarations.get(record.declaration.id);
+            return located !== undefined && forms.has(located.declaration.form)
+                ? [located]
+                : [];
+        }));
+    }
+    resolveNamedPath(module, sourcePath) {
+        return this.resolvePathCandidates(module, sourcePath, false).filter((record) => record.declaration.visibility === "public");
+    }
+    resolvePathCandidates(module, sourcePath, currentForBare) {
+        if (sourcePath.length === 0)
+            return [];
+        const name = sourcePath.at(-1);
+        if (name === undefined)
+            return [];
+        const target = this.resolveModuleSegments(module, sourcePath.slice(0, -1), currentForBare);
+        if (target === undefined)
+            return [];
+        const direct = (target.bindings.get(name) ?? []).map((declaration) => ({
+            name,
+            declaration,
+            carrier: target.placement,
+        }));
+        const targetExports = this.exports.get(target.key);
+        const exported = targetExports === undefined ? [] : (targetExports.get(name) ?? []);
+        return this.uniqueExports([...direct, ...exported]);
+    }
+    resolveModulePath(module, sourcePath) {
+        return this.resolveModuleSegments(module, sourcePath, false);
+    }
+    resolveModuleSegments(module, sourcePath, currentForBare) {
+        let current = module;
+        let index = 0;
+        const first = sourcePath[0];
+        if (first === "crate") {
+            const root = this.modules.get(this.moduleKey(module.rootKey, []));
+            if (root === undefined)
+                return undefined;
+            current = root;
+            index = 1;
+        }
+        else if (first === "self")
+            index = 1;
+        else if (first === "super") {
+            while (sourcePath[index] === "super") {
+                const parent = this.modules.get(this.moduleKey(module.rootKey, current.path.slice(0, -1)));
+                if (parent === undefined)
+                    return undefined;
+                current = parent;
+                ++index;
+            }
+        }
+        else if (!currentForBare) {
+            const root = this.modules.get(this.moduleKey(module.rootKey, []));
+            if (root === undefined)
+                return undefined;
+            current = root;
+        }
+        for (; index < sourcePath.length; ++index) {
+            const segment = sourcePath[index];
+            if (segment === undefined)
+                return undefined;
+            const currentExports = this.exports.get(current.key);
+            const records = [
+                ...(current.bindings.get(segment) ?? []).map((declaration) => ({
+                    name: segment,
+                    declaration,
+                    carrier: current.placement,
+                })),
+                ...(currentExports === undefined
+                    ? []
+                    : (currentExports.get(segment) ?? [])),
+            ].filter((record) => record.declaration.form === "module");
+            const modules = Array.from(new Map(records.flatMap((record) => {
+                const child = this.childModules.get(record.declaration.id);
+                return child === undefined ? [] : [[child.key, child]];
+            })).values());
+            if (modules.length !== 1)
+                return undefined;
+            const child = modules[0];
+            if (child === undefined)
+                return undefined;
+            current = child;
+        }
+        return current;
+    }
+    addExport(entries, record) {
+        const values = entries.get(record.name) ?? [];
+        const key = JSON.stringify([
+            record.name,
+            record.declaration.id,
+            record.carrier.analysis.source.id,
+        ]);
+        if (values.some((value) => JSON.stringify([
+            value.name,
+            value.declaration.id,
+            value.carrier.analysis.source.id,
+        ]) === key))
+            return false;
+        values.push(record);
+        entries.set(record.name, values);
+        return true;
+    }
+    uniqueExports(records) {
+        return Array.from(new Map(records.map((record) => [record.declaration.id, record])).values());
+    }
+    uniqueLocated(records) {
+        return Array.from(new Map(records.map((record) => [record.declaration.id, record])).values());
+    }
+    findInlineModuleDeclaration(module) {
+        const name = module.localPath.at(-1);
+        const parent = module.localPath.slice(0, -1);
+        return module.placement.analysis.declarations.find((declaration) => declaration.form === "module" &&
+            declaration.name === name &&
+            JSON.stringify(declaration.modulePath) === JSON.stringify(parent));
+    }
+    moduleDirectory(filename) {
+        const basename = node_path_1.default.basename(filename);
+        return basename === "lib.rs" ||
+            basename === "main.rs" ||
+            basename === "mod.rs"
+            ? node_path_1.default.dirname(filename)
+            : node_path_1.default.join(node_path_1.default.dirname(filename), basename.slice(0, -3));
+    }
+    sourceLocations(analysis) {
+        return Array.from(new Set([
+            EvidenceSourcePath_1.EvidenceSourcePath.slash(analysis.source.physicalPath),
+            ...analysis.source.addresses.map((address) => EvidenceSourcePath_1.EvidenceSourcePath.slash(address.absolute)),
+        ]));
+    }
+    moduleKey(rootKey, modulePath) {
+        return JSON.stringify([rootKey, modulePath]);
+    }
+    relative(value, prefix) {
+        return prefix.every((segment, index) => value[index] === segment)
+            ? value.slice(prefix.length)
+            : value;
+    }
+    publishAddress(unitId, placement, segments) {
+        if (segments.length === 0)
+            return;
+        for (const location of placement.analysis.source.addresses) {
+            const address = {
+                unitId,
+                file: location.absolute,
+                segments,
+            };
+            const key = JSON.stringify(address);
+            if (this.addresses.has(key))
+                continue;
+            this.addresses.add(key);
+            this.inventory.addresses.push(address);
+        }
+    }
+    implProblem(implementation, analysis, message, repair) {
+        this.problem("rust-impl-owner", analysis, message, repair, implementation.id);
+    }
+    problem(code, analysis, message, repair, key) {
+        if (this.reported.has(key))
+            return;
+        this.reported.add(key);
+        this.inventory.complete = false;
+        this.inventory.diagnostics.push({
+            code,
+            severity: "error",
+            message,
+            repair,
+            ...(analysis === undefined
+                ? {}
+                : { location: { file: analysis.source.physicalPath } }),
+        });
+    }
+}
+exports.EvidenceRustModuleResolver = EvidenceRustModuleResolver;