c-next 0.2.2 → 0.2.4

package/src/transpiler/logic/symbols/c/utils/__tests__/DeclaratorUtils.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Unit tests for DeclaratorUtils
+ */
+
+import { describe, it, expect } from "vitest";
+import DeclaratorUtils from "../DeclaratorUtils";
+import HeaderParser from "../../../../parser/HeaderParser";
+
+describe("DeclaratorUtils", () => {
+  describe("extractTypeFromSpecQualList", () => {
+    it("should extract simple type", () => {
+      // Parse a struct with a simple int field
+      const source = `struct Test { int value; };`;
+      const { tree } = HeaderParser.parseC(source);
+
+      // Navigate to the struct's field's specifierQualifierList
+      const structSpec = tree
+        ?.translationUnit()
+        ?.externalDeclaration(0)
+        ?.declaration()
+        ?.declarationSpecifiers()
+        ?.declarationSpecifier(0)
+        ?.typeSpecifier()
+        ?.structOrUnionSpecifier();
+
+      const fieldDecl = structSpec
+        ?.structDeclarationList()
+        ?.structDeclaration(0);
+      const specQualList = fieldDecl?.specifierQualifierList();
+
+      const result = DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+      expect(result).toBe("int");
+    });
+
+    it("should extract unsigned int type", () => {
+      const source = `struct Test { unsigned int count; };`;
+      const { tree } = HeaderParser.parseC(source);
+
+      const structSpec = tree
+        ?.translationUnit()
+        ?.externalDeclaration(0)
+        ?.declaration()
+        ?.declarationSpecifiers()
+        ?.declarationSpecifier(0)
+        ?.typeSpecifier()
+        ?.structOrUnionSpecifier();
+
+      const fieldDecl = structSpec
+        ?.structDeclarationList()
+        ?.structDeclaration(0);
+      const specQualList = fieldDecl?.specifierQualifierList();
+
+      const result = DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+      // For simple types without struct specifier, getText() is used
+      // The specifierQualifierList has "unsigned" and "int" as separate tokens
+      // which are joined with spaces
+      expect(result).toBe("unsigned int");
+    });
+
+    it("should extract anonymous struct type with proper spacing", () => {
+      // This is the bug case from issue #875
+      const source = `typedef struct {
+        int value;
+        struct {
+            unsigned int flag_a: 1;
+            unsigned int flag_b: 1;
+        } flags;
+      } config_t;`;
+      const { tree } = HeaderParser.parseC(source);
+
+      const structSpec = tree
+        ?.translationUnit()
+        ?.externalDeclaration(0)
+        ?.declaration()
+        ?.declarationSpecifiers()
+        ?.declarationSpecifier(1)
+        ?.typeSpecifier()
+        ?.structOrUnionSpecifier();
+
+      // Get the second field (flags) which is an anonymous struct
+      const flagsDecl = structSpec
+        ?.structDeclarationList()
+        ?.structDeclaration(1);
+      const specQualList = flagsDecl?.specifierQualifierList();
+
+      const result = DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+
+      // Should have proper spacing, not concatenated tokens like "struct{...}"
+      expect(result).toContain("struct {");
+      // Note: our reconstruction adds spaces around the colon, which is valid C
+      expect(result).toContain("unsigned int flag_a : 1;");
+      expect(result).toContain("unsigned int flag_b : 1;");
+    });
+
+    it("should extract anonymous union type with proper spacing", () => {
+      // Test union handling (code path: structOrUnion.Struct() returns false)
+      const source = `typedef struct {
+        union {
+            int as_int;
+            float as_float;
+        } value;
+      } variant_t;`;
+      const { tree } = HeaderParser.parseC(source);
+
+      const structSpec = tree
+        ?.translationUnit()
+        ?.externalDeclaration(0)
+        ?.declaration()
+        ?.declarationSpecifiers()
+        ?.declarationSpecifier(1)
+        ?.typeSpecifier()
+        ?.structOrUnionSpecifier();
+
+      // Get the first field (value) which is an anonymous union
+      const valueDecl = structSpec
+        ?.structDeclarationList()
+        ?.structDeclaration(0);
+      const specQualList = valueDecl?.specifierQualifierList();
+
+      const result = DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+
+      // Should use "union" keyword and have proper spacing
+      expect(result).toContain("union {");
+      expect(result).toContain("int as_int;");
+      expect(result).toContain("float as_float;");
+    });
+  });
+});

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

