@jhlagado/azm 0.2.7 → 0.2.9

package/dist/src/core/compile.js

@@ -4,10 +4,9 @@ import { createSourceFile } from '../source/source-file.js';
 import { scanLogicalLines } from '../source/logical-lines.js';
 import { stripLineComment } from '../source/strip-line-comment.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
-import { parseExpression, parseTypeExpr } from '../syntax/parse-expression.js';
-import { collectOps, expandOpInvocation, parseOpInvocation } from '../expansion/op-expansion.js';
-import { normalizeDirectiveAlias } from '../syntax/directive-aliases.js';
-import { evaluateExpression, lookupEquateRecord, } from '../semantics/expression-evaluation.js';
+import { parseLayoutDeclarationAt } from '../syntax/parse-layout-declarations.js';
+import { collectOps, expandOpInvocation, parseOpInvocation, } from '../expansion/op-expansion.js';
+import { applyConditionalAssembly } from './conditional-assembly.js';
 export function parseNextSourceItems(lines, options = {}) {
     const diagnostics = [];
     const items = [];
@@ -17,233 +16,67 @@ export function parseNextSourceItems(lines, options = {}) {
     const conditional = applyConditionalAssembly(lines, diagnostics, parseOptions.directiveAliasPolicy);
     const pendingLines = [...conditional.lines];
     const { ops, opLineIndexes } = collectOps(pendingLines, diagnostics, parseOptions);
+    const context = {
+        diagnostics,
+        items,
+        lines: pendingLines,
+        ops,
+        opLineIndexes,
+        parseOptions,
+    };
     let afterTopLevelEnd = false;
     for (let index = 0; index < pendingLines.length; index += 1) {
-        if (opLineIndexes.has(index)) {
-            continue;
-        }
-        const line = pendingLines[index];
-        if (afterTopLevelEnd && !isPostEndParseAllowed(line.text)) {
-            continue;
-        }
-        const nameLeftTypeAlias = /^([A-Za-z_][A-Za-z0-9_]*)(?::\s*|\s+)\.typealias\s+(.+)$/.exec(stripLineComment(line.text).trim());
-        if (nameLeftTypeAlias) {
-            const typeExprText = nameLeftTypeAlias[2] ?? '';
-            const typeExpr = parseTypeExpr(typeExprText);
-            if (!typeExpr) {
-                diagnostics.push(parseDiagnostic(line, `invalid .typealias target: ${typeExprText}`));
-            }
-            else {
-                items.push({
-                    kind: 'type-alias',
-                    name: nameLeftTypeAlias[1] ?? '',
-                    typeExpr,
-                    span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
-                });
-            }
-            continue;
-        }
-        const typeAlias = /^\.type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/.exec(stripLineComment(line.text).trim());
-        if (typeAlias) {
-            diagnostics.push(parseDiagnostic(line, `Use "${typeAlias[1] ?? ''} .typealias ..." for type aliases.`));
-            continue;
-        }
-        const nameLeftLayoutHeader = /^([A-Za-z_][A-Za-z0-9_]*)(?::\s*|\s+)\.(type|union)\s*$/.exec(stripLineComment(line.text).trim());
-        const prefixLayoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/.exec(stripLineComment(line.text).trim());
-        if (prefixLayoutHeader) {
-            const directive = prefixLayoutHeader[1] ?? 'type';
-            diagnostics.push(parseDiagnostic(line, `Use "${prefixLayoutHeader[2] ?? ''} .${directive}" for layouts.`));
-            const endDirective = directive === 'union' ? '.endunion' : '.endtype';
-            for (index += 1; index < pendingLines.length; index += 1) {
-                if (stripLineComment(pendingLines[index].text).trim() === endDirective) {
-                    break;
-                }
-            }
-            continue;
-        }
-        const layoutHeader = nameLeftLayoutHeader
-            ? {
-                directive: nameLeftLayoutHeader[2] ?? '',
-                name: nameLeftLayoutHeader[1] ?? '',
-            }
-            : undefined;
-        if (layoutHeader) {
-            const layoutKind = layoutHeader.directive === 'union' ? 'union' : 'record';
-            const endDirective = layoutKind === 'union' ? '.endunion' : '.endtype';
-            const fields = [];
-            let terminated = false;
-            for (index += 1; index < pendingLines.length; index += 1) {
-                const fieldLine = pendingLines[index];
-                const fieldText = stripLineComment(fieldLine.text).trim();
-                if (fieldText.length === 0) {
-                    continue;
-                }
-                if (fieldText === endDirective) {
-                    terminated = true;
-                    break;
-                }
-                const field = parseLayoutField(fieldText);
-                if (!field) {
-                    diagnostics.push(parseDiagnostic(fieldLine, `invalid .${layoutHeader.directive} field declaration`));
-                    continue;
-                }
-                fields.push(field);
-            }
-            if (!terminated) {
-                diagnostics.push(parseDiagnostic(line, `.${layoutHeader.directive} ${layoutHeader.name} missing ${endDirective}`));
-            }
-            items.push({
-                kind: 'type',
-                name: layoutHeader.name,
-                layoutKind,
-                fields,
-                span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
-            });
-            continue;
-        }
-        const opCall = parseOpInvocation(line);
-        if (opCall && !isTopLevelEnd(line.text)) {
-            const overloads = ops.get(opCall.name);
-            if (overloads) {
-                const expanded = expandOpInvocation(ops, overloads, opCall.operands, line, diagnostics);
-                if (expanded) {
-                    items.push(...expanded);
-                }
-                continue;
-            }
-        }
-        const result = parseLogicalLine(line, parseOptions);
-        diagnostics.push(...result.diagnostics);
-        items.push(...result.items);
-        if (result.items.some((item) => item.kind === 'end')) {
-            afterTopLevelEnd = true;
-        }
+        const step = parsePendingLine(context, index, afterTopLevelEnd);
+        index = step.consumedUntilIndex;
+        afterTopLevelEnd = step.afterTopLevelEnd;
     }
     return { diagnostics, items };
 }
-function applyConditionalAssembly(lines, diagnostics, directiveAliasPolicy) {
-    const out = [];
-    const equates = new Map();
-    const locationDependentEquates = new Set();
-    const stack = [];
-    for (const line of lines) {
-        const text = stripLineComment(line.text).trim();
-        const ifDirective = /^\.if\s+(.+)$/.exec(text);
-        if (ifDirective) {
-            const parentActive = conditionalActive(stack);
-            const expressionText = ifDirective[1] ?? '';
-            const value = parentActive
-                ? evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics)
-                : undefined;
-            const conditionActive = parentActive && value !== undefined && value !== 0;
-            stack.push({ line, parentActive, conditionActive, elseSeen: false });
-            continue;
-        }
-        if (/^\.else\s*$/.test(text)) {
-            const frame = stack.pop();
-            if (!frame) {
-                diagnostics.push(parseDiagnostic(line, 'unmatched .else'));
-                continue;
-            }
-            if (frame.elseSeen) {
-                diagnostics.push(parseDiagnostic(line, 'duplicate .else'));
-            }
-            stack.push({
-                line: frame.line,
-                parentActive: frame.parentActive,
-                conditionActive: frame.parentActive && !frame.conditionActive,
-                elseSeen: true,
-            });
-            continue;
-        }
-        if (/^\.endif\s*$/.test(text)) {
-            if (!stack.pop()) {
-                diagnostics.push(parseDiagnostic(line, 'unmatched .endif'));
-            }
-            continue;
-        }
-        if (!conditionalActive(stack)) {
-            continue;
-        }
-        out.push(line);
-        recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy);
+function parsePendingLine(context, index, afterTopLevelEnd) {
+    const line = context.lines[index];
+    if (shouldSkipPendingLine(context, index, line, afterTopLevelEnd)) {
+        return { consumedUntilIndex: index, afterTopLevelEnd };
     }
-    for (const frame of stack) {
-        diagnostics.push(parseDiagnostic(frame.line, 'unterminated .if'));
+    const layoutStep = parseLayoutLine(context, index);
+    if (layoutStep)
+        return { ...layoutStep, afterTopLevelEnd };
+    if (parseExpandedOpLine(context, line)) {
+        return { consumedUntilIndex: index, afterTopLevelEnd };
     }
-    return { lines: out };
+    return parseNormalLine(context, index, line, afterTopLevelEnd);
 }
-function conditionalActive(stack) {
-    return stack.every((frame) => frame.parentActive && frame.conditionActive);
+function shouldSkipPendingLine(context, index, line, afterTopLevelEnd) {
+    return context.opLineIndexes.has(index) || (afterTopLevelEnd && !isPostEndParseAllowed(line.text));
 }
-function evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics) {
-    const expression = parseExpression(expressionText);
-    if (!expression) {
-        diagnostics.push(parseDiagnostic(line, `invalid .if expression: ${expressionText}`));
-        return undefined;
-    }
-    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
-        diagnostics.push(parseDiagnostic(line, 'invalid .if expression: current location is not available during conditional assembly'));
+function parseLayoutLine(context, index) {
+    const layoutDeclaration = parseLayoutDeclarationAt(context.lines, index);
+    if (layoutDeclaration === undefined)
         return undefined;
+    context.diagnostics.push(...layoutDeclaration.diagnostics);
+    if (layoutDeclaration.item !== undefined) {
+        context.items.push(layoutDeclaration.item);
     }
-    return evaluateExpression(expression, {}, equates, { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) }, diagnostics, { currentLocation: 0 });
-}
-function recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy) {
-    const text = normalizeDirectiveAlias(stripLineComment(line.text), directiveAliasPolicy).trim();
-    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)(?::\s*|\s+)\.equ\s+(.+)$/.exec(text);
-    if (!equ) {
-        return;
-    }
-    const name = equ[1] ?? '';
-    const expressionText = equ[2] ?? '';
-    const expression = parseExpression(expressionText);
-    if (!expression) {
-        return;
-    }
-    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
-        locationDependentEquates.add(canonicalConditionalSymbolKey(name));
-    }
-    equates.set(name, {
-        expression,
-        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
-        currentLocation: 0,
-    });
+    return { consumedUntilIndex: layoutDeclaration.consumedUntilIndex };
 }
