c-next 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

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

@@ -11,6 +11,9 @@ import type {
   DeclarationSpecifiersContext,
   StructOrUnionSpecifierContext,
   EnumSpecifierContext,
+  StructDeclarationListContext,
+  StructDeclarationContext,
+  StructDeclaratorContext,
 } from "../../../parser/c/grammar/CParser";
 import SymbolUtils from "../../SymbolUtils";
 import IExtractedParameter from "../../shared/IExtractedParameter";
@@ -227,8 +230,8 @@ class DeclaratorUtils {
             // Use just the struct/union name, not "structName" concatenated
             parts.push(identifier.getText());
           } else {
-            // Anonymous struct - use full text
-            parts.push(typeSpec.getText());
+            // Anonymous struct - reconstruct with proper spacing
+            parts.push(DeclaratorUtils.reconstructAnonymousStruct(structSpec));
           }
         } else {
           parts.push(typeSpec.getText());
@@ -246,6 +249,100 @@ class DeclaratorUtils {
     return parts.join(" ") || "int";
   }
 
+  /**
+   * Reconstruct an anonymous struct/union type with proper spacing.
+   * For `struct { unsigned int flag_a: 1; }`, returns the properly formatted string
+   * instead of the concatenated tokens from getText().
+   */
+  private static reconstructAnonymousStruct(
+    structSpec: StructOrUnionSpecifierContext,
+  ): string {
+    const structOrUnion = structSpec.structOrUnion();
+    const keyword = structOrUnion.Struct() ? "struct" : "union";
+
+    const declList = structSpec.structDeclarationList();
+    if (!declList) {
+      return `${keyword} { }`;
+    }
+
+    const fields = DeclaratorUtils.reconstructStructFields(declList);
+    return `${keyword} { ${fields} }`;
+  }
+
+  /**
+   * Reconstruct struct fields with proper spacing.
+   */
+  private static reconstructStructFields(
+    declList: StructDeclarationListContext,
+  ): string {
+    const fieldStrings: string[] = [];
+
+    for (const decl of declList.structDeclaration()) {
+      const fieldStr = DeclaratorUtils.reconstructStructField(decl);
+      if (fieldStr) {
+        fieldStrings.push(fieldStr);
+      }
+    }
+
+    return fieldStrings.join(" ");
+  }
+
+  /**
+   * Reconstruct a single struct field declaration.
+   */
+  private static reconstructStructField(
+    decl: StructDeclarationContext,
+  ): string | null {
+    const specQualList = decl.specifierQualifierList();
+    if (!specQualList) return null;
+
+    // Get the base type with proper spacing
+    const baseType = DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+
+    const declaratorList = decl.structDeclaratorList();
+    if (!declaratorList) {
+      return `${baseType};`;
+    }
+
+    // Process each declarator in the list
+    const declarators: string[] = [];
+    for (const structDecl of declaratorList.structDeclarator()) {
+      const declStr = DeclaratorUtils.reconstructStructDeclarator(structDecl);
+      if (declStr) {
+        declarators.push(declStr);
+      }
+    }
+
+    if (declarators.length === 0) {
+      return `${baseType};`;
+    }
+
+    return `${baseType} ${declarators.join(", ")};`;
+  }
+
+  /**
+   * Reconstruct a struct declarator (field name with optional bitfield width).
+   */
+  private static reconstructStructDeclarator(
+    structDecl: StructDeclaratorContext,
+  ): string | null {
+    const declarator = structDecl.declarator();
+    const hasColon = structDecl.Colon() !== null;
+    const constExpr = structDecl.constantExpression();
+
+    let name = "";
+    if (declarator) {
+      name = DeclaratorUtils.extractDeclaratorName(declarator) || "";
+    }
+
+    if (hasColon && constExpr) {
+      const width = constExpr.getText();
+      return `${name}: ${width}`;
+    }
+
+    return name || null;
+  }
+
   /**
    * Extract typedef name from declaration specifiers.
    * For "typedef struct { ... } AppConfig;", this returns "AppConfig".

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

@@ -133,7 +133,7 @@ describe("CodeGenerator requireInclude", () => {
       expect(result.code).toContain("sizeof(float)");
     });
 
-    it("generates static assert for float bit indexing read", async () => {
+    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(`
@@ -145,7 +145,9 @@ describe("CodeGenerator requireInclude", () => {
 
       expect(result.success).toBe(true);
       expect(result.code).toContain("_Static_assert");
-      expect(result.code).toContain("#include <string.h>"); // For memcpy
+      // Uses union-based type punning, no memcpy needed (MISRA 21.15 compliant)
+      expect(result.code).not.toContain("#include <string.h>");
+      expect(result.code).toContain("union { float f; uint32_t u; }");
     });
   });
 

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

@@ -2051,7 +2051,15 @@ interface IFloatBitRangeContext {
 }
 
 /**
- * Handle float bit range access with memcpy shadow variable.
+ * Get the C float type name for a C-Next float type.
+ */
+const getFloatTypeName = (baseType: string): string => {
+  return baseType === "f64" ? "double" : "float";
+};
+
+/**
+ * Handle float bit range access with union-based type punning.
+ * Uses union { float f; uint32_t u; } for MISRA C:2012 Rule 21.15 compliance.
  */
 const handleFloatBitRange = (
   ctx: IFloatBitRangeContext,
@@ -2065,35 +2073,36 @@ const handleFloatBitRange = (
     );
   }
 
-  effects.push(
-    { type: "include", header: "string" },
-    { type: "include", header: "float_static_assert" },
-  );
+  effects.push({ type: "include", header: "float_static_assert" });
 
   const isF64 = ctx.baseType === "f64";
-  const shadowType = isF64 ? "uint64_t" : "uint32_t";
+  const floatType = getFloatTypeName(ctx.baseType);
+  const intType = isF64 ? "uint64_t" : "uint32_t";
   const shadowName = `__bits_${ctx.rootIdentifier}`;
   const mask = orchestrator.generateBitMask(ctx.width, isF64);
 
   const needsDeclaration = !orchestrator.hasFloatBitShadow(shadowName);
   if (needsDeclaration) {
     orchestrator.registerFloatBitShadow(shadowName);
-    orchestrator.addPendingTempDeclaration(`${shadowType} ${shadowName};`);
+    // Emit union declaration: union { float f; uint32_t u; } __bits_name;
+    orchestrator.addPendingTempDeclaration(
+      `union { ${floatType} f; ${intType} u; } ${shadowName};`,
+    );
   }
 
   const shadowIsCurrent = orchestrator.isFloatShadowCurrent(shadowName);
   orchestrator.markFloatShadowCurrent(shadowName);
 
-  if (shadowIsCurrent) {
-    if (ctx.start === "0") {
-      return `(${shadowName} & ${mask})`;
-    }
-    return `((${shadowName} >> ${ctx.start}) & ${mask})`;
+  // If shadow is not current, emit assignment: __bits_name.f = floatVar;
+  if (!shadowIsCurrent) {
+    orchestrator.addPendingTempDeclaration(`${shadowName}.f = ${ctx.result};`);
   }
+
+  // Return just the bit read expression using union member .u
   if (ctx.start === "0") {
-    return `(memcpy(&${shadowName}, &${ctx.result}, sizeof(${ctx.result})), (${shadowName} & ${mask}))`;
+    return `(${shadowName}.u & ${mask})`;
   }
-  return `(memcpy(&${shadowName}, &${ctx.result}, sizeof(${ctx.result})), ((${shadowName} >> ${ctx.start}) & ${mask}))`;
+  return `((${shadowName}.u >> ${ctx.start}) & ${mask})`;
 };
 
 // ========================================================================

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

@@ -1698,7 +1698,7 @@ describe("PostfixExpressionGenerator", () => {
   });
 
   describe("float bit indexing", () => {
-    it("generates float bit range with memcpy", () => {
+    it("generates float bit range with union-based type punning", () => {
       const typeRegistry = new Map<string, TTypeInfo>([
         [
           "f",
@@ -1726,9 +1726,11 @@ describe("PostfixExpressionGenerator", () => {
       });
 
       const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toContain("memcpy");
-      expect(result.code).toContain("__bits_f");
-      expect(result.effects).toContainEqual({
+      // Uses union member .u for bit access, not memcpy
+      expect(result.code).toContain("__bits_f.u");
+      expect(result.code).not.toContain("memcpy");
+      // No string.h needed for MISRA 21.15 compliance
+      expect(result.effects).not.toContainEqual({
         type: "include",
         header: "string",
       });
@@ -1767,7 +1769,7 @@ describe("PostfixExpressionGenerator", () => {
       ).toThrow("cannot be used at global scope");
     });
 
-    it("skips memcpy when shadow is current", () => {
+    it("uses union member when shadow is current (no re-assignment)", () => {
       const typeRegistry = new Map<string, TTypeInfo>([
         [
           "f",
@@ -1796,7 +1798,8 @@ describe("PostfixExpressionGenerator", () => {
 
       const result = generatePostfixExpression(ctx, input, state, orchestrator);
       expect(result.code).not.toContain("memcpy");
-      expect(result.code).toBe("(__bits_f & 0xFF)");
+      // Uses union member .u for bit access
+      expect(result.code).toBe("(__bits_f.u & 0xFF)");
     });
   });
 

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

@@ -324,9 +324,10 @@ const generateSwitch = (
     effects.push(...caseResult.effects);
   }
 
-  // Generate default if present
+  // Generate default case
   const defaultCtx = node.defaultCase();
   if (defaultCtx) {
+    // Explicit default from source
     const defaultResult = generateDefaultCase(
       defaultCtx,
       input,
@@ -335,6 +336,14 @@ const generateSwitch = (
     );
     lines.push(defaultResult.code);
     effects.push(...defaultResult.effects);
+  } else {
+    // Issue #855: MISRA C:2012 Rule 16.4 - every switch shall have a default
+    // Generate empty default case for compliance
+    lines.push(
+      orchestrator.indent("default: {"),
+      orchestrator.indent(orchestrator.indent("break;")),
+      orchestrator.indent("}"),
+    );
   }
 
   lines.push("}");

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

@@ -70,8 +70,11 @@ class ArrayAccessHelper {
   }
 
   /**
-   * Generate float bit range read with shadow variable.
-   * Uses memcpy pattern to safely reinterpret float bits.
+   * Generate float bit range read with union-based type punning.
+   * Uses union { float f; uint32_t u; } for MISRA 21.15 compliance.
+   *
+   * NOTE: This helper is not used in production (PostfixExpressionGenerator
+   * handles float bit access directly). It exists for testing and completeness.
    */
   static generateFloatBitRange(
     info: IArrayAccessInfo,
@@ -85,7 +88,7 @@ class ArrayAccessHelper {
       );
     }
 
-    deps.requireInclude("string");
+    // No string.h needed - uses union-based type punning
     deps.requireInclude("float_static_assert");
 
     const isF64 = info.typeInfo?.baseType === "f64";