@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/symbol-table.js

@@ -0,0 +1,179 @@
+// ---------------------------------------------------------------------------
+// SymbolTable — the single ProgramIR-derived aggregation of cross-file type
+// facts consumed by the emit phase.
+//
+// Phase 2 of the type-resolution consolidation. Previously the cross-file
+// aggregation lived as hand-rolled ad-hoc loops in transpile.ts (the ~90-line
+// block that built allClassFieldTypes / allClassAccessors /
+// allFunctionReturnTypes / allVariableTypes / allClassNames) and was then
+// duplicated again, per-file, in emit/emitters/setup.ts. This module is the
+// canonical extraction of that aggregation: buildSymbolTable walks one
+// ProgramIR, mergeSymbolTables folds many into the cross-module view, and the
+// resulting SymbolTable projects onto the existing crossModule* emitter
+// options without changing their shape (so renderers and EmitterContext fields
+// are untouched).
+//
+// The construction rules here mirror the old transpile.ts block EXACTLY —
+// including the two-pass extendsClass inheritance (own fields first, then a
+// second pass that copies missing parent fields into children) — so emitted
+// C++ is byte-identical. See the approved plan's Phase 2 risk note.
+// ---------------------------------------------------------------------------
+export function createSymbolTable() {
+    return {
+        classFieldTypes: new Map(),
+        classAccessors: new Map(),
+        functionReturnTypes: new Map(),
+        variableTypes: new Map(),
+        classNames: new Set(),
+        extends: new Map(),
+    };
+}
+/**
+ * Build a SymbolTable from a single file's ProgramIR. This is the per-file
+ * view; cross-file aggregation is done by mergeSymbolTable.
+ *
+ * Mirrors the old transpile.ts:612-666 first pass:
+ *   - class fields, interface fields, accessors, function return types, and
+ *     non-"auto" top-level variable types are collected
+ *   - extendsClass relationships are recorded for the post-merge inheritance
+ *     pass (the old code read them from programIR.classes directly)
+ * Accessor kind merge rule: getter+setter on the same name → "both".
+ *
+ * Does NOT fold parent fields into children yet — that happens once, after
+ * all files are merged, in resolveInheritance (mirroring the old two-pass
+ * structure where the second pass ran after the first pass over all files).
+ */
+export function buildSymbolTable(program) {
+    const table = createSymbolTable();
+    for (const cls of program.classes) {
+        table.classNames.add(cls.name);
+        if (cls.fields.length > 0 || cls.extendsClass) {
+            const fieldTypes = table.classFieldTypes.get(cls.name) ?? new Map();
+            for (const field of cls.fields) {
+                fieldTypes.set(field.name, field.cppType);
+            }
+            table.classFieldTypes.set(cls.name, fieldTypes);
+        }
+        if (cls.extendsClass) {
+            // NOTE: the old transpile.ts code used the RAW extendsClass string
+            // (including any template args, e.g. "Generic<std::string>") as the key
+            // into the field-type map — which is keyed by bare class names. Such a
+            // lookup silently fails for generic parents (no field entry under
+            // "Generic<std::string>"), so inheritance doesn't apply. We preserve
+            // that exact behavior here for byte-identical output rather than
+            // stripping template args (which would be "more correct" but would
+            // change which fields get inherited and thus the emitted C++).
+            table.extends.set(cls.name, cls.extendsClass);
+        }
+        if (cls.getters.length > 0 || cls.setters.length > 0) {
+            const accessors = table.classAccessors.get(cls.name) ?? new Map();
+            for (const g of cls.getters)
+                accessors.set(g.name, accessors.has(g.name) ? "both" : "getter");
+            for (const s of cls.setters)
+                accessors.set(s.name, accessors.has(s.name) ? "both" : "setter");
+            table.classAccessors.set(cls.name, accessors);
+        }
+    }
+    // Interfaces lower to C++ structs, so their fields must be visible
+    // cross-module for type-driven emit decisions. Mirrors the old
+    // transpile.ts:650-658 interface aggregation.
+    for (const iface of program.interfaces) {
+        if (iface.fields.length > 0) {
+            const fieldTypes = table.classFieldTypes.get(iface.name) ?? new Map();
+            for (const field of iface.fields) {
+                fieldTypes.set(field.name, field.cppType);
+            }
+            table.classFieldTypes.set(iface.name, fieldTypes);
+        }
+    }
+    for (const fn of program.functions) {
+        table.functionReturnTypes.set(fn.originalName, fn.returnType);
+    }
+    for (const stmt of program.topLevelStatements) {
+        if (stmt.kind === "var_decl" && stmt.cppType !== "auto") {
+            table.variableTypes.set(stmt.name, stmt.cppType);
+        }
+    }
+    return table;
+}
+/**
+ * Fold one SymbolTable into an accumulating cross-module table. This is the
+ * merge used during Pass 1 of transpile.ts to build the cross-file view from
+ * every file's per-file table.
+ *
+ * Field-type and accessor entries are merged (later files add to existing
+ * class entries); function return types and variable types are last-write-wins
+ * (matching the old Map.set behavior); class names are unioned; extends
+ * relationships are last-write-wins.
+ */
+export function mergeSymbolTable(target, source) {
+    for (const [className, fieldTypes] of source.classFieldTypes) {
+        const existing = target.classFieldTypes.get(className) ?? new Map();
+        for (const [fname, ftype] of fieldTypes) {
+            existing.set(fname, ftype);
+        }
+        target.classFieldTypes.set(className, existing);
+    }
+    for (const [className, accessors] of source.classAccessors) {
+        const existing = target.classAccessors.get(className) ?? new Map();
+        for (const [member, kind] of accessors) {
+            // Mirror buildSymbolTable's merge rule: if both getter and setter exist
+            // across the merge, the result is "both".
+            const prev = existing.get(member);
+            if (prev && prev !== kind) {
+                existing.set(member, "both");
+            }
+            else {
+                existing.set(member, kind);
+            }
+        }
+        target.classAccessors.set(className, existing);
+    }
+    for (const [fnName, retType] of source.functionReturnTypes) {
+        target.functionReturnTypes.set(fnName, retType);
+    }
+    for (const [varName, varType] of source.variableTypes) {
+        target.variableTypes.set(varName, varType);
+    }
+    for (const [child, parent] of source.extends) {
+        target.extends.set(child, parent);
+    }
+    for (const name of source.classNames) {
+        target.classNames.add(name);
+    }
+    return target;
+}
+/**
+ * Apply extendsClass field inheritance across an aggregated SymbolTable.
+ * Mirrors the old transpile.ts:668-688 SECOND pass: for each class that
+ * extends a parent present in the table, copy any parent fields the child does
+ * not already declare. Must run AFTER all files have been merged so cross-file
+ * parents are visible.
+ *
+ * Merge rule (preserved exactly): `!childFields.has(fname)` — a child's own
+ * field declaration wins over the parent's. If the child has no field entry at
+ * all but the parent does, a fresh entry seeded entirely from the parent is
+ * created (mirroring the old `else if (parentFields && !childFields)` branch).
+ */
+export function resolveInheritance(table) {
+    for (const [childName, parentName] of table.extends) {
+        const parentFields = table.classFieldTypes.get(parentName);
+        if (!parentFields)
+            continue;
+        const childFields = table.classFieldTypes.get(childName);
+        if (childFields) {
+            for (const [fname, ftype] of parentFields) {
+                if (!childFields.has(fname)) {
+                    childFields.set(fname, ftype);
+                }
+            }
+        }
+        else {
+            const fieldTypes = new Map();
+            for (const [fname, ftype] of parentFields) {
+                fieldTypes.set(fname, ftype);
+            }
+            table.classFieldTypes.set(childName, fieldTypes);
+        }
+    }
+}

