@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/java/JavaFileScanner.d.ts

@@ -1,51 +0,0 @@
-import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
-import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
-import type { IJavaFileAnalysis } from "./IJavaFileAnalysis";
-/**
- * Extracts Java packages, declarations, and Javadoc before family materialization.
- *
- * Ownership and visibility are recorded from selected source only; `JavaAdapter`
- * later reconciles compatible declaration families into graph units.
- */
-export declare class JavaFileScanner {
-    private readonly session;
-    private readonly source;
-    private readonly declarations;
-    private readonly documentation;
-    private readonly carrierDocumentation;
-    private readonly diagnostics;
-    private readonly reported;
-    private readonly text;
-    private complete;
-    /**
-     * Creates a scanner for one Java parse session and source snapshot.
-     *
-     * Javadoc carriers are collected before declaration walking so their physical
-     * attachment cannot be confused with same-named declarations elsewhere.
-     */
-    constructor(session: EvidenceParseSession, source: IEvidenceSourceFile);
-    /**
-     * Produces node-free package declarations, documentation, and diagnostics.
-     *
-     * The result records unsupported relevant forms as incomplete rather than
-     * allowing the adapter to publish a falsely complete smaller inventory.
-     */
-    scan(): IJavaFileAnalysis;
-    private scanType;
-    private scanTypeBody;
-    private scanRecordComponents;
-    private scanField;
-    private scanMethod;
-    private scanEnumConstant;
-    private scanAnnotationElement;
-    private typePublic;
-    private memberPublic;
-    private addDeclaration;
-    private collectDocumentation;
-    private attach;
-    private ensureDocumentation;
-    private annotation;
-    private nodeKey;
-    private siteId;
-    private problem;
-}

package/lib/adapters/java/JavaFileScanner.js

