c-next 0.2.8 → 0.2.10

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/ArrayAccessHelper.ts

@@ -115,6 +115,7 @@ class ArrayAccessHelper {
 
   /**
    * Generate integer bit range read: ((value >> start) & mask)
+   * Passes sourceType and targetType to BitRangeHelper for MISRA 10.3 casts.
    */
   static generateIntegerBitRange(
     info: IArrayAccessInfo,
@@ -125,6 +126,8 @@ class ArrayAccessHelper {
       varName: info.resolvedName,
       start: info.startExpr ?? "0",
       mask,
+      sourceType: info.typeInfo?.baseType,
+      targetType: info.targetType,
     });
   }
 }

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/BitRangeHelper.ts

@@ -3,6 +3,8 @@
  * Extracted from CodeGenerator to improve testability.
  */
 
+import NarrowingCastHelper from "./NarrowingCastHelper.js";
+
 /**
  * Options for generating float bit read expressions.
  */
@@ -21,6 +23,8 @@ interface IIntegerBitReadOptions {
   varName: string;
   start: string;
   mask: string;
+  sourceType?: string; // Optional: source variable type for cast detection
+  targetType?: string; // Optional: target variable type for cast
 }
 
 /**
@@ -51,14 +55,26 @@ class BitRangeHelper {
   /**
    * Generate integer bit range read: ((value >> start) & mask)
    * Optimizes away the shift when start is 0.
+   *
+   * When sourceType and targetType are provided, wraps the expression
+   * with MISRA 10.3 compliant cast if needed.
    */
   static buildIntegerBitReadExpr(options: IIntegerBitReadOptions): string {
-    const { varName, start, mask } = options;
+    const { varName, start, mask, sourceType, targetType } = options;
 
+    let expr: string;
     if (start === "0") {
-      return `((${varName}) & ${mask})`;
+      expr = `((${varName}) & ${mask})`;
+    } else {
+      expr = `((${varName} >> ${start}) & ${mask})`;
+    }
+
+    // If target type provided, wrap with MISRA cast if needed
+    if (sourceType && targetType) {
+      return NarrowingCastHelper.wrap(expr, sourceType, targetType);
     }
-    return `((${varName} >> ${start}) & ${mask})`;
+
+    return expr;
   }
 
   /**

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

@@ -0,0 +1,191 @@
+/**
+ * NarrowingCastHelper - MISRA C:2012 Rule 10.3 compliance
+ *
+ * Issue #845: Wraps expressions with explicit casts when assigning
+ * to narrower types or different essential type categories.
+ *
+ * C's integer promotion rules mean bit operations on u8/u16 produce int,
+ * which MISRA flags when assigned back to narrower types without explicit cast.
+ */
+
+import TYPE_WIDTH from "../types/TYPE_WIDTH.js";
+import CppModeHelper from "./CppModeHelper.js";
+import TYPE_MAP from "../types/TYPE_MAP.js";
+
+/**
+ * Extended type widths including C's promoted "int" type.
+ * The shared TYPE_WIDTH doesn't include "int" since it's not a C-Next type.
+ */
+const EXTENDED_TYPE_WIDTH: Record<string, number> = {
+  ...TYPE_WIDTH,
+  int: 32, // C's int after promotion
+};
+
+/**
+ * Types that get promoted to int in C's integer promotion rules.
+ * In C, operations on types smaller than int get promoted to int.
+ */
+const PROMOTED_TO_INT = new Set(["u8", "i8", "u16", "i16", "bool"]);
+
+/**
+ * Float types for cross-category detection.
+ */
+const FLOAT_TYPES = new Set(["f32", "f64", "float", "double"]);
+
+/**
+ * Integer types for cross-category detection.
+ */
+const INTEGER_TYPES = new Set([
+  "u8",
+  "u16",
+  "u32",
+  "u64",
+  "i8",
+  "i16",
+  "i32",
+  "i64",
+  "uint8_t",
+  "uint16_t",
+  "uint32_t",
+  "uint64_t",
+  "int8_t",
+  "int16_t",
+  "int32_t",
+  "int64_t",
+  "int",
+]);
+
+/**
+ * Helper for adding MISRA 10.3 compliant casts to generated C code.
+ */
+class NarrowingCastHelper {
+  /**
+   * Check if a cast is needed for MISRA 10.3 compliance.
+   * Returns true if:
+   * - Source is wider than target (narrowing)
+   * - Source and target are different essential type categories
+   *
+   * @param sourceType - Type of the expression (C-Next type or "int" for promoted)
+   * @param targetType - Type of the target variable (C-Next type)
+   */
+  static needsCast(sourceType: string, targetType: string): boolean {
+    // Same type never needs cast
+    if (sourceType === targetType) {
+      return false;
+    }
+
+    // Bool target from non-bool source always needs conversion
+    if (targetType === "bool" && sourceType !== "bool") {
+      return true;
+    }
+
+    const sourceWidth = EXTENDED_TYPE_WIDTH[sourceType];
+    const targetWidth = EXTENDED_TYPE_WIDTH[targetType];
+
+    // Unknown types - be conservative, no cast
+    if (sourceWidth === undefined || targetWidth === undefined) {
+      return false;
+    }
+
+    // Narrowing: source wider than target
+    return sourceWidth > targetWidth;
+  }
+
+  /**
+   * Wrap expression with cast if needed for MISRA 10.3 compliance.
+   *
+   * @param expr - The generated C expression
+   * @param sourceType - Type of the expression (C-Next type or "int")
+   * @param targetType - Type of the assignment target (C-Next type)
+   * @returns Expression with cast wrapper if needed, or original expression
+   */
+  static wrap(expr: string, sourceType: string, targetType: string): string {
+    if (!NarrowingCastHelper.needsCast(sourceType, targetType)) {
+      return expr;
+    }
+
+    // Bool target: use comparison instead of cast (MISRA 10.5)
+    if (targetType === "bool") {
+      return `((${expr}) != 0U)`;
+    }
+
+    // Get C type name for the target
+    const cType = TYPE_MAP[targetType] ?? targetType;
+    return CppModeHelper.cast(cType, expr);
+  }
+
+  /**
+   * Determine the result type of C integer promotion for a given type.
+   *
+   * In C, operations on types smaller than int are promoted:
+   * - u8, i8, u16, i16, bool -> int (32-bit)
+   * - u32, i32, u64, i64 -> no promotion (already >= int width)
+   *
+   * @param baseType - The C-Next type of the operand
+   * @returns "int" for promoted types, or the original type
+   */
+  static getPromotedType(baseType: string): string {
+    if (PROMOTED_TO_INT.has(baseType)) {
+      return "int";
+    }
+    return baseType;
+  }
+
+  /**
+   * Check if a type is a floating-point type.
+   */
+  static isFloatType(typeName: string): boolean {
+    return FLOAT_TYPES.has(typeName);
+  }
+
+  /**
+   * Check if a type is an integer type.
+   */
+  static isIntegerType(typeName: string): boolean {
+    return INTEGER_TYPES.has(typeName);
+  }
+
+  /**
+   * Check if conversion between source and target is a cross-type-category conversion.
+   * MISRA 10.3 requires explicit casts for different essential type categories.
+   */
+  static isCrossTypeCategoryConversion(
+    sourceType: string,
+    targetType: string,
+  ): boolean {
+    const sourceIsFloat = NarrowingCastHelper.isFloatType(sourceType);
+    const targetIsFloat = NarrowingCastHelper.isFloatType(targetType);
+    const sourceIsInt = NarrowingCastHelper.isIntegerType(sourceType);
+    const targetIsInt = NarrowingCastHelper.isIntegerType(targetType);
+
+    // Float to integer or integer to float
+    return (sourceIsFloat && targetIsInt) || (sourceIsInt && targetIsFloat);
+  }
+
+  /**
+   * Get the appropriate C float type for a C-Next type.
+   */
+  static getCFloatType(typeName: string): string {
+    if (typeName === "f32" || typeName === "float") {
+      return "float";
+    }
+    if (typeName === "f64" || typeName === "double") {
+      return "double";
+    }
+    return "double"; // Default to double
+  }
+
+  /**
+   * Wrap int-to-float conversion with explicit cast for MISRA 10.3.
+   *
+   * @param expr - The integer expression
+   * @param targetType - The float target type (f32/f64)
+   * @returns Expression with cast
+   */
+  static wrapIntToFloat(expr: string, targetType: string): string {
+    const floatType = NarrowingCastHelper.getCFloatType(targetType);
+    return CppModeHelper.cast(floatType, expr);
+  }
+}
+
+export default NarrowingCastHelper;

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

