@jhlagado/azm 0.1.0

package/dist/src/lowering/asmLoweringLd.js

@@ -0,0 +1,144 @@
+import { diagLayoutCastRuntimeIndex, isConstantLayoutCastEa } from '../semantics/layoutCastFold.js';
+function eaOperandExpr(op) {
+    if (op.kind === 'Ea')
+        return op.expr;
+    if (op.kind === 'Mem')
+        return op.expr;
+    return undefined;
+}
+function ldImmediateOpcode(dst) {
+    switch (dst) {
+        case 'BC':
+            return 0x01;
+        case 'DE':
+            return 0x11;
+        case 'HL':
+            return 0x21;
+        case 'SP':
+            return 0x31;
+        default:
+            return undefined;
+    }
+}
+function tryEmitUnresolvedSymbolicImmLd(asmItem, ctx, dst, srcOp) {
+    if (srcOp.kind !== 'Imm')
+        return false;
+    if (ctx.evalImmExpr(srcOp.expr) !== undefined)
+        return false;
+    const symbolic = ctx.symbolicTargetFromExpr(srcOp.expr);
+    if (!symbolic)
+        return false;
+    const baseLower = ctx.resolveRawLabelName(symbolic.baseLower).toLowerCase();
+    const opcode = ldImmediateOpcode(dst);
+    if (opcode !== undefined) {
+        ctx.emitAbs16Fixup(opcode, baseLower, symbolic.addend, asmItem.span);
+        return true;
+    }
+    if (dst === 'IX' || dst === 'IY') {
+        ctx.emitAbs16FixupPrefixed(dst === 'IX' ? 0xdd : 0xfd, 0x21, baseLower, symbolic.addend, asmItem.span);
+        return true;
+    }
+    return false;
+}
+/** Emit ordinary abs16 fixups for folded layout-cast address expressions. */
+function tryLdFoldedLayoutCast(asmItem, ctx) {
+    if (asmItem.operands.length !== 2)
+        return false;
+    const dstOp = asmItem.operands[0];
+    const srcOp = asmItem.operands[1];
+    const span = asmItem.span;
+    const emitFromAbs = (opcode, resolved, prefixed) => {
+        if (resolved.kind !== 'abs')
+            return;
+        if (prefixed) {
+            ctx.emitAbs16FixupPrefixed(prefixed.prefix, prefixed.opcode2, resolved.baseLower, resolved.addend, span);
+        }
+        else {
+            ctx.emitAbs16Fixup(opcode, resolved.baseLower, resolved.addend, span);
+        }
+    };
+    const dstName = dstOp.kind === 'Reg' ? dstOp.name.toUpperCase() : undefined;
+    const srcEa = eaOperandExpr(srcOp);
+    const dstEa = eaOperandExpr(dstOp);
+    if (srcEa && isConstantLayoutCastEa(srcEa)) {
+        const resolved = ctx.resolveEa(srcEa, span);
+        if (resolved?.kind === 'abs') {
+            if (dstName === 'A' && srcOp.kind === 'Mem') {
+                emitFromAbs(0x3a, resolved);
+                return true;
+            }
+            if (dstName === 'HL') {
+                emitFromAbs(0x21, resolved);
+                return true;
+            }
+            if (dstName === 'DE') {
+                emitFromAbs(0x11, resolved);
+                return true;
+            }
+            if (dstName === 'BC') {
+                emitFromAbs(0x01, resolved);
+                return true;
+            }
+            if (dstName === 'SP') {
+                emitFromAbs(0x31, resolved);
+                return true;
+            }
+            if (dstName === 'IX') {
+                emitFromAbs(0x21, resolved, { prefix: 0xdd, opcode2: 0x21 });
+                return true;
+            }
+            if (dstName === 'IY') {
+                emitFromAbs(0x21, resolved, { prefix: 0xfd, opcode2: 0x21 });
+                return true;
+            }
+        }
+    }
+    if (dstEa && isConstantLayoutCastEa(dstEa)) {
+        const resolved = ctx.resolveEa(dstEa, span);
+        if (resolved?.kind === 'abs' && srcOp.kind === 'Reg' && srcOp.name.toUpperCase() === 'A') {
+            emitFromAbs(0x32, resolved);
+            return true;
+        }
+    }
+    return false;
+}
+export function tryLowerLdInstruction(asmItem, ctx) {
+    const head = asmItem.head.toLowerCase();
+    if (head !== 'ld')
+        return undefined;
+    for (const op of asmItem.operands) {
+        const ea = eaOperandExpr(op);
+        if (ea && diagLayoutCastRuntimeIndex(ctx.diagnostics, asmItem.span, ea)) {
+            ctx.syncToFlow();
+            return true;
+        }
+    }
+    if (asmItem.operands.length === 2) {
+        const dstOp = asmItem.operands[0];
+        const srcOp = asmItem.operands[1];
+        const dst = dstOp.kind === 'Reg' ? dstOp.name.toUpperCase() : undefined;
+        if (tryEmitUnresolvedSymbolicImmLd(asmItem, ctx, dst, srcOp)) {
+            ctx.syncToFlow();
+            return true;
+        }
+        if (ctx.emitAbs16LdFixup(dstOp, srcOp, asmItem.span)) {
+            ctx.syncToFlow();
+            return true;
+        }
+        if (tryLdFoldedLayoutCast(asmItem, ctx)) {
+            ctx.syncToFlow();
+            return true;
+        }
+    }
+    if (asmItem.operands.some((op) => op.kind === 'Mem' && op.expr.kind !== 'EaImm' && !ctx.isRegisterLikeMemEa(op.expr))) {
+        if (ctx.lowerLdWithEa(asmItem)) {
+            ctx.syncToFlow();
+            return true;
+        }
+    }
+    if (asmItem.operands.some(ctx.isUnresolvedLayoutLdOperand)) {
+        ctx.diagAt(ctx.diagnostics, asmItem.span, `"ld" does not accept unresolved layout operands; use explicit labels, directives, and constant layout expressions.`);
+        return true;
+    }
+    return undefined;
+}

