c-next 0.2.3 → 0.2.5

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -118,7 +118,7 @@ import ISimpleIdentifierDeps from "./types/ISimpleIdentifierDeps";
 import IPostfixChainDeps from "./types/IPostfixChainDeps";
 import IPostfixOperation from "./types/IPostfixOperation";
 // Issue #707: Expression unwrapping utility for reducing duplication
-import ExpressionUnwrapper from "./utils/ExpressionUnwrapper";
+import ExpressionUnwrapper from "../../../utils/ExpressionUnwrapper";
 // Stateless parser utilities extracted from CodeGenerator
 import CodegenParserUtils from "./utils/CodegenParserUtils";
 import IMemberSeparatorDeps from "./types/IMemberSeparatorDeps";
@@ -140,6 +140,7 @@ import PassByValueAnalyzer from "../../logic/analysis/PassByValueAnalyzer";
 // Unified parameter generation (Phase 1)
 import ParameterInputAdapter from "./helpers/ParameterInputAdapter";
 import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
+// Issue #895: Parse typedef signatures to determine pointer vs value params
 // Extracted resolvers that use CodeGenState
 import SizeofResolver from "./resolution/SizeofResolver";
 import EnumTypeResolver from "./resolution/EnumTypeResolver";
@@ -1042,11 +1043,14 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   /**
-   * Validate do-while condition.
+   * Validate condition is a boolean expression (ADR-027, Issue #884).
    * Part of IOrchestrator interface (ADR-053 A3).
    */