@@ -18,10 +18,13 @@ import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import CodeGenState from "../../../state/CodeGenState.js";
 import TypeResolver from "../TypeResolver.js";
 import ArrayInitHelper from "./ArrayInitHelper.js";
+import CppModeHelper from "./CppModeHelper.js";
 import EnumAssignmentValidator from "./EnumAssignmentValidator.js";
 import IntegerLiteralValidator from "./IntegerLiteralValidator.js";
+import NarrowingCastHelper from "./NarrowingCastHelper.js";
 import StringDeclHelper from "./StringDeclHelper.js";
 import VariableModifierBuilder from "./VariableModifierBuilder.js";
+import TYPE_MAP from "../types/TYPE_MAP.js";
 
 /**
  * Callbacks for integer validation in variable declarations.
@@ -522,8 +525,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 +534,39 @@ class VariableDeclHelper {
       getExpressionType: callbacks.getExpressionType,
     });
 
-    const result = `${decl} = ${callbacks.generateExpression(ctx.expression()!)}`;
-    CodeGenState.expectedType = savedExpectedType;
+    // Issue #872: Set expectedType for MISRA 7.2 U suffix compliance
+    // MISRA 10.3: Also check for cross-type-category conversions (int <-> float)
+    return CodeGenState.withExpectedType(typeName, () => {
+      let exprCode = callbacks.generateExpression(ctx.expression()!);
+
+      // MISRA 10.3: Check for cross-type-category conversions (int <-> float)
+      const exprType = callbacks.getExpressionType(ctx.expression()!);
+      if (
+        exprType &&
+        NarrowingCastHelper.isCrossTypeCategoryConversion(exprType, typeName)
+      ) {
+        // Int to float: add explicit cast
+        if (
+          NarrowingCastHelper.isIntegerType(exprType) &&
+          NarrowingCastHelper.isFloatType(typeName)
+        ) {
+          exprCode = NarrowingCastHelper.wrapIntToFloat(exprCode, typeName);
+        }
+        // Float to int: add explicit cast for MISRA compliance
+        // Note: For safety, users should use explicit cast in C-Next source: (i32)float
+        // which generates a clamping expression. This implicit cast is just for
+        // MISRA 10.3 compliance when user omits explicit cast.
+        if (
+          NarrowingCastHelper.isFloatType(exprType) &&
+          NarrowingCastHelper.isIntegerType(typeName)
+        ) {
+          const cType = TYPE_MAP[typeName] ?? typeName;
+          exprCode = CppModeHelper.cast(cType, exprCode);
+        }
+      }
 
-    return result;
+      return `${decl} = ${exprCode}`;
+    });
   }
 
   // ========================================================================

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

@@ -2,10 +2,11 @@
  * Unit tests for ArrayAccessHelper utility.
  * Tests array access code generation patterns without ANTLR dependencies.
  */
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import ArrayAccessHelper from "../ArrayAccessHelper";
 import IArrayAccessInfo from "../../types/IArrayAccessInfo";
 import IArrayAccessDeps from "../../types/IArrayAccessDeps";