package/dist/src/lowering/asmRangeLowering.d.ts

@@ -0,0 +1,17 @@
+import type { AsmInstructionNode, AsmItemNode, SourceSpan } from '../frontend/ast.js';
+import type { FlowState } from './assemblerFlowSetup.js';
+type Context<TCodeSegmentTag> = {
+    sourceTagForSpan: (span: SourceSpan) => TCodeSegmentTag;
+    getCurrentCodeSegmentTag: () => TCodeSegmentTag | undefined;
+    setCurrentCodeSegmentTag: (tag: TCodeSegmentTag | undefined) => void;
+    defineCodeLabel: (name: string, span: SourceSpan, scope: 'global' | 'local') => void;
+    emitAsmInstruction: (item: AsmInstructionNode) => void;
+    flowRef: {
+        readonly current: FlowState;
+    };
+    syncFromFlow: () => void;
+};
+export declare function createAsmRangeLoweringHelpers<TCodeSegmentTag>(ctx: Context<TCodeSegmentTag>): {
+    lowerAsmRange: (asmItems: readonly AsmItemNode[], startIndex: number, stopKinds: Set<string>) => number;
+};
+export {};

package/dist/src/lowering/asmRangeLowering.js

@@ -0,0 +1,39 @@
+export function createAsmRangeLoweringHelpers(ctx) {
+    const lowerAsmRange = (asmItems, startIndex, stopKinds) => {
+        let i = startIndex;
+        while (i < asmItems.length) {
+            const item = asmItems[i];
+            if (stopKinds.has(item.kind))
+                return i;
+            const prevTag = ctx.getCurrentCodeSegmentTag();
+            ctx.setCurrentCodeSegmentTag(ctx.sourceTagForSpan(item.span));
+            try {
+                if (item.kind === 'AsmLabel') {
+                    ctx.defineCodeLabel(item.name, item.span, 'global');
+                    if (!ctx.flowRef.current.reachable) {
+                        ctx.flowRef.current.reachable = true;
+                        ctx.flowRef.current.spValid = false;
+                        ctx.flowRef.current.spDelta = 0;
+                        ctx.flowRef.current.spInvalidDueToMutation = false;
+                        ctx.syncFromFlow();
+                    }
+                    i++;
+                    continue;
+                }
+                if (item.kind === 'AsmInstruction') {
+                    ctx.emitAsmInstruction(item);
+                    i++;
+                    continue;
+                }
+            }
+            finally {
+                ctx.setCurrentCodeSegmentTag(prevTag);
+            }
+            i++;
+        }
+        return i;
+    };
+    return {
+        lowerAsmRange,
+    };
+}