@@ -1,317 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JavaFileScanner = void 0;
-const JavaSyntax_1 = require("./JavaSyntax");
-const SourceText_1 = require("../../internal/SourceText");
-/**
- * Extracts Java packages, declarations, and Javadoc before family materialization.
- *
- * Ownership and visibility are recorded from selected source only; `JavaAdapter`
- * later reconciles compatible declaration families into graph units.
- */
-class JavaFileScanner {
-    session;
-    source;
-    declarations = [];
-    documentation = new Map();
-    carrierDocumentation = new Map();
-    diagnostics = [];
-    reported = new Set();
-    text;
-    complete = true;
-    /**
-     * Creates a scanner for one Java parse session and source snapshot.
-     *
-     * Javadoc carriers are collected before declaration walking so their physical
-     * attachment cannot be confused with same-named declarations elsewhere.
-     */
-    constructor(session, source) {
-        this.session = session;
-        this.source = source;
-        this.text = new SourceText_1.SourceText(source.content);
-        this.collectDocumentation();
-    }
-    /**
-     * Produces node-free package declarations, documentation, and diagnostics.
-     *
-     * The result records unsupported relevant forms as incomplete rather than
-     * allowing the adapter to publish a falsely complete smaller inventory.
-     */
-    scan() {
-        const packageDeclaration = this.session.root.namedChildren.find((child) => child.type === "package_declaration");
-        const packagePath = JavaSyntax_1.JavaSyntax.packagePath(packageDeclaration);
-        for (const item of this.session.root.namedChildren)
-            switch (item.type) {
-                case "package_declaration":
-                case "import_declaration":
-                case "line_comment":
-                case "block_comment":
-                case "module_declaration":
-                    break;
-                case "class_declaration":
-                    this.scanType(item, packagePath, undefined, "class", "class");
-                    break;
-                case "interface_declaration":
-                    this.scanType(item, packagePath, undefined, "interface", "interface");
-                    break;
-                case "enum_declaration":
-                    this.scanType(item, packagePath, undefined, "enum", "enum");
-                    break;
-                case "annotation_type_declaration":
-                    this.scanType(item, packagePath, undefined, "annotation", "annotation");
-                    break;
-                case "record_declaration":
-                    this.scanType(item, packagePath, undefined, "record", "record");
-                    break;
-                default:
-                    if (JavaSyntax_1.JavaSyntax.hasModifier(item, "public"))
-                        this.problem("java-public-form", `Public Java source form '${item.type}' is not classified by this adapter.`, "Add an explicit declaration-form rule before evaluating this public surface.", item);
-            }
-        return {
-            source: this.source,
-            declarations: this.declarations,
-            documentation: Array.from(this.documentation.values()),
-            diagnostics: this.diagnostics,
-            complete: this.complete,
-        };
-    }
-    scanType(item, packagePath, owner, kind, form) {
-        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
-        if (name === undefined) {
-            this.problem("java-type-name", `A Java ${form} declaration has no statically readable name.`, "Use one ordinary named declaration.", item);
-            return;
-        }
-        const identity = [
-            ...(owner === undefined ? packagePath : owner.identity),
-            name,
-        ];
-        const address = [...(owner?.address ?? []), name];
-        const visible = this.typePublic(item, owner);
-        const declaration = this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "type", form, identity, address, visible, owner?.declarationId);
-        const context = {
-            declarationId: declaration.id,
-            identity,
-            address,
-            kind,
-            public: visible,
-        };
-        if (kind === "record")
-            this.scanRecordComponents(item, context);
-        const body = item.childForFieldName("body");
-        if (body !== null)
-            this.scanTypeBody(body, context);
-    }
-    scanTypeBody(body, owner) {
-        for (const member of body.namedChildren)
-            switch (member.type) {
-                case "line_comment":
-                case "block_comment":
-                case "constructor_declaration":
-                case "compact_constructor_declaration":
-                case "static_initializer":
-                    break;
-                case "enum_body_declarations":
-                    this.scanTypeBody(member, owner);
-                    break;
-                case "class_declaration":
-                    this.scanType(member, [], owner, "class", "class");
-                    break;
-                case "interface_declaration":
-                    this.scanType(member, [], owner, "interface", "interface");
-                    break;
-                case "enum_declaration":
-                    this.scanType(member, [], owner, "enum", "enum");
-                    break;
-                case "annotation_type_declaration":
-                    this.scanType(member, [], owner, "annotation", "annotation");
-                    break;
-                case "record_declaration":
-                    this.scanType(member, [], owner, "record", "record");
-                    break;
-                case "field_declaration":
-                    this.scanField(member, owner, "field");
-                    break;
-                case "constant_declaration":
-                    this.scanField(member, owner, "interface-constant");
-                    break;
-                case "method_declaration":
-                    this.scanMethod(member, owner);
-                    break;
-                case "enum_constant":
-                    this.scanEnumConstant(member, owner);
-                    break;
-                case "annotation_type_element_declaration":
-                    this.scanAnnotationElement(member, owner);
-                    break;
-                default:
-                    if (JavaSyntax_1.JavaSyntax.hasModifier(member, "public"))
-                        this.problem("java-public-form", `Public Java member form '${member.type}' is not classified by this adapter.`, "Add an explicit member rule before evaluating this public type.", member);
-            }
-    }
-    scanRecordComponents(item, owner) {
-        const parameters = item.childForFieldName("parameters");
-        for (const parameter of parameters === null
-            ? []
-            : parameters.namedChildren) {
-            if (parameter.type !== "formal_parameter" &&
-                parameter.type !== "spread_parameter")
-                continue;
-            const name = JavaSyntax_1.JavaSyntax.parameterName(parameter);
-            if (name === undefined)
-                continue;
-            this.addDeclaration(parameter, parameter, JavaSyntax_1.JavaSyntax.javadoc(parameter), [this.session.range(parameter)], name, "property", "record-component", [...owner.identity, name], [...owner.address, name], owner.public, owner.declarationId);
-        }
-    }
-    scanField(item, owner, form) {
-        const declarators = item.namedChildren.filter((child) => child.type === "variable_declarator");
-        const first = declarators[0];
-        if (first === undefined)
-            return;
-        const header = this.text.range(item.startIndex, first.startIndex);
-        const documentation = JavaSyntax_1.JavaSyntax.javadoc(item);
-        const visible = this.memberPublic(item, owner, form !== "field");
-        for (const declarator of declarators) {
-            const name = JavaSyntax_1.JavaSyntax.name(declarator.childForFieldName("name"));
-            if (name === undefined)
-                continue;
-            this.addDeclaration(declarator, item, documentation, [header, this.session.range(declarator)], name, "property", form, [...owner.identity, name], [...owner.address, name], visible, owner.declarationId);
-        }
-    }
-    scanMethod(item, owner) {
-        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
-        if (name === undefined)
-            return;
-        this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "function", "method", [...owner.identity, name], [...owner.address, name], this.memberPublic(item, owner, owner.kind === "interface"), owner.declarationId);
-    }
-    scanEnumConstant(item, owner) {
-        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
-        if (name === undefined)
-            return;
-        this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "property", "enum-constant", [...owner.identity, name], [...owner.address, name], owner.public, owner.declarationId);
-    }
-    scanAnnotationElement(item, owner) {
-        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
-        if (name === undefined)
-            return;
-        this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "property", "annotation-element", [...owner.identity, name], [...owner.address, name], owner.public, owner.declarationId);
-    }
-    typePublic(item, owner) {
-        if (owner === undefined)
-            return JavaSyntax_1.JavaSyntax.hasModifier(item, "public");
-        if (!owner.public)
-            return false;
-        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "private"))
-            return false;
-        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "protected"))
-            return false;
-        return owner.kind === "interface" || owner.kind === "annotation"
-            ? true
-            : JavaSyntax_1.JavaSyntax.hasModifier(item, "public");
-    }
-    memberPublic(item, owner, implicit) {
-        if (!owner.public)
-            return false;
-        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "private"))
-            return false;
-        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "protected"))
-            return false;
-        return implicit || JavaSyntax_1.JavaSyntax.hasModifier(item, "public");
-    }
-    addDeclaration(item, siteNode, documentationNode, content, name, symbol, form, identity, address, visible, ownerDeclarationId) {
-        const site = {
-            id: this.siteId(siteNode),
-            file: this.source.physicalPath,
-            range: this.text.range(documentationNode?.startIndex ?? siteNode.startIndex, siteNode.endIndex),
-            content,
-        };
-        const declaration = {
-            id: `java:${this.source.id}:declaration:${form}:${item.startIndex}:${name}`,
-            name,
-            symbol,
-            form,
-            identity,
-            address,
-            site,
-            public: visible,
-            ...(ownerDeclarationId === undefined ? {} : { ownerDeclarationId }),
-        };
-        this.declarations.push(declaration);
-        if (documentationNode !== null) {
-            const documentation = this.carrierDocumentation.get(this.nodeKey(documentationNode));
-            if (documentation !== undefined)
-                this.attach(documentation, declaration.id, site.id);
-        }
-        return declaration;
-    }
-    collectDocumentation() {
-        const comments = [
-            ...this.session.root.descendantsOfType("line_comment"),
-            ...this.session.root.descendantsOfType("block_comment"),
-        ];
-        for (const comment of comments) {
-            const syntax = JavaSyntax_1.JavaSyntax.comment(comment);
-            const range = this.session.range(comment);
-            const javadoc = comment.type === "block_comment" && comment.text.startsWith("/**");
-            const raw = this.source.content.slice(range.start.offset + syntax.opening.length, range.end.offset - syntax.closing.length);
-            if (!javadoc && !this.annotation(raw))
-                continue;
-            const documentation = this.ensureDocumentation(range, syntax);
-            this.carrierDocumentation.set(this.nodeKey(comment), documentation);
-        }
-        const literals = [...this.session.root.descendantsOfType("string_literal")];
-        for (const literal of literals) {
-            const syntax = JavaSyntax_1.JavaSyntax.string(literal);
-            if (syntax === undefined)
-                continue;
-            const raw = literal.text.slice(syntax.opening.length, literal.text.length - syntax.closing.length);
-            if (this.annotation(raw))
-                this.ensureDocumentation(this.session.range(literal), syntax);
-        }
-    }
-    attach(documentation, declarationId, siteId) {
-        if (!documentation.attachments.some((attachment) => attachment.declarationId === declarationId &&
-            attachment.siteId === siteId))
-            documentation.attachments.push({ declarationId, siteId });
-    }
-    ensureDocumentation(range, syntax) {
-        const key = `${range.start.offset}:${range.end.offset}`;
-        let documentation = this.documentation.get(key);
-        if (documentation === undefined) {
-            documentation = {
-                id: `java:${this.source.id}:documentation:${key}`,
-                range,
-                syntax,
-                attachments: [],
-            };
-            this.documentation.set(key, documentation);
-        }
-        return documentation;
-    }
-    annotation(raw) {
-        return /(?:^|[\r\n])[ \t]*@(evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link|internal|hidden|ignore)\b/u.test(raw);
-    }
-    nodeKey(node) {
-        return `${node.startIndex}:${node.endIndex}`;
-    }
-    siteId(node) {
-        return `java:${this.source.id}:site:${this.nodeKey(node)}`;
-    }
-    problem(code, message, repair, node) {
-        const key = `${code}:${node.startIndex}:${node.endIndex}`;
-        if (this.reported.has(key))
-            return;
-        this.reported.add(key);
-        this.complete = false;
-        this.diagnostics.push({
-            code,
-            severity: "error",
-            message,
-            repair,
-            location: {
-                file: this.source.physicalPath,
-                range: this.session.range(node),
-            },
-        });
-    }
-}
-exports.JavaFileScanner = JavaFileScanner;

