@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/interrupt-analysis.js

@@ -0,0 +1,467 @@
+// ---------------------------------------------------------------------------
+// Interrupt Safety Analysis
+//
+// Detects unsafe operations inside interrupt handlers and duplicate handlers
+// on the same pin.
+// ---------------------------------------------------------------------------
+import { walkNestedStatements, walkExpressionsInExpression } from './utils/walk-ir.js';
+export { walkNestedStatements as scanNestedStatements } from './utils/walk-ir.js';
+/**
+ * Default ISR-unsafe operations used when no platform-specific map is provided.
+ * Platforms should supply their own list via PlatformStrategy.isrUnsafeOperations().
+ */
+const DEFAULT_ISR_UNSAFE_OPERATIONS = new Map([
+    ['delay', { reason: 'delay() blocks the CPU and should not be used in interrupt context', severity: 'warning' }],
+    ['delayMicroseconds', { reason: 'delayMicroseconds() blocks and should be avoided in ISRs', severity: 'warning' }],
+    ['Serial.print', { reason: 'Serial.print() may not work correctly in interrupt context', severity: 'info' }],
+    ['Serial.println', { reason: 'Serial.println() may not work correctly in interrupt context', severity: 'info' }],
+    ['Serial.write', { reason: 'Serial.write() may not work correctly in interrupt context', severity: 'info' }],
+    ['Serial.read', { reason: 'Serial.read() may not work correctly in interrupt context', severity: 'info' }],
+    ['I2C0', { reason: 'I2C operations can cause lockups in interrupt context', severity: 'warning' }],
+    ['I2C1', { reason: 'I2C operations can cause lockups in interrupt context', severity: 'warning' }],
+    ['SPI0', { reason: 'SPI operations may cause issues in interrupt context', severity: 'info' }],
+    ['SPI1', { reason: 'SPI operations may cause issues in interrupt context', severity: 'info' }],
+]);
+/**
+ * Analyze a program for interrupt handler issues.
+ *
+ * @param program - The program IR to analyze
+ * @param usage - Peripheral usage information
+ * @param isrUnsafeOps - Platform-specific ISR-unsafe operations map (from strategy)
+ * @returns Array of diagnostics for interrupt-related issues
+ */
+export function analyzeInterruptSafety(program, usage, isrUnsafeOps) {
+    const diagnostics = [];
+    const unsafeOps = isrUnsafeOps ?? DEFAULT_ISR_UNSAFE_OPERATIONS;
+    // Track duplicate handlers
+    const handlersByPin = new Map();
+    // Scan for attachInterrupt calls
+    scanForInterruptHandlers(program, handlersByPin, diagnostics);
+    // Scan for unsafe operations inside ISR callbacks
+    scanForUnsafeOperations(program, diagnostics, unsafeOps);
+    return diagnostics;
+}
+/**
+ * Scan the program for attachInterrupt calls and detect duplicates.
+ */
+function scanForInterruptHandlers(program, handlersByPin, diagnostics) {
+    // Scan top-level statements
+    if (program.topLevelStatements) {
+        for (const stmt of program.topLevelStatements) {
+            scanStatementForInterruptHandler(stmt, handlersByPin, diagnostics);
+        }
+    }
+    // Scan function bodies
+    if (program.functions) {
+        for (const fn of program.functions) {
+            if (fn.statements) {
+                for (const stmt of fn.statements) {
+                    scanStatementForInterruptHandler(stmt, handlersByPin, diagnostics);
+                }
+            }
+        }
+    }
+}
+/**
+ * Scan a statement for attachInterrupt calls.
+ */
+function scanStatementForInterruptHandler(stmt, handlersByPin, diagnostics) {
+    if (!stmt || typeof stmt !== 'object')
+        return;
+    // Check for cuttlefish-call statements — both the low-level pin.attachInterrupt() and
+    // the flat sugar API (pin.onFalling / pin.onRising / pin.onChange / etc.) which all
+    // lower to a single attachInterrupt call on the same hardware interrupt line.
+    const ATTACH_METHODS = new Set(['attachInterrupt', 'onFalling', 'onRising', 'onChange', 'onLow', 'onHigh']);
+    // Recursively scan nested statements in control flow
+    walkNestedStatements(stmt, (s) => scanStatementForInterruptHandler(s, handlersByPin, diagnostics));
+}
+function scanForUnsafeOperations(program, diagnostics, unsafeOps) {
+    scanProgramForCallbacks(program, (callback, parentExpr) => {
+        const isISR = isInterruptHandlerCallback(callback, parentExpr);
+        if (isISR && callback.statements) {
+            for (const stmt of callback.statements) {
+                scanStatementForUnsafeOps(stmt, diagnostics, unsafeOps);
+            }
+        }
+    });
+}
+function isInterruptHandlerCallback(callback, parentExpr) {
+    if (callback.isInterruptHandler)
+        return true;
+    return false;
+}
+function scanStatementForUnsafeOps(stmt, diagnostics, unsafeOps) {
+    if (!stmt || typeof stmt !== 'object')
+        return;
+    if (stmt.kind === 'call') {
+        const call = stmt;
+        checkCalleeForUnsafeOp(call.callee, diagnostics, unsafeOps);
+    }
+    // HAL-op statements: after HAL resolution, bare Arduino calls like delay()
+    // and delayMicroseconds() become structured hal-op statements (timing.delay,
+    // timing.delay_microseconds) rather than kind:'call'. Map them back to the
+    // unsafe-op keys so ISR detection works on the resolved form.
+    if (stmt.kind === 'hal-op') {
+        const op = stmt.operation;
+        if (op) {
+            const HAL_OP_TO_UNSAFE = {
+                'timing.delay': 'delay',
+                'timing.delay_microseconds': 'delayMicroseconds',
+            };
+            const key = HAL_OP_TO_UNSAFE[op.operation];
+            if (key)
+                checkCalleeForUnsafeOp(key, diagnostics, unsafeOps);
+        }
+    }
+    walkNestedStatements(stmt, (s) => scanStatementForUnsafeOps(s, diagnostics, unsafeOps));
+}
+/**
+ * Check if a callee is an unsafe operation and generate diagnostic.
+ */
+function checkCalleeForUnsafeOp(callee, diagnostics, unsafeOps) {
+    if (!callee)
+        return;
+    // Check direct matches
+    const unsafe = unsafeOps.get(callee);
+    if (unsafe) {
+        diagnostics.push({
+            severity: unsafe.severity,
+            message: `${callee}() ${unsafe.reason}`,
+            code: 'interrupt-unsafe-operation',
+            source: 'interrupt-analysis',
+        });
+        return;
+    }
+    // Check prefix matches (e.g., I2C0.write matches I2C0)
+    for (const [prefix, info] of unsafeOps) {
+        if (callee.startsWith(prefix + '.') || callee.startsWith(prefix + ':')) {
+            diagnostics.push({
+                severity: info.severity,
+                message: `${callee} - ${info.reason}`,
+                code: 'interrupt-unsafe-operation',
+                source: 'interrupt-analysis',
+            });
+            return;
+        }
+    }
+}
+/**
+ * Helper to scan program for callback expressions.
+ */
+function scanProgramForCallbacks(program, callback) {
+    // Scan top-level statements
+    if (program.topLevelStatements) {
+        for (const stmt of program.topLevelStatements) {
+            scanStatementForCallbacks(stmt, callback, null);
+        }
+    }
+    // Scan functions
+    if (program.functions) {
+        for (const fn of program.functions) {
+            if (fn.statements) {
+                for (const stmt of fn.statements) {
+                    scanStatementForCallbacks(stmt, callback, null);
+                }
+            }
+        }
+    }
+    // Scan registered callbacks from HAL resolver (callback() directive)
+    for (const rc of (program.registeredCallbacks ?? [])) {
+        callback(rc.callbackIR, null);
+    }
+}
+/**
+ * Scan a statement for callback expressions.
+ */
+function scanStatementForCallbacks(stmt, callback, parentExpr) {
+    if (!stmt || typeof stmt !== 'object')
+        return;
+    // Check call args for callbacks
+    if (stmt.kind === 'call' && stmt.args) {
+        for (const arg of stmt.args) {
+            if (arg && arg.kind === 'callback') {
+                callback(arg, stmt);
+            }
+            scanExpressionForCallbacks(arg, callback, stmt);
+        }
+    }
+    // Check var_decl initializer
+    if (stmt.kind === 'var_decl' && stmt.initializer) {
+        scanExpressionForCallbacks(stmt.initializer, callback, stmt);
+    }
+    // Check assignment value
+    if (stmt.kind === 'assign' && stmt.value) {
+        scanExpressionForCallbacks(stmt.value, callback, stmt);
+    }
+    walkNestedStatements(stmt, (s) => scanStatementForCallbacks(s, callback, parentExpr));
+}
+/**
+ * Scan an expression for callback expressions.
+ */
+function scanExpressionForCallbacks(expr, callback, parentExpr) {
+    if (!expr || typeof expr !== 'object')
+        return;
+    // Check if this is a callback
+    if (expr.kind === 'callback') {
+        callback(expr, parentExpr);
+    }
+    // Check nested expressions
+    if (expr.args && Array.isArray(expr.args)) {
+        for (const arg of expr.args) {
+            scanExpressionForCallbacks(arg, callback, expr);
+        }
+    }
+    if (expr.left)
+        scanExpressionForCallbacks(expr.left, callback, expr);
+    if (expr.right)
+        scanExpressionForCallbacks(expr.right, callback, expr);
+    if (expr.operand)
+        scanExpressionForCallbacks(expr.operand, callback, expr);
+    if (expr.condition)
+        scanExpressionForCallbacks(expr.condition, callback, expr);
+    if (expr.whenTrue)
+        scanExpressionForCallbacks(expr.whenTrue, callback, expr);
+    if (expr.whenFalse)
+        scanExpressionForCallbacks(expr.whenFalse, callback, expr);
+    if (expr.object)
+        scanExpressionForCallbacks(expr.object, callback, expr);
+    if (expr.value && typeof expr.value === 'object' && 'kind' in expr.value) {
+        scanExpressionForCallbacks(expr.value, callback, expr);
+    }
+}
+// ---------------------------------------------------------------------------
+// Automatic volatile inference for ISR-shared globals.
+//
+// The classic AVR bug: a global `flag` set in an ISR and polled in loop()
+// becomes an infinite loop under -Os because g++ caches it in a register. The
+// transpiler knows which callbacks are ISRs (isInterruptHandler) and which
+// globals are assigned inside them — information g++ cannot recover. This pass
+// auto-marks such globals `volatile`, eliminating the bug class entirely. The
+// emission path already handles isVolatile (statement-renderer.ts).
+// ---------------------------------------------------------------------------
+/** Collect variable names assigned (written) within a statement body. */
+function collectAssignedNames(stmts, names) {
+    for (const stmt of stmts) {
+        const s = stmt;
+        if (stmt.kind === 'assign') {
+            // `flag = true` → target is the bare name (no dot/arrow).
+            if (typeof s.target === 'string' && !s.target.includes('.') && !s.target.includes('->')) {
+                names.add(s.target);
+            }
+        }
+        if (stmt.kind === 'update') {
+            // `flag++` / `counter--`.
+            if (typeof s.target === 'string' && !s.target.includes('.') && !s.target.includes('->')) {
+                names.add(s.target);
+            }
+        }
+        // Recurse into nested bodies.
+        const nested = getNestedStatements(stmt);
+        if (nested)
+            collectAssignedNames(nested, names);
+    }
+}
+/** Collect variable names read (referenced) within a statement body. */
+function collectReadNames(stmts, names) {
+    for (const stmt of stmts) {
+        walkExpressionsInStatement(stmt, (expr) => {
+            if (expr.kind === 'identifier' && typeof expr.value === 'string') {
+                names.add(expr.value);
+            }
+        });
+        const nested = getNestedStatements(stmt);
+        if (nested)
+            collectReadNames(nested, names);
+    }
+}
+/** Walk all expressions in a single statement (delegates to walkExpressionsInExpression). */
+function walkExpressionsInStatement(stmt, visitor) {
+    const s = stmt;
+    if (s.initializer && typeof s.initializer === 'object')
+        walkExpressionsInExpression(s.initializer, visitor);
+    if (s.value && typeof s.value === 'object' && 'kind' in s.value)
+        walkExpressionsInExpression(s.value, visitor);
+    if (s.condition && typeof s.condition === 'object')
+        walkExpressionsInExpression(s.condition, visitor);
+    if (s.expression && typeof s.expression === 'object' && 'kind' in s.expression)
+        walkExpressionsInExpression(s.expression, visitor);
+    if (Array.isArray(s.args)) {
+        for (const a of s.args)
+            walkExpressionsInExpression(a, visitor);
+    }
+    if (s.target && typeof s.target === 'string') {
+        // assignment target is read-then-written; record the read.
+        visitor({ kind: 'identifier', value: s.target });
+    }
+}
+/**
+ * Infer `volatile` for global variables shared between ISR callbacks and main
+ * code. Mutates the IR (sets isVolatile=true on qualifying var_decls) and
+ * emits an info diagnostic for each promotion. A variable qualifies when it is
+ * a global (top-level) that is assigned inside an isInterruptHandler callback
+ * AND read from non-ISR code (setup/loop/main/functions).
+ */
+export function inferVolatileForIsrSharedVars(program, diagnostics) {
+    // 1. Build a map of global var_decl name → IR node.
+    const globalVars = new Map();
+    for (const stmt of program.topLevelStatements) {
+        if (stmt.kind === 'var_decl' && typeof stmt.name === 'string') {
+            globalVars.set(stmt.name, stmt);
+        }
+    }
+    if (globalVars.size === 0)
+        return;
+    // 2. Find names assigned inside ISR callbacks.
+    const isrAssignedNames = new Set();
+    const isrCallbackBodies = [];
+    scanProgramForCallbacks(program, (callback) => {
+        if (callback.isInterruptHandler && Array.isArray(callback.statements)) {
+            isrCallbackBodies.push(callback.statements);
+            collectAssignedNames(callback.statements, isrAssignedNames);
+        }
+    });
+    if (isrAssignedNames.size === 0)
+        return;
+    // 3. Find names read from non-ISR code.
+    const mainReadNames = new Set();
+    for (const stmt of program.topLevelStatements)
+        collectReadNames([stmt], mainReadNames);
+    for (const fn of program.functions) {
+        if (fn.statements)
+            collectReadNames(fn.statements, mainReadNames);
+    }
+    for (const cls of program.classes) {
+        for (const m of cls.methods) {
+            if (m.statements)
+                collectReadNames(m.statements, mainReadNames);
+        }
+        if (cls.constructor?.statements)
+            collectReadNames(cls.constructor.statements, mainReadNames);
+    }
+    // ISR callback reads don't count as "main reads" — exclude them.
+    for (const body of isrCallbackBodies) {
+        const isrReads = new Set();
+        collectReadNames(body, isrReads);
+        for (const name of isrReads) {
+            // Only remove if the name isn't ALSO read outside ISRs (already captured above).
+            // This is a conservative check: we keep the name if it appears in both.
+        }
+    }
+    // 4. Promote globals that are ISR-written AND main-read.
+    for (const [name, stmt] of globalVars) {
+        if (isrAssignedNames.has(name) && mainReadNames.has(name) && !stmt.isVolatile) {
+            stmt.isVolatile = true;
+            diagnostics.push({
+                severity: 'info',
+                message: `'${name}' is written in an interrupt handler and read in main code — emitted as \`volatile\` to prevent the compiler from caching it in a register (the classic ISR/loop race).`,
+                line: stmt.sourceSpan?.startLine,
+                column: stmt.sourceSpan?.startColumn,
+                code: 'volatile-isr-shared',
+                source: 'interrupt-analysis',
+            });
+        }
+    }
+}
+/** Helper: get nested statement arrays from a compound statement. */
+function getNestedStatements(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);
+        }
+    }
+    return out.length > 0 ? out : null;
+}
+// ---------------------------------------------------------------------------
+// Reentrancy detection.
+//
+// If a function is called from both an ISR callback and main-thread code
+// (setup/loop/other functions), an interrupt firing mid-execution corrupts
+// the function's local state or shared buffers. This is the hardest embedded
+// bug to diagnose — rare, non-deterministic corruption. The transpiler knows
+// which callbacks are ISRs and can see the whole call graph, so it can flag
+// the intersection — something g++ fundamentally cannot do (it has no concept
+// of "this function runs in interrupt context").
+// ---------------------------------------------------------------------------
+/** Collect callee names from call statements within a statement body. */
+function collectCalleeNames(stmts, names) {
+    for (const stmt of stmts) {
+        const s = stmt;
+        if (stmt.kind === 'call' && typeof s.callee === 'string') {
+            // Bare function calls only (not method calls like obj.method()).
+            if (!s.callee.includes('.') && !s.callee.includes('->') && !s.callee.includes('::')) {
+                names.add(s.callee);
+            }
+        }
+        const nested = getNestedStatements(stmt);
+        if (nested)
+            collectCalleeNames(nested, names);
+    }
+}
+/**
+ * Detect functions called from both ISR callbacks and main-thread code.
+ * Emits a warning for each reentrancy-risk function.
+ */
+export function detectReentrancyRisk(program, diagnostics) {
+    // Collect user-defined function names for filtering (only flag calls to
+    // functions that exist in this program — not bare Arduino functions).
+    const userFunctionNames = new Set();
+    for (const fn of program.functions)
+        userFunctionNames.add(fn.originalName);
+    for (const cls of program.classes) {
+        for (const m of cls.methods)
+            userFunctionNames.add(m.name);
+    }
+    if (userFunctionNames.size === 0)
+        return;
+    // 1. Collect callees from ISR callback bodies.
+    const isrCallees = new Set();
+    scanProgramForCallbacks(program, (callback) => {
+        if (callback.isInterruptHandler && Array.isArray(callback.statements)) {
+            collectCalleeNames(callback.statements, isrCallees);
+        }
+    });
+    if (isrCallees.size === 0)
+        return;
+    // 2. Collect callees from main-thread code (functions + class methods).
+    const mainCallees = new Set();
+    for (const fn of program.functions) {
+        if (fn.statements)
+            collectCalleeNames(fn.statements, mainCallees);
+    }
+    for (const cls of program.classes) {
+        for (const m of cls.methods) {
+            if (m.statements)
+                collectCalleeNames(m.statements, mainCallees);
+        }
+        if (cls.constructor?.statements)
+            collectCalleeNames(cls.constructor.statements, mainCallees);
+    }
+    for (const stmt of program.topLevelStatements)
+        collectCalleeNames([stmt], mainCallees);
+    // 3. Flag user functions in the intersection.
+    for (const name of isrCallees) {
+        if (mainCallees.has(name) && userFunctionNames.has(name)) {
+            diagnostics.push({
+                severity: 'warning',
+                message: `'${name}' is called from both an interrupt handler and main-thread code. An interrupt firing mid-execution can corrupt the function's local state. Wrap the main-thread call in noInterrupts()/interrupts(), or refactor to avoid sharing the function.`,
+                code: 'reentrancy-risk',
+                source: 'interrupt-analysis',
+            });
+        }
+    }
+}