package/dist/src/lowering/asmRawDataLowering.d.ts

@@ -0,0 +1,16 @@
+import type { ImmExprNode, SourceSpan } from '../frontend/ast.js';
+import type { Context } from './programLowering.js';
+type RawValueLike = ImmExprNode | string | {
+    kind: string;
+    value?: unknown;
+};
+export type RawDataLike = {
+    span: SourceSpan;
+    name?: string;
+    directive: 'db' | 'dw' | 'ds' | 'cstr' | 'pstr' | 'istr';
+    values?: RawValueLike[];
+    size?: ImmExprNode;
+    fill?: ImmExprNode;
+};
+export declare function createAsmRawDataLowerer(ctx: Context): (decl: RawDataLike) => void;
+export {};

package/dist/src/lowering/asmRawDataLowering.js

@@ -0,0 +1,209 @@
+import { sizeOfTypeExpr } from '../semantics/layout.js';
+import { containsCurrentLocation, evalAsmImmAtCurrent, placementAddressAtOffset, publishAsmAddressConst, } from './asmDirectiveTraversal.js';
+function rawStringValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!('kind' in value))
+        return undefined;
+    if (value.kind === 'AsmString') {
+        return typeof value.value === 'string' ? value.value : undefined;
+    }
+    return undefined;
+}
+function rawImmValue(value) {
+    if (typeof value === 'string')
+        return undefined;
+    if (!('kind' in value))
+        return undefined;
+    return value.kind.startsWith('Imm') ? value : undefined;
+}
+function evalRawDataSize(ctx, size) {
+    if (size.kind === 'ImmName') {
+        const constValue = ctx.env.equates.get(size.name) ?? ctx.env.equates.get(size.name.toLowerCase());
+        const enumValue = ctx.env.enums.get(size.name);
+        if (constValue === undefined && enumValue === undefined) {
+            const typeExpr = { kind: 'TypeName', span: size.span, name: size.name };
+            const typeSize = sizeOfTypeExpr(typeExpr, ctx.env, undefined);
+            if (typeSize !== undefined)
+                return typeSize;
+        }
+    }
+    return ctx.evalImmExpr(size, ctx.env, ctx.diagnostics);
+}
+export function createAsmRawDataLowerer(ctx) {
+    return (decl) => {
+        const activePlacement = ctx.activePlacementRef.current;
+        const name = decl.name ?? '';
+        if (name.length > 0) {
+            const lower = name.toLowerCase();
+            if (ctx.taken.has(lower)) {
+                const alreadyPending = ctx.pending.some((symbol) => symbol.name.toLowerCase() === lower);
+                if (!alreadyPending)
+                    ctx.diag(ctx.diagnostics, decl.span.file, `Duplicate symbol name "${name}".`);
+            }
+            else {
+                ctx.taken.add(lower);
+                const offset = activePlacement === 'code' ? ctx.codeOffsetRef.current : ctx.dataOffsetRef.current;
+                const address = placementAddressAtOffset(ctx, activePlacement, offset);
+                if (address !== undefined)
+                    publishAsmAddressConst(ctx, name, address);
+                const pending = {
+                    kind: 'label',
+                    name,
+                    placement: activePlacement,
+                    offset,
+                    file: decl.span.file,
+                    line: decl.span.start.line,
+                    scope: 'global',
+                };
+                ctx.pending.push(pending);
+                ctx.recordLoweredAsmItem({ kind: 'label', name }, decl.span);
+            }
+        }
+        const writeByte = (value) => {
+            if (activePlacement === 'code') {
+                const offset = ctx.codeOffsetRef.current;
+                ctx.codeBytes.set(offset, value & 0xff);
+                ctx.codeOffsetRef.current = offset + 1;
+            }
+            else {
+                const offset = ctx.dataOffsetRef.current;
+                ctx.dataBytes.set(offset, value & 0xff);
+                ctx.dataOffsetRef.current = offset + 1;
+            }
+        };
+        const writeWord = (value) => {
+            writeByte(value & 0xff);
+            writeByte((value >> 8) & 0xff);
+        };
+        const currentAddress = () => {
+            const offset = activePlacement === 'code' ? ctx.codeOffsetRef.current : ctx.dataOffsetRef.current;
+            return placementAddressAtOffset(ctx, activePlacement, offset);
+        };
+        if (decl.directive === 'ds') {
+            if (!decl.size) {
+                ctx.diag(ctx.diagnostics, decl.span.file, `Raw data size is missing for "${name}".`);
+                return;
+            }
+            const size = evalRawDataSize(ctx, decl.size);
+            if (size === undefined || size < 0) {
+                ctx.diag(ctx.diagnostics, decl.span.file, `Failed to evaluate raw data size for "${name}".`);
+                return;
+            }
+            const fill = decl.fill ? ctx.evalImmExpr(decl.fill, ctx.env, ctx.diagnostics) : undefined;
+            if (decl.fill && fill === undefined) {
+                ctx.diag(ctx.diagnostics, decl.span.file, `Failed to evaluate raw data fill for "${name}".`);
+                return;
+            }
+            ctx.recordLoweredAsmItem({
+                kind: 'ds',
+                size: { kind: 'literal', value: size },
+                ...(decl.fill ? { fill: ctx.lowerImmExprForLoweredAsm(decl.fill) } : {}),
+            }, decl.span);
+            if (fill === undefined) {
+                if (activePlacement === 'code') {
+                    ctx.codeOffsetRef.current += size;
+                }
+                else {
+                    ctx.dataOffsetRef.current += size;
+                }
+                return;
+            }
+            for (let i = 0; i < size; i++)
+                writeByte(fill);
+            return;
+        }
+        if (decl.directive === 'cstr' || decl.directive === 'pstr' || decl.directive === 'istr') {
+            const stringValue = rawStringValue((decl.values ?? [])[0] ?? '');
+            if (stringValue === undefined) {
+                ctx.diag(ctx.diagnostics, decl.span.file, `"${decl.directive}" expects a string value.`);
+                return;
+            }
+            const bytes = [...stringValue].map((char) => char.codePointAt(0) ?? 0);
+            const emittedBytes = [];
+            const writeStringByte = (value) => {
+                const byte = value & 0xff;
+                writeByte(byte);
+                emittedBytes.push(byte);
+            };
+            if (decl.directive === 'cstr') {
+                for (const byte of bytes)
+                    writeStringByte(byte);
+                writeStringByte(0);
+            }
+            else if (decl.directive === 'pstr') {
+                writeStringByte(bytes.length);
+                for (const byte of bytes)
+                    writeStringByte(byte);
+            }
+            else if (bytes.length > 0) {
+                for (let i = 0; i < bytes.length; i++) {
+                    const isLast = i === bytes.length - 1;
+                    writeStringByte(bytes[i] | (isLast ? 0x80 : 0));
+                }
+            }
+            if (emittedBytes.length > 0) {
+                ctx.recordLoweredAsmItem({
+                    kind: 'db',
+                    values: emittedBytes.map((value) => ({ kind: 'literal', value })),
+                }, decl.span);
+            }
+            return;
+        }
+        const loweredValues = [];
+        for (const value of decl.values ?? []) {
+            const stringValue = rawStringValue(value);
+            if (stringValue !== undefined) {
+                if (decl.directive !== 'db') {
+                    ctx.diag(ctx.diagnostics, decl.span.file, `String raw data values are only valid for "db".`);
+                    continue;
+                }
+                for (const char of stringValue) {
+                    const byte = char.codePointAt(0) ?? 0;
+                    writeByte(byte);
+                    loweredValues.push({ kind: 'literal', value: byte & 0xff });
+                }
+                continue;
+            }
+            const imm = rawImmValue(value);
+            if (!imm) {
+                ctx.diag(ctx.diagnostics, decl.span.file, `Failed to evaluate raw data value for "${name}".`);
+                if (decl.directive === 'db')
+                    writeByte(0);
+                else
+                    writeWord(0);
+                continue;
+            }
+            const usesCurrentLocation = containsCurrentLocation(imm);
+            const current = usesCurrentLocation ? currentAddress() : undefined;
+            if (usesCurrentLocation && current === undefined) {
+                ctx.diag(ctx.diagnostics, decl.span.file, `Failed to evaluate current location.`);
+                if (decl.directive === 'db')
+                    writeByte(0);
+                else
+                    writeWord(0);
+                continue;
+            }
+            const evaluated = current === undefined
+                ? ctx.evalImmExpr(imm, ctx.env, ctx.diagnostics)
+                : evalAsmImmAtCurrent(ctx, imm, current);
+            loweredValues.push(evaluated === undefined
+                ? ctx.lowerImmExprForLoweredAsm(imm)
+                : { kind: 'literal', value: evaluated });
+            if (evaluated !== undefined) {
+                if (decl.directive === 'db')
+                    writeByte(evaluated);
+                else
+                    writeWord(evaluated);
+                continue;
+            }
+            if (decl.directive === 'db')
+                writeByte(0);
+            else
+                writeWord(0);
+        }
+        ctx.recordLoweredAsmItem(decl.directive === 'db'
+            ? { kind: 'db', values: loweredValues }
+            : { kind: 'dw', values: loweredValues }, decl.span);
+    };
+}