package/lib/adapters/java/JavaSyntax.d.ts

@@ -1,18 +0,0 @@
-import type { Node } from "web-tree-sitter";
-import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
-/**
- * Grammar-specific Java names, packages, modifiers, literals, and Javadoc.
- *
- * Java extraction uses these helpers to interpret parser nodes without resolving
- * compiler symbols, preserving source-spelled ownership and documentation boundaries.
- */
-export declare namespace JavaSyntax {
-    function name(node: Node | null): string | undefined;
-    function path(node: Node | null): string[] | undefined;
-    function packagePath(node: Node | undefined): string[];
-    function parameterName(node: Node): string | undefined;
-    function hasModifier(node: Node, modifier: string): boolean;
-    function javadoc(node: Node): Node | null;
-    function comment(node: Node): IEvidenceCommentSyntax;
-    function string(node: Node): IEvidenceCommentSyntax | undefined;
-}

package/lib/adapters/java/JavaSyntax.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JavaSyntax = void 0;
-/**
- * Grammar-specific Java names, packages, modifiers, literals, and Javadoc.
- *
- * Java extraction uses these helpers to interpret parser nodes without resolving
- * compiler symbols, preserving source-spelled ownership and documentation boundaries.
- */
-var JavaSyntax;
-(function (JavaSyntax) {
-    function name(node) {
-        return node !== null && node.type === "identifier" ? node.text : undefined;
-    }
-    JavaSyntax.name = name;
-    function path(node) {
-        if (node === null)
-            return undefined;
-        const direct = name(node);
-        if (direct !== undefined)
-            return [direct];
-        if (node.type !== "scoped_identifier")
-            return undefined;
-        const scope = path(node.childForFieldName("scope"));
-        const suffix = name(node.childForFieldName("name"));
-        return scope === undefined || suffix === undefined
-            ? undefined
-            : [...scope, suffix];
-    }
-    JavaSyntax.path = path;
-    function packagePath(node) {
-        if (node === undefined)
-            return [];
-        for (const child of node.namedChildren) {
-            const candidate = path(child);
-            if (candidate !== undefined)
-                return candidate;
-        }
-        return [];
-    }
-    JavaSyntax.packagePath = packagePath;
-    function parameterName(node) {
-        if (node.type === "formal_parameter")
-            return name(node.childForFieldName("name"));
-        if (node.type !== "spread_parameter")
-            return undefined;
-        const declarator = node.namedChildren.find((child) => child.type === "variable_declarator");
-        return declarator === undefined
-            ? undefined
-            : name(declarator.childForFieldName("name"));
-    }
-    JavaSyntax.parameterName = parameterName;
-    function hasModifier(node, modifier) {
-        const modifiers = node.namedChildren.find((child) => child.type === "modifiers");
-        return modifiers === undefined
-            ? false
-            : modifiers.children.some((child) => child.type === modifier);
-    }
-    JavaSyntax.hasModifier = hasModifier;
-    function javadoc(node) {
-        const previous = node.previousNamedSibling;
-        return previous !== null &&
-            previous.type === "block_comment" &&
-            previous.text.startsWith("/**")
-            ? previous
-            : null;
-    }
-    JavaSyntax.javadoc = javadoc;
-    function comment(node) {
-        if (node.type === "line_comment")
-            return {
-                opening: "//",
-                closing: "",
-                linePrefix: "//",
-                tagBoundaries: true,
-                allowWithdrawal: false,
-            };
-        const javadoc = node.text.startsWith("/**");
-        return {
-            opening: javadoc ? "/**" : "/*",
-            closing: "*/",
-            tagBoundaries: true,
-            allowWithdrawal: javadoc,
-            ...(javadoc ? { linePrefix: "*" } : {}),
-        };
-    }
-    JavaSyntax.comment = comment;
-    function string(node) {
-        if (node.type !== "string_literal")
-            return undefined;
-        const delimiter = node.text.startsWith('"""') ? '"""' : '"';
-        return {
-            opening: delimiter,
-            closing: delimiter,
-            tagBoundaries: true,
-            allowWithdrawal: false,
-        };
-    }
-    JavaSyntax.string = string;
-})(JavaSyntax || (exports.JavaSyntax = JavaSyntax = {}));

