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

package/dist/emit/emitters/function-emitter-impl.js

@@ -5,6 +5,7 @@ import { escapeCppKeyword } from "../../utils/strings.js";
 import { parsedIsPlainStructType } from "../../api/shared/cpp-type-ir.js";
 import { entryHasUI } from "../../ui-hook.js";
 import { activeNamespaceNames } from "../../ir/build-ir-state.js";
+import { buildCoopSchedInjection } from "../../api/shared/coop-scheduler.js";
 export function emitPostClassDeclarations(ctx) {
     const { strategy, effectiveEmitMode, mappedFunctions, isEntryFile, topLevelScope } = ctx;
     const platformReservedNames = strategy.reservedNames();
@@ -31,6 +32,12 @@ export function emitPostClassDeclarations(ctx) {
     if (ctx.promotedVarDecls.size > 0) {
         for (const [varName, info] of ctx.promotedVarDecls) {
             appendSourceLine(ctx, `${info.cppType} ${escapeCppKeyword(varName, platformReservedNames)} = {};`);
+            // Seed the top-level scope's type map so subsequent assign rendering
+            // (e.g. the deferred `c = SafeInt(0)` initializer) can resolve the
+            // variable's type and inject template args / casts via
+            // renderValueForTarget. Without this, type-aware rendering of promoted
+            // vars is unreachable (inferLvalueCppType returns undefined).
+            ctx.topLevelScope.knownVariableTypes.set(varName, { cppType: info.cppType });
         }
         appendSourceLine(ctx, "");
     }
@@ -62,7 +69,7 @@ export function emitPostClassDeclarations(ctx) {
             // Still register the field types so downstream rendering (e.g. string-concat
             // wrapping via interfaceFieldTypes) can resolve property accesses on the var.
             const fieldTypeEntries = statement.initializer.fields.map((field) => {
-                const inferred = inferObjectFieldType(field.value, ctx.globalPointerVarTypes, ctx.knownFunctionReturnTypes, ctx.knownTopLevelObjectTypes, ctx.knownTopLevelObjectFields, ctx.largeEnumNames, statement.name, field.name, strategy.defaultNumericType(), (o, n) => strategy.resolvePinType?.(o, n));
+                const inferred = inferObjectFieldType(field.value, ctx.globalPointerVarTypes, ctx.knownFunctionReturnTypes, ctx.knownTopLevelObjectTypes, ctx.knownTopLevelObjectFields, ctx.largeEnumNames, statement.name, field.name, strategy.defaultNumericType(ctx.compliance.isEnabled() ? ctx.compliance : undefined), (o, n) => strategy.resolvePinType?.(o, n));
                 return [field.name, inferred];
             });
             if (hasExplicitNamedType) {
@@ -240,6 +247,29 @@ export function emitFunctions(ctx) {
             ctx.sourceMapEntries = ctx.headerMapEntries;
             ctx.headerMapEntries = _swapMaps;
         }
+        // Cooperative scheduler trampolines (Phase 0).
+        //
+        // When the strategy opts into priority/time-budget scheduling, the driver
+        // function's per-frame pumps are routed through the no-STL CoopSched. The
+        // trampolines (file-scope `static void __tc_coop_*(void*)`) must appear
+        // before the driver function definition so CoopSched can call them; they
+        // reference only global/static names (task instances, pump functions) so
+        // no captures are needed. Emitted once, ahead of the driver only.
+        const asyncDriverFnForTrampolines = strategy.asyncDriverFunctionName();
+        if (fn.name === asyncDriverFnForTrampolines &&
+            (hasPromiseRuntime || asyncTaskClasses.length > 0 || usesTimers)) {
+            const coopConfig = strategy.getAsyncRuntimeConfig();
+            if (coopConfig.enablePriority || coopConfig.enableTimeBudget) {
+                const coopUnits = buildDriverCoopUnits(asyncTaskClasses.map(t => t.taskVarName), hasPromiseRuntime, usesTimers);
+                if (coopUnits.length > 0) {
+                    const { trampolines } = buildCoopSchedInjection(coopUnits);
+                    appendSourceLine(ctx, "// ── CoopSched trampolines (priority/time-budget scheduling) ──");
+                    for (const t of trampolines)
+                        appendSourceLine(ctx, t);
+                    appendSourceLine(ctx, "");
+                }
+            }
+        }
         emitCommentLines(fn.leadingComments, "", (line) => appendSourceLine(ctx, line));
         if (fn.typeParameters && fn.typeParameters.length > 0) {
             appendSourceLine(ctx, `template<typename ${fn.typeParameters.join(", typename ")}>`);
@@ -286,12 +316,12 @@ export function emitFunctions(ctx) {
                 appendSourceLine(ctx, `  while (${loop.continueCondition}) {`);
                 appendSourceLine(ctx, `    ${loop.preIteration}`);
             }
-            appendSourceLine(ctx, `  uint32_t __tc_ui_now = (uint32_t)${strategy.currentTimeMillis()};`);
+            appendSourceLine(ctx, `  uint32_t __tc_ui_now = static_cast<uint32_t>(${strategy.currentTimeMillis()});`);
             appendSourceLine(ctx, "  static uint32_t __tc_ui_last_tick = __tc_ui_now;");
             appendSourceLine(ctx, "  uint32_t __tc_ui_delta = __tc_ui_now - __tc_ui_last_tick;");
             appendSourceLine(ctx, "  __tc_ui_last_tick = __tc_ui_now;");
             appendSourceLine(ctx, "  if (__tc_ui_delta > 250) __tc_ui_delta = 250;");
-            appendSourceLine(ctx, "  ui_tick((uint16_t)__tc_ui_delta);");
+            appendSourceLine(ctx, "  ui_tick(static_cast<uint16_t>(__tc_ui_delta));");
             if (loop) {
                 appendSourceLine(ctx, `    ${loop.postIteration}`);
                 appendSourceLine(ctx, `  }`);
@@ -302,9 +332,30 @@ export function emitFunctions(ctx) {
             const asyncConfig = strategy.getAsyncRuntimeConfig();
             asyncConfig.hasPromiseRuntime = hasPromiseRuntime;
             asyncConfig.hasTimers = usesTimers;
-            const injectionLines = strategy.asyncLoopInjection(taskNames, asyncConfig);
-            for (const line of injectionLines) {
-                appendSourceLine(ctx, `  ${line}`);
+            // Cooperative scheduler path (Phase 0): when opted in, replace the flat
+            // per-frame pump sequence with a single CoopSched dispatch. The work
+            // units mirror exactly what the strategy's asyncLoopInjection() would
+            // have emitted (so Zephyr, which omits the microtask pump, still omits
+            // it), but they are dispatched in priority order and budget-bounded.
+            if (asyncConfig.enablePriority || asyncConfig.enableTimeBudget) {
+                const coopUnits = buildDriverCoopUnits(taskNames, hasPromiseRuntime, usesTimers);
+                if (coopUnits.length > 0) {
+                    const { injection } = buildCoopSchedInjection(coopUnits);
+                    for (const line of injection)
+                        appendSourceLine(ctx, line);
+                }
+                else {
+                    // No work units: fall back to the strategy's own injection.
+                    const injectionLines = strategy.asyncLoopInjection(taskNames, asyncConfig);
+                    for (const line of injectionLines)
+                        appendSourceLine(ctx, `  ${line}`);
+                }
+            }
+            else {
+                const injectionLines = strategy.asyncLoopInjection(taskNames, asyncConfig);
+                for (const line of injectionLines) {
+                    appendSourceLine(ctx, `  ${line}`);
+                }
             }
         }
         if (isLoopDriver && lastIsReturn) {
@@ -436,3 +487,42 @@ export function emitFunctionForwardDeclarations(ctx) {
         appendSourceLine(ctx, "");
     }
 }
+/**
+ * Build the CoopSched work units for the driver function's per-frame pumps.
+ *
+ * The units mirror what a strategy's asyncLoopInjection() emits as a flat
+ * sequence, so the cooperative scheduler preserves each strategy's decisions
+ * about WHICH pumps run (e.g. Zephyr omits the std::function microtask pump
+ * because its async path is state-machine-based). Default priorities:
+ *   - async task .run()        → priority 1 (latency-sensitive: drives awaits)
+ *   - microtask pump           → priority 1 (continuations of resolved promises)
+ *   - cooperative timer pump   → priority 0 (less latency-critical)
+ * Both are tunable via AsyncRuntimeConfig.schedulerPriorities; the scheduler
+ * bucket-walks from the highest level down to 0.
+ */
+function buildDriverCoopUnits(taskVarNames, hasPromiseRuntime, hasTimers) {
+    const units = [];
+    let taskIdx = 0;
+    for (const name of taskVarNames) {
+        units.push({
+            name: `task_${taskIdx++}`,
+            body: `${name}.run();`,
+            priority: 1,
+        });
+    }
+    if (hasPromiseRuntime) {
+        units.push({
+            name: "microtasks",
+            body: "cuttlefish_pump_microtasks();",
+            priority: 1,
+        });
+    }
+    if (hasTimers) {
+        units.push({
+            name: "timers",
+            body: "__tc_timer_runtime.run();",
+            priority: 0,
+        });
+    }
+    return units;
+}

package/dist/emit/emitters/line-appender.js

@@ -1,7 +1,17 @@
 import { cloneEmissionScopeState, recordVariableType } from "../snprintf-helpers.js";
 import { emitCommentLines } from "../utils/index.js";
 import { escapeCppKeyword } from "../../utils/strings.js";
+import { formatLinemarker, shouldEmitMarker, sourceKey } from "./line-marker.js";
 export function appendSourceLine(ctx, line, entry) {
+    // GDB debug mode: emit a linemarker before lines whose source span transitions.
+    // Runs only when an entry is present (raw braces/whitespace carry no span).
+    if (ctx.debugMode === 'gdb' && entry) {
+        const next = sourceKey(entry.tsSpan);
+        if (shouldEmitMarker(ctx.lastEmittedSource, next)) {
+            ctx.sourceLines.push(formatLinemarker(entry.tsSpan.filePath, entry.tsSpan.startLine));
+        }
+        ctx.lastEmittedSource = next;
+    }
     ctx.sourceLines.push(line);
     if (!entry)
         return;
@@ -17,6 +27,15 @@ export function appendSourceLine(ctx, line, entry) {
     });
 }
 export function appendHeaderLine(ctx, line, entry) {
+    // GDB debug mode: same transition logic as appendSourceLine, against the
+    // shared lastEmittedSource slot. See line-marker.ts for rationale.
+    if (ctx.debugMode === 'gdb' && entry) {
+        const next = sourceKey(entry.tsSpan);
+        if (shouldEmitMarker(ctx.lastEmittedSource, next)) {
+            ctx.headerLines.push(formatLinemarker(entry.tsSpan.filePath, entry.tsSpan.startLine));
+        }
+        ctx.lastEmittedSource = next;
+    }
     ctx.headerLines.push(line);
     if (!entry)
         return;

package/dist/emit/emitters/line-marker.d.ts

@@ -0,0 +1,38 @@
+import type { SourceSpan } from '../../types.js';
+/**
+ * A previously-emitted source location, used for transition detection so we
+ * emit a linemarker only when the source file or line actually changes.
+ */
+export interface EmittedSource {
+    filePath: string;
+    /** 0-based source line (matches SourceSpan.startLine). */
+    line: number;
+}
+/**
+ * Format a GCC linemarker for the given path and 0-based source line.
+ * Output form: `# <line+1> "<path>"`.
+ *
+ * The path is normalized to forward slashes (Windows backslashes break GDB
+ * source resolution from the ESP-IDF build directory) and resolved to an
+ * absolute path so GDB finds the .ts file regardless of its cwd.
+ *
+ * GCC accepts both `#line N "F"` and the linemarker form `# N "F"`; we use
+ * the latter because it's what GCC emits in preprocessed output and it flows
+ * cleanly into DWARF.
+ */
+export declare function formatLinemarker(filePath: string, line: number): string;
+/**
+ * Decide whether a linemarker should be emitted before the next source line,
+ * given the previously-emitted marker (or null for the first one).
+ *
+ * Returns true only on file or line transition — this keeps the emitted C++
+ * clean (one marker per source-span change, not per emitted C++ line, which
+ * would be noisy and slow).
+ */
+export declare function shouldEmitMarker(prev: EmittedSource | null, next: EmittedSource): boolean;
+/**
+ * Extract the {filePath, line} for transition tracking from a SourceSpan.
+ * SourceSpan.startLine is 0-based; kept 0-based here so shouldEmitMarker
+ * compares apples to apples (formatLinemarker does the +1 at format time).
+ */
+export declare function sourceKey(span: SourceSpan): EmittedSource;

package/dist/emit/emitters/line-marker.js

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+/**
+ * Format a GCC linemarker for the given path and 0-based source line.
+ * Output form: `# <line+1> "<path>"`.
+ *
+ * The path is normalized to forward slashes (Windows backslashes break GDB
+ * source resolution from the ESP-IDF build directory) and resolved to an
+ * absolute path so GDB finds the .ts file regardless of its cwd.
+ *
+ * GCC accepts both `#line N "F"` and the linemarker form `# N "F"`; we use
+ * the latter because it's what GCC emits in preprocessed output and it flows
+ * cleanly into DWARF.
+ */
+export function formatLinemarker(filePath, line) {
+    const absolute = resolve(filePath);
+    const normalized = absolute.split(/[\\/]/).join('/');
+    return `# ${line + 1} "${normalized}"`;
+}
+/**
+ * Decide whether a linemarker should be emitted before the next source line,
+ * given the previously-emitted marker (or null for the first one).
+ *
+ * Returns true only on file or line transition — this keeps the emitted C++
+ * clean (one marker per source-span change, not per emitted C++ line, which
+ * would be noisy and slow).
+ */
+export function shouldEmitMarker(prev, next) {
+    if (prev === null)
+        return true;
+    return prev.filePath !== next.filePath || prev.line !== next.line;
+}
+/**
+ * Extract the {filePath, line} for transition tracking from a SourceSpan.
+ * SourceSpan.startLine is 0-based; kept 0-based here so shouldEmitMarker
+ * compares apples to apples (formatLinemarker does the +1 at format time).
+ */
+export function sourceKey(span) {
+    return { filePath: span.filePath, line: span.startLine };
+}

package/dist/emit/emitters/output-finalizer.js

@@ -1,8 +1,11 @@
 import path from "node:path";
-import { writeText } from "../../utils/fs.js";
+import { writeText, readText } from "../../utils/fs.js";
 import { makeGeneratedMap, writeSourceMap } from "../../mapping/source-map.js";
 import { dedupe, hasConsoleCalls, resolveTranspiledModuleInclude } from "../utils/index.js";
 import { appendHeaderLine } from "./line-appender.js";
+import { runSelfCheck } from "../compliance/rule-engine.js";
+import { renderRegistryJson } from "../compliance/deviation-writer.js";
+import { renderArxml } from "../compliance/arxml-writer.js";
 /** Derives a unique C preprocessor guard name from a source file path. */
 function sanitizeGuardName(filePath) {
     // Use the basename minus extension, uppercased, with non-alphanumeric
@@ -262,6 +265,82 @@ export function finalizeOutput(ctx) {
         : undefined;
     const diagnostics = [...program.diagnostics, ...ctx.profileDiagnostics, ...ctx.emitDiagnostics];
     diagnostics.push(...strategy.emitDiagnostics(options.emitMode));
+    // ── AUTOSAR compliance self-check + sidecar ────────────────────────────
+    // Runs only when --autosar is warn or strict. Emits an AUTOSAR_<ruleId>
+    // diagnostic per finding (severity: error for required unrecorded
+    // violations in strict mode, otherwise warning) and writes the sidecar
+    // deviation registry next to the emitted artifact.
+    if (ctx.compliance.isEnabled()) {
+        // Scan the ACTUAL file content (post-writeText) rather than ctx.sourceLines,
+        // because some ctx.sourceLines entries contain embedded newlines (e.g. ESP32
+        // shim blocks pushed as multi-line strings), making array indices != file
+        // line numbers. Reading the written file gives correct 1:1 line numbers.
+        const actualSourceLines = outputHeaderPath
+            ? readText(sourcePath).split("\n")
+            : readText(sourcePath).split("\n");
+        const actualHeaderLines = outputHeaderPath
+            ? readText(outputHeaderPath).split("\n")
+            : [];
+        const findings = runSelfCheck(ctx.compliance, actualSourceLines, actualHeaderLines);
+        const mode = ctx.compliance.mode();
+        // Helper: map a C++ generated line back to its originating TS source
+        // line via the source map, so diagnostics point at the user's code.
+        const mapCppLineToTs = (cppLine) => {
+            // Find the source-map entry whose generated range covers cppLine.
+            // Entries are ordered by generatedStartLine; find the last one whose
+            // start is ≤ cppLine.
+            let best = null;
+            for (const entry of ctx.sourceMapEntries) {
+                if (entry.generatedStartLine <= cppLine) {
+                    if (!best || entry.generatedStartLine > best.generatedStartLine) {
+                        best = entry;
+                    }
+                }
+            }
+            if (best) {
+                return { filePath: best.tsSpan.filePath, line: best.tsSpan.startLine };
+            }
+            return null;
+        };
+        for (const f of findings) {
+            const isError = mode === "strict" &&
+                f.kind === "unrecorded-violation" &&
+                f.severity === "required";
+            // Map the C++ line back to TS so the diagnostic points at user code.
+            const tsLoc = mapCppLineToTs(f.line);
+            const emittedFile = f.file === "header" ? `${baseName}.h` : path.basename(sourcePath);
+            const cppRef = `${emittedFile}:${f.line}`;
+            const tsRef = tsLoc ? `${path.basename(tsLoc.filePath)}:${tsLoc.line}` : null;
+            const locationDesc = tsRef
+                ? `${tsRef} (emitted at ${cppRef})`
+                : cppRef;
+            const diag = {
+                severity: isError ? "error" : "warning",
+                code: `AUTOSAR_${f.ruleId}`,
+                message: `AUTOSAR ${f.ruleId} ${f.kind} at ${locationDesc}: ${f.snippet}`,
+                // Point the diagnostic at the TS source line (if mapped) so the
+                // CLI's file:line:col display is meaningful to the user. If the
+                // violation is in framework/runtime shim code with no TS origin,
+                // point at the emitted C++ artifact instead.
+                filePath: tsLoc?.filePath ?? sourcePath,
+                line: tsLoc?.line ?? f.line,
+                column: 1,
+            };
+            diagnostics.push(diag);
+        }
+        // Sidecar deviation registry — written for both warn and strict modes
+        // alongside the emitted artifact (mirrors how .thcppmap.json sits next
+        // to the .cpp/.ino today).
+        const toolVersion = options.toolVersion ?? "unknown";
+        const registryPath = path.join(outDir, `${baseName}.autosar-deviations.json`);
+        writeText(registryPath, renderRegistryJson(ctx.compliance, path.basename(sourcePath), toolVersion));
+        // Optional ARXML projection (Artop/DaVinci tooling). Gated behind
+        // --autosar-arxml so projects that don't need it pay no cost.
+        if (options.autosarArxml) {
+            const arxmlPath = path.join(outDir, `${baseName}.autosar-deviations.arxml`);
+            writeText(arxmlPath, renderArxml(ctx.compliance, path.basename(sourcePath)));
+        }
+    }
     return {
         headerPath: outputHeaderPath,
         sourcePath,

package/dist/emit/emitters/setup.d.ts

@@ -1,3 +1,20 @@
 import type { ProgramIR } from "../../api/index.js";
 import type { EmitterContext, EmitterOptions } from "./emitter-context.js";
+/**
+ * Detect whether a program uses @typecad/safety. The safety transform pass
+ * injects safety.* ops when in use; strategies consult this to decide
+ * whether to emit the __tc_gpio_read shim that the safety voter calls.
+ * Mirrors programUsesWdt() above (same inline walker pattern).
+ *
+ * `hal-expr` (the expression-position safety.read_safe lowering produced
+ * by `const r = safe.read(pin)`) lives in expression trees, not at statement
+ * level — but it's carried inside a var_decl statement whose initializer is
+ * the hal-expr, and the var_decl gets visited as a top-level statement. We
+ * detect both: statement-level `hal-op` operations, and any statement whose
+ * rendered initializer text mentions safety.* (a defensive catch for the
+ * hal-expr-in-initializer case). The latter is rarely needed because the
+ * voter's read_safe op is also captured at the call site, but kept for
+ * robustness.
+ */
+export declare function programUsesSafety(program: ProgramIR): boolean;
 export declare function buildEmitterContext(program: ProgramIR, options: EmitterOptions): EmitterContext;