@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/build-ir-state.js

@@ -0,0 +1,306 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getDefaultBoardConstants } from "./board-resolver.js";
+// IrTypeScope replaces the three proxied globals (activeLocalTypes,
+// activeGlobalTypes, activeClassFieldTypes) that previously lived on this
+// module as createMapProxy exports. The scope lifecycle is managed here via
+// the reset hooks (resetBuildState creates a fresh scope per file;
+// resetFunctionScopeState re-seeds locals from classFields between functions).
+// See symbol-types.ts for the full design.
+import { createIrTypeScope, setCurrentIrTypeScope, getCurrentIrTypeScope, resetIrTypeScopeFunctionState, } from "./symbol-types.js";
+export class CompilationContext {
+    constructor() {
+        this.topLevelClasses = new Map();
+        this.registerFieldMap = new Map();
+        this.hoistedNestedFunctions = [];
+        this.hoistedNestedClasses = [];
+        this.hoistedNestedEnums = [];
+        this.hoistedNestedInterfaces = [];
+        this.hoistedNestedTypeAliases = [];
+        this.nestedFunctionAliases = new Map();
+        this.nestedClassAliases = new Map();
+        this.activeCArrayVars = new Set();
+        this.activeArrayLiteralVars = new Set();
+        this.activeStringVars = new Set();
+        this.mutableArrayVars = new Set();
+        this.arrayLiteralSizes = new Map();
+        this.filteredArrayLengthVars = new Map();
+        this.activeNamespaceNames = new Set();
+        this.topLevelClassNames = new Set();
+        // Names of top-level interfaces. Interfaces lower to C++ structs (value
+        // types), so a variable of an interface type is a value — never a pointer,
+        // never null. Tracked separately from topLevelClassNames (classes are always
+        // reference types / pointers) so the null-comparison guard in
+        // expression-to-ir can recognize an interface-typed value as a value type.
+        this.topLevelInterfaceNames = new Set();
+        this.classTypeNames = new Set();
+        this.activeEnumNames = new Set();
+        this.activeStringEnumNames = new Set();
+        this.activePinUsage = new Map();
+        this.activePeripheralUsage = new Map();
+        this.peripheralAliasMap = new Map();
+        this.pinAliasMap = new Map();
+        this.mcuPinForwardMap = new Map();
+        this.mcuPinReverseMap = new Map();
+        this.requiredIncludes = new Set();
+        this.registeredCallbacks = [];
+        this._currentBoardConstants = undefined;
+        // The three type maps that used to live here (activeLocalTypes,
+        // activeGlobalTypes, activeClassFieldTypes) now live on the IrTypeScope
+        // managed in symbol-types.ts. They are NOT context-scoped: the IR build is
+        // synchronous per file and the scope pointer is a module-local variable.
+        // See symbol-types.ts for the full rationale.
+        this.activeExtendsClass = undefined;
+        this.contextId = Math.random().toString(36).slice(2, 8);
+        this.halInstances = new Map();
+        /**
+         * Top-level `const x = <receiver>.<method>(...)` alias declarations, recorded
+         * as varName → receiver source text in a cheap up-front pass (no resolution).
+         * `resolveHALReceiver` follows this lazily so a function that references `x`
+         * resolves correctly even when declared before the `const x = ...`. This makes
+         * HAL resolution order-independent (demo #34 Finding C). Only mode-setter
+         * methods (asOutput/asInput/...) are recorded here — value-bearing reads are
+         * excluded so they don't alias the pin (Finding B).
+         */
+        this.topLevelAliasReceivers = new Map();
+        this.floatVariables = new Set();
+        this.snprintfCounter = 0;
+        this.callbackPlaceholderCounter = 0;
+        this.activeStrategy = null;
+        this.restParamFunctions = new Map();
+        /**
+         * Diagnostics sink for the current file build. Populated by buildProgramIR
+         * with the same array returned in ProgramIR.diagnostics, so diagnostics
+         * pushed from deep in IR lowering (e.g. renderExprAsText's fallback paths)
+         * flow into the fatal-gate check in transpile.ts without that diagnostic
+         * array having to be threaded through ~80 call sites. May be empty before
+         * buildProgramIR assigns it; callers must null-check.
+         */
+        this.diagnostics = [];
+        /**
+         * Module-level free-function return types for the file currently being
+         * lowered. Populated by buildProgramIR so UI callbacks / timers can resolve
+         * helper return types. Cleared in resetBuildState.
+         */
+        this.activeFunctionReturnTypes = new Map();
+    }
+}
+/**
+ * AsyncLocalStorage for context isolation across parallel transpilations.
+ * When no store is active (e.g. in tests or non-async code paths), the
+ * globalDefaultContext is used as fallback.
+ *
+ * IMPORTANT: `resetBuildState()` must be called between transpilations to
+ * clear the globalDefaultContext. In watch mode, this is done automatically
+ * at the start of each `transpileFile()` call.
+ */
+export const contextStorage = new AsyncLocalStorage();
+const globalDefaultContext = new CompilationContext();
+export function getContext() {
+    return contextStorage.getStore() || globalDefaultContext;
+}
+// 3. Helper Proxy creators
+function createMapProxy(getContextKey) {
+    return new Proxy(new Map(), {
+        get(target, prop) {
+            const actual = getContextKey(getContext());
+            const value = Reflect.get(actual, prop, actual);
+            return typeof value === 'function' ? value.bind(actual) : value;
+        },
+        set(target, prop, value) {
+            const actual = getContextKey(getContext());
+            return Reflect.set(actual, prop, value, actual);
+        }
+    });
+}
+function createSetProxy(getContextKey) {
+    return new Proxy(new Set(), {
+        get(target, prop) {
+            const actual = getContextKey(getContext());
+            const value = Reflect.get(actual, prop, actual);
+            return typeof value === 'function' ? value.bind(actual) : value;
+        },
+        set(target, prop, value) {
+            const actual = getContextKey(getContext());
+            return Reflect.set(actual, prop, value, actual);
+        }
+    });
+}
+function createArrayProxy(getContextKey) {
+    return new Proxy([], {
+        get(target, prop) {
+            const actual = getContextKey(getContext());
+            const value = Reflect.get(actual, prop, actual);
+            return typeof value === 'function' ? value.bind(actual) : value;
+        },
+        set(target, prop, value) {
+            const actual = getContextKey(getContext());
+            return Reflect.set(actual, prop, value, actual);
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(getContextKey(getContext()));
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            return Reflect.getOwnPropertyDescriptor(getContextKey(getContext()), prop);
+        }
+    });
+}
+// 4. Export proxies matching the original module API
+export const topLevelClasses = createMapProxy(ctx => ctx.topLevelClasses);
+export const registerFieldMap = createMapProxy(ctx => ctx.registerFieldMap);
+export const halInstances = createMapProxy(ctx => ctx.halInstances);
+export const topLevelAliasReceivers = createMapProxy(ctx => ctx.topLevelAliasReceivers);
+export const floatVariables = createSetProxy(ctx => ctx.floatVariables);
+export const hoistedNestedFunctions = createArrayProxy(ctx => ctx.hoistedNestedFunctions);
+export const hoistedNestedClasses = createArrayProxy(ctx => ctx.hoistedNestedClasses);
+export const hoistedNestedEnums = createArrayProxy(ctx => ctx.hoistedNestedEnums);
+export const hoistedNestedInterfaces = createArrayProxy(ctx => ctx.hoistedNestedInterfaces);
+export const hoistedNestedTypeAliases = createArrayProxy(ctx => ctx.hoistedNestedTypeAliases);
+export const nestedFunctionAliases = createMapProxy(ctx => ctx.nestedFunctionAliases);
+export const nestedClassAliases = createMapProxy(ctx => ctx.nestedClassAliases);
+export const activeCArrayVars = createSetProxy(ctx => ctx.activeCArrayVars);
+export const activeArrayLiteralVars = createSetProxy(ctx => ctx.activeArrayLiteralVars);
+export const activeStringVars = createSetProxy(ctx => ctx.activeStringVars);
+export const mutableArrayVars = createSetProxy(ctx => ctx.mutableArrayVars);
+export const arrayLiteralSizes = createMapProxy(ctx => ctx.arrayLiteralSizes);
+export const filteredArrayLengthVars = createMapProxy(ctx => ctx.filteredArrayLengthVars);
+export const activeNamespaceNames = createSetProxy(ctx => ctx.activeNamespaceNames);
+export const topLevelClassNames = createSetProxy(ctx => ctx.topLevelClassNames);
+export const topLevelInterfaceNames = createSetProxy(ctx => ctx.topLevelInterfaceNames);
+export const classTypeNames = createSetProxy(ctx => ctx.classTypeNames);
+export const activeEnumNames = createSetProxy(ctx => ctx.activeEnumNames);
+export const activeStringEnumNames = createSetProxy(ctx => ctx.activeStringEnumNames);
+export const activePinUsage = createMapProxy(ctx => ctx.activePinUsage);
+export const activePeripheralUsage = createMapProxy(ctx => ctx.activePeripheralUsage);
+export const peripheralAliasMap = createMapProxy(ctx => ctx.peripheralAliasMap);
+export const pinAliasMap = createMapProxy(ctx => ctx.pinAliasMap);
+export const mcuPinForwardMap = createMapProxy(ctx => ctx.mcuPinForwardMap);
+export const mcuPinReverseMap = createMapProxy(ctx => ctx.mcuPinReverseMap);
+export const requiredIncludes = createSetProxy(ctx => ctx.requiredIncludes);
+export const registeredCallbacks = createArrayProxy(ctx => ctx.registeredCallbacks);
+// activeLocalTypes / activeGlobalTypes / activeClassFieldTypes were proxied
+// globals; they now live on the IrTypeScope (symbol-types.ts). Callers that
+// still reference these by name must migrate to getCurrentIrTypeScope().
+export const discriminatedUnionVariantNames = new Map();
+export const restParamFunctions = createMapProxy(ctx => ctx.restParamFunctions);
+export const activeFunctionReturnTypes = createMapProxy(ctx => ctx.activeFunctionReturnTypes);
+export function getActiveExtendsClass() { return getContext().activeExtendsClass; }
+export function setActiveExtendsClass(v) { getContext().activeExtendsClass = v; }
+// Static configurations
+export const PIN_FACTORY_FUNCTIONS = new Set([
+    "createDigitalPin",
+    "createPWMPin",
+    "createAnalogPin",
+    "createInterruptPin",
+]);
+export const CONSTANT_FOLD_FUNCTIONS = new Set([]);
+export const TYPED_ARRAY_ELEMENT_MAP = {
+    Uint8Array: "uint8_t",
+    Int8Array: "int8_t",
+    Uint16Array: "uint16_t",
+    Int16Array: "int16_t",
+    Uint32Array: "uint32_t",
+    Int32Array: "int32_t",
+    Float32Array: "float",
+    Float64Array: "double",
+};
+// 5. Getter/Setter for BoardConstants
+export function getCurrentBoardConstants() {
+    return getContext()._currentBoardConstants || getDefaultBoardConstants();
+}
+export function setCurrentBoardConstants(v) {
+    const ctx = getContext();
+    ctx._currentBoardConstants = v;
+    if (v) {
+        // Populate peripheral aliases (e.g. UART0 -> Serial, I2C0 -> Wire)
+        for (const [key, value] of v.entries()) {
+            if (key.startsWith("peripherals.aliases.")) {
+                const alias = key.slice("peripherals.aliases.".length);
+                peripheralAliasMap.set(alias, String(value));
+            }
+        }
+        // Populate pin aliases (e.g. D0 -> 0, A0 -> 14, LED -> 13)
+        const pinNames = new Map();
+        const pinNumbers = new Map();
+        for (const [key, value] of v.entries()) {
+            const nameMatch = key.match(/^pins\.all\.(\d+)\.name$/);
+            if (nameMatch) {
+                pinNames.set(parseInt(nameMatch[1]), String(value));
+                continue;
+            }
+            const numMatch = key.match(/^pins\.all\.(\d+)\.number$/);
+            if (numMatch) {
+                pinNumbers.set(parseInt(numMatch[1]), String(value));
+                continue;
+            }
+            const directMatch = key.match(/^pins\.([a-z_][a-z0-9_]*)$/);
+            if (directMatch && typeof value !== 'object') {
+                const pinName = directMatch[1].toUpperCase();
+                if (pinName !== 'ALL' && pinName !== 'DIGITAL' && pinName !== 'ANALOG' && pinName !== 'PWM' && pinName !== 'UNSAFE' && pinName !== 'I2C' && pinName !== 'SPI' && pinName !== 'UART') {
+                    pinAliasMap.set(pinName, String(value));
+                }
+            }
+        }
+        for (const [idx, name] of pinNames) {
+            const num = pinNumbers.get(idx);
+            if (num !== undefined) {
+                pinAliasMap.set(name, num);
+                mcuPinForwardMap.set(name, num);
+                mcuPinReverseMap.set(num, name);
+            }
+        }
+    }
+}
+// 6. State management hooks
+export function resetBuildState() {
+    hoistedNestedFunctions.length = 0;
+    hoistedNestedClasses.length = 0;
+    hoistedNestedEnums.length = 0;
+    hoistedNestedInterfaces.length = 0;
+    hoistedNestedTypeAliases.length = 0;
+    nestedFunctionAliases.clear();
+    topLevelAliasReceivers.clear();
+    nestedClassAliases.clear();
+    resetFunctionScopeState();
+    activeNamespaceNames.clear();
+    topLevelClassNames.clear();
+    topLevelInterfaceNames.clear();
+    classTypeNames.clear();
+    activeEnumNames.clear();
+    activeStringEnumNames.clear();
+    topLevelClasses.clear();
+    // Start a fresh IrTypeScope for this file. The old activeGlobalTypes was a
+    // file-scoped map cleared here; activeLocalTypes/activeClassFieldTypes were
+    // function/class-scoped and cleared in resetFunctionScopeState. Creating a
+    // new scope object clears all three at once and re-binds the current scope.
+    setCurrentIrTypeScope(createIrTypeScope());
+    peripheralAliasMap.clear();
+    pinAliasMap.clear();
+    mcuPinForwardMap.clear();
+    mcuPinReverseMap.clear();
+    activePinUsage.clear();
+    activePeripheralUsage.clear();
+    requiredIncludes.clear();
+    registeredCallbacks.length = 0;
+    discriminatedUnionVariantNames.clear();
+    restParamFunctions.clear();
+    activeFunctionReturnTypes.clear();
+    getContext()._currentBoardConstants = undefined;
+}
+export function resetFunctionScopeState() {
+    activeCArrayVars.clear();
+    activeArrayLiteralVars.clear();
+    activeStringVars.clear();
+    mutableArrayVars.clear();
+    arrayLiteralSizes.clear();
+    filteredArrayLengthVars.clear();
+    // Clear the function-scoped portion of the current IrTypeScope (locals) and
+    // re-seed it from classFields so `this->field` lookups keep resolving in the
+    // next method. Mirrors the old behavior where resetFunctionScopeState copied
+    // activeClassFieldTypes into activeLocalTypes. globals/classFields survive
+    // (they are file-scoped, not function-scoped).
+    const scope = getCurrentIrTypeScope();
+    if (scope) {
+        resetIrTypeScopeFunctionState(scope);
+    }
+    getContext().activeExtendsClass = undefined;
+}

package/dist/ir/build-ir.d.ts

@@ -0,0 +1,2 @@
+import { ClassIR, ProgramIR } from "../api/index.js";
+export declare function buildProgramIR(fileName: string, sourceText: string, boardPackage?: string, prebuiltClassMap?: Map<string, ClassIR>): ProgramIR;