package/lib/adapters/java/JavaTypeKind.d.ts

@@ -1,7 +0,0 @@
-/**
- * Java type context that determines implicit member visibility.
- *
- * Member extraction carries this context because interfaces, annotations, and
- * other nominal forms supply different defaults when modifiers are omitted.
- */
-export type JavaTypeKind = "class" | "interface" | "enum" | "annotation" | "record";

package/lib/adapters/kotlin/IKotlinDeclaration.d.ts

@@ -1,77 +0,0 @@
-import type { IEvidenceUnitSite } from "../../structures/IEvidenceUnitSite";
-import type { EvidenceProgrammingSymbol } from "../../typings/EvidenceProgrammingSymbol";
-import type { IKotlinTypeReference } from "./IKotlinTypeReference";
-/**
- * Represents one Kotlin declaration before overload families become inventory units.
- *
- * The scanner keeps source-level visibility, receiver, and alias information here
- * because snapshot-wide resolution can change the semantic owner of an extension.
- */
-export interface IKotlinDeclaration {
-    /** Identifies this physical extraction record within the source snapshot.
-     *
-     * Receiver resolution and documentation attachments use this scanner-local value before unit materialization assigns a semantic ID.
-     */
-    id: string;
-    /** Gives the literal Kotlin name decoded from the declaration.
-     *
-     * The scanner combines it with receiver and lexical paths while preserving its source spelling for diagnostics.
-     */
-    name: string;
-    /** Classifies the declaration in Evidence's language-independent selector vocabulary.
-     *
-     * The adapter retains this category while reconciling package-scoped overload families.
-     */
-    symbol: EvidenceProgrammingSymbol;
-    /** Lists type-parameter names visible at this declaration's lexical scope.
-     *
-     * Deferred receiver parsing uses these names to reject type-variable receivers that static nominal lookup cannot resolve.
-     */
-    typeParameters: string[];
-    /**
-     * Holds the nominal target when this declaration introduces a type alias.
-     *
-     * Later receiver resolution expands it only in the source context where its
-     * imports and file-private visibility rules are valid.
-     */
-    aliasTarget?: IKotlinTypeReference;
-    /**
-     * Retains the declared extension receiver before nominal lookup.
-     *
-     * Extension members belong to the resolved receiver type rather than to the
-     * file that happens to declare the extension.
-     */
-    receiver?: IKotlinTypeReference;
-    /** Lists package and lexical ownership segments for the semantic unit.
-     *
-     * Receiver resolution may replace the extension's lexical owner with its resolved nominal receiver.
-     */
-    identity: string[];
-    /** Lists public accessor segments as projected from the source file.
-     *
-     * These remain distinct from `identity` so consumers can cite the public spelling of an extension declaration.
-     */
-    address: string[];
-    /** Retains the physical declaration site and content used by hosts and fingerprints.
-     *
-     * A reconciled overload family can retain several of these source occurrences.
-     */
-    site: IEvidenceUnitSite;
-    /** States whether this declaration and each containing owner are public.
-     *
-     * The adapter retains non-public records for receiver lookup but does not publish their units or addresses.
-     */
-    public: boolean;
-    /**
-     * Records Kotlin file-private visibility for nominal lookup.
-     *
-     * A same-named declaration in another file must not satisfy a receiver or
-     * alias reference that can only see this physical source.
-     */
-    filePrivate: boolean;
-    /** Identifies the containing declaration when this record is a member.
-     *
-     * Omission denotes a package-level declaration; materialization uses this link to propagate ownership and withdrawals.
-     */
-    ownerDeclarationId?: string;
-}