package/dist/src/lowering/asmSourceEmitter.d.ts

@@ -0,0 +1,4 @@
+import type { LoweringContext } from './programLowering.js';
+import { createAssemblerInstructionEmitters } from './assemblerLoweringPhases.js';
+export type AsmSourceEmitter = ReturnType<typeof createAssemblerInstructionEmitters>;
+export declare function createAsmSourceEmitter(ctx: LoweringContext): AsmSourceEmitter;

package/dist/src/lowering/asmSourceEmitter.js

@@ -0,0 +1,9 @@
+import { createAssemblerInstructionEmitters, createAsmSourceFlowPhase, prepareAssemblerInstructionSetupPhase, } from './assemblerLoweringPhases.js';
+function createAsmSourceSetup(ctx) {
+    return prepareAssemblerInstructionSetupPhase(ctx);
+}
+export function createAsmSourceEmitter(ctx) {
+    const setup = createAsmSourceSetup(ctx);
+    const flow = createAsmSourceFlowPhase(setup);
+    return createAssemblerInstructionEmitters(setup, flow);
+}

package/dist/src/lowering/asmSourceInstructionLowering.d.ts

@@ -0,0 +1,4 @@
+import type { AsmInstructionNode } from '../frontend/ast.js';
+import type { LoweringContext } from './programLowering.js';
+/** Lowers one top-level instruction in ASM source via op expansion and full ld/ea pipelines. */
+export declare function lowerAsmSourceInstruction(ctx: LoweringContext, item: AsmInstructionNode): void;