package/dist/ir/symbol-types.d.ts

@@ -0,0 +1,56 @@
+export type CppTypeHint = string;
+/**
+ * The bundle of type maps one IR-build scope consults. `locals` and
+ * `classFields` are deliberately separate Maps even though both were folded
+ * into the old activeLocalTypes at reset time — keeping them distinct makes
+ * the re-seed-on-reset step visible instead of implicit.
+ */
+export interface IrTypeScope {
+    /** Function-scoped variable types. Reset between functions, re-seeded from
+     *  classFields (mirrors resetFunctionScopeState). */
+    locals: Map<string, CppTypeHint>;
+    /** File-scoped module-level variable types. Accumulates across functions. */
+    globals: Map<string, CppTypeHint>;
+    /** Class field types keyed `this->fieldName`. Populated once per class,
+     *  survives function resets. */
+    classFields: Map<string, CppTypeHint>;
+}
+export declare function createIrTypeScope(): IrTypeScope;
+/**
+ * Reset the function-scoped portion of a scope (locals only), then re-seed
+ * locals from classFields so `this->field` lookups keep resolving in the next
+ * method. Mirrors the old resetFunctionScopeState behavior exactly.
+ */
+export declare function resetIrTypeScopeFunctionState(scope: IrTypeScope): void;
+/**
+ * Re-populate the scope's `locals` view from a caller-supplied Map, after
+ * resetFunctionScopeState has already cleared locals and re-seeded from
+ * classFields. Used by lowerStatementList at each entry to mirror the old
+ * behavior where activeLocalTypes was cleared, re-seeded from classFields,
+ * and then synced from the threaded localVariableTypes.
+ *
+ * IMPORTANT: this COPIES entries (it does not alias the maps). The threaded
+ * `localVariableTypes` map accumulates across nested lowerStatementList calls
+ * (if/for/while bodies pass it down by reference and must NOT be cleared by a
+ * nested reset); `scope.locals` is the function-resettable view that readers
+ * in expression-to-ir consult. Keeping them as distinct maps with a sync copy
+ * here, plus mirrored writes at every localVariableTypes.set site, preserves
+ * the original semantics exactly. Aliasing them would let a nested reset wipe
+ * the parent's accumulated locals.
+ */
+export declare function bindIrTypeScopeLocals(scope: IrTypeScope, locals: Map<string, CppTypeHint>): void;
+/**
+ * Mirror a single write into the scope's locals view. Callers that write to
+ * the threaded localVariableTypes map must also call this so the
+ * getCurrentIrTypeScope().locals readers see the new entry. This replaces the
+ * old activeLocalTypes.set(...) calls that ran alongside localVariableTypes.set.
+ */
+export declare function setScopeLocalType(name: string, type: CppTypeHint): void;
+export declare function setCurrentIrTypeScope(scope: IrTypeScope | undefined): void;
+export declare function getCurrentIrTypeScope(): IrTypeScope | undefined;
+/**
+ * Returns the current scope, throwing if none is set. For call sites that are
+ * only reachable mid-lowering (the module-private readers in
+ * expression-to-ir.ts), where an unset scope would be a programming error.
+ */
+export declare function requireCurrentIrTypeScope(): IrTypeScope;

