@jhlagado/azm 0.1.0

package/dist/src/frontend/grammarData.d.ts

@@ -0,0 +1,14 @@
+export declare const TOP_LEVEL_KEYWORDS: Set<string>;
+export declare const ALL_REGISTER_NAMES: Set<string>;
+export declare const INDEX_REG8_NAMES: Set<string>;
+export declare const INDEX_REG16_NAMES: Set<string>;
+export declare const INDEX_MEM_BASE_REGISTERS: Set<string>;
+export declare const IMM_BINARY_OPERATOR_PRECEDENCE: Map<string, number>;
+export declare const IMM_BINARY_OPERATORS: Set<string>;
+export declare const IMM_UNARY_OPERATOR_SET: Set<string>;
+export declare const IMM_MULTI_CHAR_OPERATORS: Set<string>;
+export declare const CHAR_ESCAPE_VALUES: Map<string, number>;
+declare const MATCHER_TYPE_LIST: readonly ["reg8", "reg16", "idx16", "cc", "imm8", "imm16", "ea", "mem8", "mem16"];
+export declare const MATCHER_TYPES: Set<string>;
+export declare const MATCHER_KIND_BY_TYPE: Readonly<Record<(typeof MATCHER_TYPE_LIST)[number], 'MatcherReg8' | 'MatcherReg16' | 'MatcherIdx16' | 'MatcherCc' | 'MatcherImm8' | 'MatcherImm16' | 'MatcherEa' | 'MatcherMem8' | 'MatcherMem16'>>;
+export {};

package/dist/src/frontend/grammarData.js

@@ -0,0 +1,65 @@
+const TOP_LEVEL_KEYWORD_LIST = ['enum', 'type', 'union', 'op'];
+export const TOP_LEVEL_KEYWORDS = new Set(TOP_LEVEL_KEYWORD_LIST);
+const REGISTERS_8 = ['A', 'B', 'C', 'D', 'E', 'H', 'L'];
+const REGISTERS_8_EXTENDED = ['IXH', 'IXL', 'IYH', 'IYL', 'I', 'R'];
+const REGISTERS_16_GENERAL = ['HL', 'DE', 'BC', 'SP', 'IX', 'IY'];
+const REGISTERS_16_SPECIAL = ['AF'];
+const REGISTERS_16 = [...REGISTERS_16_GENERAL, ...REGISTERS_16_SPECIAL];
+const REGISTERS_16_SHADOW = ["AF'"];
+const ALL_REGISTER_NAME_LIST = [
+    ...REGISTERS_8,
+    ...REGISTERS_8_EXTENDED,
+    ...REGISTERS_16,
+    ...REGISTERS_16_SHADOW,
+];
+export const ALL_REGISTER_NAMES = new Set(ALL_REGISTER_NAME_LIST);
+export const INDEX_REG8_NAMES = new Set(REGISTERS_8);
+const INDEX_REG16_LIST = ['HL', 'DE', 'BC'];
+export const INDEX_REG16_NAMES = new Set(INDEX_REG16_LIST);
+const INDEX_MEM_BASE_REGISTER_LIST = ['IX', 'IY'];
+export const INDEX_MEM_BASE_REGISTERS = new Set(INDEX_MEM_BASE_REGISTER_LIST);
+const IMM_OPERATOR_PRECEDENCE = [
+    { level: 7, ops: ['*', '/', '%'] },
+    { level: 6, ops: ['+', '-'] },
+    { level: 5, ops: ['<<', '>>'] },
+    { level: 4, ops: ['&'] },
+    { level: 3, ops: ['^'] },
+    { level: 2, ops: ['|'] },
+];
+export const IMM_BINARY_OPERATOR_PRECEDENCE = new Map(IMM_OPERATOR_PRECEDENCE.flatMap(({ level, ops }) => ops.map((op) => [op, level])));
+export const IMM_BINARY_OPERATORS = new Set(IMM_BINARY_OPERATOR_PRECEDENCE.keys());
+const IMM_UNARY_OPERATORS = ['+', '-', '~'];
+export const IMM_UNARY_OPERATOR_SET = new Set(IMM_UNARY_OPERATORS);
+export const IMM_MULTI_CHAR_OPERATORS = new Set(['<<', '>>']);
+export const CHAR_ESCAPE_VALUES = new Map([
+    ['n', 10],
+    ['r', 13],
+    ['t', 9],
+    ['0', 0],
+    ['\\', 92],
+    ["'", 39],
+    ['"', 34],
+]);
+const MATCHER_TYPE_LIST = [
+    'reg8',
+    'reg16',
+    'idx16',
+    'cc',
+    'imm8',
+    'imm16',
+    'ea',
+    'mem8',
+    'mem16',
+];
+export const MATCHER_TYPES = new Set(MATCHER_TYPE_LIST);
+export const MATCHER_KIND_BY_TYPE = {
+    reg8: 'MatcherReg8',
+    reg16: 'MatcherReg16',
+    idx16: 'MatcherIdx16',
+    cc: 'MatcherCc',
+    imm8: 'MatcherImm8',
+    imm16: 'MatcherImm16',
+    ea: 'MatcherEa',
+    mem8: 'MatcherMem8',
+    mem16: 'MatcherMem16',
+};