-  validateDoWhileCondition(ctx: Parser.ExpressionContext): void {
-    TypeValidator.validateDoWhileCondition(ctx);
+  validateConditionIsBoolean(
+    ctx: Parser.ExpressionContext,
+    conditionType: string,
+  ): void {
+    TypeValidator.validateConditionIsBoolean(ctx, conditionType);
   }
 
   /**
@@ -1238,7 +1242,7 @@ export default class CodeGenerator implements IOrchestrator {
   generateParameterList(ctx: Parser.ParameterListContext): string {
     return ctx
       .parameter()
-      .map((p) => this.generateParameter(p))
+      .map((p, index) => this.generateParameter(p, index))
       .join(", ");
   }
 
@@ -1563,8 +1567,8 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Issue #561: Analyze modifications in a parse tree without full code generation.
-   * Used by Pipeline.transpileSource() to collect modification info from includes
-   * for cross-file const inference (unified with Pipeline.run() behavior).
+   * Used by the transpile() pipeline to collect modification info from includes
+   * for cross-file const inference.
    *
    * Issue #565: Now accepts optional cross-file data for transitive propagation.
    * When a file calls a function from an included file that modifies its param,
@@ -3496,6 +3500,17 @@ export default class CodeGenerator implements IOrchestrator {
 
     // For C-Next/C structs, generate designated initializer
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
+
+    // Issue #882: In C++ mode, anonymous structs/unions must use plain brace init.
+    // Compound literals like (struct { ... }){ ... } create incompatible types in C++
+    // because each struct { ... } definition creates a distinct nominal type.
+    if (
+      CodeGenState.cppMode &&
+      (typeName.startsWith("struct {") || typeName.startsWith("union {"))
+    ) {
+      return `{ ${fieldInits.join(", ")} }`;
+    }
+
     return `(${castType}){ ${fieldInits.join(", ")} }`;
   }
 
@@ -3670,7 +3685,10 @@ export default class CodeGenerator implements IOrchestrator {
     return typedef ? functionCode + typedef : functionCode;
   }
 
-  private generateParameter(ctx: Parser.ParameterContext): string {
+  private generateParameter(
+    ctx: Parser.ParameterContext,
+    paramIndex?: number,
+  ): string {
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
 
@@ -3682,9 +3700,22 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Pre-compute CodeGenState-dependent values
     const isModified = this._isCurrentParameterModified(name);
-    const isPassByValue = this._isPassByValueType(typeName, name);
+
+    // Issue #895: For callback-compatible functions, determine pointer/value
+    // from the typedef signature, not from normal C-Next pass-by-value rules
+    const callbackInfo =
+      paramIndex === undefined
+        ? null
+        : FunctionContextManager.getCallbackTypedefParamInfo(paramIndex);
+    const isPassByValue = callbackInfo
+      ? !callbackInfo.shouldBePointer
+      : this._isPassByValueType(typeName, name);
+    const isCallbackCompatible = callbackInfo !== null;
 
     // Build normalized input using adapter
+    // Issue #895: Force pass-by-reference and const from typedef signature
+    const forcePassByReference = callbackInfo?.shouldBePointer ?? false;
+    const forceConst = callbackInfo?.shouldBeConst ?? false;
     const input = ParameterInputAdapter.fromAST(ctx, {
       getTypeName: (t) => this.getTypeName(t),
       generateType: (t) => this.generateType(t),
@@ -3694,6 +3725,9 @@ export default class CodeGenerator implements IOrchestrator {
       typeMap: TYPE_MAP,
       isModified,
       isPassByValue,
+      isCallbackCompatible,
+      forcePassByReference,
+      forceConst,
     });
 
     // Use shared builder with C/C++ mode
@@ -3763,6 +3797,21 @@ export default class CodeGenerator implements IOrchestrator {
       return true;
     }
 
+    // Callback-compatible functions: struct params become pass-by-value
+    // to match C function pointer typedef signatures
+    // NOTE: This assumes the C typedef expects pass-by-value structs.
+    // Issue #895 describes cases where the typedef expects pointers instead.
+    // A full fix requires parsing the typedef signature to determine which.
+    if (
+      CodeGenState.currentFunctionName &&
+      CodeGenState.callbackCompatibleFunctions.has(
+        CodeGenState.currentFunctionName,
+      ) &&
+      this.isKnownStruct(typeName)
+    ) {
+      return true;
+    }
+
     return false;
   }
 
@@ -4152,16 +4201,21 @@ export default class CodeGenerator implements IOrchestrator {
     const isStructParam = paramInfo?.isStruct ?? false;
     const isCppAccess = hasGlobal && this.isCppScopeSymbol(firstId);
     const separatorDeps = this._buildMemberSeparatorDeps();
+    // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+    const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
 
     const separatorCtx: ISeparatorContext =
       MemberSeparatorResolver.buildContext(
-        firstId,
-        hasGlobal,
-        hasThis,
-        CodeGenState.currentScope,
-        isStructParam,
+        {
+          firstId,
+          hasGlobal,
+          hasThis,
+          currentScope: CodeGenState.currentScope,
+          isStructParam,
+          isCppAccess,
+          forcePointerSemantics,
+        },
         separatorDeps,
-        isCppAccess,
       );
 
     return {

package/src/transpiler/output/codegen/TypeResolver.ts

@@ -10,7 +10,7 @@ import SIGNED_TYPES from "./types/SIGNED_TYPES";
 import UNSIGNED_TYPES from "./types/UNSIGNED_TYPES";
 import TYPE_WIDTH from "./types/TYPE_WIDTH";
 import TYPE_RANGES from "./types/TYPE_RANGES";
-import ExpressionUnwrapper from "./utils/ExpressionUnwrapper";
+import ExpressionUnwrapper from "../../../utils/ExpressionUnwrapper";
 
 /**
  * Internal type info tracked through postfix suffix chains.

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

@@ -714,16 +714,19 @@ class TypeValidator {
   }
 
   // ========================================================================
-  // Do-While Validation (ADR-027)
+  // Condition Boolean Validation (ADR-027, Issue #884)
   // ========================================================================
 
-  static validateDoWhileCondition(ctx: Parser.ExpressionContext): void {
+  static validateConditionIsBoolean(
+    ctx: Parser.ExpressionContext,
+    conditionType: string,
+  ): void {
     const ternaryExpr = ctx.ternaryExpression();
     const orExprs = ternaryExpr.orExpression();
 
     if (orExprs.length !== 1) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression, not a ternary (MISRA C:2012 Rule 14.4)`,
+        `Error E0701: ${conditionType} condition must be a boolean expression, not a ternary (MISRA C:2012 Rule 14.4)`,
       );
     }
 
@@ -737,7 +740,7 @@ class TypeValidator {
     const andExpr = orExpr.andExpression(0);
     if (!andExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
       );
     }
 
@@ -748,7 +751,7 @@ class TypeValidator {
     const equalityExpr = andExpr.equalityExpression(0);
     if (!equalityExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
       );
     }
 
@@ -759,7 +762,7 @@ class TypeValidator {
     const relationalExpr = equalityExpr.relationalExpression(0);
     if (!relationalExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`,
       );
     }
 
@@ -773,7 +776,7 @@ class TypeValidator {
     }
 
     throw new Error(
-      `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)\n  help: use explicit comparison: ${text} > 0 or ${text} != 0`,
+      `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)\n  help: use explicit comparison: ${text} > 0 or ${text} != 0`,
     );
   }
 

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

@@ -312,7 +312,9 @@ describe("ExpressionWalker - const inference integration", () => {
       }
     `;
     const transpiler = new Transpiler({ inputs: [] });
-    const transpileResult = await transpiler.transpileSource(source);
+    const transpileResult = (
+      await transpiler.transpile({ kind: "source", source: source })
+    ).files[0];
     expect(transpileResult.success).toBe(true);
     // The caller function should NOT have const param because x is passed to modifyParam
     // which modifies its parameter
@@ -340,7 +342,9 @@ describe("ExpressionWalker - const inference integration", () => {
       }
     `;
     const transpiler = new Transpiler({ inputs: [] });
-    const transpileResult = await transpiler.transpileSource(source);
+    const transpileResult = (
+      await transpiler.transpile({ kind: "source", source: source })
+    ).files[0];
     expect(transpileResult.success).toBe(true);
     // x should not be const because it's passed through a modifying call chain
     expect(transpileResult.code).not.toContain("void caller(const uint32_t x)");
@@ -367,7 +371,9 @@ describe("ExpressionWalker - const inference integration", () => {
       }
     `;
     const transpiler = new Transpiler({ inputs: [] });
-    const transpileResult = await transpiler.transpileSource(source);
+    const transpileResult = (
+      await transpiler.transpile({ kind: "source", source: source })
+    ).files[0];
     expect(transpileResult.success).toBe(true);
     // x should not be const
     expect(transpileResult.code).not.toContain("void caller(const uint32_t x)");

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(