package/dist/ir/symbol-types.js

@@ -0,0 +1,107 @@
+// ---------------------------------------------------------------------------
+// IrTypeScope — the per-file, per-function type/symbol scratch space.
+//
+// Phase 1 of the type-resolution consolidation. Previously the IR build mutated
+// three `AsyncLocalStorage`-proxied globals (activeLocalTypes,
+// activeGlobalTypes, activeClassFieldTypes) exported from build-ir-state.ts.
+// Those globals were a redundant shadow of the `localVariableTypes` parameter
+// already threaded through control-flow.ts / expressions.ts / variables.ts /
+// type-resolution.ts (see statement-to-ir.ts:397, which synced the threaded
+// map back INTO the global on every function boundary).
+//
+// IrTypeScope replaces all three globals with an explicit object:
+//   - `locals`     (was activeLocalTypes): function-scoped, reset between
+//                  functions, re-seeded from `classFields` on reset (mirroring
+//                  the old resetFunctionScopeState behavior at build-ir-state).
+//   - `globals`    (was activeGlobalTypes): file-scoped, accumulates across
+//                  functions; cleared once per file in resetBuildState.
+//   - `classFields` (was activeClassFieldTypes): keyed `this->fieldName`;
+//                  populated by declaration-builders / function-builder and
+//                  survives function resets so `this->x` resolves in every
+//                  method of the class.
+//
+// Module-private readers in expression-to-ir.ts consult whichever IrTypeScope
+// is "current" via getCurrentIrTypeScope(); the IR-build entry points push a
+// scope as current before lowering and clear it on reset. This preserves the
+// old global behavior exactly while making the data flow explicit.
+// ---------------------------------------------------------------------------
+export function createIrTypeScope() {
+    return {
+        locals: new Map(),
+        globals: new Map(),
+        classFields: new Map(),
+    };
+}
+/**
+ * Reset the function-scoped portion of a scope (locals only), then re-seed
+ * locals from classFields so `this->field` lookups keep resolving in the next
+ * method. Mirrors the old resetFunctionScopeState behavior exactly.
+ */
+export function resetIrTypeScopeFunctionState(scope) {
+    scope.locals.clear();
+    for (const [key, value] of scope.classFields) {
+        scope.locals.set(key, value);
+    }
+}
+/**
+ * Re-populate the scope's `locals` view from a caller-supplied Map, after
+ * resetFunctionScopeState has already cleared locals and re-seeded from
+ * classFields. Used by lowerStatementList at each entry to mirror the old
+ * behavior where activeLocalTypes was cleared, re-seeded from classFields,
+ * and then synced from the threaded localVariableTypes.
+ *
+ * IMPORTANT: this COPIES entries (it does not alias the maps). The threaded
+ * `localVariableTypes` map accumulates across nested lowerStatementList calls
+ * (if/for/while bodies pass it down by reference and must NOT be cleared by a
+ * nested reset); `scope.locals` is the function-resettable view that readers
+ * in expression-to-ir consult. Keeping them as distinct maps with a sync copy
+ * here, plus mirrored writes at every localVariableTypes.set site, preserves
+ * the original semantics exactly. Aliasing them would let a nested reset wipe
+ * the parent's accumulated locals.
+ */
+export function bindIrTypeScopeLocals(scope, locals) {
+    // Fold the threaded map's current entries into the already-re-seeded locals.
+    for (const [key, value] of locals) {
+        scope.locals.set(key, value);
+    }
+}
+/**
+ * Mirror a single write into the scope's locals view. Callers that write to
+ * the threaded localVariableTypes map must also call this so the
+ * getCurrentIrTypeScope().locals readers see the new entry. This replaces the
+ * old activeLocalTypes.set(...) calls that ran alongside localVariableTypes.set.
+ */
+export function setScopeLocalType(name, type) {
+    getCurrentIrTypeScope()?.locals.set(name, type);
+}
+// ---------------------------------------------------------------------------
+// "Current" scope — the module-private readers in expression-to-ir.ts consult
+// this when their caller did not pass an explicit scope. This keeps the ~25
+// transformer call sites of expressionToIR(...) that don't carry a scope
+// working unchanged, while still removing the AsyncLocalStorage global.
+//
+// The current-scope pointer is intentionally module-local (not async-local):
+// the IR build is single-threaded and synchronous per file, and the entry
+// points (build-ir.ts → lowerStatementList) always set the scope before any
+// expression lowering happens within that file.
+// ---------------------------------------------------------------------------
+let currentIrTypeScope;
+export function setCurrentIrTypeScope(scope) {
+    currentIrTypeScope = scope;
+}
+export function getCurrentIrTypeScope() {
+    return currentIrTypeScope;
+}
+/**
+ * Returns the current scope, throwing if none is set. For call sites that are
+ * only reachable mid-lowering (the module-private readers in
+ * expression-to-ir.ts), where an unset scope would be a programming error.
+ */
+export function requireCurrentIrTypeScope() {
+    const scope = currentIrTypeScope;
+    if (!scope) {
+        throw new Error("requireCurrentIrTypeScope: no IrTypeScope is active. An IR-build entry " +
+            "point must call setCurrentIrTypeScope() before lowering expressions.");
+    }
+    return scope;
+}

