@jhlagado/azm 0.1.1 → 0.2.1

package/dist/src/register-care/smartComments.js

@@ -0,0 +1,243 @@
+import { expandCarrierList } from './carriers.js';
+const COMPACT_SOURCE_TAG_RE = /^;?\s*!\s*(in|out|clobbers|preserves)(?:\s+(.+))?$/i;
+const COMPACT_SOURCE_LINE_RE = /^\s*;\s*!\s*(?:in|out|maybe-out|clobbers|preserves)(?:\s|$)/i;
+const INTERFACE_TAG_RE = /^\s*(in|out|clobbers|preserves)(?:\s+(.+))?$/i;
+const CARRIER_RE = /^\{([^}]+)\}(?:\s+(.+))?$/;
+function parseCarrierPayload(rest) {
+    if (!rest)
+        return undefined;
+    const match = CARRIER_RE.exec(rest.trim());
+    if (match) {
+        const carriers = match[1].split(',').map((value) => value.trim()).filter(Boolean);
+        const name = match[2]?.trim();
+        return { carriers, ...(name ? { name } : {}) };
+    }
+    const tokens = rest.trim().split(/\s+/u);
+    const carriers = [];
+    let consumed = 0;
+    for (const token of tokens) {
+        const cleaned = token.replace(/[.:;]+$/u, '');
+        const parts = cleaned
+            .split(',')
+            .map((value) => value.trim())
+            .filter(Boolean);
+        if (parts.length === 0 || !expandCarrierList(parts))
+            break;
+        carriers.push(...parts);
+        consumed += 1;
+    }
+    if (carriers.length === 0)
+        return undefined;
+    const name = tokens.slice(consumed).join(' ').trim();
+    return { carriers, ...(name ? { name } : {}) };
+}
+export function parseSmartCommentLine(line) {
+    const trimmed = line.trim();
+    const expectOut = /^;?\s*expects\s+out\s+(.+)$/i.exec(trimmed);
+    if (expectOut !== null) {
+        const payload = parseCarrierPayload(expectOut[1]?.trim());
+        if (!payload)
+            return undefined;
+        const carriers = expandCarrierList(payload.carriers);
+        if (!carriers || carriers.length === 0)
+            return undefined;
+        return { kind: 'expectOut', carriers, ...(payload.name ? { name: payload.name } : {}) };
+    }
+    const match = COMPACT_SOURCE_TAG_RE.exec(trimmed);
+    if (!match)
+        return undefined;
+    const tag = match[1].toLowerCase();
+    const rest = match[2]?.trim();
+    const payload = parseCarrierPayload(rest);
+    if (!payload)
+        return undefined;
+    const carriers = expandCarrierList(payload.carriers);
+    if (!carriers || carriers.length === 0)
+        return undefined;
+    if (tag === 'in')
+        return { kind: 'in', carriers, ...(payload.name ? { name: payload.name } : {}) };
+    if (tag === 'out')
+        return { kind: 'out', carriers, ...(payload.name ? { name: payload.name } : {}) };
+    if (tag === 'clobbers')
+        return { kind: 'clobbers', carriers };
+    if (tag === 'preserves')
+        return { kind: 'preserves', carriers };
+    return undefined;
+}
+function parseInterfaceContractLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith(';'))
+        return undefined;
+    const extern = /^extern\s+(\S+)\s*$/i.exec(trimmed);
+    if (extern !== null)
+        return { kind: 'extern', name: extern[1] };
+    if (/^end\s*$/i.test(trimmed))
+        return { kind: 'end' };
+    const match = INTERFACE_TAG_RE.exec(trimmed);
+    if (!match)
+        return undefined;
+    const tag = match[1].toLowerCase();
+    const rest = match[2]?.trim();
+    if (!rest)
+        return undefined;
+    const rawCarriers = rest.split(',').map((part) => part.trim());
+    if (rawCarriers.length === 0 || rawCarriers.some((part) => part.length === 0))
+        return undefined;
+    const carriers = expandCarrierList(rawCarriers);
+    if (!carriers || carriers.length === 0)
+        return undefined;
+    if (tag === 'in')
+        return { kind: 'in', carriers };
+    if (tag === 'out')
+        return { kind: 'out', carriers };
+    if (tag === 'clobbers')
+        return { kind: 'clobbers', carriers };
+    if (tag === 'preserves')
+        return { kind: 'preserves', carriers };
+    return undefined;
+}
+function isCompactSourceCommentLine(line) {
+    return COMPACT_SOURCE_LINE_RE.test(line);
+}
+export function parseSmartComments(sourceLineComments) {
+    const out = [];
+    for (const [file, comments] of sourceLineComments) {
+        for (const [line, text] of comments) {
+            const parsed = parseSmartCommentLine(`;${text}`);
+            if (parsed) {
+                out.push({ file, line, comment: parsed });
+            }
+        }
+    }
+    return out.sort((a, b) => (a.file === b.file ? a.line - b.line : a.file.localeCompare(b.file)));
+}
+function appendUnique(items, values) {
+    for (const value of values) {
+        if (!items.includes(value)) {
+            items.push(value);
+        }
+    }
+}
+function isCommentOnlyLine(line) {
+    return /^\s*;/.test(line);
+}
+function applyContractComment(contract, comment) {
+    if (comment.kind === 'in')
+        appendUnique(contract.in, comment.carriers);
+    if (comment.kind === 'out')
+        appendUnique(contract.out, comment.carriers);
+    if (comment.kind === 'clobbers')
+        appendUnique(contract.clobbers, comment.carriers);
+    if (comment.kind === 'preserves')
+        appendUnique(contract.preserves, comment.carriers);
+}
+function hasContractContent(contract) {
+    return (contract.in.length > 0 ||
+        contract.out.length > 0 ||
+        contract.clobbers.length > 0 ||
+        contract.preserves.length > 0);
+}
+function collectPrecedingCommentBlock(routine, sourceTexts) {
+    const source = sourceTexts.get(routine.span.file);
+    if (source === undefined)
+        return { comments: [], complete: false };
+    const lines = source.split(/\r?\n/);
+    const rawBlock = [];
+    for (let index = routine.span.start.line - 2; index >= 0; index -= 1) {
+        const text = lines[index] ?? '';
+        if (!isCommentOnlyLine(text))
+            break;
+        rawBlock.push({ line: index + 1, text });
+    }
+    rawBlock.reverse();
+    let compactStart = rawBlock.length;
+    while (compactStart > 0 &&
+        isCompactSourceCommentLine(rawBlock[compactStart - 1]?.text ?? '')) {
+        compactStart -= 1;
+    }
+    return {
+        complete: compactStart < rawBlock.length,
+        comments: (compactStart < rawBlock.length ? rawBlock.slice(compactStart) : rawBlock).flatMap((item) => {
+            const parsed = parseSmartCommentLine(item.text);
+            return parsed ? [{ file: routine.span.file, line: item.line, comment: parsed }] : [];
+        }),
+    };
+}
+function buildImplicitRoutineContracts(routines, sourceTexts) {
+    const contracts = new Map();
+    for (const routine of routines) {
+        const docBlock = collectPrecedingCommentBlock(routine, sourceTexts);
+        if (docBlock.comments.some((item) => item.comment.kind === 'extern' || item.comment.kind === 'end')) {
+            continue;
+        }
+        const contract = {
+            name: routine.name,
+            in: [],
+            out: [],
+            clobbers: [],
+            preserves: [],
+            ...(docBlock.complete ? { complete: true } : {}),
+        };
+        for (const item of docBlock.comments) {
+            applyContractComment(contract, item.comment);
+        }
+        if (hasContractContent(contract)) {
+            contracts.set(routine.name, contract);
+        }
+    }
+    return contracts;
+}
+export function buildRoutineContracts(comments, routines = [], sourceTexts = new Map()) {
+    const contracts = new Map();
+    let current;
+    for (const item of comments) {
+        if (item.comment.kind === 'extern') {
+            current = {
+                name: item.comment.name,
+                in: [],
+                out: [],
+                clobbers: [],
+                preserves: [],
+            };
+            contracts.set(item.comment.name, current);
+            continue;
+        }
+        if (item.comment.kind === 'end') {
+            current = undefined;
+            continue;
+        }
+        if (current !== undefined) {
+            applyContractComment(current, item.comment);
+        }
+    }
+    for (const [name, contract] of buildImplicitRoutineContracts(routines, sourceTexts)) {
+        if (!contracts.has(name)) {
+            contracts.set(name, contract);
+        }
+    }
+    return contracts;
+}
+export function parseInterfaceContracts(text, file = '<register-care-interface>') {
+    const comments = [];
+    const lines = text.split(/\r?\n/u);
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        if (trimmed.startsWith(';')) {
+            throw new Error(`${file}:${index + 1}: .asmi files do not permit comments`);
+        }
+        const comment = parseInterfaceContractLine(line);
+        if (comment === undefined) {
+            throw new Error(`${file}:${index + 1}: invalid register-care interface line \"${trimmed}\"`);
+        }
+        comments.push({ file, line: index + 1, comment });
+    }
+    const routines = buildRoutineContracts(comments);
+    const out = new Map();
+    for (const [name, contract] of routines) {
+        if (hasContractContent(contract))
+            out.set(name, contract);
+    }
+    return out;
+}