package/dist/src/lowering/asmSourceInstructionLowering.js

@@ -0,0 +1,14 @@
+import { createAsmSourceEmitter } from './asmSourceEmitter.js';
+const asmSourceEmitterByContext = new WeakMap();
+function asmSourceEmitterForContext(ctx) {
+    let emitter = asmSourceEmitterByContext.get(ctx);
+    if (emitter)
+        return emitter;
+    emitter = createAsmSourceEmitter(ctx);
+    asmSourceEmitterByContext.set(ctx, emitter);
+    return emitter;
+}
+/** Lowers one top-level instruction in ASM source via op expansion and full ld/ea pipelines. */
+export function lowerAsmSourceInstruction(ctx, item) {
+    asmSourceEmitterForContext(ctx).emitAsmInstruction(item);
+}

package/dist/src/lowering/asmUtils.d.ts

@@ -0,0 +1,13 @@
+import type { AsmOperandNode, EaExprNode, ImmExprNode } from '../frontend/ast.js';
+type AsmUtilsContext = {
+    /** Returns true when `name` matches a declared enum (used to normalize asm tokens); callback must stay pure. */
+    isEnumName: (name: string) => boolean;
+};
+export declare function cloneImmExpr(expr: ImmExprNode): ImmExprNode;
+export declare function cloneEaExpr(ea: EaExprNode): EaExprNode;
+export declare function cloneOperand(op: AsmOperandNode): AsmOperandNode;
+export declare function flattenEaDottedName(ea: EaExprNode): string | undefined;
+export declare function createAsmUtilityHelpers(ctx: AsmUtilsContext): {
+    normalizeFixedToken: (op: AsmOperandNode) => string | undefined;
+};
+export {};

