@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/ui-element-auto-wire.d.ts

@@ -0,0 +1,50 @@
+interface AutoWireNode {
+    tag: string;
+    id?: string;
+    text?: string;
+    children?: AutoWireNode[];
+    options?: Array<{
+        value: string;
+        text: string;
+    }>;
+    name?: string;
+    checked?: boolean;
+    href?: string;
+    /** Rich-text runs (present only for text nodes with mixed inline content).
+     *  A run may carry an href (inline <a href>); those make the node a link
+     *  target that needs a click handler so it's hit-testable. */
+    runs?: Array<{
+        href?: string;
+    }>;
+    /** True when text contains a `{expr}` interpolation; auto-wire synthesizes an
+     *  implicit text binding for it (no id required — {expr} references a signal). */
+    hasInterpolation?: boolean;
+    /** Declarative on:* event handlers (named-function references). Each value
+     *  names an exported TS function emitted as a standalone C++ function. */
+    events?: {
+        click?: string;
+        hold?: string;
+        release?: string;
+        change?: string;
+    };
+    /** Declarative bind:* two-way bindings (signal names). bind:text on <input>
+     *  composes a text binding + an input binding; bind:value on <range>/<check>
+     *  composes a value binding + a change/click handler. */
+    bind?: {
+        text?: string;
+        value?: string;
+    };
+}
+export declare function getRadioGroups(): Map<string, {
+    id: string;
+    nodeIndex: number;
+}[]>;
+/** Register a screen ID → index mapping (called during multi-screen setup). */
+export declare function registerScreenId(id: string, index: number): void;
+/** Resolve a href="#screenId" to a screen index, or undefined if unknown. */
+export declare function resolveScreenHref(href: string | undefined): number | undefined;
+/**
+ * Walk the styled tree and auto-wire built-in element behaviors.
+ */
+export declare function autoWireElements(treeName: string, root: AutoWireNode, startIndex?: number): number;
+export {};

package/dist/ir/ui-element-auto-wire.js