-function expressionReferencesCurrentLocation(expression, equates, locationDependentEquates, visiting = new Set()) {
-    switch (expression.kind) {
-        case 'current-location':
-            return true;
-        case 'symbol': {
-            if (locationDependentEquates.has(canonicalConditionalSymbolKey(expression.name))) {
-                return true;
-            }
-            const lookup = lookupEquateRecord(equates, expression.name);
-            if (!lookup || visiting.has(canonicalConditionalSymbolKey(lookup.key))) {
-                return false;
-            }
-            const nextVisiting = new Set(visiting);
-            nextVisiting.add(canonicalConditionalSymbolKey(lookup.key));
-            return expressionReferencesCurrentLocation(lookup.record.expression, equates, locationDependentEquates, nextVisiting);
-        }
-        case 'byte-function':
-        case 'unary':
-            return expressionReferencesCurrentLocation(expression.expression, equates, locationDependentEquates, visiting);
-        case 'binary':
-            return (expressionReferencesCurrentLocation(expression.left, equates, locationDependentEquates, visiting) ||
-                expressionReferencesCurrentLocation(expression.right, equates, locationDependentEquates, visiting));
-        case 'layout-cast':
-            return (expressionReferencesCurrentLocation(expression.base, equates, locationDependentEquates, visiting) ||
-                expression.path.some((part) => part.kind === 'index' &&
-                    expressionReferencesCurrentLocation(part.expression, equates, locationDependentEquates, visiting)));
-        case 'number':
-        case 'type-size':
-        case 'sizeof':
-        case 'offset':
-            return false;
-    }
+function parseExpandedOpLine(context, line) {
+    const opCall = parseOpInvocation(line);
+    if (!opCall || isTopLevelEnd(line.text))
+        return false;
+    const overloads = context.ops.get(opCall.name);
+    if (!overloads)
+        return false;
+    const expanded = expandOpInvocation(context.ops, overloads, opCall.operands, line, context.diagnostics);
+    context.items.push(...expanded);
+    return true;
 }
-function canonicalConditionalSymbolKey(name) {
-    return name.toLowerCase();
+function parseNormalLine(context, index, line, afterTopLevelEnd) {
+    const result = parseLogicalLine(line, context.parseOptions);
+    context.diagnostics.push(...result.diagnostics);
+    context.items.push(...result.items);
+    return {
+        consumedUntilIndex: index,
+        afterTopLevelEnd: afterTopLevelEnd || result.items.some((item) => item.kind === 'end'),
+    };
 }
 export function compileSource(sourceText, options = {}) {
     const source = createSourceFile(options.entryName ?? '<memory>', sourceText);
@@ -273,59 +106,3 @@ function isTopLevelEnd(text) {
 function isPostEndParseAllowed(text) {
     return /^(?:\.binfrom|\.binto|binfrom|binto)\b/i.test(stripLineComment(text).trim());
 }
-function parseLayoutField(text) {
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/.exec(text);
-    if (!match) {
-        return undefined;
-    }
-    const name = match[1] ?? '';
-    const directive = (match[2] ?? '').toLowerCase();
-    const operand = match[3]?.trim();
-    switch (directive) {
-        case '.byte':
-            return operand === undefined ? { name, size: 1 } : undefined;
-        case '.word':
-        case '.addr':
-            return operand === undefined ? { name, size: 2 } : undefined;
-        case '.field': {
-            if (operand === undefined) {
-                return undefined;
-            }
-            const size = /^[0-9]+$/.test(operand) ? Number.parseInt(operand, 10) : undefined;
-            if (size !== undefined) {
-                return size > 0 ? { name, size } : undefined;
-            }
-            const scalar = scalarFieldSize(operand);
-            if (scalar !== undefined) {
-                return { name, size: scalar };
-            }
-            const typeExpr = parseTypeExpr(operand);
-            return typeExpr ? { name, size: 0, typeExpr } : undefined;
-        }
-    }
-}
-function scalarFieldSize(typeName) {
-    switch (typeName.toLowerCase()) {
-        case 'byte':
-            return 1;
-        case 'word':
-        case 'addr':
-            return 2;
-        default:
-            return undefined;
-    }
-}
-function parseDiagnostic(line, message) {
-    return {
-        severity: 'error',
-        code: 'AZMN_PARSE',
-        message,
-        sourceName: line.sourceName,
-        line: line.line,
-        column: firstColumn(line.text),
-    };
-}
-function firstColumn(text) {
-    const match = /\S/.exec(text);
-    return match ? match.index + 1 : 1;
-}

package/dist/src/core/conditional-assembly.d.ts

@@ -0,0 +1,6 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { LogicalLine } from '../source/logical-lines.js';
+import { type DirectiveAliasPolicy } from '../syntax/directive-aliases.js';
+export declare function applyConditionalAssembly(lines: readonly LogicalLine[], diagnostics: Diagnostic[], directiveAliasPolicy: DirectiveAliasPolicy | undefined): {
+    readonly lines: readonly LogicalLine[];
+};

package/dist/src/core/conditional-assembly.js

@@ -0,0 +1,181 @@
+import { stripLineComment } from '../source/strip-line-comment.js';
+import { normalizeDirectiveAlias } from '../syntax/directive-aliases.js';
+import { parseExpression } from '../syntax/parse-expression.js';
+import { evaluateExpression, lookupEquateRecord, } from '../semantics/expression-evaluation.js';
+export function applyConditionalAssembly(lines, diagnostics, directiveAliasPolicy) {
+    const out = [];
+    const equates = new Map();
+    const locationDependentEquates = new Set();
+    const stack = [];
+    for (const line of lines) {
+        const directive = parseConditionalDirective(line);
+        if (applyConditionalDirective(directive, line, stack, equates, locationDependentEquates, diagnostics)) {
+            continue;
+        }
+        if (!conditionalActive(stack)) {
+            continue;
+        }
+        out.push(line);
+        recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy);
+    }
+    for (const frame of stack) {
+        diagnostics.push(parseDiagnostic(frame.line, 'unterminated .if'));
+    }
+    return { lines: out };
+}
+function parseConditionalDirective(line) {
+    const text = stripLineComment(line.text).trim();
+    const ifDirective = /^\.if\s+(.+)$/.exec(text);
+    if (ifDirective)
+        return { kind: 'if', expressionText: ifDirective[1] ?? '' };
+    if (/^\.else\s*$/.test(text))
+        return { kind: 'else' };
+    if (/^\.endif\s*$/.test(text))
+        return { kind: 'endif' };
+    return { kind: 'none' };
+}
+function applyConditionalDirective(directive, line, stack, equates, locationDependentEquates, diagnostics) {
+    switch (directive.kind) {
+        case 'if':
+            pushConditionalFrame(line, directive.expressionText, stack, equates, locationDependentEquates, diagnostics);
+            return true;
+        case 'else':
+            flipConditionalFrame(line, stack, diagnostics);
+            return true;
+        case 'endif':
+            popConditionalFrame(line, stack, diagnostics);
+            return true;
+        case 'none':
+            return false;
+    }
+}
+function pushConditionalFrame(line, expressionText, stack, equates, locationDependentEquates, diagnostics) {
+    const parentActive = conditionalActive(stack);
+    const value = parentActive
+        ? evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics)
+        : undefined;
+    stack.push({
+        line,
+        parentActive,
+        conditionActive: parentActive && value !== undefined && value !== 0,
+        elseSeen: false,
+    });
+}
+function flipConditionalFrame(line, stack, diagnostics) {
+    const frame = stack.pop();
+    if (!frame) {
+        diagnostics.push(parseDiagnostic(line, 'unmatched .else'));
+        return;
+    }
+    if (frame.elseSeen) {
+        diagnostics.push(parseDiagnostic(line, 'duplicate .else'));
+    }
+    stack.push({
+        line: frame.line,
+        parentActive: frame.parentActive,
+        conditionActive: frame.parentActive && !frame.conditionActive,
+        elseSeen: true,
+    });
+}
+function popConditionalFrame(line, stack, diagnostics) {
+    if (!stack.pop()) {
+        diagnostics.push(parseDiagnostic(line, 'unmatched .endif'));
+    }
+}
+function conditionalActive(stack) {
+    return stack.every((frame) => frame.parentActive && frame.conditionActive);
+}
+function evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics) {
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        diagnostics.push(parseDiagnostic(line, `invalid .if expression: ${expressionText}`));
+        return undefined;
+    }
+    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
+        diagnostics.push(parseDiagnostic(line, 'invalid .if expression: current location is not available during conditional assembly'));
+        return undefined;
+    }
+    return evaluateExpression(expression, {}, equates, { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) }, diagnostics, { currentLocation: 0 });
+}
+function recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy) {
+    const text = normalizeDirectiveAlias(stripLineComment(line.text), directiveAliasPolicy).trim();
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)(?::\s*|\s+)\.equ\s+(.+)$/.exec(text);
+    if (!equ) {
+        return;
+    }
+    const name = equ[1] ?? '';
+    const expressionText = equ[2] ?? '';
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        return;
+    }
+    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
+        locationDependentEquates.add(canonicalConditionalSymbolKey(name));
+    }
+    equates.set(name, {
+        expression,
+        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        currentLocation: 0,
+    });
+}
+function expressionReferencesCurrentLocation(expression, equates, locationDependentEquates, visiting = new Set()) {
+    if (expression.kind === 'current-location')
+        return true;
+    if (expression.kind === 'symbol') {
+        return symbolReferencesCurrentLocation(expression.name, equates, locationDependentEquates, visiting);
+    }
+    return expressionChildExpressions(expression).some((child) => expressionReferencesCurrentLocation(child, equates, locationDependentEquates, visiting));
+}
+function expressionChildExpressions(expression) {
+    switch (expression.kind) {
+        case 'byte-function':
+        case 'unary':
+            return [expression.expression];
+        case 'binary':
+            return [expression.left, expression.right];
+        case 'layout-cast':
+            return layoutCastChildExpressions(expression);
+        default:
+            return [];
+    }
+}
+function layoutCastChildExpressions(expression) {
+    return [
+        expression.base,
+        ...expression.path.flatMap((part) => (part.kind === 'index' ? [part.expression] : [])),
+    ];
+}
+function symbolReferencesCurrentLocation(name, equates, locationDependentEquates, visiting) {
+    if (locationDependentEquates.has(canonicalConditionalSymbolKey(name))) {
+        return true;
+    }
+    const lookup = lookupEquateRecord(equates, name);
+    if (!lookup)
+        return false;
+    return equateReferencesCurrentLocation(lookup, equates, locationDependentEquates, visiting);
+}
+function equateReferencesCurrentLocation(lookup, equates, locationDependentEquates, visiting) {
+    const key = canonicalConditionalSymbolKey(lookup.key);
+    if (visiting.has(key))
+        return false;
+    const nextVisiting = new Set(visiting);
+    nextVisiting.add(key);
+    return expressionReferencesCurrentLocation(lookup.record.expression, equates, locationDependentEquates, nextVisiting);
+}
+function canonicalConditionalSymbolKey(name) {
+    return name.toLowerCase();
+}
+function parseDiagnostic(line, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+    };
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}

