c-next 0.2.8 → 0.2.9

package/src/transpiler/output/codegen/generators/support/__tests__/IncludeGenerator.test.ts

@@ -156,6 +156,44 @@ describe("IncludeGenerator", () => {
 
       expect(result).toBe("#include <lib.h>");
     });
+
+    it("transforms angle bracket .cnx include to .hpp in C++ mode", () => {
+      const result = transformIncludeDirective("#include <utils.cnx>", {
+        sourcePath: null,
+        cppMode: true,
+      });
+      expect(result).toBe("#include <utils.hpp>");
+    });
+
+    it("resolves path from inputs with .hpp in C++ mode", () => {
+      vi.mocked(CnxFileResolver.findCnxFile).mockReturnValue(
+        "/project/src/Display/utils.cnx",
+      );
+      vi.mocked(CnxFileResolver.getRelativePathFromInputs).mockReturnValue(
+        "Display/utils.cnx",
+      );
+
+      const result = transformIncludeDirective("#include <utils.cnx>", {
+        sourcePath: "/project/src/main.cnx",
+        includeDirs: ["/project/src/Display"],
+        inputs: ["/project/src"],
+        cppMode: true,
+      });
+
+      expect(result).toBe("#include <Display/utils.hpp>");
+    });
+
+    it("falls back to .hpp in C++ mode when file not found", () => {
+      vi.mocked(CnxFileResolver.findCnxFile).mockReturnValue(null);
+
+      const result = transformIncludeDirective("#include <missing.cnx>", {
+        sourcePath: "/project/src/main.cnx",
+        inputs: ["/project/src"],
+        cppMode: true,
+      });
+
+      expect(result).toBe("#include <missing.hpp>");
+    });
   });
 
   // ==========================================================================
@@ -221,6 +259,28 @@ describe("IncludeGenerator", () => {
         }),
       ).toThrow(/Referenced in:.*main\.cnx/);
     });
+
+    it("transforms quoted .cnx include to .hpp in C++ mode", () => {
+      vi.mocked(CnxFileResolver.cnxFileExists).mockReturnValue(true);
+
+      const result = transformIncludeDirective('#include "helper.cnx"', {
+        sourcePath: "/project/src/main.cnx",
+        cppMode: true,
+      });
+
+      expect(result).toBe('#include "helper.hpp"');
+    });
+
+    it("transforms quoted include with relative path to .hpp in C++ mode", () => {
+      vi.mocked(CnxFileResolver.cnxFileExists).mockReturnValue(true);
+
+      const result = transformIncludeDirective('#include "../lib/utils.cnx"', {
+        sourcePath: "/project/src/main.cnx",
+        cppMode: true,
+      });
+
+      expect(result).toBe('#include "../lib/utils.hpp"');
+    });
   });
 
   // ==========================================================================
@@ -262,6 +322,14 @@ describe("IncludeGenerator", () => {
       });
       expect(result).toBe("int x = 5;");
     });
+
+    it("passes through .h includes unchanged even in C++ mode", () => {
+      const result = transformIncludeDirective('#include "myheader.h"', {
+        sourcePath: "/project/main.cnx",
+        cppMode: true,
+      });
+      expect(result).toBe('#include "myheader.h"');
+    });
   });
 
   // ==========================================================================

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