package/dist/src/lowering/asmUtils.js

@@ -0,0 +1,105 @@
+function cloneOffsetPath(path) {
+    return {
+        ...path,
+        steps: path.steps.map((step) => step.kind === 'OffsetIndex' ? { ...step, expr: cloneImmExpr(step.expr) } : { ...step }),
+    };
+}
+export function cloneImmExpr(expr) {
+    if (expr.kind === 'ImmLiteral')
+        return { ...expr };
+    if (expr.kind === 'ImmCurrentLocation')
+        return { ...expr };
+    if (expr.kind === 'ImmName')
+        return { ...expr };
+    if (expr.kind === 'ImmSizeof')
+        return { ...expr };
+    if (expr.kind === 'ImmOffset')
+        return { ...expr, path: cloneOffsetPath(expr.path) };
+    if (expr.kind === 'ImmUnary')
+        return { ...expr, expr: cloneImmExpr(expr.expr) };
+    return { ...expr, left: cloneImmExpr(expr.left), right: cloneImmExpr(expr.right) };
+}
+export function cloneEaExpr(ea) {
+    switch (ea.kind) {
+        case 'EaName':
+            return { ...ea };
+        case 'EaImm':
+            return { ...ea, expr: cloneImmExpr(ea.expr) };
+        case 'EaLayoutCast':
+            return { ...ea, base: cloneEaExpr(ea.base) };
+        case 'EaField':
+            return { ...ea, base: cloneEaExpr(ea.base) };
+        case 'EaIndex':
+            return {
+                ...ea,
+                base: cloneEaExpr(ea.base),
+                index: ea.index.kind === 'IndexEa'
+                    ? { ...ea.index, expr: cloneEaExpr(ea.index.expr) }
+                    : ea.index.kind === 'IndexImm'
+                        ? { ...ea.index, value: cloneImmExpr(ea.index.value) }
+                        : ea.index.kind === 'IndexMemIxIy' && ea.index.disp
+                            ? { ...ea.index, disp: cloneImmExpr(ea.index.disp) }
+                            : { ...ea.index },
+            };
+        case 'EaAdd':
+        case 'EaSub':
+            return { ...ea, base: cloneEaExpr(ea.base), offset: cloneImmExpr(ea.offset) };
+    }
+}
+export function cloneOperand(op) {
+    switch (op.kind) {
+        case 'Reg':
+        case 'PortC':
+            return { ...op };
+        case 'Imm':
+        case 'PortImm8':
+            return { ...op, expr: cloneImmExpr(op.expr) };
+        case 'Ea':
+        case 'Mem':
+            return { ...op, expr: cloneEaExpr(op.expr) };
+    }
+}
+export function flattenEaDottedName(ea) {
+    if (ea.kind === 'EaName')
+        return ea.name;
+    if (ea.kind === 'EaImm')
+        return undefined;
+    if (ea.kind === 'EaLayoutCast')
+        return undefined;
+    if (ea.kind === 'EaField') {
+        const base = flattenEaDottedName(ea.base);
+        return base ? `${base}.${ea.field}` : undefined;
+    }
+    return undefined;
+}
+export function createAsmUtilityHelpers(ctx) {
+    const enumImmExprFromOperand = (op) => {
+        if (op.kind === 'Imm')
+            return op.expr;
+        if (op.kind !== 'Ea')
+            return undefined;
+        const name = flattenEaDottedName(op.expr);
+        if (!name || !ctx.isEnumName(name))
+            return undefined;
+        return { kind: 'ImmName', span: op.span, name };
+    };
+    const normalizeFixedToken = (op) => {
+        switch (op.kind) {
+            case 'Reg':
+                return op.name.toUpperCase();
+            case 'Imm':
+                if (op.expr.kind === 'ImmName')
+                    return op.expr.name.toUpperCase();
+                return undefined;
+            case 'Ea': {
+                const enumExpr = enumImmExprFromOperand(op);
+                return enumExpr?.kind === 'ImmName' ? enumExpr.name.toUpperCase() : undefined;
+            }
+            default:
+                return undefined;
+        }
+    };
+    return {
+        normalizeFixedToken,
+    };
+}