@@ -0,0 +1,218 @@
+// ---------------------------------------------------------------------------
+// Auto-wire built-in elements — when the transpiler encounters <check>,
+// <select>, or <button> in the HTML, it automatically registers the default
+// behavior (onClick handlers, visual bindings) so the author doesn't have to.
+//
+// Authors can still override or add to this behavior in their TS code.
+// For custom elements, use <view> + <text> + manual bindings.
+// ---------------------------------------------------------------------------
+import { recordClickHandler, recordBinding, markRunNode, lowerInterpolationText } from "./transformers/ui-call-resolver.js";
+import { recordInputBinding } from "./transformers/ui-reactive.js";
+// Track radio groups for mutual exclusion
+const radioGroups = new Map();
+// Track screen IDs → screen indices for link navigation.
+const screenIdMap = new Map();
+export function getRadioGroups() { return radioGroups; }
+/** Register a screen ID → index mapping (called during multi-screen setup). */
+export function registerScreenId(id, index) {
+    screenIdMap.set(id, index);
+}
+/** Resolve a href="#screenId" to a screen index, or undefined if unknown. */
+export function resolveScreenHref(href) {
+    if (!href)
+        return undefined;
+    const target = href.startsWith("#") ? href.slice(1) : href;
+    return screenIdMap.get(target);
+}
+/**
+ * Walk the styled tree and auto-wire built-in element behaviors.
+ */
+export function autoWireElements(treeName, root, startIndex = 0) {
+    if (startIndex === 0)
+        radioGroups.clear();
+    let nodeIndex = startIndex;
+    const walk = (node) => {
+        const currentIndex = nodeIndex++;
+        // Record run-bearing node indices so the binding resolver can reject
+        // PROP_TEXT bindings on them (runs are static-only).
+        if (node.runs && node.runs.length > 0)
+            markRunNode(currentIndex);
+        // Auto-wire nodes with an id, <a href> links, run-bearing link nodes
+        // (an inline <a href> inside a paragraph makes the paragraph a tap target),
+        // {expr} text interpolations, and on:* declarative event handlers. The last
+        // two may have no id — {expr} references a signal; on:* names a function.
+        const hasLinkRun = !!node.runs?.some(r => r.href);
+        const hasEvents = !!node.events && Object.keys(node.events).length > 0;
+        const hasBind = !!node.bind && Object.keys(node.bind).length > 0;
+        if (node.id || node.href || hasLinkRun || node.hasInterpolation || hasEvents || hasBind) {
+            autoWireNode(treeName, node, currentIndex);
+        }
+        node.children?.forEach(walk);
+    };
+    walk(root);
+    return nodeIndex;
+}
+function autoWireNode(treeName, node, nodeIndex) {
+    // {expr} text interpolation → synthesize an implicit text binding. This runs
+    // before the id/href guard below because an interpolation node may have no id
+    // ({expr} references a signal, not a screen.<id> handle). recordBinding rejects
+    // run-bearing nodes via the run-text-binding-conflict guard, so inline+interp
+    // combinations are caught there rather than here.
+    if (node.hasInterpolation && node.text) {
+        const cppBody = lowerInterpolationText(node.text);
+        if (cppBody) {
+            recordBinding({
+                nodeIndex,
+                property: "text",
+                fnName: `__ui_interp_${nodeIndex}`,
+                cppBody,
+            });
+        }
+    }
+    // bind:* declarative two-way bindings → compose a read-binding (signal→node)
+    // with a write-callback (node→signal). bind:text on <input> uses a text
+    // binding + an input binding (fires on keyboard commit). bind:value on
+    // <range>/<check> uses a value binding + a change/click handler.
+    if (node.bind) {
+        if (node.bind.text) {
+            const sig = node.bind.text;
+            // Read: signal → node text (reuses the binding table).
+            recordBinding({
+                nodeIndex,
+                property: "text",
+                fnName: `__ui_bindtext_${nodeIndex}`,
+                cppBody: `snprintf(buf, size, "%s", ${sig});`,
+            });
+            // Write: keyboard commit → signal.set(text).
+            recordInputBinding({
+                nodeIndex,
+                cbFnName: `__ui_bindtext_cb_${nodeIndex}`,
+                cbFnBody: `${sig}.set(std::string(text));`,
+            });
+        }
+        if (node.bind.value) {
+            const sig = node.bind.value;
+            // Read: signal → node value.
+            recordBinding({
+                nodeIndex,
+                property: "value",
+                fnName: `__ui_bindval_${nodeIndex}`,
+                cppExpr: sig,
+            });
+            // Write: range drag / check toggle → signal.set(value).
+            recordClickHandler({
+                nodeIndex,
+                kind: node.tag === "check" ? "click" : "rangechange",
+                fnName: `__ui_bindval_cb_${nodeIndex}`,
+                callbackBody: `${sig}.set(__ui_nodes[${nodeIndex}].value);`,
+            });
+        }
+    }
+    // on:* declarative event handlers → record click/hold/release/change handlers
+    // that reference the named C++ function by name (no inlined body). The named
+    // function comes from the author's `export function name() {...}` in TS,
+    // which the transpiler emits as a standalone C++ function.
+    if (node.events) {
+        const kindMap = { click: "click", hold: "hold", release: "release", change: "change" };
+        for (const key of Object.keys(node.events)) {
+            const fnName = node.events[key];
+            if (fnName) {
+                recordClickHandler({
+                    nodeIndex,
+                    kind: kindMap[key],
+                    fnName,
+                    callbackBody: "",
+                    isNamedRef: true,
+                });
+            }
+        }
+    }
+    // The check/select/radio branches generate fnNames from node.id, so they
+    // require one. The href (navigation) branch below works with or without id.
+    // Run-bearing link nodes also work without id (handler body is a no-op; the
+    // real navigation happens via the run hit-test in the tap path).
+    const hasLinkRun = !!node.runs?.some(r => r.href);
+    if (!node.id && !node.href && !hasLinkRun)
+        return;
+    if (node.tag === "check") {
+        // Auto-wire: onClick toggles value 0↔1
+        recordClickHandler({
+            nodeIndex,
+            kind: "click",
+            fnName: `__ui_${node.id}_autoclick`,
+            callbackBody: `__ui_nodes[${nodeIndex}].value = (__ui_nodes[${nodeIndex}].value > 0 ? 0 : 1);`,
+        });
+    }
+    if (node.tag === "select") {
+        // Use parsed options (from <option> children) or fallback to comma text
+        const options = node.options && node.options.length > 0
+            ? node.options.map(o => o.text)
+            : (node.text || "").split(",").map(s => s.trim()).filter(Boolean);
+        const count = Math.max(options.length, 2);
+        // Auto-wire: onClick cycles value 0..count-1
+        recordClickHandler({
+            nodeIndex,
+            kind: "click",
+            fnName: `__ui_${node.id}_autoclick`,
+            callbackBody: `__ui_nodes[${nodeIndex}].value = (__ui_nodes[${nodeIndex}].value + 1) % ${count};`,
+        });
+        // Auto-bind text to show the current option via snprintf if/else chain
+        const branches = options.map((opt, i) => {
+            if (i === 0)
+                return `if (__ui_nodes[${nodeIndex}].value == 0) { snprintf(buf, size, "%s", "${opt}"); }`;
+            return `else if (__ui_nodes[${nodeIndex}].value == ${i}) { snprintf(buf, size, "%s", "${opt}"); }`;
+        }).join(" ");
+        const elseBranch = `else { snprintf(buf, size, "%s", "${options[0] || ""}"); }`;
+        recordBinding({
+            nodeIndex,
+            property: "text",
+            fnName: `__ui_${node.id}_autotext`,
+            cppBody: branches + " " + elseBranch,
+        });
+    }
+    if (node.tag === "radio" && node.name) {
+        // Register this radio in its group
+        const groupName = node.name;
+        if (!radioGroups.has(groupName))
+            radioGroups.set(groupName, []);
+        const group = radioGroups.get(groupName);
+        group.push({ id: node.id, nodeIndex });
+        // Auto-wire: onClick clears all radios in the group, then selects this one.
+        // The generated C++ references the radio group table by index.
+        const groupIdx = Array.from(radioGroups.keys()).indexOf(groupName);
+        recordClickHandler({
+            nodeIndex,
+            kind: "click",
+            fnName: `__ui_${node.id}_autoclick`,
+            callbackBody: `for (uint8_t __r = 0; __r < __ui_radio_groups[${groupIdx}].count; __r++) { uint16_t __rn = __ui_radio_groups[${groupIdx}].nodeIndices[__r]; __ui_nodes[__rn].value = 0; ui_mark_dirty(__rn); } __ui_nodes[${nodeIndex}].value = 1; ui_mark_dirty(${nodeIndex});`,
+        });
+    }
+    // Auto-wire <a href="#screenId"> links: onClick navigates to the target screen.
+    if (node.href) {
+        const targetScreen = resolveScreenHref(node.href);
+        if (targetScreen !== undefined) {
+            recordClickHandler({
+                nodeIndex,
+                kind: "click",
+                fnName: `__ui_${node.id ?? "link" + nodeIndex}_nav`,
+                callbackBody: `ui_navigate(${targetScreen});`,
+            });
+        }
+        else {
+            console.error(`[auto-wire] WARNING: <a href="${node.href}"> (id=${node.id}) target screen not found. Known screens: ${[...screenIdMap.keys()].join(", ")}`);
+        }
+    }
+    else if (hasLinkRun) {
+        // Run-bearing link node (an inline <a href> inside a paragraph). The link
+        // targets live on the runs and are resolved into the model at lower time;
+        // the tap path calls ui_rich_link_hit / richLinkHit to pick the target.
+        // Register a no-op click handler so the node is hit-testable in the first
+        // place (hit-test only considers nodes with a registered handler).
+        recordClickHandler({
+            nodeIndex,
+            kind: "click",
+            fnName: `__ui_${node.id ?? "richlink" + nodeIndex}_nav`,
+            callbackBody: `/* rich-text link; target resolved by ui_rich_link_hit */`,
+        });
+    }
+}