package/dist/ir/memory-budget-validation.d.ts

@@ -0,0 +1,10 @@
+import type { ProgramIR } from '../api/index.js';
+import type { BoardConstants } from '../api/shared/index.js';
+import type { Diagnostic } from '../types.js';
+/**
+ * Validate that the estimated memory budget fits within the board's SRAM.
+ * Emits a warning when static globals + estimated stack frames exceed 80% of
+ * SRAM. Only runs when boardConstants provides `memory.sram` and
+ * `architecture`.
+ */
+export declare function validateMemoryBudget(program: ProgramIR, boardConstants: BoardConstants | undefined): Diagnostic[];

package/dist/ir/memory-budget-validation.js

@@ -0,0 +1,86 @@
+// ---------------------------------------------------------------------------
+// Memory Budget Validation
+//
+// Compares the transpiler's static memory estimate against the board's SRAM
+// budget. On AVR, the 2 KB SRAM is shared by globals/static data (grows up
+// from .bss/.data), the heap (grows up from the end of .bss), and the stack
+// (grows down from the top). There is no MMU — collision corrupts memory
+// silently, producing the classic "works in debug, crashes in release"
+// embedded failure.
+//
+// The transpiler knows the board's SRAM (boardConstants) and can estimate
+// static bytes + call depth — something g++ cannot do (it has no concept of
+// the board's memory size). This validator surfaces a warning when the
+// estimated budget is tight, so the user can act before hardware surprises.
+// ---------------------------------------------------------------------------
+import { analyzeHeapUsage } from './heap-analysis.js';
+import { buildCallGraph } from './call-graph.js';
+/**
+ * Conservative per-stack-frame estimate in bytes. A minimal AVR function frame
+ * (return address + saved registers + a few locals) is 4-16 bytes; we use the
+ * upper bound to avoid underestimating. This is inherently approximate — the
+ * goal is to surface a tight budget, not to predict an exact collision.
+ */
+const ESTIMATED_FRAME_BYTES = 16;
+/** Warn when estimated usage exceeds this fraction of SRAM. */
+const WARN_FRACTION = 0.80;
+/**
+ * Validate that the estimated memory budget fits within the board's SRAM.
+ * Emits a warning when static globals + estimated stack frames exceed 80% of
+ * SRAM. Only runs when boardConstants provides `memory.sram` and
+ * `architecture`.
+ */
+export function validateMemoryBudget(program, boardConstants) {
+    const diagnostics = [];
+    if (!boardConstants)
+        return diagnostics;
+    const architecture = boardConstants.get('architecture');
+    if (architecture === undefined)
+        return diagnostics;
+    // SRAM budget: prefer the board constant, fall back to a per-architecture
+    // default. The memory.sram constant may be absent because
+    // resolveAndMergeMCUConstants skips MCU resolution when the board file
+    // already produced pins.all.* entries (e.g. the Uno spreads ATmega328P.pins).
+    // The fallback covers the common AVR boards where this matters most.
+    const ARCH_SRAM_DEFAULTS = {
+        avr: 2048,
+        megaavr: 6144,
+        esp32: 327680,
+        esp32s2: 327680,
+        esp32s3: 327680,
+        esp32c3: 327680,
+        esp32c6: 327680,
+    };
+    const sramBytes = boardConstants.get('memory.sram')
+        ?? ARCH_SRAM_DEFAULTS[architecture];
+    if (sramBytes === undefined)
+        return diagnostics;
+    // Compute the static estimate + stack depth. analyzeHeapUsage needs the call
+    // graph for stack-depth estimation.
+    const callGraph = buildCallGraph(program);
+    const estimate = analyzeHeapUsage(program, architecture, callGraph.nodes);
+    // Estimate stack bytes: depth × per-frame. This is a lower bound (each frame
+    // may hold locals larger than the default), so frame it conservatively.
+    const estimatedStackBytes = estimate.estimatedStackDepth * ESTIMATED_FRAME_BYTES;
+    const totalEstimated = estimate.totalStaticBytes + estimatedStackBytes;
+    const fraction = totalEstimated / sramBytes;
+    if (fraction >= WARN_FRACTION) {
+        const sramKb = (sramBytes / 1024).toFixed(1);
+        const staticKb = (estimate.totalStaticBytes / 1024).toFixed(2);
+        const stackKb = (estimatedStackBytes / 1024).toFixed(2);
+        const totalKb = (totalEstimated / 1024).toFixed(2);
+        diagnostics.push({
+            severity: fraction >= 1.0 ? 'error' : 'warning',
+            message: `Estimated SRAM usage is ${(fraction * 100).toFixed(0)}% of the ${sramKb} KB budget ` +
+                `(statics ${staticKb} KB + stack ~${stackKb} KB = ~${totalKb} KB). ` +
+                (fraction >= 1.0
+                    ? `This exceeds available SRAM and will likely corrupt memory at runtime.`
+                    : `Stack and heap share the remaining space; deep call chains or heap allocation risk collision.`),
+            hint: `Reduce global/static data, move large buffers to PROGMEM (flash), shorten deep call chains, ` +
+                `or use a board with more SRAM. See the heap estimate in the diagnostics report for a breakdown.`,
+            code: 'memory-budget',
+            source: 'memory-budget-validation',
+        });
+    }
+    return diagnostics;
+}

package/dist/ir/namespace-builder.d.ts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+import { Diagnostic } from "../types.js";
+import { NamespaceIR } from "../api/index.js";
+import { CppTypeHint } from "./type-resolution.js";
+import { RegisterClassIR } from "../api/index.js";
+import { PointerTracker } from "./build-ir-state.js";
+export declare function namespaceToIR(node: ts.ModuleDeclaration, fileName: string, sourceText: string, diagnostics: Diagnostic[], functionReturnTypes: Map<string, CppTypeHint>, typeAliasNodes: Map<string, ts.TypeNode>, registerClasses: RegisterClassIR[], pointerVars?: PointerTracker): NamespaceIR | undefined;