package/lib/adapters/kotlin/IKotlinDocumentation.d.ts

@@ -1,31 +0,0 @@
-import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
-import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
-import type { IKotlinDocumentationAttachment } from "./IKotlinDocumentationAttachment";
-/**
- * Represents a Kotlin documentation carrier or tag-bearing unsupported carrier.
- *
- * KDoc attachment is established from source adjacency, while tagged text in an
- * ineligible carrier remains present for a host-level diagnostic.
- */
-export interface IKotlinDocumentation {
-    /** Identifies this physical KDoc or unsupported carrier within the scanned source.
-     *
-     * Attachments and host generation use this scanner-local value, which is distinct from a declaration's semantic identity.
-     */
-    id: string;
-    /** Locates the carrier's original half-open UTF-16 source span.
-     *
-     * The adapter preserves this range for diagnostics and annotation-range exclusion.
-     */
-    range: IEvidenceSourceRange;
-    /** Defines the carrier delimiters and annotation-reading rules.
-     *
-     * KDoc parsing uses this syntax rather than guessing from raw source text.
-     */
-    syntax: IEvidenceCommentSyntax;
-    /** Lists declaration sites that accept this carrier as KDoc.
-     *
-     * The scanner establishes these source-adjacent attachments before receiver and unit resolution.
-     */
-    attachments: IKotlinDocumentationAttachment[];
-}