package/dist/src/lowering/assemblerFlowSetup.d.ts

@@ -0,0 +1,54 @@
+import type { Diagnostic, DiagnosticId } from '../diagnosticTypes.js';
+import type { AsmInstructionNode, AsmOperandNode, SourceSpan } from '../frontend/ast.js';
+import type { PendingSymbol, SourceSegmentTag } from './loweringTypes.js';
+export type FlowState = {
+    reachable: boolean;
+    spDelta: number;
+    spValid: boolean;
+    spInvalidDueToMutation: boolean;
+};
+export type OpExpansionFrame = {
+    key: string;
+    name: string;
+    declSpan: SourceSpan;
+    callSiteSpan: SourceSpan;
+};
+type AssemblerFlowSetupContext = {
+    diagnostics: Diagnostic[];
+    diagAt: (diagnostics: Diagnostic[], span: SourceSpan, message: string) => void;
+    diagAtWithId: (diagnostics: Diagnostic[], span: SourceSpan, id: DiagnosticId, message: string) => void;
+    getCurrentCodeSegmentTag: () => SourceSegmentTag | undefined;
+    setCurrentCodeSegmentTag: (tag: SourceSegmentTag | undefined) => void;
+    taken: Set<string>;
+    traceLabel: (offset: number, name: string, span?: SourceSpan) => void;
+    pending: PendingSymbol[];
+    getCodeOffset: () => number;
+    emitInstr: (head: string, operands: AsmOperandNode[], span: SourceSpan) => boolean;
+    generatedLabelCounterRef: {
+        current: number;
+    };
+    formatAsmOperandForOpDiag: (op: AsmOperandNode) => string;
+};
+export declare function createAssemblerFlowSetupHelpers({ diagnostics, diagAt, diagAtWithId, getCurrentCodeSegmentTag, setCurrentCodeSegmentTag, taken, traceLabel, pending, getCodeOffset, emitInstr, generatedLabelCounterRef, formatAsmOperandForOpDiag, }: AssemblerFlowSetupContext): {
+    currentOpExpansionFrame: (opExpansionStack: OpExpansionFrame[]) => OpExpansionFrame | undefined;
+    rootOpExpansionFrame: (opExpansionStack: OpExpansionFrame[]) => OpExpansionFrame | undefined;
+    currentMacroCallSiteSpan: (opExpansionStack: OpExpansionFrame[]) => SourceSpan | undefined;
+    formatInstructionForOpExpansionDiag: (inst: AsmInstructionNode) => string;
+    appendInvalidOpExpansionDiagnostic: (inst: AsmInstructionNode, diagnosticsStart: number, opExpansionStack: OpExpansionFrame[]) => void;
+    sourceTagForSpan: (span: SourceSpan, opExpansionStack: OpExpansionFrame[]) => SourceSegmentTag;
+    withCodeSourceTag: <T>(tag: SourceSegmentTag, fn: () => T) => T;
+    syncFromFlow: (flow: FlowState, tracked: {
+        delta: number;
+        valid: boolean;
+        invalid: boolean;
+    }) => void;
+    syncToFlow: (flow: FlowState, tracked: {
+        delta: number;
+        valid: boolean;
+        invalid: boolean;
+    }) => void;
+    newHiddenLabel: (prefix: string) => string;
+    defineCodeLabel: (name: string, span: SourceSpan, scope: "global" | "local") => void;
+    emitVirtualReg16Transfer: (asmItem: AsmInstructionNode) => boolean;
+};
+export {};