@jhlagado/azm 0.1.0 → 0.2.0

package/dist/src/{registerCare → register-care}/tooling.js

@@ -16,8 +16,8 @@ export function codeActionForOutputCandidate(candidate) {
     };
 }
 export function diagnosticForOutputCandidate(candidate) {
-    const codeAction = codeActionForOutputCandidate(candidate);
-    return {
+    const codeAction = candidate.autoFixable === true ? codeActionForOutputCandidate(candidate) : undefined;
+    const diagnostic = {
         kind: 'register-care-output-candidate',
         severity: 'info',
         file: candidate.file,
@@ -27,23 +27,34 @@ export function diagnosticForOutputCandidate(candidate) {
         carriers: candidate.carriers,
         autoFixable: candidate.autoFixable === true,
         message: candidate.message,
-        codeAction,
     };
+    if (codeAction !== undefined) {
+        diagnostic.codeAction = codeAction;
+    }
+    return diagnostic;
 }
 export function analyzeRegisterCareForTools(loaded, options) {
-    const result = analyzeRegisterCare(loaded, {
+    const profile = options.registerCareProfile ?? options.profile;
+    const baseResultOptions = {
         ...options,
         emitReport: options.emitReport === true,
         emitInterface: options.emitInterface === true,
         emitAnnotations: false,
-    });
+        fixRegisterContracts: false,
+    };
+    const result = analyzeRegisterCare(loaded, profile === undefined
+        ? baseResultOptions
+        : { ...baseResultOptions, registerCareProfile: profile });
     const outputCandidates = result.outputCandidates ?? [];
     const candidateDiagnostics = outputCandidates.map(diagnosticForOutputCandidate);
+    const codeActions = outputCandidates
+        .filter((candidate) => candidate.autoFixable === true)
+        .map(codeActionForOutputCandidate);
     return {
         diagnostics: result.diagnostics,
         outputCandidates,
         candidateDiagnostics,
-        codeActions: candidateDiagnostics.map((diagnostic) => diagnostic.codeAction),
+        codeActions,
         ...(result.reportText !== undefined ? { reportText: result.reportText } : {}),
         ...(result.interfaceText !== undefined ? { interfaceText: result.interfaceText } : {}),
     };

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

@@ -0,0 +1,165 @@
+import type { Z80Instruction } from '../z80/instruction.js';
+export type RegisterCareMode = 'off' | 'audit' | 'warn' | 'error' | 'strict';
+export type RegisterCareUnit = 'A' | 'B' | 'C' | 'D' | 'E' | 'H' | 'L' | 'IXH' | 'IXL' | 'IYH' | 'IYL' | 'SPH' | 'SPL' | 'carry' | 'zero' | 'sign' | 'parity' | 'halfCarry';
+export type SmartComment = {
+    kind: 'extern';
+    name: string;
+} | {
+    kind: 'end';
+} | {
+    kind: 'in';
+    carriers: RegisterCareUnit[];
+    name?: string;
+} | {
+    kind: 'out';
+    carriers: RegisterCareUnit[];
+    name?: string;
+} | {
+    kind: 'clobbers';
+    carriers: RegisterCareUnit[];
+} | {
+    kind: 'preserves';
+    carriers: RegisterCareUnit[];
+} | {
+    kind: 'expectOut';
+    carriers: RegisterCareUnit[];
+    name?: string;
+};
+export interface LocatedSmartComment {
+    file: string;
+    line: number;
+    comment: SmartComment;
+}
+export interface RoutineContract {
+    name: string;
+    in: RegisterCareUnit[];
+    out: RegisterCareUnit[];
+    clobbers: RegisterCareUnit[];
+    preserves: RegisterCareUnit[];
+    complete?: boolean;
+}
+export interface RegisterCareInstruction {
+    instruction: Z80Instruction;
+    file: string;
+    line: number;
+    column: number;
+    labels: string[];
+}
+export interface RegisterCareRoutine {
+    name: string;
+    labels: string[];
+    entryLabels: string[];
+    instructions: RegisterCareInstruction[];
+    span: {
+        file: string;
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+}
+export interface RegisterCareDirectCall {
+    target: string;
+    file: string;
+    line: number;
+    column: number;
+}
+export interface RegisterCareProgramModel {
+    routines: RegisterCareRoutine[];
+    directCalls: RegisterCareDirectCall[];
+}
+export type StackEffect = {
+    kind: 'none';
+} | {
+    kind: 'push';
+    units: RegisterCareUnit[];
+} | {
+    kind: 'pop';
+    units: RegisterCareUnit[];
+} | {
+    kind: 'exchangeTop';
+    units: RegisterCareUnit[];
+} | {
+    kind: 'unknown';
+};
+export type ControlEffect = {
+    kind: 'fallthrough';
+} | {
+    kind: 'call';
+    target?: string;
+    conditional: boolean;
+} | {
+    kind: 'rst';
+    vector?: number;
+} | {
+    kind: 'return';
+    conditional: boolean;
+} | {
+    kind: 'jump';
+    target?: string;
+    conditional: boolean;
+} | {
+    kind: 'unknown';
+};
+export interface InstructionEffect {
+    reads: RegisterCareUnit[];
+    writes: RegisterCareUnit[];
+    stack: StackEffect;
+    control: ControlEffect;
+}
+export interface ValueRelation {
+    out: RegisterCareUnit[];
+    from: RegisterCareUnit[];
+}
+export interface RoutineSummary {
+    name: string;
+    mayRead: RegisterCareUnit[];
+    mayWrite: RegisterCareUnit[];
+    mayOutput?: RegisterCareUnit[];
+    preserved: RegisterCareUnit[];
+    valueRelations?: ValueRelation[];
+}
+export interface RegisterCareOutputCandidate {
+    file: string;
+    line: number;
+    column: number;
+    routine: string;
+    carriers: RegisterCareUnit[];
+    autoFixable?: boolean;
+    message: string;
+}
+export interface RegisterCareConflict {
+    file: string;
+    line: number;
+    column: number;
+    callTarget: string;
+    carriers: RegisterCareUnit[];
+    message: string;
+}
+export interface RegisterCareReportModel {
+    entryFile: string;
+    mode: RegisterCareMode;
+    profile?: string;
+    summaries: RoutineSummary[];
+    conflicts: RegisterCareConflict[];
+    outputCandidates?: RegisterCareOutputCandidate[];
+    unknownCalls: string[];
+}
+export interface AnalyzeRegisterCareOptions {
+    mode: RegisterCareMode;
+    emitReport: boolean;
+    emitInterface: boolean;
+    emitAnnotations?: boolean;
+    fixRegisterContracts?: boolean;
+    registerCareProfile?: 'mon3';
+    interfaceContracts?: RoutineContract[];
+    acceptedOutputCandidates?: ReadonlyMap<string, RegisterCareUnit[]>;
+}
+export interface RegisterCareAnnotationFile {
+    readonly path: string;
+    readonly text: string;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/src/semantics/expression-evaluation.d.ts

@@ -0,0 +1,29 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { Expression } from '../model/expression.js';
+import type { LayoutField } from '../model/source-item.js';
+import type { SourceSpan } from '../source/source-span.js';
+export interface EquateRecord {
+    readonly expression: Expression;
+    readonly span: SourceSpan;
+    readonly currentLocation: number;
+    readonly enumMember?: boolean;
+    readonly stringValue?: string;
+}
+export interface LayoutRecord {
+    readonly kind: 'record' | 'union';
+    readonly fields: readonly LayoutField[];
+    readonly span: SourceSpan;
+}
+export declare function lookupEquateRecord(equates: ReadonlyMap<string, EquateRecord>, name: string): {
+    readonly key: string;
+    readonly record: EquateRecord;
+} | undefined;
+export declare function lookupSymbolValue(symbols: Readonly<Record<string, number>>, name: string): number | undefined;
+export declare function evaluateExpression(expression: Expression, labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, span: SourceSpan, diagnostics: Diagnostic[], options: {
+    readonly currentLocation: number;
+    readonly layouts?: ReadonlyMap<string, LayoutRecord> | undefined;
+    readonly visiting?: ReadonlySet<string>;
+    readonly reportUnknown?: boolean;
+}): number | undefined;
+export declare function diagnostic(span: SourceSpan, message: string): Diagnostic;
+export declare function validateLayouts(layouts: ReadonlyMap<string, LayoutRecord>, diagnostics: Diagnostic[]): void;

package/dist/src/semantics/expression-evaluation.js

@@ -0,0 +1,409 @@
+function canonicalSymbolKey(name) {
+    return name.toLowerCase();
+}
+function lookupLabelValue(labels, name) {
+    if (labels[name] !== undefined) {
+        return labels[name];
+    }
+    const lower = canonicalSymbolKey(name);
+    for (const [key, value] of Object.entries(labels)) {
+        if (key.toLowerCase() === lower) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function lookupEquateRecord(equates, name) {
+    const direct = equates.get(name);
+    if (direct !== undefined) {
+        return { key: name, record: direct };
+    }
+    const lower = canonicalSymbolKey(name);
+    for (const [key, record] of equates) {
+        if (key.toLowerCase() === lower) {
+            return { key, record };
+        }
+    }
+    return undefined;
+}
+export function lookupSymbolValue(symbols, name) {
+    return lookupLabelValue(symbols, name);
+}
+export function evaluateExpression(expression, labels, equates, span, diagnostics, options) {
+    switch (expression.kind) {
+        case 'number':
+            return expression.value;
+        case 'current-location':
+            return options.currentLocation;
+        case 'type-size':
+            return evaluateTypeSize(expression.typeExpr, labels, equates, span, diagnostics, options);
+        case 'sizeof':
+            return evaluateSizeof(expression.typeExpr, options.layouts, span, diagnostics);
+        case 'offset':
+            return evaluateOffset(expression.typeExpr, expression.path, options.layouts, span, diagnostics);
+        case 'layout-cast':
+            return evaluateLayoutCast(expression, labels, equates, span, diagnostics, options);
+        case 'symbol':
+            return evaluateSymbol(expression.name, labels, equates, span, diagnostics, options);
+        case 'unary':
+            return evaluateUnary(expression, labels, equates, span, diagnostics, options);
+        case 'binary':
+            return evaluateBinary(expression, labels, equates, span, diagnostics, options);
+    }
+}
+function evaluateTypeSize(typeExpr, labels, equates, span, diagnostics, options) {
+    if (options.layouts) {
+        const sizeDiagnostics = [];
+        const size = typeExprSize(typeExpr, options.layouts, span, sizeDiagnostics, new Set([typeExpr.name]));
+        if (size !== undefined) {
+            return size;
+        }
+        if (typeExpr.length !== undefined || scalarSize(typeExpr.name) !== undefined) {
+            diagnostics.push(...sizeDiagnostics);
+            return undefined;
+        }
+    }
+    if (typeExpr.length !== undefined) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    return evaluateSymbol(typeExpr.name, labels, equates, span, diagnostics, options);
+}
+function evaluateLayoutCast(expression, labels, equates, span, diagnostics, options) {
+    const base = evaluateExpression(expression.base, labels, equates, span, diagnostics, options);
+    if (base === undefined) {
+        return undefined;
+    }
+    if (!options.layouts) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(expression.typeExpr)}`));
+        return undefined;
+    }
+    const offset = layoutCastOffset(expression.typeExpr, expression.path, labels, equates, options.layouts, span, diagnostics, options);
+    return offset === undefined ? undefined : base + offset;
+}
+export function diagnostic(span, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_SYMBOL',
+        message,
+        sourceName: span.sourceName,
+        line: span.line,
+        column: span.column,
+    };
+}
+export function validateLayouts(layouts, diagnostics) {
+    for (const [name, layout] of layouts) {
+        layoutSize(name, layout, layouts, layout.span, diagnostics, new Set([name]));
+    }
+}
+function evaluateSymbol(name, labels, equates, span, diagnostics, options) {
+    const label = lookupLabelValue(labels, name);
+    if (label !== undefined) {
+        return label;
+    }
+    const equate = lookupEquateRecord(equates, name);
+    if (equate) {
+        if (options.visiting?.has(equate.key)) {
+            diagnostics.push(diagnostic(span, `recursive symbol: ${name}`));
+            return undefined;
+        }
+        return evaluateExpression(equate.record.expression, labels, equates, equate.record.span, diagnostics, {
+            currentLocation: equate.record.currentLocation,
+            visiting: new Set([...(options.visiting ?? []), equate.key]),
+            layouts: options.layouts,
+            ...(options.reportUnknown !== undefined ? { reportUnknown: options.reportUnknown } : {}),
+        });
+    }
+    if (hasUnqualifiedEnumMember(name, equates)) {
+        diagnostics.push(diagnostic(span, `Enum member "${name}" must be qualified.`));
+        return undefined;
+    }
+    if (options.reportUnknown ?? true) {
+        diagnostics.push(diagnostic(span, `unknown symbol: ${name}`));
+    }
+    return undefined;
+}
+function evaluateSizeof(typeExpr, layouts, span, diagnostics) {
+    if (!layouts) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    return typeExprSize(typeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+}
+function evaluateOffset(typeExpr, path, layouts, span, diagnostics) {
+    if (!layouts) {
+        diagnostics.push(diagnostic(span, `unknown type: ${formatTypeExpr(typeExpr)}`));
+        return undefined;
+    }
+    const diagnosticCount = diagnostics.length;
+    const offset = offsetPath(typeExpr, path, layouts, span, diagnostics);
+    if (offset !== undefined) {
+        return offset;
+    }
+    if (diagnostics.length === diagnosticCount) {
+        diagnostics.push(diagnostic(span, `unknown field "${formatOffsetPath(path)}" in type ${formatTypeExpr(typeExpr)}`));
+    }
+    return undefined;
+}
+function typeExprSize(typeExpr, layouts, span, diagnostics, visiting) {
+    const scalar = scalarSize(typeExpr.name);
+    const baseSize = scalar ??
+        (() => {
+            const layout = layouts.get(typeExpr.name);
+            if (!layout) {
+                diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
+                return undefined;
+            }
+            return layoutSize(typeExpr.name, layout, layouts, span, diagnostics, visiting);
+        })();
+    if (baseSize === undefined) {
+        return undefined;
+    }
+    return typeExpr.length === undefined ? baseSize : baseSize * typeExpr.length;
+}
+function layoutSize(typeName, layout, layouts, span, diagnostics, visiting) {
+    const fieldSizes = [];
+    for (const field of layout.fields) {
+        const size = fieldSize(field, layouts, span, diagnostics, visiting);
+        if (size === undefined) {
+            return undefined;
+        }
+        fieldSizes.push(size);
+    }
+    return layout.kind === 'union'
+        ? fieldSizes.reduce((largest, size) => Math.max(largest, size), 0)
+        : fieldSizes.reduce((sum, size) => sum + size, 0);
+}
+function fieldSize(field, layouts, span, diagnostics, visiting) {
+    if (field.typeExpr === undefined) {
+        return field.size;
+    }
+    if (visiting.has(field.typeExpr.name)) {
+        diagnostics.push(diagnostic(span, visiting.size === 1
+            ? `Self-referential field type "${field.typeExpr.name}" has no finite size; use .addr for a pointer field.`
+            : `recursive type: ${field.typeExpr.name}`));
+        return undefined;
+    }
+    return typeExprSize(field.typeExpr, layouts, span, diagnostics, new Set([...visiting, field.typeExpr.name]));
+}
+function offsetPath(typeExpr, parts, layouts, span, diagnostics) {
+    const [head, ...tail] = parts;
+    if (head === undefined) {
+        return undefined;
+    }
+    if (head.kind === 'index') {
+        if (typeExpr.length === undefined) {
+            return undefined;
+        }
+        if (head.index >= typeExpr.length) {
+            diagnostics.push(diagnostic(span, `array index ${head.index} out of range for ${formatTypeExpr(typeExpr)}`));
+            return undefined;
+        }
+        const elementTypeExpr = { name: typeExpr.name };
+        const stride = typeExprSize(elementTypeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+        if (stride === undefined) {
+            return undefined;
+        }
+        if (tail.length === 0) {
+            return head.index * stride;
+        }
+        const nestedOffset = offsetPath(elementTypeExpr, tail, layouts, span, diagnostics);
+        return nestedOffset === undefined ? undefined : head.index * stride + nestedOffset;
+    }
+    if (typeExpr.length !== undefined) {
+        return undefined;
+    }
+    const layout = layouts.get(typeExpr.name);
+    if (!layout) {
+        diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
+        return undefined;
+    }
+    let currentOffset = 0;
+    for (const field of layout.fields) {
+        const fieldOffset = layout.kind === 'union' ? 0 : currentOffset;
+        if (field.name === head.name) {
+            if (field.typeExpr !== undefined) {
+                const size = fieldSize(field, layouts, span, diagnostics, new Set([typeExpr.name]));
+                if (size === undefined) {
+                    return undefined;
+                }
+            }
+            if (tail.length === 0) {
+                return fieldOffset;
+            }
+            if (field.typeExpr === undefined) {
+                return undefined;
+            }
+            const nestedOffset = offsetPath(field.typeExpr, tail, layouts, span, diagnostics);
+            return nestedOffset === undefined ? undefined : fieldOffset + nestedOffset;
+        }
+        const size = fieldSize(field, layouts, span, diagnostics, new Set([typeExpr.name]));
+        if (size === undefined) {
+            return undefined;
+        }
+        currentOffset += size;
+    }
+    return undefined;
+}
+function layoutCastOffset(typeExpr, parts, labels, equates, layouts, span, diagnostics, options) {
+    const [head, ...tail] = parts;
+    if (head === undefined) {
+        return 0;
+    }
+    if (head.kind === 'index') {
+        if (typeExpr.length === undefined) {
+            return undefined;
+        }
+        const registerName = registerIndexName(head.expression);
+        if (registerName) {
+            diagnostics.push(diagnostic(span, `runtime register index "${registerName}" is not supported in layout casts`));
+            return undefined;
+        }
+        const index = evaluateExpression(head.expression, labels, equates, span, diagnostics, {
+            ...options,
+            layouts,
+        });
+        if (index === undefined) {
+            return undefined;
+        }
+        if (index < 0 || index >= typeExpr.length) {
+            diagnostics.push(diagnostic(span, `array index ${index} out of range for ${formatTypeExpr(typeExpr)}`));
+            return undefined;
+        }
+        const elementTypeExpr = { name: typeExpr.name };
+        const stride = typeExprSize(elementTypeExpr, layouts, span, diagnostics, new Set([typeExpr.name]));
+        if (stride === undefined) {
+            return undefined;
+        }
+        const nestedOffset = layoutCastOffset(elementTypeExpr, tail, labels, equates, layouts, span, diagnostics, options);
+        return nestedOffset === undefined ? undefined : index * stride + nestedOffset;
+    }
+    if (typeExpr.length !== undefined) {
+        return undefined;
+    }
+    const layout = layouts.get(typeExpr.name);
+    if (!layout) {
+        diagnostics.push(diagnostic(span, `unknown type: ${typeExpr.name}`));
+        return undefined;
+    }
+    let currentOffset = 0;
+    for (const field of layout.fields) {
+        const fieldOffset = layout.kind === 'union' ? 0 : currentOffset;
+        if (field.name === head.name) {
+            if (field.typeExpr !== undefined) {
+                const size = fieldSize(field, layouts, span, diagnostics, new Set([typeExpr.name]));
+                if (size === undefined) {
+                    return undefined;
+                }
+            }
+            if (tail.length === 0) {
+                return fieldOffset;
+            }
+            if (field.typeExpr === undefined) {
+                return undefined;
+            }
+            const nestedOffset = layoutCastOffset(field.typeExpr, tail, labels, equates, layouts, span, diagnostics, options);
+            return nestedOffset === undefined ? undefined : fieldOffset + nestedOffset;
+        }
+        const size = fieldSize(field, layouts, span, diagnostics, new Set([typeExpr.name]));
+        if (size === undefined) {
+            return undefined;
+        }
+        currentOffset += size;
+    }
+    return undefined;
+}
+function registerIndexName(expression) {
+    switch (expression.kind) {
+        case 'symbol':
+            return /^(a|b|c|d|e|h|l|af|bc|de|hl|ix|iy|sp|i|r|ixh|ixl|iyh|iyl)$/i.test(expression.name)
+                ? expression.name.toUpperCase()
+                : undefined;
+        case 'unary':
+            return registerIndexName(expression.expression);
+        case 'binary':
+            return registerIndexName(expression.left) ?? registerIndexName(expression.right);
+        default:
+            return undefined;
+    }
+}
+function formatTypeExpr(typeExpr) {
+    return typeExpr.length === undefined ? typeExpr.name : `${typeExpr.name}[${typeExpr.length}]`;
+}
+function formatOffsetPath(path) {
+    return path.map((part) => (part.kind === 'field' ? part.name : `[${part.index}]`)).join('.');
+}
+function scalarSize(typeName) {
+    switch (typeName.toLowerCase()) {
+        case 'byte':
+            return 1;
+        case 'word':
+        case 'addr':
+            return 2;
+        default:
+            return undefined;
+    }
+}
+function hasUnqualifiedEnumMember(name, equates) {
+    if (name.includes('.')) {
+        return false;
+    }
+    const suffix = `.${name}`;
+    for (const [key, record] of equates) {
+        if (record.enumMember === true && key.endsWith(suffix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function evaluateUnary(expression, labels, equates, span, diagnostics, options) {
+    const value = evaluateExpression(expression.expression, labels, equates, span, diagnostics, options);
+    if (value === undefined) {
+        return undefined;
+    }
+    switch (expression.operator) {
+        case '+':
+            return value;
+        case '-':
+            return -value;
+        case '~':
+            return ~value;
+    }
+}
+function evaluateBinary(expression, labels, equates, span, diagnostics, options) {
+    const left = evaluateExpression(expression.left, labels, equates, span, diagnostics, options);
+    const right = evaluateExpression(expression.right, labels, equates, span, diagnostics, options);
+    if (left === undefined || right === undefined) {
+        return undefined;
+    }
+    switch (expression.operator) {
+        case '*':
+            return left * right;
+        case '/':
+            if (right === 0) {
+                diagnostics.push(diagnostic(span, 'Divide by zero in imm expression.'));
+                return undefined;
+            }
+            return Math.trunc(left / right);
+        case '%':
+            if (right === 0) {
+                diagnostics.push(diagnostic(span, 'modulo by zero in expression'));
+                return undefined;
+            }
+            return left % right;
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '&':
+            return left & right;
+        case '^':
+            return left ^ right;
+        case '|':
+            return left | right;
+        case '<<':
+            return left << right;
+        case '>>':
+            return left >> right;
+    }
+}

package/dist/src/source/logical-lines.d.ts

@@ -0,0 +1,7 @@
+import type { SourceFile } from './source-file.js';
+export interface LogicalLine {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly text: string;
+}
+export declare function scanLogicalLines(source: SourceFile): LogicalLine[];

package/dist/src/source/logical-lines.js

@@ -0,0 +1,11 @@
+export function scanLogicalLines(source) {
+    const normalized = source.text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const rawLines = normalized.endsWith('\n')
+        ? normalized.slice(0, -1).split('\n')
+        : normalized.split('\n');
+    return rawLines.map((text, index) => ({
+        sourceName: source.name,
+        line: index + 1,
+        text,
+    }));
+}

package/dist/src/source/source-file.d.ts

@@ -0,0 +1,5 @@
+export interface SourceFile {
+    readonly name: string;
+    readonly text: string;
+}
+export declare function createSourceFile(name: string, text: string): SourceFile;

package/dist/src/source/source-file.js

@@ -0,0 +1,3 @@
+export function createSourceFile(name, text) {
+    return { name, text };
+}

package/dist/src/source/source-span.d.ts

@@ -0,0 +1,5 @@
+export interface SourceSpan {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}