package/dist/ir/timer0-pwm-timing-conflict.d.ts

@@ -0,0 +1,4 @@
+import type { Diagnostic } from '../types.js';
+import type { BoardConstants } from './board-resolver.js';
+import type { PeripheralUsage } from './peripheral-usage.js';
+export declare function validateTimer0PWMTimingConflict(usage: PeripheralUsage, boardConstants: BoardConstants | undefined): Diagnostic[];

package/dist/ir/timer0-pwm-timing-conflict.js

@@ -0,0 +1,71 @@
+import { findBoardPinByName, formatPinReference } from './board-pin-utils.js';
+function getTimer0PwmPins(boardConstants) {
+    if (!boardConstants) {
+        return [];
+    }
+    const pinsByIndex = new Map();
+    for (const [key, value] of boardConstants) {
+        const match = key.match(/^pins\.all\.(\d+)\.name$/);
+        if (!match || typeof value !== 'string') {
+            continue;
+        }
+        const pinIndex = match[1];
+        const numberValue = boardConstants.get(`pins.all.${pinIndex}.number`);
+        const aliasesValue = boardConstants.get(`pins.all.${pinIndex}.aliases`);
+        const aliases = typeof aliasesValue === 'string' && aliasesValue.length > 0
+            ? aliasesValue.split(',').map(entry => entry.trim()).filter(Boolean)
+            : [];
+        pinsByIndex.set(pinIndex, {
+            pinNumber: typeof numberValue === 'number' ? numberValue : Number(pinIndex),
+            canonicalName: value,
+            aliases,
+        });
+    }
+    const timer0Pins = [];
+    for (const [key, value] of boardConstants) {
+        // Check for timer field first, fall back to OC register regex
+        const timerMatch = key.match(/^pins\.all\.(\d+)\.functions\.(\d+)\.timer$/);
+        if (timerMatch && value === 'timer0') {
+            const pin = pinsByIndex.get(timerMatch[1]);
+            if (pin) {
+                timer0Pins.push(pin);
+            }
+            continue;
+        }
+        const match = key.match(/^pins\.all\.(\d+)\.functions\.\d+\.role$/);
+        if (!match || typeof value !== 'string' || !/^OC0[A-Z]?$/i.test(value)) {
+            continue;
+        }
+        const pin = pinsByIndex.get(match[1]);
+        if (pin && !timer0Pins.some(p => p.pinNumber === pin.pinNumber)) {
+            timer0Pins.push(pin);
+        }
+    }
+    return timer0Pins;
+}
+export function validateTimer0PWMTimingConflict(usage, boardConstants) {
+    if (!usage.timer0 || usage.pwmPinsUsed.size === 0) {
+        return [];
+    }
+    const timer0Pins = getTimer0PwmPins(boardConstants)
+        .filter(pin => usage.pwmPinsUsed.has(pin.pinNumber));
+    if (timer0Pins.length === 0) {
+        return [];
+    }
+    const boardName = boardConstants?.get('name');
+    const boardLabel = typeof boardName === 'string' && boardName.length > 0
+        ? ` on ${boardName}`
+        : '';
+    const pinReferences = timer0Pins
+        .sort((left, right) => left.pinNumber - right.pinNumber)
+        .map((pin) => {
+        const usedName = [pin.canonicalName, ...pin.aliases].find(name => usage.pinsUsed.has(name)) ?? pin.canonicalName;
+        return formatPinReference(usedName, findBoardPinByName(pin.canonicalName, boardConstants));
+    });
+    return [{
+            severity: 'info',
+            code: 'timer0-pwm-timing-conflict',
+            source: 'timer0-pwm-timing-conflict',
+            message: `${pinReferences.join(', ')} use Timer0 PWM${boardLabel}, and your program also relies on Timer0-backed timing APIs such as delay(), millis(), or micros(). This coupling is common on AVR boards, so prefer non-Timer0 PWM pins when you want PWM behavior isolated from core timing.`,
+        }];
+}

