@typecad/cuttlefish 1.0.0-alpha.3 → 1.0.0-alpha.7

package/dist/ir/expression-to-ir.js

@@ -264,15 +264,52 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
             return `(sizeof(${safeText}) / sizeof(${safeText}[0]))`;
         }
         if (ts.isCallExpression(receiverNode)) {
-            const returnType = ts.isPropertyAccessExpression(receiverNode.expression) && ts.isIdentifier(receiverNode.expression.expression)
-                ? getCurrentIrTypeScope()?.locals.get(receiverNode.expression.expression.text)
-                : undefined;
-            if (returnType === "std::string")
-                return `static_cast<long long>(${safeText}.length())`;
+            // Case B: a HAL buffer-returning method (I2CDevice.readBytes /
+            // SPIDevice.readRegister) used INLINE as a sub-expression — e.g.
+            // `dev.readBytes(0,6).length`. These methods lower to STATEMENTS (a fill
+            // loop), not a single C++ expression, so by the time we get here the
+            // receiver text is already a leaked `for (...) __buf[__i] = Wire.read()`
+            // statement spliced where an expression is required. The buffer also has
+            // no caller-side name to sizeof. Only the var-init form is supported
+            // (`const data = dev.readBytes(...)`); emit a clear diagnostic so the
+            // user gets an actionable error instead of inscrutable broken C++.
+            if (/\bfor\s*\(/.test(safeText) || /__buf|__spi_buf/.test(safeText)) {
+                const calleeName = ts.isPropertyAccessExpression(receiverNode.expression)
+                    ? receiverNode.expression.name.text : "call";
+                diagnostics.push(makeDiagnostic(sourceText, receiverNode.getStart(), `\`${calleeName}(...)\` returns a buffer and cannot be queried inline. Capture it into a variable first (e.g. \`const data = ${calleeName}(...)\`), then use \`data.length\`.`, "error", "TC_BUFFER_INLINE_LENGTH"));
+                return `0 /* ${calleeName}() result must be captured into a variable to use .length */`;
+            }
+            // Resolve the call's RETURN type (not the receiver object's type, which
+            // the previous code incorrectly did). Method calls resolve via the class
+            // registry; free-function calls resolve by scanning the source AST for
+            // the declared return type.
+            const returnType = resolveExprCppType(receiverNode)
+                ?? resolveCallReturnTypeForNullGuard(receiverNode, sourceText);
+            if (returnType) {
+                const parsed = parseCppType(returnType);
+                // std::string → .length(); any STL container (vector/map/set) → .size().
+                if (parsedIsStdString(returnType)) {
+                    return `static_cast<long long>(${safeText}.length())`;
+                }
+                if (parsedIsVector(returnType) || parsedIsMap(returnType) || parsedIsSet(returnType) || isContainer(parsed)) {
+                    return `static_cast<long long>(${safeText}.size())`;
+                }
+                // A raw pointer / decayed-array return (e.g. uint8_t*) carries no size
+                // at the call site — sizeof would yield sizeof(pointer). This is
+                // genuinely un-sizeable inline; surface it rather than emit wrong code.
+                if (parsedIsPointer(returnType) || /\]\s*$/.test(returnType)) {
+                    const calleeName = ts.isPropertyAccessExpression(receiverNode.expression)
+                        ? receiverNode.expression.name.text
+                        : (ts.isIdentifier(receiverNode.expression) ? receiverNode.expression.text : "call");
+                    diagnostics.push(makeDiagnostic(sourceText, receiverNode.getStart(), `Cannot use \`.length\` on \`${calleeName}()\` which returns a pointer (${returnType}); the size is not available at the call site. Capture the buffer into a variable first.`, "error", "TC_LENGTH_ON_POINTER_RETURN"));
+                    return `0 /* .length unavailable on ${returnType} return */`;
+                }
+            }
             // Cast .size() to long long to match the loop-counter type (TS number ->
             // long long). Without this, `i < vec.size()` compares long long vs
             // size_t (unsigned) and g++ -Wall warns -Wsign-compare on every
-            // indexed loop over an array.
+            // indexed loop over an array. (Fallback for unresolvable return types —
+            // historically every call-result .length landed here.)
             return `static_cast<long long>(${safeText}.size())`;
         }
         // Resolve by concrete cppType first so std::string vars render member calls