package/dist/src/frontend/immExprUtils.d.ts

@@ -0,0 +1,2 @@
+import type { ImmExprNode } from './ast.js';
+export declare function containsCurrentLocation(expr: ImmExprNode): boolean;

package/dist/src/frontend/immExprUtils.js

@@ -0,0 +1,12 @@
+export function containsCurrentLocation(expr) {
+    switch (expr.kind) {
+        case 'ImmCurrentLocation':
+            return true;
+        case 'ImmUnary':
+            return containsCurrentLocation(expr.expr);
+        case 'ImmBinary':
+            return containsCurrentLocation(expr.left) || containsCurrentLocation(expr.right);
+        default:
+            return false;
+    }
+}

package/dist/src/frontend/parseAsmFlatDirectiveLine.d.ts

@@ -0,0 +1,17 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { SourceItemNode, SourceSpan } from './ast.js';
+import type { DirectiveAliasPolicy } from './directiveAliases.js';
+import type { ParseItemContext } from './parseSourceItemDispatch.js';
+/** Parses one source-file line of ASM flat assembler directives. */
+export declare function parseAsmFlatDirectiveLine(args: {
+    rest: string;
+    stmtSpan: SourceSpan;
+    filePath: string;
+    lineNo: number;
+    diagnostics: Diagnostic[];
+    ctx: Extract<ParseItemContext, {
+        scope: 'source';
+    }>;
+    aliasPolicy?: DirectiveAliasPolicy;
+    stringEquates: Map<string, string>;
+}): SourceItemNode[] | undefined;

package/dist/src/frontend/parseAsmFlatDirectiveLine.js

