c-next 0.2.3 → 0.2.4

package/src/transpiler/output/codegen/__tests__/RequireInclude.test.ts

@@ -20,7 +20,9 @@ describe("CodeGenerator requireInclude", () => {
     it("includes stdint.h for u8 type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("u8 value <- 0;");
+      const result = (
+        await transpiler.transpile({ kind: "source", source: "u8 value <- 0;" })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdint.h>");
@@ -29,7 +31,12 @@ describe("CodeGenerator requireInclude", () => {
     it("includes stdint.h for u16 type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("u16 value <- 0;");
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: "u16 value <- 0;",
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdint.h>");
@@ -38,7 +45,12 @@ describe("CodeGenerator requireInclude", () => {
     it("includes stdint.h for u32 type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("u32 value <- 0;");
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: "u32 value <- 0;",
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdint.h>");
@@ -47,7 +59,12 @@ describe("CodeGenerator requireInclude", () => {
     it("includes stdint.h for i32 type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("i32 value <- 0;");
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: "i32 value <- 0;",
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdint.h>");
@@ -56,14 +73,19 @@ describe("CodeGenerator requireInclude", () => {
     it("includes stdint.h for bitmap types", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(`
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: `
         bitmap8 Flags {
           enabled,
           active,
           reserved[6]
         }
         Flags f <- 0;
-      `);
+      `,
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdint.h>");
@@ -74,7 +96,12 @@ describe("CodeGenerator requireInclude", () => {
     it("includes stdbool.h for bool type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("bool flag <- false;");
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: "bool flag <- false;",
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdbool.h>");
@@ -85,9 +112,12 @@ describe("CodeGenerator requireInclude", () => {
     it("includes string.h for bounded string type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(
-        'string<32> name <- "test";',
-      );
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: 'string<32> name <- "test";',
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <string.h>");
@@ -96,9 +126,12 @@ describe("CodeGenerator requireInclude", () => {
     it("includes string.h for const string inference", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(
-        'const string message <- "hello";',
-      );
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: 'const string message <- "hello";',
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <string.h>");
@@ -109,7 +142,12 @@ describe("CodeGenerator requireInclude", () => {
     it("generates ISR typedef for ISR type", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("ISR handler <- null;");
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: "ISR handler <- null;",
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("typedef void (*ISR)(void)");
@@ -120,13 +158,18 @@ describe("CodeGenerator requireInclude", () => {
     it("generates static assert for float bit indexing write", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(`
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: `
         f32 setByte(u8 b) {
           f32 value <- 0.0;
           value[0, 8] <- b;
           return value;
         }
-      `);
+      `,
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("_Static_assert");
@@ -136,12 +179,17 @@ describe("CodeGenerator requireInclude", () => {
     it("generates static assert for float bit indexing read (no string.h)", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(`
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: `
         u8 getByte() {
           f32 value <- 1.0;
           return value[0, 8];
         }
-      `);
+      `,
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("_Static_assert");
@@ -155,11 +203,16 @@ describe("CodeGenerator requireInclude", () => {
     it("includes limits.h for float-to-int clamp cast", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(`
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: `
         i32 convert(f32 value) {
           return (i32)value;
         }
-      `);
+      `,
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <limits.h>");
@@ -170,11 +223,16 @@ describe("CodeGenerator requireInclude", () => {
     it("includes multiple headers when needed", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource(`
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: `
         bool check(u32 value, string<16> name) {
           return value > 0;
         }
-      `);
+      `,
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("#include <stdint.h>");
@@ -185,7 +243,12 @@ describe("CodeGenerator requireInclude", () => {
     it("does not include unused headers", async () => {
       const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
 
-      const result = await transpiler.transpileSource("void doNothing() { }");
+      const result = (
+        await transpiler.transpile({
+          kind: "source",
+          source: "void doNothing() { }",
+        })
+      ).files[0];
 
       expect(result.success).toBe(true);
       expect(result.code).not.toContain("#include <stdint.h>");

package/src/transpiler/output/codegen/__tests__/TrackVariableTypeHelpers.test.ts

@@ -12,7 +12,9 @@ import Transpiler from "../../../Transpiler";
  */
 async function transpileSource(source: string): Promise<string> {
   const transpiler = new Transpiler({ inputs: [] });
-  const result = await transpiler.transpileSource(source);
+  const result = (
+    await transpiler.transpile({ kind: "source", source: source })
+  ).files[0];
   if (result.errors && result.errors.length > 0) {
     throw new Error(
       `Transpile failed: ${result.errors.map((e) => e.message).join(", ")}`,

package/src/transpiler/output/codegen/__tests__/TypeValidator.test.ts

@@ -1820,7 +1820,7 @@ describe("TypeValidator", () => {
   // Tests - Do-While Validation (ADR-027)
   // ========================================================================
 
-  describe("validateDoWhileCondition", () => {
+  describe("validateConditionIsBoolean", () => {
     function createFullDoWhileExpression(
       text: string,
       options?: {
@@ -1874,36 +1874,44 @@ describe("TypeValidator", () => {
       const ctx = createFullDoWhileExpression("x < 10", {
         hasRelational: true,
       });
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("allows conditions with equality operators", () => {
       setupState();
       const ctx = createFullDoWhileExpression("x = 0", { hasEquality: true });
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("allows conditions with && operator", () => {
       setupState();
       const ctx = createFullDoWhileExpression("a && b", { hasAnd: true });
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("allows conditions with || operator", () => {
       setupState();
       const ctx = createFullDoWhileExpression("a || b", { hasOr: true });
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("throws for bare value condition", () => {
       setupState();
       const ctx = createFullDoWhileExpression("count");
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "E0701",
-      );
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "do-while condition must be a boolean expression",
-      );
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("do-while condition must be a boolean expression");
     });
 
     it("throws for ternary in do-while condition", () => {
@@ -1914,9 +1922,9 @@ describe("TypeValidator", () => {
           orExpression: () => [{}, {}], // Multiple orExpressions = ternary
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "E0701",
-      );
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
     });
 
     it("allows boolean literals", () => {
@@ -1948,7 +1956,9 @@ describe("TypeValidator", () => {
           orExpression: antlrArray([orExpr]),
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("allows negation expressions", () => {
@@ -1979,7 +1989,9 @@ describe("TypeValidator", () => {
           orExpression: antlrArray([orExpr]),
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("allows bool type variables", () => {
@@ -2016,15 +2028,17 @@ describe("TypeValidator", () => {
           orExpression: antlrArray([orExpr]),
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).not.toThrow();
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).not.toThrow();
     });
 
     it("shows help message in error", () => {
       setupState();
       const ctx = createFullDoWhileExpression("count");
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "help: use explicit comparison: count > 0 or count != 0",
-      );
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("help: use explicit comparison: count > 0 or count != 0");
     });
 
     it("throws when no andExpression", () => {
@@ -2039,9 +2053,9 @@ describe("TypeValidator", () => {
           orExpression: antlrArray([orExpr]),
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "E0701",
-      );
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
     });
 
     it("throws when no equalityExpression", () => {
@@ -2059,9 +2073,9 @@ describe("TypeValidator", () => {
           orExpression: antlrArray([orExpr]),
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "E0701",
-      );
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
     });
 
     it("throws when no relationalExpression", () => {
@@ -2082,9 +2096,9 @@ describe("TypeValidator", () => {
           orExpression: antlrArray([orExpr]),
         }),
       } as unknown as Parser.ExpressionContext;
-      expect(() => TypeValidator.validateDoWhileCondition(ctx)).toThrow(
-        "E0701",
-      );
+      expect(() =>
+        TypeValidator.validateConditionIsBoolean(ctx, "do-while"),
+      ).toThrow("E0701");
     });
   });
 

package/src/transpiler/output/codegen/generators/IOrchestrator.ts

@@ -208,8 +208,11 @@ interface IOrchestrator {
     switchExpr: Parser.ExpressionContext,
   ): void;
 
-  /** Validate do-while condition (ADR-027) */
-  validateDoWhileCondition(ctx: Parser.ExpressionContext): void;
+  /** Validate condition is a boolean expression (ADR-027, Issue #884) */
+  validateConditionIsBoolean(
+    ctx: Parser.ExpressionContext,
+    conditionType: string,
+  ): void;
 
   /** Validate no function calls in condition (Issue #254, E0702) */
   validateConditionNoFunctionCall(

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -200,7 +200,7 @@ function createMockOrchestrator(overrides?: {
     indent: vi.fn((text) => text),
     validateNoEarlyExits: vi.fn(),
     validateSwitchStatement: vi.fn(),
-    validateDoWhileCondition: vi.fn(),
+    validateConditionIsBoolean: vi.fn(),
     validateConditionNoFunctionCall: vi.fn(),
     validateTernaryConditionNoFunctionCall: vi.fn(),
     generateAssignmentTarget: vi.fn(),

package/src/transpiler/output/codegen/generators/statements/ControlFlowGenerator.ts

@@ -118,6 +118,9 @@ const generateIf = (
   // Issue #254: Validate no function calls in condition (E0702)
   orchestrator.validateConditionNoFunctionCall(node.expression(), "if");
 
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(node.expression(), "if");
+
   // Generate with cache enabled
   const condition = orchestrator.generateExpression(node.expression());
 
@@ -161,6 +164,9 @@ const generateWhile = (
   // Issue #254: Validate no function calls in condition (E0702)
   orchestrator.validateConditionNoFunctionCall(node.expression(), "while");
 
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(node.expression(), "while");
+
   const condition = orchestrator.generateExpression(node.expression());
 
   // Issue #250: Flush any temp vars from condition BEFORE generating body
@@ -189,12 +195,12 @@ const generateDoWhile = (
 ): IGeneratorOutput => {
   const effects: TGeneratorEffect[] = [];
 
-  // Validate the condition is a boolean expression (E0701)
-  orchestrator.validateDoWhileCondition(node.expression());
-
   // Issue #254: Validate no function calls in condition (E0702)
   orchestrator.validateConditionNoFunctionCall(node.expression(), "do-while");
 
+  // Issue #884: Validate condition is a boolean expression (E0701)
+  orchestrator.validateConditionIsBoolean(node.expression(), "do-while");
+
   const body = orchestrator.generateBlock(node.block());
   const condition = orchestrator.generateExpression(node.expression());
 
@@ -311,6 +317,9 @@ const generateFor = (
   if (node.expression()) {
     // Issue #254: Validate no function calls in condition (E0702)
     orchestrator.validateConditionNoFunctionCall(node.expression()!, "for");
+
+    // Issue #884: Validate condition is a boolean expression (E0701)
+    orchestrator.validateConditionIsBoolean(node.expression()!, "for");
     condition = orchestrator.generateExpression(node.expression()!);
   }
 

package/src/transpiler/output/codegen/generators/statements/__tests__/ControlFlowGenerator.test.ts

@@ -364,7 +364,7 @@ function createMockOrchestrator(options?: {
     registerLocalVariable: vi.fn(),
     flushPendingTempDeclarations: vi.fn(() => options?.tempDeclarations ?? ""),
     validateConditionNoFunctionCall: vi.fn(),
-    validateDoWhileCondition: vi.fn(),
+    validateConditionIsBoolean: vi.fn(),
     countStringLengthAccesses: vi.fn(() => new Map()),
     countBlockLengthAccesses: vi.fn(),
     setupLengthCache: vi.fn(() => options?.lengthCacheDecls ?? ""),
@@ -690,15 +690,15 @@ describe("ControlFlowGenerator", () => {
       const ctx = createMockDoWhileStatement({ expr });
       const input = createMockInput();
       const state = createMockState();
-      const validateDoWhileCondition = vi.fn();
+      const validateConditionIsBoolean = vi.fn();
       const orchestrator = {
         ...createMockOrchestrator(),
-        validateDoWhileCondition,
+        validateConditionIsBoolean,
       } as unknown as IOrchestrator;
 
       generateDoWhile(ctx, input, state, orchestrator);
 
-      expect(validateDoWhileCondition).toHaveBeenCalledWith(expr);
+      expect(validateConditionIsBoolean).toHaveBeenCalledWith(expr, "do-while");
     });
 
     it("validates no function calls in condition (Issue #254)", () => {

package/src/transpiler/output/codegen/helpers/FunctionContextManager.ts

@@ -149,12 +149,20 @@ class FunctionContextManager {
       callbacks,
     );
 
+    // For callback-compatible functions, struct params use by-value semantics
+    // (no pointer dereference, dot access instead of arrow in C mode)
+    const isCallbackCompat =
+      CodeGenState.currentFunctionName !== null &&
+      CodeGenState.callbackCompatibleFunctions.has(
+        CodeGenState.currentFunctionName,
+      );
+
     // Register in currentParameters
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: typeInfo.isStruct,
+      isStruct: isCallbackCompat ? false : typeInfo.isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString,

package/src/transpiler/output/headers/HeaderGeneratorUtils.ts

@@ -284,9 +284,12 @@ class HeaderGeneratorUtils {
       }
     }
 
-    // External type header includes
+    // External type header includes (skip duplicates of user includes)
+    const userIncludeSet = new Set(options.userIncludes ?? []);
     for (const directive of headersToInclude) {
-      lines.push(directive);
+      if (!userIncludeSet.has(directive)) {
+        lines.push(directive);
+      }
     }
 
     // Add blank line if any includes were added

package/src/transpiler/state/CodeGenState.ts

@@ -128,6 +128,9 @@ export default class CodeGenState {
   /** Callback field types: "Struct.field" -> callbackTypeName */
   static callbackFieldTypes: Map<string, string> = new Map();
 
+  /** Functions that need C-callback-compatible (by-value) struct parameters */
+  static callbackCompatibleFunctions: Set<string> = new Set();
+
   // ===========================================================================
   // PASS-BY-VALUE ANALYSIS (Issue #269)
   // ===========================================================================
@@ -324,6 +327,9 @@ export default class CodeGenState {
     this.functionSignatures = new Map();
     this.callbackTypes = new Map();
     this.callbackFieldTypes = new Map();
+    // Note: callbackCompatibleFunctions is NOT reset here — it's populated by
+    // FunctionCallAnalyzer (which runs before CodeGenerator.generate()) and must
+    // persist into code generation. It is cleared at the start of each Transpiler run.
 
     // Pass-by-value analysis
     this.modifiedParameters = new Map();

package/src/transpiler/types/IPipelineFile.ts

@@ -3,8 +3,8 @@ import IDiscoveredFile from "../data/types/IDiscoveredFile";
 /**
  * A file descriptor for the unified transpilation pipeline.
  *
- * Supports both disk-based files (from run()) and in-memory sources
- * (from transpileSource()). The pipeline reads content via:
+ * Supports both disk-based files (kind: 'files') and in-memory sources
+ * (kind: 'source'). The pipeline reads content via:
  *   file.source ?? this.fs.readFile(file.path)
  */
 interface IPipelineFile {

package/src/transpiler/types/IPipelineInput.ts

@@ -4,7 +4,7 @@ import IPipelineFile from "./IPipelineFile";
 /**
  * Input to the unified transpilation pipeline (_executePipeline).
  *
- * Both run() and transpileSource() construct this and delegate to the pipeline.
+ * transpile() constructs this via discoverIncludes() and delegates to the pipeline.
  */
 interface IPipelineInput {
   /** C-Next files to process (in dependency order) */

package/src/transpiler/types/TTranspileInput.ts

@@ -0,0 +1,18 @@
+/**
+ * Input to the unified transpile() method.
+ *
+ * Discriminated union:
+ * - { kind: 'files' } — CLI mode, discovers from config.inputs, writes to disk
+ * - { kind: 'source', ... } — API mode, in-memory source, returns results as strings
+ */
+type TTranspileInput =
+  | { readonly kind: "files" }
+  | {
+      readonly kind: "source";
+      readonly source: string;
+      readonly workingDir?: string;
+      readonly includeDirs?: string[];
+      readonly sourcePath?: string;
+    };
+
+export default TTranspileInput;

package/src/utils/constants/TypeConstants.ts

@@ -20,6 +20,28 @@ class TypeConstants {
     "float",
     "double",
   ];
+
+  /**
+   * Unsigned integer types valid as array/bit subscript indexes.
+   *
+   * Used by:
+   * - ArrayIndexTypeAnalyzer: validating subscript index types
+   */
+  static readonly UNSIGNED_INDEX_TYPES: readonly string[] = [
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "bool",
+  ];
+
+  /**
+   * Signed integer types (rejected as subscript indexes).
+   *
+   * Used by:
+   * - ArrayIndexTypeAnalyzer: detecting signed integer subscript indexes
+   */
+  static readonly SIGNED_TYPES: readonly string[] = ["i8", "i16", "i32", "i64"];
 }
 
 export default TypeConstants;