@@ -916,6 +953,20 @@ export function expressionToIR(expr, sourceText, diagnostics, pointerVars = new
         };
     }
     if (ts.isCallExpression(expr)) {
+        // ---- rawCppExpr() — compile-time C++ injection in expression context ----
+        // Mirrors the statement-position rawCpp()/__EMIT__ path, but emits the raw
+        // text as an expression (e.g. for IDF macros like WIFI_INIT_CONFIG_DEFAULT()
+        // that produce struct values). The type parameter is a TS hint only — the
+        // transpiler emits the raw text verbatim.
+        if (ts.isIdentifier(expr.expression) && expr.expression.text === "rawCppExpr") {
+            const arg = expr.arguments[0];
+            if (arg && ts.isStringLiteral(arg)) {
+                return { kind: "raw", value: arg.text };
+            }
+            if (arg && ts.isNoSubstitutionTemplateLiteral(arg)) {
+                return { kind: "raw", value: arg.text };
+            }
+        }
         // ---- board() / boardResolve() — compile-time board constant lookup ----
         if (ts.isIdentifier(expr.expression) && (expr.expression.text === "board" || expr.expression.text === "boardResolve")) {
             const pathArg = expr.arguments[0];

package/dist/ir/feature-registry.js

@@ -198,11 +198,13 @@ function kindBasedLintRules() {
 // `no-restricted-syntax` selector for real-time editor warnings. Kept here so
 // that all editor-time selectors live in one place.
 //
-// NOTE on async/generator/yield severity: these are flagged as `"error"` by
-// ESLint (matching the prior hand-maintained config) but the transpiler only
-// emits a `TS2CPP_ASYNC_STUB` *warning* at build time and emits stub code.
-// The severity mismatch is intentional and documented here — it is not a bug
-// this refactor introduces or should silently "fix".
+// NOTE on async/await: the transpiler fully supports these — each `async`
+// function is lowered to a cooperative state-machine task driven from
+// `loop()` (see `emit/utils/async-state-machine.ts` and the
+// `async-runtime-static.ts` microtask pump). `await expr` lowers to the task
+// yielding between segments, so blocking waits become polls. They are
+// therefore intentionally NOT linted here. Generators/yield and
+// `for await...of` still have no lowering and remain flagged.
 const CONTEXT_LINT_RULES = [
     {
         selector: "ForOfStatement[await=true]",
@@ -244,26 +246,6 @@ const CONTEXT_LINT_RULES = [
         message: "[transpiler] .then() on a Promise is not supported (no promise runtime). Use synchronous return values or callbacks.",
         source: "context",
     },
-    {
-        selector: "FunctionDeclaration[async=true]",
-        message: "[transpiler] async functions are recognized for parse-compatibility but cannot produce correct embedded behavior (no event loop). Use a synchronous function.",
-        source: "context",
-    },
-    {
-        selector: "FunctionExpression[async=true]",
-        message: "[transpiler] async function expressions are recognized for parse-compatibility but cannot produce correct embedded behavior (no event loop). Use a synchronous function.",
-        source: "context",
-    },
-    {
-        selector: "ArrowFunctionExpression[async=true]",
-        message: "[transpiler] async arrow functions are recognized for parse-compatibility but cannot produce correct embedded behavior (no event loop). Use a synchronous arrow function.",
-        source: "context",
-    },
-    {
-        selector: "AwaitExpression",
-        message: "[transpiler] await is stripped to an inline expression — semantics are approximate and there is no event loop on bare metal. Avoid in firmware.",
-        source: "context",
-    },
     {
         selector: "FunctionDeclaration[generator=true]",
         message: "[transpiler] generator functions (function*) have no coroutine runtime on bare metal and are effectively unusable. Avoid.",

package/dist/ir/hal/hal-emitter.d.ts

@@ -19,9 +19,12 @@ export declare function maybeEscapeResolvedText(text: string): string;
 export declare function stripCStrAfterStringLiteral(followingLiteralText: string, resolvedValue: string): string;
 /** Resolve an arbitrary expression to its text form, with this/param substitution. */
 export declare function resolveExpressionText(expr: ts.Expression, instance: HALInstance, paramNames: string[], callArgTexts: string[], paramDefaults?: Map<string, string>): string | null;
+/** True when a HAL semantic call name wraps a GPIO/hardware ISR callback. */
+export declare function semanticCallUsesIsrCallback(fnName: string): boolean;
 /** Scan an expression AST for callback() calls, extract callback IR from callArgs,
- *  register them, and patch callArgTexts with placeholder names. */
-export declare function extractAndRegisterCallbacks(expr: ts.Expression, paramNames: string[], callArgs: ExpressionIR[], callArgTexts: string[]): void;
+ *  register them, and patch callArgTexts with placeholder names.
+ *  @param isInterruptHandler — only true for GPIO interrupt attach paths. */
+export declare function extractAndRegisterCallbacks(expr: ts.Expression, paramNames: string[], callArgs: ExpressionIR[], callArgTexts: string[], isInterruptHandler?: boolean): void;
 /** Process a HAL method body, resolving emit()/include()/semantic calls.
  *  Returns { emitLines, halOps, returnValue, returnClassName } or null if unresolvable.
  *

package/dist/ir/hal/hal-emitter.js

@@ -5,6 +5,7 @@ import { renderExprAsText } from "../render-expr.js";
 import { escapeCppKeyword } from "../../utils/strings.js";
 import { halClassRegistry, halGlobalFunctions } from "./hal-parser.js";
 import { tryResolveSemanticCall, tryResolveBoardResolveArg, tryResolveCompoundSemanticReturn, resolveConcatPath } from "./hal-plugins.js";
+import { cppTypeForHalOp } from "../../emit/utils/hal-op-cpp-type.js";
 /** Escape C++ keywords in resolved text, but only when the text looks like a
  *  variable reference (not a literal like "false", "true", "42", or a string). */
 export function maybeEscapeResolvedText(text) {
@@ -275,9 +276,22 @@ export function resolveExpressionText(expr, instance, paramNames, callArgTexts,
     }
     return expr.getText ? expr.getText() : null;
 }
+/** Semantic HAL helpers whose callbacks run in true ISR context (need IRAM_ATTR).
+ *  WiFi event handlers, timers, setInterval, etc. use callback() too but run in
+ *  a task / event loop — marking those as ISRs puts printf in IRAM and, on
+ *  ESP-IDF, trips -Werror=attributes when IRAM_ATTR's __COUNTER__ disagrees
+ *  between forward declaration and definition. */
+const ISR_CALLBACK_SEMANTIC_FNS = new Set([
+    "interruptAttach",
+]);
+/** True when a HAL semantic call name wraps a GPIO/hardware ISR callback. */
+export function semanticCallUsesIsrCallback(fnName) {
+    return ISR_CALLBACK_SEMANTIC_FNS.has(fnName);
+}
 /** Scan an expression AST for callback() calls, extract callback IR from callArgs,
- *  register them, and patch callArgTexts with placeholder names. */
-export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgTexts) {
+ *  register them, and patch callArgTexts with placeholder names.
+ *  @param isInterruptHandler — only true for GPIO interrupt attach paths. */
+export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgTexts, isInterruptHandler = false) {
     function scan(node) {
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "callback") {
             const cbArg = node.arguments[0];
@@ -292,6 +306,8 @@ export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgT
                                 kind: "callback",
                                 params: callbackIR.params.map((p) => p.name),
                                 statements: callbackIR.body,
+                                ...(callbackIR.returnType && callbackIR.returnType !== "void" ? { returnType: callbackIR.returnType } : {}),
+                                ...(callbackIR.params ? { typedParams: callbackIR.params.map((p) => ({ name: p.name, cppType: p.cppType })).filter((p) => p.cppType && p.cppType !== "void") } : {}),
                                 sourceSpan: callbackIR.body[0]?.sourceSpan ?? {
                                     filePath: "",
                                     startLine: 0,
@@ -301,10 +317,12 @@ export function extractAndRegisterCallbacks(expr, paramNames, callArgs, callArgT
                                     startOffset: 0,
                                     endOffset: 0,
                                 },
-                                isInterruptHandler: true,
+                                ...(isInterruptHandler ? { isInterruptHandler: true } : {}),
                             }
                             : callbackIR;
-                        normalized.isInterruptHandler = true;
+                        if (isInterruptHandler) {
+                            normalized.isInterruptHandler = true;
+                        }
                         registeredCallbacks.push({ placeholderName: placeholder, callbackIR: normalized });
                         callArgTexts[paramIdx] = placeholder;
                     }
@@ -399,8 +417,9 @@ export function processHALMethodBody(instance, methodName, callArgs) {
             if (ts.isIdentifier(call.expression)) {
                 // Extract callbacks from semantic call arguments and patch callArgTexts
                 // with placeholder names before resolving (mirrors the emit() path).
+                const isIsr = semanticCallUsesIsrCallback(call.expression.text);
                 for (const arg of call.arguments) {
-                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                 }
                 const semanticOp = tryResolveSemanticCall(call.expression.text, call.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                 if (semanticOp) {
@@ -468,8 +487,9 @@ export function processHALMethodBody(instance, methodName, callArgs) {
                 actualRetExpr = actualRetExpr.expression;
             }
             if (ts.isCallExpression(actualRetExpr) && ts.isIdentifier(actualRetExpr.expression)) {
+                const isIsr = semanticCallUsesIsrCallback(actualRetExpr.expression.text);
                 for (const arg of actualRetExpr.arguments) {
-                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                    extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                 }
                 const semanticOp = tryResolveSemanticCall(actualRetExpr.expression.text, actualRetExpr.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                 if (semanticOp) {
@@ -594,8 +614,9 @@ export function processStatementList(stmts, instance, paramNames, callArgTexts,
                 }
                 else {
                     // R3: Try semantic HAL function call
+                    const isIsr = semanticCallUsesIsrCallback(call.expression.text);
                     for (const arg of call.arguments) {
-                        extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts);
+                        extractAndRegisterCallbacks(arg, paramNames, callArgs, callArgTexts, isIsr);
                     }
                     const semanticOp = tryResolveSemanticCall(call.expression.text, call.arguments, instance, paramNames, callArgTexts, paramDefaults, callArgs);
                     if (semanticOp) {
@@ -696,14 +717,21 @@ export function buildSnprintfFromConcat(expr) {
             else if (part.kind === "template_string" && part.expression.kind === "hal-expr") {
                 // HAL expression inside template literal — resolve via strategy
                 const resolved = resolveHALExprToText(part.expression);
-                if (resolved !== null) {
-                    formatString += "%d";
-                    args.push(resolved);
-                    estimatedLength += 12;
+                const argText = resolved !== null ? resolved : text;
+                const cppType = cppTypeForHalOp(part.expression.operation.operation);
+                if (cppType === "const char*" || (cppType !== undefined && /char\s*\*$/.test(cppType))) {
+                    formatString += "%s";
+                    args.push(argText);
+                    estimatedLength += 32;
+                }
+                else if (cppType === "bool") {
+                    formatString += "%s";
+                    args.push(`(${argText} ? "true" : "false")`);
+                    estimatedLength += 5;
                 }
                 else {
                     formatString += "%d";
-                    args.push(text);
+                    args.push(argText);
                     estimatedLength += 12;
                 }
             }

package/dist/ir/hal/hal-parser.d.ts

@@ -50,6 +50,12 @@ export declare function extractMethods(cls: ts.ClassDeclaration): Map<string, HA
 export declare function loadHALModules(force?: boolean): void;
 /** Get constructor includes for a HAL class. */
 export declare function getCtorIncludes(className: string): string[];
+/** Map an HttpClass factory method name to its HTTP verb, or null. */
+export declare function httpFactoryVerb(methodName: string): string | null;
+/** Render an Http factory URL argument as C++ expression text (string
+ *  literals quoted, identifiers/member accesses verbatim), or null when the
+ *  argument shape can't be resolved at compile time. */
+export declare function httpUrlArgText(arg: ts.Expression): string | null;
 /** Resolve a call receiver to a tracked HAL instance. */
 export declare function resolveHALReceiver(receiver: ts.Expression): HALInstance | null;
 /** Build field values from constructor arguments using the field mapping.

package/dist/ir/hal/hal-parser.js

@@ -210,6 +210,30 @@ export function loadHALModules(force = false) {
 export function getCtorIncludes(className) {
     return halCtorIncludes.get(className) ?? [];
 }
+/** Map an HttpClass factory method name to its HTTP verb, or null. */
+export function httpFactoryVerb(methodName) {
+    switch (methodName) {
+        case "get": return "GET";
+        case "post": return "POST";
+        case "put": return "PUT";
+        case "del": return "DELETE";
+        case "head": return "HEAD";
+        case "patch": return "PATCH";
+        default: return null;
+    }
+}
+/** Render an Http factory URL argument as C++ expression text (string
+ *  literals quoted, identifiers/member accesses verbatim), or null when the
+ *  argument shape can't be resolved at compile time. */
+export function httpUrlArgText(arg) {
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg))
+        return JSON.stringify(arg.text);
+    if (ts.isIdentifier(arg))
+        return arg.text;
+    if (ts.isPropertyAccessExpression(arg))
+        return arg.getText();
+    return null;
+}
 /** Resolve a call receiver to a tracked HAL instance. */
 export function resolveHALReceiver(receiver) {
     const result = (() => {
@@ -336,6 +360,51 @@ export function resolveHALReceiver(receiver) {
                         return { className: "ToneChain", fieldValues };
                     }
                 }
+                // Specialized handling for Http factory chaining
+                // (Http.get(url).header(...).send()): the factory records the HTTP
+                // verb and URL into the HttpRequest instance so send() can resolve
+                // this._method / this._url.
+                if (innerInstance.className === "HttpClass") {
+                    const verb = httpFactoryVerb(methodName);
+                    if (verb && receiver.arguments.length > 0) {
+                        const urlText = httpUrlArgText(receiver.arguments[0]);
+                        if (urlText) {
+                            return {
+                                className: "HttpRequest",
+                                fieldValues: new Map([["_method", verb], ["_url", urlText]]),
+                            };
+                        }
+                    }
+                }
+                // Specialized handling for BLE factory chaining
+                // (Ble.server(name).characteristic(uuid,type,perms).onRead(handler)):
+                // server() creates a BleServer with _name, _charCount from a global
+                // counter (persists across separate server() calls so multi-char
+                // servers get unique indices), _svcCount=1.
+                // characteristic() reads _charCount for the add_char call,
+                // then sets _lastChar=_charCount and increments _charCount so the next
+                // characteristic gets the next slot. onRead/onWrite read _lastChar.
+                if (innerInstance.className === "BleClass" && methodName === "server" && receiver.arguments.length > 0) {
+                    const nameText = httpUrlArgText(receiver.arguments[0]);
+                    if (nameText) {
+                        return {
+                            className: "BleServer",
+                            fieldValues: new Map([["_name", nameText], ["_charCount", "0"], ["_lastChar", "0"], ["_svcCount", "1"]]),
+                        };
+                    }
+                }
+                if (innerInstance.className === "BleServer" && methodName === "characteristic") {
+                    // characteristic(uuid, type, perms) returns this (BleServer).
+                    // The C++ shim auto-assigns the char index at runtime via
+                    // __tc_ble.current_char, so the resolver doesn't need to track indices.
+                    return innerInstance;
+                }
+                if (innerInstance.className === "BleServer" && methodName === "service") {
+                    // service() returns this (BleServer); advance the service counter.
+                    const svc = Number(innerInstance.fieldValues.get("_svcCount") ?? "1") + 1;
+                    innerInstance.fieldValues.set("_svcCount", String(svc));
+                    return innerInstance;
+                }
                 // General fallback: if the method is known to return another HAL class, carry over fields
                 const classEntry = halClassRegistry.get(innerInstance.className);
                 const methodEntry = classEntry?.methods.get(methodName);
@@ -345,6 +414,11 @@ export function resolveHALReceiver(receiver) {
                         return { className: returnClassName, fieldValues: new Map(innerInstance.fieldValues) };
                     }
                 }
+                // Fluent `this`-returning methods (e.g. HttpRequest.header/timeout):
+                // the chain result is the same instance, so keep resolving through it.
+                if (methodEntry && methodEntry.methodNode.type && methodEntry.methodNode.type.kind === ts.SyntaxKind.ThisType) {
+                    return innerInstance;
+                }
             }
         }
         // Inline new expression: new Pin(x).method()