@@ -0,0 +1,187 @@
+import { parseAsmLine } from './asm80/asmLine.js';
+import { parseAsmRawValues } from './asm80/parseAsmRawValues.js';
+import { parseImmExprFromText } from './parseImm.js';
+import { parseDiag as diag } from './parseDiagnostics.js';
+import { looksLikeRawDataDirectiveStart } from './parseRawDataDirectiveStart.js';
+import { parseBareRawDataDirective, parseRawDataSizeOperands } from './parseRawDataDirectives.js';
+function isAsmFlatDirectiveLine(rest) {
+    const trimmed = rest.trim();
+    if (looksLikeRawDataDirectiveStart(trimmed))
+        return true;
+    if (/^(?:[A-Za-z_][A-Za-z0-9_]*\s*:\s*)?\.?(db|dw|ds)\b/i.test(trimmed))
+        return true;
+    return /^(?:[A-Za-z_][A-Za-z0-9_]*\s*:\s*)?\.?(org|align|equ|binfrom|binto|end)\b/i.test(trimmed);
+}
+function normalizeRawDataDirectiveText(text) {
+    const match = /^\.?(db|dw|ds)\b(.*)$/i.exec(text.trim());
+    if (!match)
+        return undefined;
+    return `${match[1].toLowerCase()}${match[2]}`;
+}
+function isStringEquate(name, stringEquates) {
+    const normalized = name.startsWith('@') ? name.slice(1) : name;
+    return stringEquates.has(normalized.toLowerCase());
+}
+function directiveColumn(text, directive) {
+    const index = text.toLowerCase().indexOf(directive.toLowerCase());
+    return index < 0 ? 1 : index + 1;
+}
+function asmRawDataToNode(parsed, stmtSpan, filePath, diagnostics, stringEquates) {
+    if (parsed.directive === 'ds') {
+        const ds = parseRawDataSizeOperands(parsed.valuesText, stmtSpan.start.line, stmtSpan, filePath, diagnostics);
+        return {
+            kind: 'AsmRawData',
+            span: stmtSpan,
+            name: parsed.label,
+            directive: 'ds',
+            size: ds?.size,
+            fill: ds?.fill,
+            valuesText: parsed.valuesText,
+        };
+    }
+    const values = parseAsmRawValues(filePath, parsed.valuesText, stmtSpan, diagnostics, stringEquates);
+    return {
+        kind: 'AsmRawData',
+        span: stmtSpan,
+        name: parsed.label,
+        directive: parsed.directive,
+        values,
+        valuesText: parsed.valuesText,
+    };
+}
+/** Parses one source-file line of ASM flat assembler directives. */
+export function parseAsmFlatDirectiveLine(args) {
+    const { rest, stmtSpan, filePath, lineNo, diagnostics, ctx, aliasPolicy, stringEquates } = args;
+    const trimmed = rest.trim();
+    const parsedAsm = parseAsmLine(filePath, trimmed, lineNo, stmtSpan.start.offset, aliasPolicy);
+    if (ctx.asmEnded && parsedAsm?.kind !== 'binfrom' && parsedAsm?.kind !== 'binto') {
+        return [];
+    }
+    if (!isAsmFlatDirectiveLine(trimmed) &&
+        parsedAsm?.kind !== 'rawData' &&
+        parsedAsm?.kind !== 'equ' &&
+        parsedAsm?.kind !== 'org' &&
+        parsedAsm?.kind !== 'align' &&
+        parsedAsm?.kind !== 'binfrom' &&
+        parsedAsm?.kind !== 'binto' &&
+        parsedAsm?.kind !== 'end' &&
+        parsedAsm?.kind !== 'unsupportedDirective') {
+        return undefined;
+    }
+    const inlineLabelRaw = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*\.?(db|dw|ds)\b(.*)$/i.exec(trimmed);
+    if (inlineLabelRaw) {
+        return parsedAsm?.kind === 'rawData'
+            ? [asmRawDataToNode(parsedAsm, stmtSpan, filePath, diagnostics, stringEquates)]
+            : [];
+    }
+    const inlineLabelEqu = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*\.?equ\b\s*(.+)$/i.exec(trimmed);
+    if (inlineLabelEqu) {
+        const exprText = inlineLabelEqu[2].trim();
+        return [
+            {
+                kind: 'AsmEqu',
+                span: stmtSpan,
+                name: inlineLabelEqu[1],
+                exprText,
+                value: parseImmExprFromText(filePath, exprText, stmtSpan, diagnostics, !isStringEquate(inlineLabelEqu[1], stringEquates)),
+            },
+        ];
+    }
+    const bareEqu = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.?equ\b\s*(.+)$/i.exec(trimmed);
+    if (bareEqu) {
+        const exprText = bareEqu[2].trim();
+        return [
+            {
+                kind: 'AsmEqu',
+                span: stmtSpan,
+                name: bareEqu[1],
+                exprText,
+                value: parseImmExprFromText(filePath, exprText, stmtSpan, diagnostics, !isStringEquate(bareEqu[1], stringEquates)),
+            },
+        ];
+    }
+    const labelOnly = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*$/.exec(trimmed);
+    if (labelOnly) {
+        return [{ kind: 'AsmLabel', span: stmtSpan, name: labelOnly[1] }];
+    }
+    if (parsedAsm?.kind === 'rawData') {
+        return [asmRawDataToNode(parsedAsm, stmtSpan, filePath, diagnostics, stringEquates)];
+    }
+    const bareRawText = normalizeRawDataDirectiveText(trimmed);
+    const bareRaw = bareRawText
+        ? parseBareRawDataDirective(bareRawText, lineNo, stmtSpan, filePath, diagnostics)
+        : undefined;
+    if (bareRaw)
+        return [bareRaw];
+    const orgMatch = /^\.?org\b\s*(.*)$/i.exec(trimmed);
+    if (orgMatch) {
+        const exprText = orgMatch[1].trim();
+        return [
+            {
+                kind: 'AsmOrg',
+                span: stmtSpan,
+                exprText,
+                value: parseImmExprFromText(filePath, exprText, stmtSpan, diagnostics),
+            },
+        ];
+    }
+    const parsed = parsedAsm;
+    if (!parsed)
+        return undefined;
+    if (parsed.kind === 'instruction' || parsed.kind === 'label')
+        return undefined;
+    switch (parsed.kind) {
+        case 'equ':
+            return [
+                {
+                    kind: 'AsmEqu',
+                    span: stmtSpan,
+                    name: parsed.name,
+                    exprText: parsed.exprText,
+                    value: parseImmExprFromText(filePath, parsed.exprText, stmtSpan, diagnostics, !isStringEquate(parsed.name, stringEquates)),
+                },
+            ];
+        case 'org':
+            return [
+                {
+                    kind: 'AsmOrg',
+                    span: stmtSpan,
+                    exprText: parsed.exprText,
+                    value: parseImmExprFromText(filePath, parsed.exprText, stmtSpan, diagnostics),
+                },
+            ];
+        case 'binfrom':
+            return [
+                {
+                    kind: 'AsmBinFrom',
+                    span: stmtSpan,
+                    exprText: parsed.exprText,
+                    value: parseImmExprFromText(filePath, parsed.exprText, stmtSpan, diagnostics),
+                },
+            ];
+        case 'binto':
+            return [
+                {
+                    kind: 'AsmBinTo',
+                    span: stmtSpan,
+                    exprText: parsed.exprText,
+                    value: parseImmExprFromText(filePath, parsed.exprText, stmtSpan, diagnostics),
+                },
+            ];
+        case 'align': {
+            const value = parseImmExprFromText(filePath, parsed.exprText, stmtSpan, diagnostics);
+            return value ? [{ kind: 'AsmAlign', span: stmtSpan, value }] : [];
+        }
+        case 'end':
+            ctx.asmEnded = true;
+            return [{ kind: 'AsmEnd', span: stmtSpan }];
+        case 'unsupportedDirective':
+            diag(diagnostics, filePath, `Unsupported ASM80 directive ".${parsed.directive}".`, {
+                line: lineNo,
+                column: directiveColumn(trimmed, parsed.directive),
+            });
+            return [];
+        default:
+            return undefined;
+    }
+}