package/dist/src/register-care/sourceText.d.ts

@@ -0,0 +1,8 @@
+type SourceLines = {
+    lines: string[];
+    trailingNewline: boolean;
+    eol: '\n' | '\r\n';
+};
+export declare function splitSourceLines(text: string): SourceLines;
+export declare function joinSourceLines({ lines, trailingNewline, eol }: SourceLines): string;
+export {};

package/dist/src/register-care/sourceText.js

@@ -0,0 +1,15 @@
+function lineEnding(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+export function splitSourceLines(text) {
+    const eol = lineEnding(text);
+    const trailingNewline = text.endsWith('\n');
+    const lines = text.split(/\r?\n/);
+    if (trailingNewline)
+        lines.pop();
+    return { lines, trailingNewline, eol };
+}
+export function joinSourceLines({ lines, trailingNewline, eol }) {
+    const text = lines.join(eol);
+    return trailingNewline ? `${text}${eol}` : text;
+}

package/dist/src/register-care/summaries.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { AnalyzeRegisterCareOptions, RegisterCareDirectCall, RegisterCareRoutine, RoutineContract, RoutineSummary, RegisterCareUnit, RegisterCareOutputCandidate } from './types.js';
+export declare function buildProfileSummaries(profileName: AnalyzeRegisterCareOptions['registerCareProfile']): RoutineSummary[];
+export declare function buildProfileSummaryLookup(profileName: AnalyzeRegisterCareOptions['registerCareProfile']): Map<string, RoutineSummary>;
+export declare function routineNames(routines: readonly RegisterCareRoutine[]): string[];
+export declare function buildSummaries(routines: readonly RegisterCareRoutine[], contractMap: Map<string, RoutineContract>, profileSummaries?: readonly RoutineSummary[]): RoutineSummary[];
+export declare function buildSummaryByName(routines: readonly RegisterCareRoutine[], summaries: readonly RoutineSummary[], profileSummaries?: readonly RoutineSummary[]): Map<string, RoutineSummary>;
+export declare function withAcceptedOutputs(summaries: readonly RoutineSummary[], acceptedOutputCandidates: ReadonlyMap<string, RegisterCareUnit[]> | undefined): RoutineSummary[];
+export declare function unknownBoundaryDiagnostics(directBoundaries: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): Diagnostic[];
+export declare function unknownCallList(directBoundaries: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): string[];
+export declare function buildOutputCandidateFixability(routines: readonly RegisterCareRoutine[], outputCandidates: readonly RegisterCareOutputCandidate[], autoFixableCandidateKeys: (routines: RegisterCareRoutine[], outputCandidates: RegisterCareOutputCandidate[]) => ReadonlySet<string>): ReadonlyMap<string, boolean>;
+export declare function outputCandidateKey(file: string, line: number, column: number): string;

package/dist/src/register-care/summaries.js

@@ -0,0 +1,121 @@
+import { getRegisterCareProfile } from './profiles.js';
+import { inferRoutineSummariesToFixedPoint, summariesWithExternalContracts, } from './routine-summaries.js';
+function unique(values) {
+    const out = [];
+    for (const value of values) {
+        if (!out.includes(value))
+            out.push(value);
+    }
+    return out;
+}
+function isLocalLabel(name) {
+    return name.startsWith('.');
+}
+function boundaryLabels(routine) {
+    return routine.entryLabels.length > 0
+        ? routine.entryLabels
+        : routine.labels.filter((label) => !isLocalLabel(label));
+}
+function routineNameSet(routines) {
+    return new Set(routines.flatMap((routine) => boundaryLabels(routine)));
+}
+export function buildProfileSummaries(profileName) {
+    const profile = getRegisterCareProfile(profileName);
+    if (profile === undefined) {
+        return [];
+    }
+    return [...profile.rst.values(), ...profile.rstServices.values()];
+}
+export function buildProfileSummaryLookup(profileName) {
+    const profile = getRegisterCareProfile(profileName);
+    const out = new Map();
+    if (profile === undefined)
+        return out;
+    for (const summary of profile.rst.values()) {
+        out.set(summary.name, summary);
+    }
+    for (const summary of profile.rstServices.values()) {
+        out.set(summary.name, summary);
+    }
+    return out;
+}
+export function routineNames(routines) {
+    return routines.flatMap((routine) => boundaryLabels(routine));
+}
+export function buildSummaries(routines, contractMap, profileSummaries = []) {
+    const names = routineNameSet(routines);
+    const routineSummaries = inferRoutineSummariesToFixedPoint([...routines], contractMap, names, [...profileSummaries]);
+    const summaries = routineSummaries.map((item) => item.summary);
+    return summariesWithExternalContracts(summaries, contractMap, names);
+}
+export function buildSummaryByName(routines, summaries, profileSummaries = []) {
+    const out = new Map();
+    const byRoutine = new Map();
+    for (const summary of summaries) {
+        byRoutine.set(summary.name, summary);
+        out.set(summary.name, summary);
+    }
+    for (const summary of profileSummaries) {
+        out.set(summary.name, summary);
+    }
+    for (const routine of routines) {
+        const routineSummary = byRoutine.get(routine.name);
+        if (routineSummary === undefined)
+            continue;
+        for (const alias of boundaryLabels(routine)) {
+            out.set(alias, routineSummary);
+        }
+    }
+    return out;
+}
+export function withAcceptedOutputs(summaries, acceptedOutputCandidates) {
+    if (!acceptedOutputCandidates || acceptedOutputCandidates.size === 0) {
+        return [...summaries];
+    }
+    return summaries.map((summary) => {
+        const accepted = acceptedOutputCandidates.get(summary.name);
+        if (!accepted || accepted.length === 0) {
+            return summary;
+        }
+        const written = new Set(summary.mayWrite);
+        const promoted = accepted.filter((unit) => written.has(unit));
+        if (promoted.length === 0) {
+            return summary;
+        }
+        const valueRelations = [...summary.valueRelations];
+        for (const unit of promoted) {
+            if (!valueRelations.some((relation) => relation.out.includes(unit))) {
+                valueRelations.push({ out: [unit], from: [] });
+            }
+        }
+        return { ...summary, valueRelations };
+    });
+}
+export function unknownBoundaryDiagnostics(directBoundaries, knownRoutines) {
+    return directBoundaries
+        .filter((boundary) => !knownRoutines.has(boundary.target))
+        .map((boundary) => ({
+        severity: 'warning',
+        code: 'AZMN_REGISTER_CARE',
+        message: `Register-care cannot prove ${boundary.subject}; add a routine body or .asmi extern contract.`,
+        sourceName: boundary.file,
+        line: boundary.line,
+        column: boundary.column,
+    }));
+}
+export function unknownCallList(directBoundaries, knownRoutines) {
+    return unique(directBoundaries
+        .filter((boundary) => !knownRoutines.has(boundary.target))
+        .map((boundary) => boundary.target)).sort();
+}
+export function buildOutputCandidateFixability(routines, outputCandidates, autoFixableCandidateKeys) {
+    const autoFixable = autoFixableCandidateKeys([...routines], [...outputCandidates]);
+    const out = new Map();
+    for (const candidate of outputCandidates) {
+        out.set(outputCandidateKey(candidate.file, candidate.line, candidate.column), autoFixable.has(outputCandidateKey(candidate.file, candidate.line, candidate.column)));
+    }
+    return out;
+}
+export function outputCandidateKey(file, line, column) {
+    return `${file}:${line}:${column}`;
+}

package/dist/src/register-care/summary.d.ts

@@ -0,0 +1,3 @@
+import type { RegisterCareRoutine, RoutineContract, RoutineSummary } from './types.js';
+export declare function inferRoutineSummary(routine: RegisterCareRoutine, boundarySummaries?: ReadonlyMap<string, RoutineSummary>): RoutineSummary;
+export declare function applyRoutineContract(summary: RoutineSummary, contract: RoutineContract): RoutineSummary;