@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/transformers/hal-call-resolver.js

@@ -0,0 +1,274 @@
+import ts from "typescript";
+import { resolveHALReceiver, processHALMethodBody } from "../hal-resolver.js";
+import { expressionToIR } from "../expression-to-ir.js";
+import { renderExprAsText } from "../render-expr.js";
+import { collectChainedHALEmits, emitLinesToIR, halOpsToIR } from "./hal-emit-helpers.js";
+import { resolveNamespaceMethodCall } from "./namespace-methods.js";
+import { makeSourceSpan } from "../ast-node-utils.js";
+/**
+ * Resolve a HAL method call using the HAL resolver.
+ * Handles all HAL classes: Pin, I2CBus, SPIBus, SerialPort, EEPROMClass, WDTClass,
+ * plus device accessor patterns (I2CDevice, SPIDevice) and namespace methods (Pulse, Shift, Random).
+ */
+export function tryResolveHALMethod(call, fileName, sourceText, diagnostics, pointerVars) {
+    let method;
+    let instance = null;
+    if (ts.isPropertyAccessExpression(call.expression)) {
+        method = call.expression.name.text;
+        const receiver = call.expression.expression;
+        instance = resolveHALReceiver(receiver);
+    }
+    else if (ts.isIdentifier(call.expression)) {
+        method = call.expression.text;
+        // Global functions are treated as methods on a pseudo-instance with no class
+        instance = { className: "", fieldValues: new Map() };
+    }
+    else {
+        return null;
+    }
+    const argIRs = call.arguments.map(a => expressionToIR(a, sourceText, diagnostics, pointerVars));
+    // Try HAL class method resolution via resolver
+    if (instance) {
+        const result = processHALMethodBody(instance, method, argIRs);
+        if (result) {
+            // Collect emit lines and halOps from chained inner calls: led.tone(440).for(400)
+            // The receiver of this call is itself a chained HAL call (led.tone(440)).
+            // We need to process that inner call to collect its emit lines too.
+            const chainedEmits = [];
+            const chainedHalOps = [];
+            if (ts.isPropertyAccessExpression(call.expression)) {
+                const innerReceiver = call.expression.expression;
+                collectChainedHALEmits(innerReceiver, sourceText, diagnostics, pointerVars, chainedEmits, chainedHalOps);
+            }
+            // Prefer hal-op IR over raw emit lines, but preserve emit lines if both are generated
+            const allHalOps = [...chainedHalOps, ...result.halOps];
+            const allEmits = [...chainedEmits, ...result.emitLines];
+            if (allHalOps.length > 0 && allEmits.length > 0) {
+                const emitIR = emitLinesToIR(allEmits, call, fileName, sourceText);
+                const halOpIR = halOpsToIR(allHalOps, call, fileName, sourceText);
+                const body = [];
+                if (emitIR) {
+                    if (emitIR.kind === "block")
+                        body.push(...emitIR.body);
+                    else
+                        body.push(emitIR);
+                }
+                if (halOpIR) {
+                    if (halOpIR.kind === "block")
+                        body.push(...halOpIR.body);
+                    else
+                        body.push(halOpIR);
+                }
+                return {
+                    kind: "block",
+                    body,
+                    sourceSpan: makeSourceSpan(call, fileName, sourceText)
+                };
+            }
+            if (allHalOps.length > 0)
+                return halOpsToIR(allHalOps, call, fileName, sourceText);
+            if (allEmits.length > 0)
+                return emitLinesToIR(allEmits, call, fileName, sourceText);
+            // take()/release() are compile-time ownership markers — no runtime C++ on
+            // Arduino. Keep a call IR node so peripheral-ownership validation can see
+            // the bus name; emission is suppressed in StatementRenderer.renderCall.
+            if ((method === "take" || method === "release") && ts.isPropertyAccessExpression(call.expression)) {
+                const callReceiver = call.expression.expression;
+                const busInstance = resolveHALReceiver(callReceiver);
+                const busName = busInstance?.canonicalBusName
+                    ?? (ts.isIdentifier(callReceiver)
+                        ? callReceiver.text
+                        : renderExprAsText(expressionToIR(callReceiver, sourceText, diagnostics, pointerVars)) ?? "unknown");
+                return {
+                    kind: "call",
+                    callee: `${busName}.${method}`,
+                    args: argIRs,
+                    sourceSpan: makeSourceSpan(call, fileName, sourceText),
+                };
+            }
+            if (result.returnValue === "this" && ts.isPropertyAccessExpression(call.expression)) {
+                const objText = renderExprAsText(expressionToIR(call.expression.expression, sourceText, diagnostics, pointerVars));
+                return {
+                    kind: "call",
+                    callee: `${objText}.${method}`,
+                    args: argIRs,
+                    sourceSpan: makeSourceSpan(call, fileName, sourceText)
+                };
+            }
+            if (result.returnValue)
+                return emitLinesToIR([`${result.returnValue};`], call, fileName, sourceText);
+        }
+    }
+    const receiver = ts.isPropertyAccessExpression(call.expression) ? call.expression.expression : null;
+    // Try device accessor pattern: <bus>.device(addr).method(args)
+    // This resolves I2CDevice and SPIDevice calls
+    if (receiver && ts.isCallExpression(receiver)) {
+        const deviceCall = receiver;
+        if (ts.isPropertyAccessExpression(deviceCall.expression) && deviceCall.expression.name.text === "device") {
+            const busReceiver = deviceCall.expression.expression;
+            const busInstance = resolveHALReceiver(busReceiver);
+            if (busInstance) {
+                // Resolve device() arguments to create a device instance
+                const deviceArgs = deviceCall.arguments;
+                if (deviceArgs && deviceArgs.length > 0) {
+                    // Determine the device class based on bus class
+                    const deviceClassName = busInstance.className === "SPIBus" ? "SPIDevice" : "I2CDevice";
+                    // Build field values for the device: _bus from bus instance, _address/_cs from device() arg
+                    const deviceFieldValues = new Map();
+                    const busField = busInstance.fieldValues.get("_bus");
+                    if (busField)
+                        deviceFieldValues.set("_bus", busField);
+                    const deviceArg = deviceArgs[0];
+                    if (ts.isNumericLiteral(deviceArg)) {
+                        const fieldName = busInstance.className === "SPIBus" ? "_cs" : "_address";
+                        deviceFieldValues.set(fieldName, deviceArg.text);
+                    }
+                    else if (ts.isIdentifier(deviceArg)) {
+                        // For SPI device, resolve the pin
+                        const pinInstance = resolveHALReceiver(deviceArg);
+                        if (pinInstance && pinInstance.fieldValues.has("_pin")) {
+                            deviceFieldValues.set("_cs", pinInstance.fieldValues.get("_pin"));
+                        }
+                    }
+                    const deviceInstance = { className: deviceClassName, fieldValues: deviceFieldValues };
+                    const argIRs = call.arguments.map(a => expressionToIR(a, sourceText, diagnostics, pointerVars));
+                    const result = processHALMethodBody(deviceInstance, method, argIRs);
+                    if (result) {
+                        if (result.halOps.length > 0)
+                            return halOpsToIR(result.halOps, call, fileName, sourceText);
+                        if (result.emitLines.length > 0)
+                            return emitLinesToIR(result.emitLines, call, fileName, sourceText);
+                        if (result.returnValue)
+                            return emitLinesToIR([`${result.returnValue};`], call, fileName, sourceText);
+                    }
+                }
+            }
+        }
+    }
+    // ── Inline fallbacks for namespace methods the HAL resolver can't express ──
+    if (receiver && ts.isIdentifier(receiver)) {
+        const ns = receiver.text;
+        const nsResult = resolveNamespaceMethodCall(ns, method, argIRs);
+        if (nsResult) {
+            if (nsResult.halOps.length > 0)
+                return halOpsToIR(nsResult.halOps, call, fileName, sourceText);
+            if (nsResult.returnValue)
+                return emitLinesToIR([`${nsResult.returnValue};`], call, fileName, sourceText);
+            if (nsResult.emitLines.length > 0)
+                return emitLinesToIR(nsResult.emitLines, call, fileName, sourceText);
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a HAL call for use in variable initializers and expression contexts.
+ * Returns emitLines and returnValue via the HAL resolver.
+ */
+export function resolveHALCallForVarInit(call, sourceText, diagnostics, pointerVars) {
+    if (!ts.isPropertyAccessExpression(call.expression))
+        return null;
+    const method = call.expression.name.text;
+    const receiver = call.expression.expression;
+    const argIRs = call.arguments.map(a => expressionToIR(a, sourceText, diagnostics, pointerVars));
+    const instance = resolveHALReceiver(receiver);
+    if (instance) {
+        const result = processHALMethodBody(instance, method, argIRs);
+        if (result) {
+            // Variable-initializer context is effectively expression context: the
+            // returnValue is substituted into `T name = <returnValue>;`. A leading
+            // `return ` (baked into HAL rawCpp for statement context) would leak as
+            // `T name = return Preferences.getString(...);`. Strip it. Demo #33.
+            const returnValue = result.returnValue ? result.returnValue.replace(/^\s*return\s+/, "") : result.returnValue;
+            return { emitLines: result.emitLines, halOps: result.halOps, returnValue, returnClassName: result.returnClassName };
+        }
+    }
+    // Try device accessor pattern
+    if (ts.isCallExpression(receiver)) {
+        const deviceCall = receiver;
+        if (ts.isPropertyAccessExpression(deviceCall.expression) && deviceCall.expression.name.text === "device") {
+            const busReceiver = deviceCall.expression.expression;
+            const busInstance = resolveHALReceiver(busReceiver);
+            if (busInstance) {
+                const deviceArgs = deviceCall.arguments;
+                if (deviceArgs && deviceArgs.length > 0) {
+                    const deviceClassName = busInstance.className === "SPIBus" ? "SPIDevice" : "I2CDevice";
+                    const deviceFieldValues = new Map();
+                    const busField = busInstance.fieldValues.get("_bus");
+                    if (busField)
+                        deviceFieldValues.set("_bus", busField);
+                    const deviceArg = deviceArgs[0];
+                    if (ts.isNumericLiteral(deviceArg)) {
+                        const fieldName = busInstance.className === "SPIBus" ? "_cs" : "_address";
+                        deviceFieldValues.set(fieldName, deviceArg.text);
+                    }
+                    else if (ts.isIdentifier(deviceArg)) {
+                        const pinInstance = resolveHALReceiver(deviceArg);
+                        if (pinInstance && pinInstance.fieldValues.has("_pin")) {
+                            deviceFieldValues.set("_cs", pinInstance.fieldValues.get("_pin"));
+                        }
+                    }
+                    const deviceInstance = { className: deviceClassName, fieldValues: deviceFieldValues };
+                    const result = processHALMethodBody(deviceInstance, method, argIRs);
+                    if (result)
+                        return { emitLines: result.emitLines, halOps: result.halOps, returnValue: result.returnValue };
+                }
+            }
+        }
+    }
+    // Namespace method fallbacks (Pulse, Shift, Random) — used in variable initializer context
+    if (ts.isIdentifier(receiver)) {
+        const ns = receiver.text;
+        return resolveNamespaceMethodCall(ns, method, argIRs);
+    }
+    return null;
+}
+/**
+ * Try to resolve a HAL expression call for use inside expression contexts.
+ * Returns a raw string ExpressionIR if resolved, or null if not a HAL call.
+ * Side effects (emitLines) are accumulated and returned separately.
+ */
+export function tryResolveHALExpression(call, sourceText, diagnostics, pointerVars) {
+    if (!ts.isPropertyAccessExpression(call.expression))
+        return null;
+    const method = call.expression.name.text;
+    const receiver = call.expression.expression;
+    const argIRs = call.arguments.map(a => expressionToIR(a, sourceText, diagnostics, pointerVars));
+    const instance = resolveHALReceiver(receiver);
+    if (instance) {
+        const result = processHALMethodBody(instance, method, argIRs);
+        if (result) {
+            // Prefer hal-expr for semantic HAL operations
+            if (result.halOps.length > 0) {
+                // Use the last halOp as the expression; preceding ones are side effects
+                const lastOp = result.halOps[result.halOps.length - 1];
+                return {
+                    ir: { kind: "hal-expr", operation: lastOp },
+                    sideEffects: result.emitLines,
+                };
+            }
+            if (result.returnValue === "this") {
+                // Return structured method call for analysis
+                const objText = renderExprAsText(expressionToIR(receiver, sourceText, diagnostics, pointerVars));
+                return {
+                    ir: { kind: "method-call", callee: `${objText}.${method}`, args: argIRs },
+                    sideEffects: result.emitLines
+                };
+            }
+            if (result.returnValue) {
+                // Expression context: a leading `return ` (baked into many HAL
+                // rawCpp definitions for statement context) is invalid inside an
+                // expression and would leak as e.g.
+                // `strcmp(return Preferences.getString(...), ...)` (avr-g++: "expected
+                // primary-expression before 'return'"). Strip it here so the value is
+                // usable as a sub-expression. Statement context keeps the `return`
+                // via tryResolveHALMethod. Demo #33 Finding B.
+                const exprValue = result.returnValue.replace(/^\s*return\s+/, "");
+                return { ir: { kind: "raw", value: exprValue }, sideEffects: result.emitLines };
+            }
+            if (result.emitLines.length > 0) {
+                return { ir: { kind: "raw", value: "0" }, sideEffects: result.emitLines };
+            }
+        }
+    }
+    return null;
+}

package/dist/ir/transformers/hal-emit-helpers.d.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { Diagnostic } from "../../types.js";
+import { HALOpIR, StatementIR } from "../../api/index.js";
+import { PointerTracker } from "../build-ir-state.js";
+/**
+ * Recursively collect emit lines from chained HAL method calls.
+ * For an expression like led.tone(440).for(400), this collects
+ * the emit lines from the inner led.tone(440) call.
+ */
+export declare function collectChainedHALEmits(expr: ts.Expression, sourceText: string, diagnostics: Diagnostic[], pointerVars: PointerTracker, emitLines: string[], halOps?: HALOpIR[]): void;
+/** Convert emit lines to a StatementIR (single emit or block of emits). */
+export declare function emitLinesToIR(lines: string[], node: ts.Node, fileName: string, sourceText: string): StatementIR | null;
+/** Convert HALOpIR array to hal-op StatementIR nodes. */
+export declare function halOpsToIR(ops: HALOpIR[], node: ts.Node, fileName: string, sourceText: string): StatementIR | null;

package/dist/ir/transformers/hal-emit-helpers.js

@@ -0,0 +1,63 @@
+import ts from "typescript";
+import { makeSourceSpan } from "../ast-node-utils.js";
+import { expressionToIR } from "../expression-to-ir.js";
+import { resolveHALReceiver, processHALMethodBody } from "../hal-resolver.js";
+/**
+ * Recursively collect emit lines from chained HAL method calls.
+ * For an expression like led.tone(440).for(400), this collects
+ * the emit lines from the inner led.tone(440) call.
+ */
+export function collectChainedHALEmits(expr, sourceText, diagnostics, pointerVars, emitLines, halOps = []) {
+    // Chained call: led.tone(440).for(400) — the receiver is the inner call led.tone(440)
+    if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
+        const method = expr.expression.name.text;
+        const innerReceiver = expr.expression.expression;
+        const instance = resolveHALReceiver(innerReceiver);
+        if (instance) {
+            const argIRs = expr.arguments.map(a => expressionToIR(a, sourceText, diagnostics, pointerVars));
+            const result = processHALMethodBody(instance, method, argIRs);
+            if (result) {
+                if (result.emitLines.length > 0) {
+                    // Prepend inner emits so they appear before outer emits
+                    emitLines.unshift(...result.emitLines);
+                }
+                if (result.halOps.length > 0) {
+                    halOps.unshift(...result.halOps);
+                }
+            }
+        }
+        // Continue recursion to collect deeper chain levels
+        if (ts.isCallExpression(innerReceiver) && ts.isPropertyAccessExpression(innerReceiver)) {
+            collectChainedHALEmits(innerReceiver, sourceText, diagnostics, pointerVars, emitLines, halOps);
+        }
+    }
+}
+/** Convert emit lines to a StatementIR (single emit or block of emits). */
+export function emitLinesToIR(lines, node, fileName, sourceText) {
+    if (lines.length === 0)
+        return null;
+    const emitStmts = lines.map(line => ({
+        kind: "call",
+        sourceSpan: makeSourceSpan(node, fileName, sourceText),
+        callee: "__EMIT__",
+        args: [{ kind: "string", value: line }],
+    }));
+    return emitStmts.length === 1
+        ? emitStmts[0]
+        : { kind: "block", body: emitStmts, sourceSpan: makeSourceSpan(node, fileName, sourceText) };
+}
+/** Convert HALOpIR array to hal-op StatementIR nodes. */
+export function halOpsToIR(ops, node, fileName, sourceText) {
+    if (ops.length === 0)
+        return null;
+    const span = makeSourceSpan(node, fileName, sourceText);
+    const halStmts = ops.map(op => ({
+        kind: "hal-op",
+        sourceSpan: span,
+        operation: op,
+        returns_value: false,
+    }));
+    return halStmts.length === 1
+        ? halStmts[0]
+        : { kind: "block", body: halStmts, sourceSpan: span };
+}

package/dist/ir/transformers/namespace-methods.d.ts

@@ -0,0 +1,20 @@
+import { ExpressionIR, HALOpIR } from "../../api/index.js";
+export type NamespaceMethodResult = {
+    emitLines: string[];
+    halOps: HALOpIR[];
+    returnValue?: string;
+} | null;
+/**
+ * Resolve a Pulse, Shift, or Random namespace method call to its C++ equivalent.
+ *
+ * These methods are handled as inline fallbacks because they don't map to
+ * HAL class instances — they are free-standing Arduino API functions accessed
+ * through TypeCAD namespace objects.
+ *
+ * @param ns       - The namespace identifier text ("Pulse", "Shift", "Random")
+ * @param method   - The method name (e.g. "in", "out", "seed", "number")
+ * @param argIRs   - Pre-built ExpressionIR for each call argument
+ * @returns A result object compatible with both statement and expression contexts,
+ *          or null if the ns/method combination is not recognized.
+ */
+export declare function resolveNamespaceMethodCall(ns: string, method: string, argIRs: ExpressionIR[]): NamespaceMethodResult;

package/dist/ir/transformers/namespace-methods.js

@@ -0,0 +1,110 @@
+import { renderExprAsText } from "../render-expr.js";
+import { halInstances } from "../hal-resolver.js";
+/**
+ * Resolve a Pulse, Shift, or Random namespace method call to its C++ equivalent.
+ *
+ * These methods are handled as inline fallbacks because they don't map to
+ * HAL class instances — they are free-standing Arduino API functions accessed
+ * through TypeCAD namespace objects.
+ *
+ * @param ns       - The namespace identifier text ("Pulse", "Shift", "Random")
+ * @param method   - The method name (e.g. "in", "out", "seed", "number")
+ * @param argIRs   - Pre-built ExpressionIR for each call argument
+ * @returns A result object compatible with both statement and expression contexts,
+ *          or null if the ns/method combination is not recognized.
+ */
+export function resolveNamespaceMethodCall(ns, method, argIRs) {
+    const argText = (idx) => {
+        const a = argIRs[idx];
+        if (!a)
+            return "";
+        return renderExprAsText(a);
+    };
+    const resolvePinArg = (idx) => {
+        const text = argText(idx);
+        const inst = halInstances.get(text);
+        if (inst && inst.fieldValues.has("_pin"))
+            return inst.fieldValues.get("_pin");
+        return text;
+    };
+    const resolveBoolArg = (idx) => {
+        const text = argText(idx);
+        if (text === "true")
+            return "HIGH";
+        if (text === "false")
+            return "LOW";
+        return text;
+    };
+    if (ns === "Pulse") {
+        // Legacy free-function style: Pulse.in(pin, level)
+        if (method === "in") {
+            const pin = resolvePinArg(0);
+            const level = resolveBoolArg(1);
+            const timeout = argText(2);
+            const call = timeout
+                ? `pulseIn(${pin}, ${level}, ${timeout})`
+                : `pulseIn(${pin}, ${level})`;
+            return { emitLines: [], halOps: [], returnValue: call };
+        }
+        // Current fluent API: Pulse.on(pin) returns a PulseMeasurement builder.
+        // The builder methods (.high(), .low(), .timeout()) are chained, so we
+        // can't resolve them here — but the static Pulse.long() can be handled.
+        if (method === "long" || method === "long_") {
+            const pin = resolvePinArg(0);
+            const level = resolveBoolArg(1);
+            const timeout = argText(2);
+            const call = timeout
+                ? `pulseInLong(${pin}, ${level}, ${timeout})`
+                : `pulseInLong(${pin}, ${level})`;
+            return { emitLines: [], halOps: [], returnValue: call };
+        }
+        // Pulse.long(pin, value) static method (current API)
+        if (method === "long") {
+            const pin = resolvePinArg(0);
+            const value = argText(1);
+            return { emitLines: [], halOps: [], returnValue: `pulseInLong(${pin}, ${value})` };
+        }
+    }
+    if (ns === "Shift") {
+        if (method === "in") {
+            return {
+                emitLines: [],
+                halOps: [],
+                returnValue: `shiftIn(${resolvePinArg(0)}, ${resolvePinArg(1)}, ${argText(2)})`,
+            };
+        }
+        if (method === "out") {
+            return {
+                emitLines: [`shiftOut(${resolvePinArg(0)}, ${resolvePinArg(1)}, ${argText(2)}, ${argText(3)});`],
+                halOps: [],
+            };
+        }
+    }
+    if (ns === "Random") {
+        if (method === "seed") {
+            return { emitLines: [`randomSeed(${argText(0)});`], halOps: [] };
+        }
+        if (method === "number") {
+            const min = argText(0);
+            const max = argText(1);
+            return {
+                emitLines: [],
+                halOps: [],
+                returnValue: max ? `random(${min}, ${max})` : `random(${min})`,
+            };
+        }
+        // Current class API: Random.upTo(max) → random(max)
+        if (method === "upTo") {
+            return { emitLines: [], halOps: [], returnValue: `random(${argText(0)})` };
+        }
+        // Random.between(min, max) → random(min, max)
+        if (method === "between") {
+            return { emitLines: [], halOps: [], returnValue: `random(${argText(0)}, ${argText(1)})` };
+        }
+        // Random.int() → random(2147483647)
+        if (method === "int") {
+            return { emitLines: [], halOps: [], returnValue: `random(2147483647)` };
+        }
+    }
+    return null;
+}

package/dist/ir/transformers/register-assignment.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { Diagnostic } from "../../types.js";
+import { StatementIR, ExpressionIR } from "../../api/index.js";
+export declare function tryLowerRegisterWrite(statement: ts.ExpressionStatement, expr: ts.BinaryExpression, fileName: string, sourceText: string, diagnostics: Diagnostic[]): StatementIR | null;
+export declare function tryLowerRegisterRead(expr: ts.PropertyAccessExpression, sourceText: string, diagnostics: Diagnostic[]): ExpressionIR | null;

package/dist/ir/transformers/register-assignment.js

@@ -0,0 +1,56 @@
+import ts from "typescript";
+import { extractNodeComments, makeSourceSpan } from "../ast-node-utils.js";
+import { registerFieldMap } from "../build-ir-state.js";
+import { expressionToIR } from "../expression-to-ir.js";
+import { renderExprAsText } from "../render-expr.js";
+export function tryLowerRegisterWrite(statement, expr, fileName, sourceText, diagnostics) {
+    if (ts.isPropertyAccessExpression(expr.left) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        const objExpr = expr.left.expression;
+        const fieldName = expr.left.name.text;
+        if (ts.isIdentifier(objExpr)) {
+            const regName = objExpr.text;
+            const fieldMap = registerFieldMap.get(regName);
+            if (fieldMap) {
+                const field = fieldMap.get(fieldName);
+                if (field) {
+                    const fieldMask = ((1 << field.width) - 1) >>> 0;
+                    const fieldMaskUL = fieldMask + 'UL';
+                    const shiftMask = (fieldMask << field.lo) >>> 0;
+                    const shiftMaskUL = shiftMask + 'UL';
+                    const valueIR = expressionToIR(expr.right, sourceText, diagnostics);
+                    const valueText = renderExprAsText(valueIR);
+                    const comments = extractNodeComments(statement, sourceText);
+                    return {
+                        kind: "assign",
+                        sourceSpan: makeSourceSpan(statement, fileName, sourceText),
+                        leadingComments: comments.leadingComments,
+                        trailingComments: comments.trailingComments,
+                        target: `*${regName}`,
+                        operator: "=",
+                        value: { kind: "raw", value: `(*${regName} & ~${shiftMaskUL}) | ((${valueText} & ${fieldMaskUL}) << ${field.lo})` },
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}
+export function tryLowerRegisterRead(expr, sourceText, diagnostics) {
+    if (ts.isIdentifier(expr.expression)) {
+        const regName = expr.expression.text;
+        const fieldName = expr.name.text;
+        const fieldMap = registerFieldMap.get(regName);
+        if (fieldMap) {
+            const field = fieldMap.get(fieldName);
+            if (field) {
+                const mask = ((1 << field.width) - 1) >>> 0;
+                const maskUL = mask + 'UL';
+                if (field.lo === 0 && field.width === 1) {
+                    return { kind: "raw", value: `(*${regName} >> ${field.lo}) & 1UL` };
+                }
+                return { kind: "raw", value: `(*${regName} >> ${field.lo}) & ${maskUL}` };
+            }
+        }
+    }
+    return null;
+}