package/dist/src/frontend/parseAsmInstruction.d.ts

@@ -0,0 +1,3 @@
+import type { AsmInstructionNode, SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+export declare function parseAsmInstruction(filePath: string, text: string, instrSpan: SourceSpan, diagnostics: Diagnostic[]): AsmInstructionNode | undefined;

package/dist/src/frontend/parseAsmInstruction.js

@@ -0,0 +1,73 @@
+import { parseImmExprFromText } from './parseImm.js';
+import { parseAsmOperand } from './parseOperands.js';
+function splitTopLevelCommaSeparated(text) {
+    const parts = [];
+    let current = '';
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '(') {
+            parenDepth++;
+            current += ch;
+            continue;
+        }
+        if (ch === ')') {
+            parenDepth = Math.max(parenDepth - 1, 0);
+            current += ch;
+            continue;
+        }
+        if (ch === '[') {
+            bracketDepth++;
+            current += ch;
+            continue;
+        }
+        if (ch === ']') {
+            bracketDepth = Math.max(bracketDepth - 1, 0);
+            current += ch;
+            continue;
+        }
+        if (ch === ',' && parenDepth === 0 && bracketDepth === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    parts.push(current.trim());
+    return parts.filter((part) => part.length > 0);
+}
+export function parseAsmInstruction(filePath, text, instrSpan, diagnostics) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    const firstSpace = trimmed.search(/\s/);
+    const head = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+    const headLower = head.toLowerCase();
+    const rest = firstSpace === -1 ? '' : trimmed.slice(firstSpace).trim();
+    const operands = [];
+    if (rest.length > 0) {
+        const preferDottedImmediate = filePath.toLowerCase().endsWith('.asm');
+        const parseInOutOperand = (operandText) => {
+            const t = operandText.trim();
+            if (t.startsWith('(') && t.endsWith(')')) {
+                const inner = t.slice(1, -1).trim();
+                if (/^c$/i.test(inner))
+                    return { kind: 'PortC', span: instrSpan };
+                const expr = parseImmExprFromText(filePath, inner, instrSpan, diagnostics);
+                if (expr)
+                    return { kind: 'PortImm8', span: instrSpan, expr };
+            }
+            return parseAsmOperand(filePath, t, instrSpan, diagnostics, true, preferDottedImmediate);
+        };
+        const parts = splitTopLevelCommaSeparated(rest);
+        for (const part of parts) {
+            const opNode = headLower === 'in' || headLower === 'out'
+                ? parseInOutOperand(part)
+                : parseAsmOperand(filePath, part, instrSpan, diagnostics, true, preferDottedImmediate);
+            if (opNode)
+                operands.push(opNode);
+        }
+    }
+    return { kind: 'AsmInstruction', span: instrSpan, head: headLower, operands };
+}