package/dist/src/expansion/op-constant-expression.d.ts

@@ -0,0 +1,3 @@
+import type { Expression } from '../model/expression.js';
+export declare function expressionFitsKnownImm8(expression: Expression): boolean;
+export declare function expressionFitsKnownImm16(expression: Expression): boolean;

package/dist/src/expansion/op-constant-expression.js

@@ -0,0 +1,52 @@
+const BINARY_CONSTANT_OPERATORS = new Map([
+    ['+', (left, right) => left + right],
+    ['-', (left, right) => left - right],
+    ['*', (left, right) => left * right],
+    ['/', (left, right) => (right === 0 ? undefined : Math.trunc(left / right))],
+    ['%', (left, right) => (right === 0 ? undefined : left % right)],
+    ['&', (left, right) => left & right],
+    ['^', (left, right) => left ^ right],
+    ['|', (left, right) => left | right],
+    ['<<', (left, right) => left << right],
+    ['>>', (left, right) => left >> right],
+]);
+export function expressionFitsKnownImm8(expression) {
+    const value = expressionConstantValue(expression);
+    return value === undefined || (value >= -0x80 && value <= 0xff);
+}
+export function expressionFitsKnownImm16(expression) {
+    const value = expressionConstantValue(expression);
+    return value === undefined || (value >= -0x8000 && value <= 0xffff);
+}
+function expressionConstantValue(expression) {
+    switch (expression.kind) {
+        case 'number':
+            return expression.value;
+        case 'unary':
+            return unaryConstantValue(expression);
+        case 'binary':
+            return binaryConstantValue(expression);
+        default:
+            return undefined;
+    }
+}
+function unaryConstantValue(expression) {
+    const value = expressionConstantValue(expression.expression);
+    if (value === undefined)
+        return undefined;
+    switch (expression.operator) {
+        case '+':
+            return value;
+        case '-':
+            return -value;
+        case '~':
+            return ~value;
+    }
+}
+function binaryConstantValue(expression) {
+    const left = expressionConstantValue(expression.left);
+    const right = expressionConstantValue(expression.right);
+    if (left === undefined || right === undefined)
+        return undefined;
+    return BINARY_CONSTANT_OPERATORS.get(expression.operator)?.(left, right);
+}

package/dist/src/expansion/op-expand-selected.d.ts

@@ -0,0 +1,5 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { SourceItem } from '../model/source-item.js';
+import type { LogicalLineLike, OpDecl } from './op-expansion.js';
+import { type OpOperand } from './op-operands.js';
+export declare function expandSelectedOp(ops: ReadonlyMap<string, readonly OpDecl[]>, overloads: readonly OpDecl[], operands: readonly OpOperand[], line: LogicalLineLike, diagnostics: Diagnostic[], stack: readonly OpDecl[]): readonly SourceItem[];