package/dist/ir/unit-suspicion-validation.d.ts

@@ -0,0 +1,12 @@
+import { ProgramIR } from '../api/index.js';
+import { Diagnostic } from '../types.js';
+/**
+ * Validate peripheral config values for common unit mistakes.
+ *
+ * Scans the program IR for cuttlefish-call nodes that configure peripherals
+ * with bare numbers and emits warnings when values look suspicious.
+ *
+ * @param program - The program IR to validate
+ * @returns Array of diagnostics for suspicious peripheral config values
+ */
+export declare function validateUnitSuspicion(program: ProgramIR): Diagnostic[];

package/dist/ir/unit-suspicion-validation.js

@@ -0,0 +1,296 @@
+// ---------------------------------------------------------------------------
+// Unit Suspicion Validation
+//
+// Warns when bare numbers passed to peripheral config methods look suspicious.
+// For example, passing 9600 to an SPI frequency (which expects Hz, not baud)
+// or passing 100 to I2C speed (which expects Hz, not kHz).
+//
+// This validator complements the two-tier peripheral config approach:
+// - Enum values (BaudRate._9600, I2CSpeed.FAST, etc.) are always safe
+// - Bare numbers in .config builders are validated here for common mistakes
+// ---------------------------------------------------------------------------
+// Standard baud rates for UART
+const KNOWN_BAUD_RATES = new Set([
+    300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200,
+    230400, 460800, 921600,
+]);
+// Standard I2C clock speeds in Hz
+const KNOWN_I2C_SPEEDS = new Set([
+    100_000, // Standard (100 kHz)
+    400_000, // Fast (400 kHz)
+    1_000_000, // Fast Plus (1 MHz)
+    3_400_000, // High Speed (3.4 MHz)
+]);
+// Standard SPI clock frequencies in Hz
+const KNOWN_SPI_FREQUENCIES = new Set([
+    125_000, // 125 kHz
+    250_000, // 250 kHz
+    500_000, // 500 kHz
+    1_000_000, // 1 MHz
+    2_000_000, // 2 MHz
+    4_000_000, // 4 MHz
+    8_000_000, // 8 MHz
+    16_000_000, // 16 MHz
+]);
+/**
+ * Extract a numeric value from an expression IR node.
+ * Returns `undefined` if the expression is not a simple numeric literal.
+ */
+function extractNumericValue(expr) {
+    if (!expr || typeof expr !== 'object')
+        return undefined;
+    // Direct numeric literal
+    if (expr.kind === 'number') {
+        return expr.value;
+    }
+    return undefined;
+}
+/**
+ * Check if a baud rate value is suspicious.
+ * Warns if the value is not a standard baud rate.
+ */
+function checkBaudRate(value) {
+    if (KNOWN_BAUD_RATES.has(value))
+        return undefined;
+    // Check for common mistakes
+    // User might have intended a standard rate but typo'd
+    for (const known of KNOWN_BAUD_RATES) {
+        // Close to a standard rate (within 10%)
+        if (value > known * 0.9 && value < known * 1.1) {
+            return `Baud rate ${value} is close to standard rate ${known}. Did you mean ${known}?`;
+        }
+    }
+    // Very low values might be confused with kHz
+    if (value > 0 && value < 100) {
+        return `Baud rate ${value} is unusually low. UART baud rates are typically ≥ 300.`;
+    }
+    return undefined;
+}
+/**
+ * Check if an I2C speed value is suspicious.
+ * Warns if the value looks like it's in kHz instead of Hz.
+ */
+function checkI2CSpeed(value) {
+    if (KNOWN_I2C_SPEEDS.has(value))
+        return undefined;
+    // Common mistake: passing kHz value instead of Hz
+    // e.g., 100 instead of 100000, 400 instead of 400000
+    if (value > 0 && value < 10000) {
+        // Check if multiplying by 1000 gives a known speed
+        const asHz = value * 1000;
+        if (KNOWN_I2C_SPEEDS.has(asHz)) {
+            return `I2C speed ${value} looks like a kHz value. Did you mean ${asHz} (${value} kHz)? I2C speed is specified in Hz.`;
+        }
+    }
+    // Check for close matches to standard speeds
+    for (const known of KNOWN_I2C_SPEEDS) {
+        if (value > known * 0.9 && value < known * 1.1) {
+            return `I2C speed ${value} is close to standard speed ${known}. Did you mean ${known}?`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if an SPI frequency value is suspicious.
+ * Warns if the value looks like it's in kHz or MHz instead of Hz,
+ * or if it's a standard baud rate mistakenly used for SPI.
+ */
+function checkSPIFrequency(value) {
+    if (KNOWN_SPI_FREQUENCIES.has(value))
+        return undefined;
+    // Common mistake: passing kHz value instead of Hz
+    if (value > 0 && value < 100000) {
+        const asHz = value * 1000;
+        if (KNOWN_SPI_FREQUENCIES.has(asHz)) {
+            return `SPI frequency ${value} looks like a kHz value. Did you mean ${asHz}? SPI frequency is specified in Hz.`;
+        }
+    }
+    // Common mistake: passing MHz value instead of Hz
+    if (value > 0 && value <= 16) {
+        const asHz = value * 1_000_000;
+        if (KNOWN_SPI_FREQUENCIES.has(asHz)) {
+            return `SPI frequency ${value} looks like an MHz value. Did you mean ${asHz}? SPI frequency is specified in Hz.`;
+        }
+    }
+    // Check if a standard baud rate was mistakenly used for SPI
+    if (KNOWN_BAUD_RATES.has(value)) {
+        return `Value ${value} is a standard UART baud rate, not a typical SPI clock frequency. SPI frequencies are usually powers-of-two divisors of the system clock.`;
+    }
+    // Check for close matches to standard frequencies
+    for (const known of KNOWN_SPI_FREQUENCIES) {
+        if (value > known * 0.9 && value < known * 1.1) {
+            return `SPI frequency ${value} is close to standard frequency ${known}. Did you mean ${known}?`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check a peripheral config value via the appropriate checker. Emits a
+ * diagnostic if the value looks like a unit mistake (kHz instead of Hz, a
+ * baud rate used as SPI freq, etc.). Only literal numbers are checked —
+ * expressions/variables are opaque to this validator.
+ */
+function checkConfigValue(kind, rawValue, diagnostics) {
+    // HAL ops carry resolved numeric values as `number` when the source arg was
+    // a literal, or as `string` expression text otherwise. Only check numbers.
+    const value = typeof rawValue === 'number' ? rawValue
+        : typeof rawValue === 'string' && /^\d+$/.test(rawValue) ? parseInt(rawValue, 10)
+            : null;
+    if (value === null)
+        return;
+    const message = kind === 'baud' ? checkBaudRate(value)
+        : kind === 'i2c' ? checkI2CSpeed(value)
+            : checkSPIFrequency(value);
+    if (message) {
+        diagnostics.push({
+            severity: 'warning',
+            message,
+            code: 'unit-suspicion',
+            source: 'unit-suspicion-validation',
+        });
+    }
+}
+/**
+ * Recursively scan a statement and its children for suspicious peripheral
+ * config values. Recognizes the HAL ops that carry clock/baud/frequency
+ * values (i2c.set_clock, uart.begin, spi.begin_transaction) and call
+ * statements whose callee matches known config method names.
+ */
+function scanStatement(stmt, diagnostics) {
+    if (!stmt || typeof stmt !== 'object')
+        return;
+    const s = stmt;
+    // HAL-op statements carry structured operations with resolved values.
+    if (stmt.kind === 'hal-op' && s.operation) {
+        const op = s.operation;
+        switch (op.operation) {
+            case 'i2c.set_clock':
+                checkConfigValue('i2c', op.hz, diagnostics);
+                break;
+            case 'uart.begin':
+                checkConfigValue('baud', op.baud, diagnostics);
+                break;
+            // SPI frequency flows through SPISettings construction text, which the
+            // HAL op carries as a string — the numeric extraction in
+            // checkConfigValue handles bare-digit strings.
+            case 'spi.begin_transaction':
+                if (typeof op.settings === 'string') {
+                    // SPISettings({freq}, ...) — try to extract the leading frequency.
+                    const m = op.settings.match(/^\s*(\d+)/);
+                    if (m)
+                        checkConfigValue('spi', parseInt(m[1], 10), diagnostics);
+                }
+                break;
+        }
+    }
+    // Call statements: match config method names with a numeric literal arg.
+    // This catches pre-HAL-resolution calls and library-level config helpers.
+    if (stmt.kind === 'call' && typeof s.callee === 'string' && Array.isArray(s.args)) {
+        const method = s.callee.split('.').pop() ?? s.callee;
+        if (method === 'setClock' && s.args.length >= 2) {
+            checkConfigValue('i2c', extractNumericValue(s.args[1]), diagnostics);
+        }
+        else if (method === 'setBaudRate' || method === 'begin') {
+            // Serial.begin(baud) / setBaudRate(baud) — last numeric arg is the baud.
+            for (const arg of s.args) {
+                const v = extractNumericValue(arg);
+                if (v !== undefined)
+                    checkConfigValue('baud', v, diagnostics);
+            }
+        }
+        else if (method === 'setFrequency' && s.args.length >= 2) {
+            checkConfigValue('spi', extractNumericValue(s.args[1]), diagnostics);
+        }
+    }
+    // Recurse into nested statements
+    if (s.body && Array.isArray(s.body)) {
+        for (const child of s.body)
+            scanStatement(child, diagnostics);
+    }
+    if (s.thenBranch && Array.isArray(s.thenBranch)) {
+        for (const child of s.thenBranch)
+            scanStatement(child, diagnostics);
+    }
+    if (s.elseBranch && Array.isArray(s.elseBranch)) {
+        for (const child of s.elseBranch)
+            scanStatement(child, diagnostics);
+    }
+    if (s.statements && Array.isArray(s.statements)) {
+        for (const child of s.statements)
+            scanStatement(child, diagnostics);
+    }
+    if (s.initializer && typeof s.initializer === 'object' && s.initializer.kind) {
+        scanStatement(s.initializer, diagnostics);
+    }
+    if (s.increment && typeof s.increment === 'object' && s.increment.kind) {
+        scanStatement(s.increment, diagnostics);
+    }
+    if (s.cases && Array.isArray(s.cases)) {
+        for (const c of s.cases) {
+            if (c.body && Array.isArray(c.body)) {
+                for (const child of c.body)
+                    scanStatement(child, diagnostics);
+            }
+        }
+    }
+    if (s.tryBlock && Array.isArray(s.tryBlock)) {
+        for (const child of s.tryBlock)
+            scanStatement(child, diagnostics);
+    }
+    if (s.catchBlock && Array.isArray(s.catchBlock)) {
+        for (const child of s.catchBlock)
+            scanStatement(child, diagnostics);
+    }
+    if (s.finallyBlock && Array.isArray(s.finallyBlock)) {
+        for (const child of s.finallyBlock)
+            scanStatement(child, diagnostics);
+    }
+}
+/**
+ * Validate peripheral config values for common unit mistakes.
+ *
+ * Scans the program IR for cuttlefish-call nodes that configure peripherals
+ * with bare numbers and emits warnings when values look suspicious.
+ *
+ * @param program - The program IR to validate
+ * @returns Array of diagnostics for suspicious peripheral config values
+ */
+export function validateUnitSuspicion(program) {
+    const diagnostics = [];
+    // Scan top-level statements
+    if (program.topLevelStatements) {
+        for (const stmt of program.topLevelStatements) {
+            scanStatement(stmt, diagnostics);
+        }
+    }
+    // Scan function bodies
+    if (program.functions) {
+        for (const fn of program.functions) {
+            if (fn.statements) {
+                for (const stmt of fn.statements) {
+                    scanStatement(stmt, diagnostics);
+                }
+            }
+        }
+    }
+    // Scan class methods
+    if (program.classes) {
+        for (const cls of program.classes) {
+            if (cls.methods) {
+                for (const method of cls.methods) {
+                    if (method.statements) {
+                        for (const stmt of method.statements) {
+                            scanStatement(stmt, diagnostics);
+                        }
+                    }
+                }
+            }
+            if (cls.constructor?.statements) {
+                for (const stmt of cls.constructor.statements) {
+                    scanStatement(stmt, diagnostics);
+                }
+            }
+        }
+    }
+    return diagnostics;
+}

package/dist/ir/utils/walk-ir.d.ts

@@ -0,0 +1,6 @@
+import type { StatementIR, ExpressionIR, ProgramIR } from "../../api/index.js";
+export declare function walkNestedStatements(stmt: StatementIR, visitor: (s: StatementIR) => void): void;
+export declare function walkStatements(stmts: StatementIR[], visitor: (stmt: StatementIR) => void): void;
+export declare function walkExpressionsInExpression(expr: ExpressionIR, visitor: (expr: ExpressionIR) => void): void;
+export declare function walkExpressions(stmts: StatementIR[], visitor: (expr: ExpressionIR) => void): void;
+export declare function walkProgramIR(program: ProgramIR, visitor: (stmt: StatementIR) => void): void;