package/dist/ir/timing-validation.d.ts

@@ -0,0 +1,7 @@
+import type { ProgramIR } from '../api/index.js';
+import type { Diagnostic } from '../types.js';
+/**
+ * Detect blocking delay() calls inside loop()'s body. Emits a warning for
+ * each, explaining the cooperative-async alternative.
+ */
+export declare function validateBlockingDelayInLoop(program: ProgramIR): Diagnostic[];

package/dist/ir/timing-validation.js

@@ -0,0 +1,95 @@
+// ---------------------------------------------------------------------------
+// Timing Validation
+//
+// Detects blocking delay() calls inside loop(). On Arduino, loop() runs
+// repeatedly and must return promptly so the runtime can service the async
+// microtask queue, UI rendering, and sensor polling. A delay() inside loop()
+// freezes all of these for the delay duration — directly causing the UI
+// tearing/scroll-responsiveness problems the AGENTS.md rendering guardrails
+// address at the display layer.
+//
+// The transpiler knows what loop() semantically is (the repeated entry point);
+// g++ sees only an ordinary function. This validator flags blocking delays in
+// loop()'s direct body so the user can replace them with the cooperative
+// Async.sleep() / millis()-comparison pattern.
+// ---------------------------------------------------------------------------
+/** Check a single statement for a blocking delay call or hal-op. */
+function isBlockingDelay(stmt) {
+    const s = stmt;
+    // Direct call: delay(...) or delayMicroseconds(...)
+    if (stmt.kind === 'call' && typeof s.callee === 'string') {
+        if (s.callee === 'delay' || s.callee === 'delayMicroseconds')
+            return true;
+    }
+    // Hal-op: after HAL resolution, delay() becomes timing.delay /
+    // timing.delay_microseconds.
+    if (stmt.kind === 'hal-op' && s.operation?.operation) {
+        if (s.operation.operation === 'timing.delay' || s.operation.operation === 'timing.delay_microseconds') {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Detect blocking delay() calls inside loop()'s body. Emits a warning for
+ * each, explaining the cooperative-async alternative.
+ */
+export function validateBlockingDelayInLoop(program) {
+    const diagnostics = [];
+    const loopFn = program.functions.find(fn => fn.originalName === 'loop');
+    if (!loopFn || !loopFn.statements)
+        return diagnostics;
+    const visit = (stmts) => {
+        for (const stmt of stmts) {
+            if (isBlockingDelay(stmt)) {
+                const s = stmt;
+                diagnostics.push({
+                    severity: 'warning',
+                    message: `Blocking delay() inside loop() freezes the async microtask queue and UI rendering ` +
+                        `for the delay duration. This causes display tearing and makes the sketch unresponsive.`,
+                    hint: `Use the cooperative pattern instead: track elapsed time with millis() comparisons, ` +
+                        `or use Async.sleep(ms) / Async.yield() to let other tasks run between checks.`,
+                    line: stmt.sourceSpan?.startLine,
+                    column: stmt.sourceSpan?.startColumn,
+                    code: 'blocking-delay-in-loop',
+                    source: 'timing-validation',
+                });
+            }
+            // Recurse into nested compound bodies (if/for/while/switch/try blocks).
+            const nested = getNested(stmt);
+            if (nested)
+                visit(nested);
+        }
+    };
+    visit(loopFn.statements);
+    return diagnostics;
+}
+/** Get nested statement arrays from a compound statement. */
+function getNested(stmt) {
+    const s = stmt;
+    const out = [];
+    if (Array.isArray(s.body))
+        out.push(...s.body);
+    if (Array.isArray(s.thenBranch))
+        out.push(...s.thenBranch);
+    if (Array.isArray(s.elseBranch))
+        out.push(...s.elseBranch);
+    if (Array.isArray(s.tryBlock))
+        out.push(...s.tryBlock);
+    if (Array.isArray(s.catchBlock))
+        out.push(...s.catchBlock);
+    if (Array.isArray(s.finallyBlock))
+        out.push(...s.finallyBlock);
+    if (Array.isArray(s.cases)) {
+        for (const c of s.cases) {
+            if (Array.isArray(c.body))
+                out.push(...c.body);
+        }
+    }
+    // for-loop initializer/increment are statements too.
+    if (s.initializer && typeof s.initializer === 'object' && s.initializer.kind)
+        out.push(s.initializer);
+    if (s.increment && typeof s.increment === 'object' && s.increment.kind)
+        out.push(s.increment);
+    return out.length > 0 ? out : null;
+}

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

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { Diagnostic } from "../../types.js";
+import { StatementIR, ExpressionIR } from "../../api/index.js";
+export declare const ARRAY_METHODS_REQUIRING_STATIC_ARRAY: Set<string>;
+export declare function prescanArrayUsage(statement: ts.Statement): void;
+export declare function prescanExprForArrayMethods(expr: ts.Expression): void;
+export declare function buildInlineForLoop(span: any, srcSize: number, srcName: string, paramName: string, bodyExpr: ts.Expression, sourceText: string, diagnostics: Diagnostic[], assignTarget: string, _isFilter: boolean): StatementIR;
+export declare function tryLowerArrayAndStringMethods(expr: ts.CallExpression, sourceText: string, diagnostics: Diagnostic[], pointerVars: any): ExpressionIR | null;