@typecad/cuttlefish 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/emit/expression-renderer.js

@@ -10,6 +10,7 @@ import { accessorGetterName } from "./utils/cpp-helpers.js";
 import { INTEGRAL_CPP_TYPE_RE } from "./utils/cpp-helpers.js";
 import { renderPeripheralProperty } from "../mapping/peripheral-names.js";
 import { parseCppType, renderCppType, bareType, parsedIsPointer, parsedIsVector, needsCStrForStringLike } from "../api/shared/cpp-type-ir.js";
+import { cppTypeForHalOp } from "./utils/hal-op-cpp-type.js";
 /**
  * Renders ExpressionIR nodes to C++ code strings.
  */
@@ -79,6 +80,18 @@ export class ExpressionRenderer {
         if (!expr || typeof expr !== 'object' || !expr.kind) {
             return "/* invalid expression */";
         }
+        // When a per-scope knownVariableTypes is passed (e.g. a function's child
+        // emission scope carrying its parameters), install it on the instance for
+        // the duration of this render so every recursive render() call and
+        // renderIdentifier() reads the merged scope (globals + params). Without
+        // this, recursive paths that don't forward knownVariableTypes (ternary
+        // branches, call args, array elements, …) would resolve identifiers
+        // against only the top-level scope, missing function parameters — which
+        // breaks reserved-name escaping for params like `min`/`max` on Arduino.
+        const prevKnownVariableTypes = this.knownVariableTypes;
+        if (knownVariableTypes) {
+            this.knownVariableTypes = knownVariableTypes;
+        }
         let rendered;
         switch (expr.kind) {
             case "number": {
@@ -99,7 +112,7 @@ export class ExpressionRenderer {
                 rendered = expr.value ? "true" : "false";
                 break;
             case "identifier":
-                rendered = this.renderIdentifier(expr.value);
+                rendered = this.renderIdentifier(expr.value, knownVariableTypes);
                 break;
             case "raw":
                 rendered = this.renderRaw(expr.value, exprTransformer);
@@ -149,6 +162,18 @@ export class ExpressionRenderer {
             case "method-call":
                 rendered = this.renderMethodCall(expr, exprTransformer);
                 break;
+            case "call": {
+                // Bare call expression: `Name(args)` with no receiver (e.g. a
+                // constructor call `SafeInt(x)` written inline, or a free function).
+                // Method-on-receiver calls lower as "method-call"; this arm is for the
+                // receiverless form. The callee is escaped against C++ reserved names;
+                // when a target type is in scope, renderValueForTarget (the caller)
+                // wraps this with template args (SafeInt(x) -> SafeInt<int32_t>(x)).
+                const callArgs = expr.args.map(a => this.render(a, exprTransformer)).join(", ");
+                const callCallee = escapeCppKeyword(exprTransformer ? exprTransformer(expr.callee) : expr.callee, this.strategy.reservedNames());
+                rendered = `${callCallee}(${callArgs})`;
+                break;
+            }
             case "element-access":
                 rendered = this.renderElementAccess(expr, exprTransformer, knownVariableTypes);
                 break;
@@ -191,9 +216,10 @@ export class ExpressionRenderer {
                     `This is a transpiler bug; the renderer is missing a case for this kind.`);
             }
         }
+        this.knownVariableTypes = prevKnownVariableTypes;
         return normalizeRawExpression(rendered, this.strategy, this.classNameMap);
     }
-    renderIdentifier(value) {
+    renderIdentifier(value, scopeKnownVariableTypes) {
         const nullVal = this.strategy.nullValue();
         // expression-to-ir lowers the TS `null` literal to the identifier sentinel
         // "nullptr" and `undefined` to "CUTTLEFISH_UNDEFINED". Both must route
@@ -209,7 +235,27 @@ export class ExpressionRenderer {
         if (this.strategy.passthroughMacroNames().has(value)) {
             return value;
         }
-        return escapeCppKeyword(value, this.strategy.reservedNames());
+        // Platform-reserved names (e.g. Arduino `Serial`, or the `min`/`max` math
+        // macros) are globals/macros provided by the framework headers. Escaping
+        // them would break references to those globals — UNLESS the name is a
+        // user-declared variable/parameter that shadows and would collide. Check
+        // both the instance field (globals/locals seen so far) AND the per-scope
+        // map passed by the caller (function parameters, which live in the child
+        // emission scope and aren't on the instance field). Declaration sites
+        // already escape user vars (renderParameters → renderTypedName), so the
+        // body references must escape to match.
+        const reservedNames = this.strategy.reservedNames();
+        if (reservedNames.has(value)) {
+            const isUserVar = (this.knownVariableTypes !== undefined && this.knownVariableTypes.has(value)) ||
+                (scopeKnownVariableTypes !== undefined && scopeKnownVariableTypes.has(value)) ||
+                (this.pointerVarTypes !== undefined && this.pointerVarTypes.has(value)) ||
+                (this.globalPointerVarTypes !== undefined && this.globalPointerVarTypes.has(value)) ||
+                (this.stringVarNames !== undefined && this.stringVarNames.has(value));
+            if (!isUserVar) {
+                return value;
+            }
+        }
+        return escapeCppKeyword(value, reservedNames);
     }
     renderRaw(value, exprTransformer) {
         const effectiveClassNameMap = this.classNameMap;
@@ -403,6 +449,8 @@ export class ExpressionRenderer {
             }
             case "unary":
                 return expr.operator === "!" ? "bool" : this.inferExpressionCppType(expr.operand, knownVariableTypes);
+            case "hal-expr":
+                return cppTypeForHalOp(expr.operation.operation);
             default:
                 return undefined;
         }
@@ -714,10 +762,16 @@ export class ExpressionRenderer {
             }
             case "hal-expr": {
                 const rendered = this.render(expr, exprTransformer);
-                // HAL expressions that resolve to string-like outputs use %s
                 if (rendered.startsWith('"') || this.stringVarNames?.has(rendered)) {
                     return { format: "%s", arg: rendered, estimatedLength: 32 };
                 }
+                const cppType = cppTypeForHalOp(expr.operation.operation);
+                if (cppType && this.isStringLikeCppType(cppType)) {
+                    return { format: "%s", arg: rendered, estimatedLength: 32 };
+                }
+                if (cppType === "bool") {
+                    return { format: "%s", arg: `(${rendered} ? "true" : "false")`, estimatedLength: 5 };
+                }
                 return { format: "%d", arg: rendered, estimatedLength: 12 };
             }
             case "method-call":
@@ -878,10 +932,27 @@ export class ExpressionRenderer {
      * (safer than a wrong cast).
      */
     renderValueForTarget(expr, targetType, knownVariableTypes, exprTransformer) {
-        const rendered = this.render(expr, exprTransformer, knownVariableTypes);
         if (!targetType)
-            return rendered;
+            return this.render(expr, exprTransformer, knownVariableTypes);
         const normalizedTarget = targetType.trim();
+        // Inject template args for constructor calls on pre-C++17 toolchains
+        // (e.g. AVR without CTAD). SafeVariable(0) → SafeVariable<int32_t>(0).
+        // Handles both `method-call` (when the constructor appears as a standalone
+        // initializer) and `call` (when it appears on the RHS of an assignment,
+        // which lowers as `T x = {}; x = T(args);`). The callee must match the
+        // template name and the target must be a `Name<...>` instantiation, so a
+        // regular function call assigned to a non-templated type never matches.
+        const tmplMatch = normalizedTarget.match(/^([A-Za-z_]\w*)<(.+)>/);
+        const exprAny = expr;
+        const isCtorCall = tmplMatch != null
+            && (exprAny.kind === "method-call" || exprAny.kind === "call")
+            && exprAny.callee === tmplMatch[1]
+            && exprAny.callee != null && !exprAny.callee.includes("<");
+        if (isCtorCall && exprAny.args) {
+            const argsText = exprAny.args.map(a => this.render(a, exprTransformer, knownVariableTypes)).join(", ");
+            return `${tmplMatch[1]}<${tmplMatch[2]}>(${argsText})`;
+        }
+        const rendered = this.render(expr, exprTransformer, knownVariableTypes);
         // Never cast into string-like storage — enums that lower to const char*
         // (string enums) already match, and a string target is never an enum boundary.
         if (this.isStringLikeCppType(normalizedTarget))
@@ -1350,6 +1421,8 @@ export class ExpressionRenderer {
     renderMethodCall(expr, exprTransformer) {
         const argsText = expr.args.map(a => this.render(a, exprTransformer)).join(", ");
         let callee = exprTransformer ? exprTransformer(expr.callee) : expr.callee;
+        const rExpr = expr.receiverExpr;
+        const mName = expr.methodName;
         // Convert . to :: for static or namespace method calls if the IR flagged them.
         if (expr.isStatic || expr.isNamespace) {
             callee = callee.replace(/\./g, "::");
@@ -1380,6 +1453,18 @@ export class ExpressionRenderer {
             return callee;
         }
         callee = this.escapeFinalMemberName(callee);
+        // Structured-receiver path: when the method-call IR carries a receiverExpr
+        // (the safe.read().ok().fail() chain builder sets this), render the receiver
+        // via the full renderer so nested lambda args survive (the flat callee string
+        // would have destroyed them as /* __lambda__ */ placeholders). The methodName
+        // is escaped against reserved names (e.g. div -> div_).
+        const receiverExpr = expr.receiverExpr;
+        const methodName = expr.methodName;
+        if (receiverExpr !== undefined && methodName !== undefined) {
+            const receiverText = this.render(receiverExpr, exprTransformer);
+            const escapedMethod = escapeCppKeyword(methodName, this.strategy.reservedNames());
+            return `${receiverText}.${escapedMethod}(${argsText})`;
+        }
         return `${callee}(${argsText})`;
     }
     escapeFinalMemberName(callee) {

package/dist/emit/route-hal-op.js

@@ -1,13 +1,26 @@
 // ---------------------------------------------------------------------------
 // Op routing — dispatch a HALOpIR to the right strategy resolver.
 //
-// display.* ops go to resolveDisplayOp (graphics-specific); everything else
-// goes to resolveHALOperation (the existing generic seam). Keeps the consumer
-// sites (expression-renderer, statement-renderer, render-expr) DRY.
+// display.* ops go to resolveDisplayOp (graphics-specific).
+// safety.*  ops go to the safety hook's resolveSafetyOp (when @typecad/safety
+//           is loaded) — NEVER to a per-target strategy, because the safety
+//           package is MCU-agnostic by construction.
+// everything else goes to resolveHALOperation (the existing generic seam).
+// Keeps the consumer sites (expression-renderer, statement-renderer,
+// render-expr) DRY.
 // ---------------------------------------------------------------------------
+import { getSafetyHook } from "../safety-hook.js";
 export function routeHALOp(op, strategy) {
-    if (typeof op.operation === "string" && op.operation.startsWith("display.")) {
-        return strategy.resolveDisplayOp?.(op);
+    if (typeof op.operation === "string") {
+        if (op.operation.startsWith("display.")) {
+            return strategy.resolveDisplayOp?.(op);
+        }
+        if (op.operation.startsWith("safety.")) {
+            // Safety ops are resolved by the @typecad/safety package via hook.
+            // Returns undefined if the package is not loaded (caller emits an
+            // unhandled-op warning).
+            return getSafetyHook()?.resolveSafetyOp?.(op);
+        }
     }
     return strategy.resolveHALOperation?.(op);
 }

package/dist/emit/snprintf-helpers.js

@@ -8,6 +8,7 @@
 // Types are imported from @typecad/cuttlefish/api/shared.
 // ---------------------------------------------------------------------------
 import { escapeCppStringLiteral, escapeSnprintfFormatFragment } from "../utils/strings.js";
+import { cppTypeForHalOp } from "./utils/hal-op-cpp-type.js";
 import { parsedElementString, parsedIsStringLike } from "../api/shared/cpp-type-ir.js";
 // ---------------------------------------------------------------------------
 // Scope state management
@@ -235,11 +236,14 @@ export function inferSnprintfArg(expr, strategy, scopeState, renderExpression, p
                         return { format: "%d", arg: renderExpression(expr), estimatedLength: 12, preludeLines: [] };
                     }
                 }
-                const arduinoIntFunctions = new Set([
-                    "digitalRead", "analogRead", "pulseIn", "pulseInLong",
-                    "Wire_available", "Serial_available",
+                const halIntFunctions = new Set([
+                    ...(strategy?.halCallNames?.() ?? new Set()),
+                    // pulseIn/pulseInLong and the Wire_available/Serial_available forms
+                    // are framework-specific suffix conventions; frameworks may add them
+                    // to halCallNames. Kept as a fallback here until all frameworks do.
+                    "pulseIn", "pulseInLong", "Wire_available", "Serial_available",
                 ]);
-                if (arduinoIntFunctions.has(funcName)) {
+                if (halIntFunctions.has(funcName)) {
                     return { format: "%d", arg: renderExpression(expr), estimatedLength: 12, preludeLines: [] };
                 }
             }
@@ -369,6 +373,13 @@ export function inferSnprintfArg(expr, strategy, scopeState, renderExpression, p
             if (rendered.startsWith('"') || stringVarNames?.has(rendered)) {
                 return { format: "%s", arg: rendered, estimatedLength: 32, preludeLines: [] };
             }
+            const cppType = cppTypeForHalOp(expr.operation.operation);
+            if (cppType && strategy.isStringLikeType(cppType)) {
+                return { format: "%s", arg: rendered, estimatedLength: 32, preludeLines: [] };
+            }
+            if (cppType === "bool") {
+                return { format: "%s", arg: `(${rendered} ? "true" : "false")`, estimatedLength: 5, preludeLines: [] };
+            }
             return { format: "%d", arg: rendered, estimatedLength: 12, preludeLines: [] };
         }
         default:

package/dist/emit/statement-renderer.d.ts

@@ -63,6 +63,14 @@ interface StatementRendererContext {
      * list. Optional so ad-hoc/test constructions still work.
      */
     diagnostics?: Diagnostic[];
+    /**
+     * Optional compliance context for A3-9-1 (fixed-width integer default).
+     * When provided and A3-9-1 is enforced, defaultNumericType() returns a
+     * fixed-width type instead of the legacy 'int'.
+     */
+    compliance?: {
+        isBanned(ruleId: string): boolean;
+    };
 }
 /**
  * Renders StatementIR nodes to C++ code strings.
@@ -83,6 +91,8 @@ export declare class StatementRenderer {
     private readonly interfaceFieldTypes;
     /** Shared emit-time diagnostics sink (see StatementRendererContext.diagnostics). */
     private readonly _diagnostics;
+    /** Compliance context for A3-9-1 fixed-width integer default. */
+    private readonly _compliance?;
     constructor(context: StatementRendererContext);
     /**
      * Gets the underlying expression renderer for direct use.

package/dist/emit/statement-renderer.js

@@ -116,6 +116,7 @@ export class StatementRenderer {
         this.namespaceNames = context.namespaceNames ?? new Set();
         this.interfaceFieldTypes = context.interfaceFieldTypes ?? new Map();
         this._diagnostics = context.diagnostics ?? [];
+        this._compliance = context.compliance;
         // Create expression renderer with shared context
         this.expressionRenderer = new ExpressionRenderer({
             strategy: context.strategy,
@@ -324,7 +325,7 @@ export class StatementRenderer {
                     this.expressionRenderer.pushPrelude([
                         `const char* ${idxVar}_keys[] = { ${keysArr} };`,
                     ]);
-                    return `for (${this.strategy.defaultNumericType()} ${idxVar} = 0; ${idxVar} < ${statement.keys.length}; ${idxVar}++)`;
+                    return `for (${this.strategy.defaultNumericType(this._compliance)} ${idxVar} = 0; ${idxVar} < ${statement.keys.length}; ${idxVar}++)`;
                 }
                 const varDecl = statement.variable;
                 if (varDecl.kind === "var_decl") {
@@ -485,6 +486,28 @@ export class StatementRenderer {
             const rawStmt = statement.callee.slice('__RAW_STMT__'.length);
             return forHeader ? rawStmt : `${rawStmt.endsWith(';') ? rawStmt : rawStmt + ';'}`;
         }
+        // Handle expression statements whose IR must render at EMIT time (not the
+        // build-time renderExprAsText). The safe.read().ok().fail() chain uses this:
+        // its lambda args can only render via the emit-time renderLambda (which
+        // produces [&](){...}), so the structured chain IR is carried as args[0]
+        // and rendered here via the expression renderer.
+        if (statement.callee === '__EXPR_STMT__' && statement.args.length >= 1) {
+            const exprText = this.expressionRenderer.render(statement.args[0], undefined, knownVariableTypes);
+            return forHeader ? exprText : `${exprText};`;
+        }
+        // Awaited network markers (__WIFI_WAIT__/__HTTP_WAIT__) reaching the
+        // plain renderer means the await sits outside an async state machine
+        // (top-level await, or a position the state-machine splitter doesn't
+        // support). Fall back to the blocking form of the op they carry.
+        if ((statement.callee === "__WIFI_WAIT__" || statement.callee === "__HTTP_WAIT__" || statement.callee === "__BLE_WAIT__" || statement.callee === "__HAL_WAIT__")
+            && statement.args[0]?.kind === "hal-expr") {
+            const resolved = routeHALOp(statement.args[0].operation, this.strategy);
+            const code = resolved?.code ?? (resolved?.expression ? `${resolved.expression};` : undefined);
+            if (code) {
+                return forHeader ? code.replace(/;$/, "") : code;
+            }
+            return `/* unhandled awaited hal-op: ${statement.args[0].operation.operation} */`;
+        }
         // Handle emit() — compile-time C++ injection
         if (statement.callee === "__EMIT__") {
             const rawText = statement.args.map(arg => this.renderEmitArg(arg)).join("");
@@ -645,13 +668,13 @@ export class StatementRenderer {
                     // that don't support std::vector → emit as a plain C-style array.
                     // Mutable arrays (.push/.pop/.indexOf) are rewritten to StaticArray<int> in
                     // the IR builder (via mutableArrayVars) and never reach this branch.
-                    const elementType = parsedElementString(rawType) ?? this.strategy.defaultNumericType();
+                    const elementType = parsedElementString(rawType) ?? this.strategy.defaultNumericType(this._compliance);
                     return forHeader
                         ? `${elementType} ${safeArrName}[] = { ${elements} }`
                         : `${elementType} ${safeArrName}[] = { ${elements} };`;
                 }
                 // Use "int" for "auto" element type since C arrays need explicit types
-                const arrayType = statement.initializer.elementType === "auto" ? this.strategy.defaultNumericType() : statement.initializer.elementType;
+                const arrayType = statement.initializer.elementType === "auto" ? this.strategy.defaultNumericType(this._compliance) : statement.initializer.elementType;
                 return forHeader
                     ? `${arrayType} ${safeArrName}[] = { ${elements} }`
                     : `${arrayType} ${safeArrName}[] = { ${elements} };`;
@@ -726,7 +749,7 @@ export class StatementRenderer {
             }
             // Handle spread array initializers
             if (statement.initializer.kind === "spread_array") {
-                let arrayType = statement.initializer.elementType === "auto" ? this.strategy.defaultNumericType() : statement.initializer.elementType;
+                let arrayType = statement.initializer.elementType === "auto" ? this.strategy.defaultNumericType(this._compliance) : statement.initializer.elementType;
                 const spreadName = this.expressionRenderer.render(statement.initializer.spreadExpr, calleeTransformer, knownVariableTypes);
                 if (statement.initializer.elementType === "auto" && knownVariableTypes && statement.initializer.spreadExpr.kind === "identifier") {
                     const srcInfo = knownVariableTypes.get(statement.initializer.spreadExpr.value);
@@ -879,11 +902,17 @@ export class StatementRenderer {
         if (this.stringEnumNames.has(typeName)) {
             return this.strategy.normalizeCppType("const char*");
         }
+        // A3-9-1: under autosar, substitute the platform's default numeric type
+        // for the legacy "int" spelling. The IR layer hardcodes "int" for number
+        // literals, so we catch it here at the renderer boundary.
+        if (typeName === "int" && this._compliance?.isBanned("A3-9-1")) {
+            return this.strategy.defaultNumericType(this._compliance);
+        }
         return this.strategy.normalizeCppType(typeName);
     }
     inferFieldType(value, parentName, fieldName) {
         return inferObjectFieldType(value, this.pointerVarTypes, this.knownFunctionReturnTypes, undefined, undefined, undefined, // largeEnumNames - would need to pass through
-        parentName, fieldName, this.strategy.defaultNumericType(), (o, n) => this.strategy.resolvePinType?.(o, n));
+        parentName, fieldName, this.strategy.defaultNumericType(this._compliance), (o, n) => this.strategy.resolvePinType?.(o, n));
     }
     /**
      * Transform console.log/error/warn calls based on target platform.