@@ -1042,11 +1042,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);
   }
 
   /**
@@ -1563,8 +1566,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 +3499,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(", ")} }`;
   }
 
@@ -3763,6 +3777,18 @@ export default class CodeGenerator implements IOrchestrator {
       return true;
     }
 
+    // Callback-compatible functions: struct params become pass-by-value
+    // to match C function pointer typedef signatures
+    if (
+      CodeGenState.currentFunctionName &&
+      CodeGenState.callbackCompatibleFunctions.has(
+        CodeGenState.currentFunctionName,
+      ) &&
+      this.isKnownStruct(typeName)
+    ) {
+      return true;
+    }
+
     return false;
   }
 

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__/CodeGenerator.test.ts

@@ -8776,7 +8776,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain(">> 4");
       });
 
-      it("should generate float bit range read with shadow variable", () => {
+      it("should generate float bit range read with union shadow variable", () => {
         const source = `
           void test() {
             f32 value <- 3.14;
@@ -8793,8 +8793,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Float bit access uses shadow variable and memcpy
-        expect(code).toContain("memcpy");
+        // Float bit access uses union-based type punning (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
     });
 
@@ -10750,7 +10751,7 @@ describe("CodeGenerator", () => {
     });
 
     describe("float bit range access helpers", () => {
-      it("should generate float bit range read with memcpy", () => {
+      it("should generate float bit range read with union", () => {
         const source = `
           void test() {
             f32 value <- 3.14;
@@ -10767,11 +10768,12 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Float bit access uses memcpy for type punning
-        expect(code).toContain("memcpy");
+        // Float bit access uses union-based type punning (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
-      it("should generate f64 bit range read", () => {
+      it("should generate f64 bit range read with union", () => {
         const source = `
           void test() {
             f64 value <- 3.14159;
@@ -10788,7 +10790,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("memcpy");
+        // f64 uses double/uint64_t union
+        expect(code).toContain("union { double f; uint64_t u; }");
+        expect(code).not.toContain("memcpy");
       });
     });
 
@@ -12264,7 +12268,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("flags");
       });
 
-      it("should handle float bit punning", () => {
+      it("should handle float bit punning with union", () => {
         const source = `
           void test() {
             f32 val <- 3.14;
@@ -12281,8 +12285,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Float bit access uses memcpy for type punning
-        expect(code).toContain("memcpy");
+        // Float bit access uses union-based type punning (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
     });
 
@@ -12870,7 +12875,7 @@ describe("CodeGenerator", () => {
 
   describe("refactored helper methods", () => {
     describe("float bit range access (PR #715 coverage)", () => {
-      it("should generate f32 bit range read with shadow and memcpy", () => {
+      it("should generate f32 bit range read with union shadow", () => {
         const source = `
           void test() {
             f32 floatVal <- 1.5;
@@ -12887,13 +12892,13 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Should use shadow variable pattern for float bit access
+        // Should use union-based type punning (MISRA 21.15 compliant)
         expect(code).toContain("__bits_floatVal");
-        expect(code).toContain("memcpy");
-        expect(code).toContain("uint32_t");
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
-      it("should generate f64 bit range read with 64-bit shadow", () => {
+      it("should generate f64 bit range read with 64-bit union shadow", () => {
         const source = `
           void test() {
             f64 doubleVal <- 2.718;
@@ -12910,10 +12915,10 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Should use 64-bit shadow for f64
+        // Should use 64-bit union for f64 (MISRA 21.15 compliant)
         expect(code).toContain("__bits_doubleVal");
-        expect(code).toContain("uint64_t");
-        expect(code).toContain("memcpy");
+        expect(code).toContain("union { double f; uint64_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
       it("should reuse shadow variable for repeated float bit reads", () => {
@@ -12934,11 +12939,13 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Shadow variable should only be declared once
-        const shadowDecls = (code.match(/uint32_t __bits_val;/g) || []).length;
+        // Union shadow should only be declared once
+        const shadowDecls = (
+          code.match(/union { float f; uint32_t u; } __bits_val;/g) || []
+        ).length;
         expect(shadowDecls).toBe(1);
-        // But memcpy may be used only on first access
-        expect(code).toContain("__bits_val");
+        // Uses union member .u for bit access
+        expect(code).toContain("__bits_val.u");
       });
 
       it("should generate integer bit range with start=0 optimization", () => {
@@ -13617,7 +13624,7 @@ describe("CodeGenerator", () => {
     });
 
     describe("float bit range edge cases", () => {
-      it("should generate f32 bit range with non-zero start position", () => {
+      it("should generate f32 bit range with non-zero start position using union", () => {
         const source = `
           void test() {
             f32 value <- 3.14;
@@ -13636,7 +13643,9 @@ describe("CodeGenerator", () => {
 
         expect(code).toContain("__bits_value");
         expect(code).toContain(">> 8");
-        expect(code).toContain("memcpy");
+        // Uses union, not memcpy (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; }");
+        expect(code).not.toContain("memcpy");
       });
 
       it("should generate f32 bit range with start=0", () => {
@@ -13661,7 +13670,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain(">> 0U");
       });
 
-      it("should handle multiple reads from same float reusing shadow", () => {
+      it("should handle multiple reads from same float reusing union shadow", () => {
         const source = `
           void test() {
             f32 data <- 2.5;
@@ -13680,10 +13689,10 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Shadow declaration should appear once
-        expect(code).toContain("uint32_t __bits_data");
-        // Multiple reads should work
-        expect(code).toContain("__bits_data");
+        // Union shadow declaration should appear once
+        expect(code).toContain("union { float f; uint32_t u; } __bits_data;");
+        // Multiple reads should work via union member
+        expect(code).toContain("__bits_data.u");
       });
     });
 
@@ -15406,7 +15415,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("& 0xFF");
       });
 
-      it("should generate float bit range access with memcpy", () => {
+      it("should generate float bit range access with union", () => {
         const source = `
           void test() {
             f32 fval <- 1.5;
@@ -15423,11 +15432,13 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("memcpy");
-        expect(code).toContain("__bits_fval");
+        // Uses union, not memcpy (MISRA 21.15 compliant)
+        expect(code).toContain("union { float f; uint32_t u; } __bits_fval;");
+        expect(code).toContain("__bits_fval.u");
+        expect(code).not.toContain("memcpy");
       });
 
-      it("should generate f64 bit range access with uint64_t shadow", () => {
+      it("should generate f64 bit range access with uint64_t union shadow", () => {
         const source = `
           void test() {
             f64 dval <- 1.5;
@@ -15444,8 +15455,10 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("uint64_t __bits_dval");
-        expect(code).toContain("memcpy");
+        // Uses union, not memcpy (MISRA 21.15 compliant)
+        expect(code).toContain("union { double f; uint64_t u; } __bits_dval;");
+        expect(code).toContain("__bits_dval.u");
+        expect(code).not.toContain("memcpy");
       });
     });
   });

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)");