@@ -66,22 +66,34 @@ class ArgumentGenerator {
 
   /**
    * Handle rvalue argument (literals or complex expressions).
+   * Issue #872: Sets expectedType for MISRA 7.2 U suffix on unsigned literals.
    */
   static handleRvalueArg(
     ctx: Parser.ExpressionContext,
     targetParamBaseType: string | undefined,
     callbacks: IArgumentGeneratorCallbacks,
   ): string {
+    // Issue #872: Early return when no target type - no state management needed
     if (!targetParamBaseType) {
       return callbacks.generateExpression(ctx);
     }
 
     const cType = TYPE_MAP[targetParamBaseType];
     if (!cType || cType === "void") {
-      return callbacks.generateExpression(ctx);
+      // Issue #872: Suppress bare enum resolution in function args (requires ADR to change)
+      return CodeGenState.withExpectedType(
+        targetParamBaseType,
+        () => callbacks.generateExpression(ctx),
+        true, // suppressEnumResolution
+      );
     }
 
-    const value = callbacks.generateExpression(ctx);
+    // Issue #872: Suppress bare enum resolution in function args (requires ADR to change)
+    const value = CodeGenState.withExpectedType(
+      targetParamBaseType,
+      () => callbacks.generateExpression(ctx),
+      true, // suppressEnumResolution
+    );
 
     // C++ mode: rvalues can bind to const T&
     if (CodeGenState.cppMode) {

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

@@ -106,11 +106,9 @@ class ArrayInitHelper {
     callbacks: IArrayInitCallbacks,
   ): string {
     const typeName = callbacks.getTypeName(typeCtx);
-    const savedExpectedType = CodeGenState.expectedType;
-    CodeGenState.expectedType = typeName;
-    const initValue = callbacks.generateExpression(expression);
-    CodeGenState.expectedType = savedExpectedType;
-    return initValue;
+    return CodeGenState.withExpectedType(typeName, () =>
+      callbacks.generateExpression(expression),
+    );
   }
 
   /**

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

@@ -54,22 +54,36 @@ class AssignmentExpectedTypeResolver {
       return AssignmentExpectedTypeResolver.resolveForSimpleIdentifier(baseId);
     }
 
-    // Case 2: Has member access - extract identifiers from postfix chain
+    // Case 2: Has postfix ops - extract identifiers from chain
     if (baseId && postfixOps.length > 0) {
       const { identifiers, hasSubscript } = analyzePostfixOps(
         baseId,
         postfixOps,
       );
 
-      // If we have member access (multiple identifiers), resolve for member chain
+      // Case 2a: Member access only (no subscript)
       if (identifiers.length >= 2 && !hasSubscript) {
         return AssignmentExpectedTypeResolver.resolveForMemberChain(
           identifiers,
         );
       }
+
+      // Case 2b: Simple array element access (arr[i] <- value)
+      // Issue #872: Resolve element type for MISRA 7.2 U suffix
+      if (identifiers.length === 1 && hasSubscript) {
+        return AssignmentExpectedTypeResolver.resolveForArrayElement(baseId);
+      }
+
+      // Case 2c: Member chain with array access (struct.arr[i] <- value)
+      // Issue #872: Walk chain and resolve element type
+      if (identifiers.length >= 2 && hasSubscript) {
+        return AssignmentExpectedTypeResolver.resolveForMemberArrayElement(
+          identifiers,
+        );
+      }
     }
 
-    // Case 3: Array access or complex patterns - no expected type resolution
+    // Case 3: Complex patterns we can't resolve
     return { expectedType: null, assignmentContext: null };
   }
 
@@ -98,10 +112,49 @@ class AssignmentExpectedTypeResolver {
    *
    * Issue #452: Enables type-aware resolution of unqualified enum members
    * for nested access (e.g., config.nested.field).
+   *
+   * Delegates to walkMemberChain shared implementation.
    */
   private static resolveForMemberChain(
     identifiers: string[],
   ): IExpectedTypeResult {
+    return AssignmentExpectedTypeResolver.walkMemberChain(identifiers);
+  }
+
+  /**
+   * Resolve expected type for array element access.
+   * Issue #872: arr[i] <- value needs baseType for MISRA 7.2 U suffix.
+   */
+  private static resolveForArrayElement(id: string): IExpectedTypeResult {
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
+    if (!typeInfo?.isArray) {
+      return { expectedType: null, assignmentContext: null };
+    }
+
+    // Element type is the baseType (e.g., u8[10] -> "u8")
+    return { expectedType: typeInfo.baseType, assignmentContext: null };
+  }
+
+  /**
+   * Resolve expected type for member chain ending with array access.
+   * Issue #872: struct.arr[i] <- value needs element type for MISRA 7.2.
+   *
+   * Delegates to walkMemberChain which handles both member chain and
+   * member-array-element patterns identically (both return final field type).
+   */
+  private static resolveForMemberArrayElement(
+    identifiers: string[],
+  ): IExpectedTypeResult {
+    return AssignmentExpectedTypeResolver.walkMemberChain(identifiers);
+  }
+
+  /**
+   * Walk a struct member chain to find the final field's type.
+   * Shared implementation for both member chain and member-array-element patterns.
+   *
+   * Issue #831: Uses SymbolTable as single source of truth for struct fields.
+   */
+  private static walkMemberChain(identifiers: string[]): IExpectedTypeResult {
     if (identifiers.length < 2) {
       return { expectedType: null, assignmentContext: null };
     }
@@ -115,8 +168,6 @@ class AssignmentExpectedTypeResolver {
 
     let currentStructType: string | undefined = rootTypeInfo.baseType;
 
-    // Walk through each member in the chain to find the final field's type
-    // Issue #831: Use SymbolTable as single source of truth for struct fields
     for (let i = 1; i < identifiers.length && currentStructType; i++) {
       const memberName = identifiers[i];
       const memberType = CodeGenState.symbolTable?.getStructFieldType(
@@ -129,13 +180,10 @@ class AssignmentExpectedTypeResolver {
       }
 
       if (i === identifiers.length - 1) {
-        // Last field in chain - this is the assignment target's type
         return { expectedType: memberType, assignmentContext: null };
       } else if (CodeGenState.isKnownStruct(memberType)) {
-        // Intermediate field - continue walking if it's a struct
         currentStructType = memberType;
       } else {
-        // Intermediate field is not a struct - can't walk further
         break;
       }
     }

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

@@ -522,8 +522,6 @@ class VariableDeclHelper {
     }
 
     const typeName = callbacks.getTypeName(typeCtx);
-    const savedExpectedType = CodeGenState.expectedType;
-    CodeGenState.expectedType = typeName;
 
     // ADR-017: Validate enum type for initialization
     EnumAssignmentValidator.validateEnumAssignment(typeName, ctx.expression()!);
@@ -533,10 +531,11 @@ class VariableDeclHelper {
       getExpressionType: callbacks.getExpressionType,
     });
 
-    const result = `${decl} = ${callbacks.generateExpression(ctx.expression()!)}`;
-    CodeGenState.expectedType = savedExpectedType;
-
-    return result;
+    // Issue #872: Set expectedType for MISRA 7.2 U suffix compliance
+    return CodeGenState.withExpectedType(
+      typeName,
+      () => `${decl} = ${callbacks.generateExpression(ctx.expression()!)}`,
+    );
   }
 
   // ========================================================================

package/src/transpiler/output/codegen/helpers/__tests__/AssignmentExpectedTypeResolver.test.ts

@@ -183,7 +183,8 @@ describe("AssignmentExpectedTypeResolver", () => {
     });
 
     describe("array access", () => {
-      it("should return null for array access target", () => {
+      // Issue #872: Array element assignments need expectedType for MISRA 7.2 U suffix
+      it("should resolve expected type for simple array element access", () => {
         CodeGenState.setVariableTypeInfo("arr", {
           baseType: "u32",
           bitWidth: 32,
@@ -194,8 +195,65 @@ describe("AssignmentExpectedTypeResolver", () => {
 
         const result = AssignmentExpectedTypeResolver.resolve(target);
 
+        expect(result.expectedType).toBe("u32");
+      });
+
+      it("should resolve expected type for u8 array element access", () => {
+        CodeGenState.setVariableTypeInfo("buffer", {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+        });
+        const target = parseAssignmentTarget("buffer[5]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBe("u8");
+      });
+
+      it("should resolve expected type for struct member array access", () => {
+        CodeGenState.setVariableTypeInfo("pkt", {
+          baseType: "Packet",
+          bitWidth: 0,
+          isArray: false,
+          isConst: false,
+        });
+        setupStructFields("Packet", new Map([["header", "u8"]]));
+        // Mark header as an array field
+        if (CodeGenState.symbols) {
+          (
+            CodeGenState.symbols.structFieldArrays as Map<string, Set<string>>
+          ).set("Packet", new Set(["header"]));
+        }
+        const target = parseAssignmentTarget("pkt.header[0]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBe("u8");
+      });
+
+      it("should resolve expected type for multi-dimensional array element", () => {
+        CodeGenState.setVariableTypeInfo("matrix", {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          arrayDimensions: [4, 8],
+          isConst: false,
+        });
+        const target = parseAssignmentTarget("matrix[0][0]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBe("u8");
+      });
+
+      it("should return null for unknown array variable", () => {
+        const target = parseAssignmentTarget("unknown[0]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
         expect(result.expectedType).toBeNull();
-        expect(result.assignmentContext).toBeNull();
       });
     });
   });

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

@@ -277,29 +277,27 @@ class HeaderGeneratorUtils {
       lines.push("#include <stdint.h>", "#include <stdbool.h>");
     }
 
-    // User includes
-    // Issue #933: Transform .h to .hpp in C++ mode so headers include correct files
+    // User includes (already have correct extension from IncludeExtractor)
     if (options.userIncludes && options.userIncludes.length > 0) {
       for (const include of options.userIncludes) {
-        const transformedInclude = options.cppMode
-          ? include.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
-          : include;
-        lines.push(transformedInclude);
+        lines.push(include);
       }
     }
 
     // External type header includes (skip duplicates of user includes)
-    // Note: External C headers stay as .h - only user includes from .cnx files get
-    // transformed to .hpp in C++ mode (those are C-Next generated headers)
-    const userIncludeSet = new Set(
-      options.userIncludes?.map((inc) =>
-        options.cppMode
-          ? inc.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
-          : inc,
-      ) ?? [],
-    );
+    // Note: headersToInclude comes from IncludeResolver which always produces .h
+    // (it runs before cppDetected is set). We need to match against userIncludes
+    // which may have .hpp in C++ mode, so normalize both for deduplication.
+    const userIncludeSet = new Set(options.userIncludes ?? []);
+    // Issue #941: Also add .h variants for dedup since headersToInclude uses .h
+    if (options.cppMode && options.userIncludes) {
+      for (const inc of options.userIncludes) {
+        // Add the .h version so we can match against headersToInclude
+        const hVersion = inc.replace(/\.hpp"/, '.h"').replace(/\.hpp>/, ".h>");
+        userIncludeSet.add(hVersion);
+      }
+    }
     for (const directive of headersToInclude) {
-      // Don't transform external C headers - they should stay as .h
       if (!userIncludeSet.has(directive)) {
         lines.push(directive);
       }

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

@@ -542,6 +542,31 @@ describe("HeaderGeneratorUtils", () => {
 
       expect(lines[lines.length - 1]).toBe("");
     });
+
+    it("passes through userIncludes as-is (extension already correct from IncludeExtractor)", () => {
+      const lines = HeaderGeneratorUtils.generateIncludes(
+        {
+          userIncludes: ['#include "types.hpp"'],
+          cppMode: true,
+        },
+        new Set(),
+      );
+
+      expect(lines).toContain('#include "types.hpp"');
+    });
+
+    it("deduplicates headersToInclude against userIncludes with .h/.hpp normalization in C++ mode", () => {
+      const result = HeaderGeneratorUtils.generateIncludes(
+        {
+          userIncludes: ['#include "types.hpp"'],
+          cppMode: true,
+        },
+        new Set(['#include "types.h"']),
+      );
+      // Should NOT have duplicate - the .h version should be filtered
+      const typeIncludes = result.filter((l) => l.includes("types"));
+      expect(typeIncludes).toEqual(['#include "types.hpp"']);
+    });
   });
 
   describe("generateCppWrapperStart", () => {

package/src/transpiler/state/CodeGenState.ts

@@ -220,6 +220,14 @@ export default class CodeGenState {
   /** Expected type for struct initializers and enum inference */
   static expectedType: string | null = null;
 
+  /**
+   * Suppress bare enum resolution even when expectedType is set.
+   * Issue #872: MISRA 7.2 requires expectedType for U suffix on function args,
+   * but bare enum resolution in function args was never allowed and changing
+   * that would require ADR approval.
+   */
+  static suppressBareEnumResolution: boolean = false;
+
   /** Track args parameter name for main() translation */
   static mainArgsName: string | null = null;
 
@@ -362,6 +370,7 @@ export default class CodeGenState {
     this.indentLevel = 0;
     this.inFunctionBody = false;
     this.expectedType = null;
+    this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
     this.assignmentContext = {
       targetName: null,
@@ -421,6 +430,37 @@ export default class CodeGenState {
     this.floatShadowCurrent.clear();
   }
 
+  /**
+   * Execute a function with a temporary expectedType, restoring on completion.
+   * Issue #872: Extracted to eliminate duplicate save/restore pattern and add exception safety.
+   *
+   * @param type - The expected type to set (if falsy, no change is made)
+   * @param fn - The function to execute
+   * @param suppressEnumResolution - If true, suppress bare enum resolution (for MISRA-only contexts)
+   * @returns The result of the function
+   */
+  static withExpectedType<T>(
+    type: string | undefined | null,
+    fn: () => T,
+    suppressEnumResolution: boolean = false,
+  ): T {
+    if (!type) {
+      return fn();
+    }
+    const savedType = this.expectedType;
+    const savedSuppress = this.suppressBareEnumResolution;
+    this.expectedType = type;
+    if (suppressEnumResolution) {
+      this.suppressBareEnumResolution = true;
+    }
+    try {
+      return fn();
+    } finally {
+      this.expectedType = savedType;
+      this.suppressBareEnumResolution = savedSuppress;
+    }
+  }
+
   // ===========================================================================
   // CONVENIENCE LOOKUP METHODS
   // ===========================================================================