package/dist/src/frontend/parseAsmStatements.d.ts

@@ -0,0 +1,6 @@
+import type { AsmItemNode, SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+type ParsedAsmStatement = AsmItemNode | AsmItemNode[] | undefined;
+export declare function appendParsedAsmStatement(out: AsmItemNode[], parsed: ParsedAsmStatement): void;
+export declare function parseAsmStatement(filePath: string, text: string, stmtSpan: SourceSpan, diagnostics: Diagnostic[]): ParsedAsmStatement;
+export {};

package/dist/src/frontend/parseAsmStatements.js

@@ -0,0 +1,16 @@
+import { parseAsmInstruction } from './parseAsmInstruction.js';
+export function appendParsedAsmStatement(out, parsed) {
+    if (!parsed)
+        return;
+    if (Array.isArray(parsed)) {
+        out.push(...parsed);
+        return;
+    }
+    out.push(parsed);
+}
+export function parseAsmStatement(filePath, text, stmtSpan, diagnostics) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    return parseAsmInstruction(filePath, trimmed, stmtSpan, diagnostics);
+}

package/dist/src/frontend/parseAsmStream.d.ts

@@ -0,0 +1,10 @@
+import type { AsmInstructionNode, AsmLabelNode, SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+type AsmStreamItem = AsmLabelNode | AsmInstructionNode;
+export declare function parseAsmStreamLine(args: {
+    rest: string;
+    filePath: string;
+    stmtSpan: SourceSpan;
+    diagnostics: Diagnostic[];
+}): AsmStreamItem[] | undefined;
+export {};

package/dist/src/frontend/parseAsmStream.js

@@ -0,0 +1,33 @@
+import { appendParsedAsmStatement, parseAsmStatement } from './parseAsmStatements.js';
+import { topLevelStartKeyword } from './parseTopLevelCommon.js';
+export function parseAsmStreamLine(args) {
+    const { rest, filePath, stmtSpan, diagnostics } = args;
+    if (topLevelStartKeyword(rest) !== undefined)
+        return undefined;
+    const content = rest.trim();
+    if (content.length === 0)
+        return [];
+    const nodes = [];
+    const asmItems = [];
+    const labelMatch = /^(@?[A-Za-z_][A-Za-z0-9_]*|\.[A-Za-z_][A-Za-z0-9_]*)\s*:(?!\=)\s*(.*)$/.exec(content);
+    if (labelMatch) {
+        const rawName = labelMatch[1];
+        const isEntry = rawName.startsWith('@');
+        nodes.push({
+            kind: 'AsmLabel',
+            span: stmtSpan,
+            name: isEntry ? rawName.slice(1) : rawName,
+            ...(isEntry ? { isEntry: true } : {}),
+        });
+        const remainder = labelMatch[2]?.trim() ?? '';
+        if (remainder.length > 0) {
+            appendParsedAsmStatement(asmItems, parseAsmStatement(filePath, remainder, stmtSpan, diagnostics));
+        }
+    }
+    else {
+        appendParsedAsmStatement(asmItems, parseAsmStatement(filePath, content, stmtSpan, diagnostics));
+    }
+    for (const item of asmItems)
+        nodes.push(item);
+    return nodes;
+}

package/dist/src/frontend/parseAsmTopLevel.d.ts

@@ -0,0 +1,18 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { SourceSpan } from './ast.js';
+import type { DirectiveAliasPolicy } from './directiveAliases.js';
+import type { ParseItemContext, ParseItemResult } from './parseSourceItemDispatch.js';
+export interface ParseAsmTopLevelInput {
+    index: number;
+    filePath: string;
+    lineNo: number;
+    rest: string;
+    stmtSpan: SourceSpan;
+    diagnostics: Diagnostic[];
+    ctx: Extract<ParseItemContext, {
+        scope: 'source';
+    }>;
+    aliasPolicy?: DirectiveAliasPolicy;
+    asmStringEquates?: Map<string, string>;
+}
+export declare function parseAsmTopLevel(args: ParseAsmTopLevelInput): ParseItemResult | undefined;

package/dist/src/frontend/parseAsmTopLevel.js

@@ -0,0 +1,34 @@
+import { parseAsmStreamLine } from './parseAsmStream.js';
+import { parseAsmFlatDirectiveLine } from './parseAsmFlatDirectiveLine.js';
+import { topLevelStartKeyword } from './parseTopLevelCommon.js';
+export function parseAsmTopLevel(args) {
+    const keyword = topLevelStartKeyword(args.rest);
+    if (keyword !== undefined) {
+        return undefined;
+    }
+    const directiveItems = parseAsmFlatDirectiveLine({
+        rest: args.rest,
+        stmtSpan: args.stmtSpan,
+        filePath: args.filePath,
+        lineNo: args.lineNo,
+        diagnostics: args.diagnostics,
+        ctx: args.ctx,
+        ...(args.aliasPolicy ? { aliasPolicy: args.aliasPolicy } : {}),
+        stringEquates: args.asmStringEquates ?? new Map(),
+    });
+    if (directiveItems !== undefined) {
+        return { nextIndex: args.index + 1, nodes: directiveItems };
+    }
+    const asmItems = parseAsmStreamLine({
+        rest: args.rest,
+        filePath: args.filePath,
+        stmtSpan: args.stmtSpan,
+        diagnostics: args.diagnostics,
+    });
+    if (asmItems === undefined)
+        return undefined;
+    return {
+        nextIndex: args.index + 1,
+        nodes: asmItems,
+    };
+}

package/dist/src/frontend/parseDiagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { Diagnostic, DiagnosticId, DiagnosticSeverity } from '../diagnosticTypes.js';
+type ParseDiagLocation = {
+    line: number;
+    column: number;
+};
+export declare function parseDiag(diagnostics: Diagnostic[], file: string, message: string, where?: ParseDiagLocation): void;
+export declare function parseDiagAt(diagnostics: Diagnostic[], file: string, message: string, line: number, column: number): void;
+export declare function parseDiagAtWithId(diagnostics: Diagnostic[], file: string, id: DiagnosticId, severity: DiagnosticSeverity, message: string, where?: ParseDiagLocation): void;
+export {};

package/dist/src/frontend/parseDiagnostics.js

@@ -0,0 +1,16 @@
+import { DiagnosticIds } from '../diagnosticTypes.js';
+export function parseDiag(diagnostics, file, message, where) {
+    parseDiagAtWithId(diagnostics, file, DiagnosticIds.ParseError, 'error', message, where);
+}
+export function parseDiagAt(diagnostics, file, message, line, column) {
+    parseDiag(diagnostics, file, message, { line, column });
+}
+export function parseDiagAtWithId(diagnostics, file, id, severity, message, where) {
+    diagnostics.push({
+        id,
+        severity,
+        message,
+        file,
+        ...(where ? { line: where.line, column: where.column } : {}),
+    });
+}

package/dist/src/frontend/parseEnum.d.ts

@@ -0,0 +1,12 @@
+import type { EnumDeclNode, SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+type ParseEnumContext = {
+    diagnostics: Diagnostic[];
+    sourcePath: string;
+    lineNo: number;
+    text: string;
+    span: SourceSpan;
+    isReservedTopLevelName: (name: string) => boolean;
+};
+export declare function parseEnumDecl(enumTail: string, ctx: ParseEnumContext): EnumDeclNode | undefined;
+export {};

package/dist/src/frontend/parseEnum.js

@@ -0,0 +1,70 @@
+import { parseDiag as diag } from './parseDiagnostics.js';
+import { diagInvalidHeaderLine, formatIdentifierToken } from './parseTopLevelCommon.js';
+export function parseEnumDecl(enumTail, ctx) {
+    const { diagnostics, sourcePath, lineNo, text, span, isReservedTopLevelName } = ctx;
+    const decl = enumTail;
+    const nameMatch = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.*))?$/.exec(decl);
+    if (!nameMatch) {
+        const invalidName = decl.split(/\s+/, 1)[0] ?? '';
+        if (invalidName.length > 0) {
+            diag(diagnostics, sourcePath, `Invalid enum name ${formatIdentifierToken(invalidName)}: expected <identifier>.`, { line: lineNo, column: 1 });
+        }
+        else {
+            diagInvalidHeaderLine(diagnostics, sourcePath, 'enum declaration', text, '<name> <member>[, ...]', lineNo);
+        }
+        return undefined;
+    }
+    const name = nameMatch[1];
+    if (isReservedTopLevelName(name)) {
+        diag(diagnostics, sourcePath, `Invalid enum name "${name}": collides with a top-level keyword.`, {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const membersText = (nameMatch[2] ?? '').trim();
+    if (membersText.length === 0) {
+        diag(diagnostics, sourcePath, `Enum "${name}" must declare at least one member`, {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const rawParts = membersText.split(',').map((p) => p.trim());
+    if (rawParts.some((p) => p.length === 0)) {
+        diag(diagnostics, sourcePath, `Trailing commas are not permitted in enum member lists`, {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const members = [];
+    const membersLower = new Set();
+    for (const m of rawParts) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(m)) {
+            diag(diagnostics, sourcePath, `Invalid enum member name ${formatIdentifierToken(m)}: expected <identifier>.`, {
+                line: lineNo,
+                column: 1,
+            });
+            continue;
+        }
+        if (isReservedTopLevelName(m)) {
+            diag(diagnostics, sourcePath, `Invalid enum member name "${m}": collides with a top-level keyword.`, {
+                line: lineNo,
+                column: 1,
+            });
+            continue;
+        }
+        const memberLower = m.toLowerCase();
+        if (membersLower.has(memberLower)) {
+            diag(diagnostics, sourcePath, `Duplicate enum member name "${m}".`, {
+                line: lineNo,
+                column: 1,
+            });
+            continue;
+        }
+        membersLower.add(memberLower);
+        members.push(m);
+    }
+    return { kind: 'EnumDecl', span, name, members };
+}

package/dist/src/frontend/parseImm.d.ts

@@ -0,0 +1,10 @@
+import type { ImmExprNode, SourceSpan, TypeExprNode } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+export declare function immLiteral(filePath: string, s: SourceSpan, value: number): ImmExprNode;
+export declare function parseTypeExprFromText(typeText: string, typeSpan: SourceSpan): TypeExprNode | undefined;
+export declare function diagIfArrayLengthMissing(diagnostics: Diagnostic[], filePath: string, typeText: string, where: {
+    line: number;
+    column: number;
+}): boolean;
+export declare function parseNumberLiteral(text: string): number | undefined;
+export declare function parseImmExprFromText(filePath: string, exprText: string, exprSpan: SourceSpan, diagnostics: Diagnostic[], emitDiagnostics?: boolean): ImmExprNode | undefined;