+import CodeGenState from "../../../../state/CodeGenState.js";
 
 /**
  * Create mock dependencies for testing.
@@ -478,4 +479,133 @@ describe("ArrayAccessHelper", () => {
       expect(mockDeps.generateBitMask).toHaveBeenCalledWith("8", false);
     });
   });
+
+  describe("generateIntegerBitRange with MISRA casts", () => {
+    let mockDeps: IArrayAccessDeps;
+
+    beforeEach(() => {
+      CodeGenState.reset();
+      CodeGenState.cppMode = false;
+      mockDeps = createMockDeps();
+    });
+
+    afterEach(() => {
+      CodeGenState.reset();
+    });
+
+    it("adds cast when target type is narrower", () => {
+      // Configure mock to return the actual mask for u8 width
+      (mockDeps.generateBitMask as ReturnType<typeof vi.fn>).mockReturnValue(
+        "0xFFU",
+      );
+
+      const info: IArrayAccessInfo = {
+        rawName: "value",
+        resolvedName: "value",
+        accessType: "bit-range",
+        startExpr: "0",
+        widthExpr: "8",
+        typeInfo: {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: false,
+          isConst: false,
+        },
+        targetType: "u8",
+        line: 1,
+      };
+      const result = ArrayAccessHelper.generateIntegerBitRange(info, mockDeps);
+      expect(result).toBe("(uint8_t)((value) & 0xFFU)");
+    });
+
+    it("no cast when target type matches source", () => {
+      (mockDeps.generateBitMask as ReturnType<typeof vi.fn>).mockReturnValue(
+        "0xFFFFU",
+      );
+
+      const info: IArrayAccessInfo = {
+        rawName: "value",
+        resolvedName: "value",
+        accessType: "bit-range",
+        startExpr: "8",
+        widthExpr: "16",
+        typeInfo: {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: false,
+          isConst: false,
+        },
+        targetType: "u32",
+        line: 1,
+      };
+      const result = ArrayAccessHelper.generateIntegerBitRange(info, mockDeps);
+      expect(result).toBe("((value >> 8) & 0xFFFFU)");
+    });
+
+    it("no cast when targetType not provided (backward compatible)", () => {
+      (mockDeps.generateBitMask as ReturnType<typeof vi.fn>).mockReturnValue(
+        "0xFFU",
+      );
+
+      const info: IArrayAccessInfo = {
+        rawName: "value",
+        resolvedName: "value",
+        accessType: "bit-range",
+        startExpr: "0",
+        widthExpr: "8",
+        typeInfo: {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: false,
+          isConst: false,
+        },
+        line: 1,
+      };
+      const result = ArrayAccessHelper.generateIntegerBitRange(info, mockDeps);
+      expect(result).toBe("((value) & 0xFFU)");
+    });
+
+    it("adds cast for u16 target from u32 source", () => {
+      (mockDeps.generateBitMask as ReturnType<typeof vi.fn>).mockReturnValue(
+        "0xFFFFU",
+      );
+
+      const info: IArrayAccessInfo = {
+        rawName: "data",
+        resolvedName: "data",
+        accessType: "bit-range",
+        startExpr: "16",
+        widthExpr: "16",
+        typeInfo: {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: false,
+          isConst: false,
+        },
+        targetType: "u16",
+        line: 1,
+      };
+      const result = ArrayAccessHelper.generateIntegerBitRange(info, mockDeps);
+      expect(result).toBe("(uint16_t)((data >> 16) & 0xFFFFU)");
+    });
+
+    it("no cast when no typeInfo provided", () => {
+      (mockDeps.generateBitMask as ReturnType<typeof vi.fn>).mockReturnValue(
+        "0xFFU",
+      );
+
+      const info: IArrayAccessInfo = {
+        rawName: "value",
+        resolvedName: "value",
+        accessType: "bit-range",
+        startExpr: "0",
+        widthExpr: "8",
+        targetType: "u8",
+        line: 1,
+      };
+      const result = ArrayAccessHelper.generateIntegerBitRange(info, mockDeps);
+      // No cast because sourceType is undefined
+      expect(result).toBe("((value) & 0xFFU)");
+    });
+  });
 });