package/lib/adapters/kotlin/IKotlinDocumentationAttachment.d.ts

@@ -1,23 +0,0 @@
-/**
- * Connects a KDoc carrier to one extracted Kotlin declaration site.
- *
- * KotlinFileScanner establishes this adjacency from source, then the
- * documentation pass uses the pair to evaluate annotations for the relevant
- * site without assigning the comment semantic ownership.
- */
-export interface IKotlinDocumentationAttachment {
-    /**
-     * Identifies the declaration extraction record that receives the KDoc.
-     *
-     * Consumers use this stable scanner-local ID to recover the declaration whose
-     * annotation is evaluated.
-     */
-    declarationId: string;
-    /**
-     * Identifies the physical declaration site covered by the KDoc.
-     *
-     * This distinguishes the adjacent source occurrence when one semantic unit
-     * has more than one declaration site.
-     */
-    siteId: string;
-}

package/lib/adapters/kotlin/IKotlinFileAnalysis.d.ts

@@ -1,39 +0,0 @@
-import type { IEvidenceDiagnostic } from "../../structures/IEvidenceDiagnostic";
-import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
-import type { IKotlinDeclaration } from "./IKotlinDeclaration";
-import type { IKotlinDocumentation } from "./IKotlinDocumentation";
-/**
- * Holds the node-free Kotlin extraction retained after a parse session closes.
- *
- * Receiver and alias resolution consumes all selected files after scanning, so
- * this boundary owns source-context facts without retaining parser objects.
- */
-export interface IKotlinFileAnalysis {
-    /** Retains the selected Kotlin source file that produced this analysis.
-     *
-     * Receiver resolution uses its physical identity for file-private lookup, and materialization uses its addresses for public citations.
-     */
-    source: IEvidenceSourceFile;
-    /** Lists extracted declarations, including non-public lookup boundaries.
-     *
-     * `KotlinReceivers` consumes the records across the snapshot before `KotlinAdapter` selects public units.
-     */
-    declarations: IKotlinDeclaration[];
-    /** Lists classified KDoc and unsupported annotation carriers from this file.
-     *
-     * The adapter preserves tagged unsupported carriers so they can produce host-level diagnostics.
-     */
-    documentation: IKotlinDocumentation[];
-    /** Lists failures encountered while establishing this file's public surface.
-     *
-     * The adapter forwards them into the inventory together with the `complete` status.
-     */
-    diagnostics: IEvidenceDiagnostic[];
-    /**
-     * States whether the scanner understood every surface-affecting form.
-     *
-     * Incomplete scans are propagated into the inventory so unsupported Kotlin
-     * syntax cannot make a coverage check pass with fewer units.
-     */
-    complete: boolean;
-}