c-next 0.2.16 → 0.2.18

package/src/transpiler/output/codegen/generators/declarationGenerators/__tests__/ScopeGenerator.test.ts

@@ -126,6 +126,8 @@ function createMockVariableDecl(options: {
   name: string;
   type: string;
   isConst?: boolean;
+  isAtomic?: boolean;
+  isVolatile?: boolean;
   initialValue?: string;
   arrayDims?: string[];
   hasStringType?: boolean;
@@ -142,6 +144,10 @@ function createMockVariableDecl(options: {
         options.arrayTypeSize,
       ),
     constModifier: () => createMockConstModifier(options.isConst ?? false),
+    // Issue #998: atomic and volatile modifiers for scope variables
+    // Uses VariableModifierBuilder for consistent handling
+    atomicModifier: () => (options.isAtomic ? ({} as unknown) : null),
+    volatileModifier: () => (options.isVolatile ? ({} as unknown) : null),
     expression: () =>
       options.initialValue ? createMockExpression(options.initialValue) : null,
     arrayDimension: () =>
@@ -772,6 +778,86 @@ describe("ScopeGenerator", () => {
       expect(result.code).toContain("static Point Canvas_point = 0;");
       expect(result.code).not.toContain("Point*");
     });
+
+    it("generates atomic variable with volatile modifier (Issue #998)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "counter",
+        type: "u32",
+        isAtomic: true,
+        initialValue: "0",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("ISR", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain(
+        "static volatile uint32_t ISR_counter = 0;",
+      );
+    });
+
+    it("generates public atomic variable with volatile but without static (Issue #998)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "flag",
+        type: "bool",
+        isAtomic: true,
+        initialValue: "false",
+      });
+      const member = createMockScopeMember({
+        visibility: "public",
+        variableDecl: varDecl,
+      });
+      const ctx = createMockScopeContext("Shared", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("volatile bool Shared_flag = false;");
+      expect(result.code).not.toContain("static volatile bool Shared_flag");
+    });
+
+    it("generates volatile-keyword variable with volatile modifier (Issue #998)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "reg",
+        type: "u8",
+        isVolatile: true,
+        initialValue: "0",
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("HW", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      const result = generateScope(ctx, input, state, orchestrator);
+
+      expect(result.code).toContain("static volatile uint8_t HW_reg = 0;");
+    });
+
+    it("throws error when both atomic and volatile are specified (Issue #998)", () => {
+      const varDecl = createMockVariableDecl({
+        name: "bad",
+        type: "u8",
+        isAtomic: true,
+        isVolatile: true,
+        initialValue: "0",
+        startLine: 10,
+      });
+      const member = createMockScopeMember({ variableDecl: varDecl });
+      const ctx = createMockScopeContext("Test", [member]);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator();
+
+      expect(() => generateScope(ctx, input, state, orchestrator)).toThrow(
+        /Cannot use both 'atomic' and 'volatile' modifiers/,
+      );
+    });
   });
 
   // ========================================================================

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

@@ -18,6 +18,7 @@ import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
 import BinaryExprUtils from "./BinaryExprUtils";
+import CodeGenState from "../../../../state/CodeGenState";
 
 /**
  * Generator context passed to child generators.
@@ -116,6 +117,7 @@ const generateAndExpr = (
  * ADR-001: = becomes == in C
  * ADR-017: Enum type safety validation
  * ADR-045: String comparison via strcmp()
+ * Issue #1032: Clear expectedType for comparison operands
  */
 const generateEqualityExpr = (
   node: Parser.EqualityExpressionContext,
@@ -151,18 +153,14 @@ const generateEqualityExpr = (
       // Generate strcmp for string comparison - needs string.h
       effects.push({ type: "include", header: "string" });
 
-      const leftResult = generateRelationalExpr(
-        exprs[0],
-        input,
-        state,
-        orchestrator,
-      );
-      const rightResult = generateRelationalExpr(
-        exprs[1],
-        input,
-        state,
-        orchestrator,
-      );
+      // Issue #1032: Clear expectedType for equality comparisons.
+      // Use CodeGenState.withoutExpectedType() to clear the global state that
+      // generators read via getState(). The passed state is not used for
+      // expectedType lookup - generators read from CodeGenState directly.
+      const [leftResult, rightResult] = CodeGenState.withoutExpectedType(() => [
+        generateRelationalExpr(exprs[0], input, state, orchestrator),
+        generateRelationalExpr(exprs[1], input, state, orchestrator),
+      ]);
       effects.push(...leftResult.effects, ...rightResult.effects);
 
       const fullText = node.getText();
@@ -183,18 +181,29 @@ const generateEqualityExpr = (
   // Issue #152: Extract operators in order from parse tree children
   // ADR-001: C-Next uses = for equality, transpile to ==
   const operators = orchestrator.getOperatorsFromChildren(node);
-  return accumulateBinaryExprs(
-    exprs,
-    operators,
-    "=",
-    generateRelationalExpr,
-    { input, state, orchestrator },
-    BinaryExprUtils.mapEqualityOperator,
+
+  // Issue #1032: Clear expectedType for equality comparisons.
+  // The U suffix for MISRA 7.2 compliance applies to assignments, not comparisons.
+  // Use CodeGenState.withoutExpectedType() to clear the global state that
+  // generators read via getState(). The passed state is not used for
+  // expectedType lookup - generators read from CodeGenState directly.
+  return CodeGenState.withoutExpectedType(() =>
+    accumulateBinaryExprs(
+      exprs,
+      operators,
+      "=",
+      generateRelationalExpr,
+      { input, state, orchestrator },
+      BinaryExprUtils.mapEqualityOperator,
+    ),
   );
 };
 
 /**
  * Generate C code for a relational expression.
+ * Issue #1032: Clear expectedType for comparison operands - MISRA 7.2 suffix
+ * should not apply to comparisons, only to assignments. This prevents
+ * `i32 < 0` from becoming `signedIdx < 0U` which changes comparison semantics.
  */
 const generateRelationalExpr = (
   node: Parser.RelationalExpressionContext,
@@ -210,11 +219,21 @@ const generateRelationalExpr = (
 
   // Issue #152: Extract operators in order from parse tree children
   const operators = orchestrator.getOperatorsFromChildren(node);
-  return accumulateBinaryExprs(exprs, operators, "<", generateBitwiseOrExpr, {
-    input,
-    state,
-    orchestrator,
-  });
+
+  // Issue #1032: Clear expectedType for relational comparisons.
+  // The U suffix for MISRA 7.2 compliance applies to assignments, not comparisons.
+  // Comparing `i32 < 0` should NOT generate `signedIdx < 0U` because that
+  // changes semantics due to C's integer promotion rules.
+  // Use CodeGenState.withoutExpectedType() to clear the global state that
+  // generators read via getState(). The passed state is not used for
+  // expectedType lookup - generators read from CodeGenState directly.
+  return CodeGenState.withoutExpectedType(() =>
+    accumulateBinaryExprs(exprs, operators, "<", generateBitwiseOrExpr, {
+      input,
+      state,
+      orchestrator,
+    }),
+  );
 };
 
 /**

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

@@ -104,6 +104,29 @@ const _parameterExpectsAddressOf = (
   return paramBaseType === argType;
 };
 
+/**
+ * Resolve an argument expression's C-Next type for the address-of decision.
+ * Prefers the expression type, then the codegen variable registry, then the C
+ * symbol table — the last covers extern C globals (e.g. an lvgl font
+ * `lv_font_montserrat_32` of type `lv_font_t`, Issue #985) whose type only
+ * header symbol collection knows. Returns null when the type can't be resolved
+ * or the argument is already an address-of expression.
+ */
+const _resolveArgType = (
+  e: ExpressionContext,
+  argCode: string,
+  typeInfoBaseType: string | undefined,
+  orchestrator: IOrchestrator,
+): string | null => {
+  const exprType = orchestrator.getExpressionType(e);
+  if (exprType) return exprType;
+  if (argCode.startsWith("&")) return null;
+  if (typeInfoBaseType) return typeInfoBaseType;
+  const cSymbol = CodeGenState.symbolTable?.getCSymbol(argCode);
+  if (cSymbol?.kind === "variable" && !cSymbol.isArray) return cSymbol.type;
+  return null;
+};
+
 /**
  * Generate argument code for a C/C++ function call.
  * Handles automatic address-of (&) for struct arguments passed to pointer params.
@@ -148,25 +171,16 @@ const _generateCFunctionArg = (
     return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
   }
 
-  // Try getExpressionType first
-  let argType = orchestrator.getExpressionType(e);
-
-  // Issue #322: If getExpressionType returns null (e.g., for this.member),
-  // fall back to looking up the generated code in the type registry
-  let isPointerVariable = false;
+  // Resolve the argument's type (expression type → variable registry → C symbol
+  // table for extern globals) to decide whether it needs address-of.
   const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
-  if (!argType && !argCode.startsWith("&")) {
-    if (typeInfo) {
-      argType = typeInfo.baseType;
-    }
-  }
-  // Issue #895 Bug B: Check if variable was inferred as a pointer
-  if (typeInfo?.isPointer) {
-    isPointerVariable = true;
-  }
+  const argType = _resolveArgType(e, argCode, typeInfo?.baseType, orchestrator);
+  // Issue #895 Bug B: a variable already inferred as a pointer must not get `&`.
+  const isPointerVariable = typeInfo?.isPointer ?? false;
 
   // Issue #948: Check if argument is an opaque scope variable (already a pointer)
-  const isOpaqueScopeVar = CodeGenState.isOpaqueScopeVariable(argCode);
+  // Issue #996: ...including an element of an opaque-handle array (arr[i])
+  const isOpaqueScopeVar = CodeGenState.isOpaqueScopeVariableAccess(argCode);
 
   // Add & if argument needs address-of to match parameter type.
   // Issue #322: struct types passed to pointer params.
@@ -284,50 +298,54 @@ const generateFunctionCall = (
   // Get function signature once for all arguments
   const sig = input.functionSignatures.get(funcExpr);
 
-  const args = argExprs
-    .map((e, idx) => {
-      // Get parameter type info from local signature or cross-file SymbolTable
-      const resolved = CallExprUtils.resolveTargetParam(
-        sig,
-        idx,
-        funcExpr,
-        input.symbolTable,
-      );
-      const targetParam = resolved.param;
-
-      // C/C++ function: use pass-by-value semantics
-      if (!isCNextFunc) {
-        return _generateCFunctionArg(e, targetParam, input, orchestrator);
-      }
-
-      // C-Next function: check if target parameter should be passed by value
-      if (
-        _shouldPassByValue(
-          funcExpr,
+  // Issue #992: Clear inDeclarationInit for function call arguments — struct
+  // initializers inside function args need compound literals, not plain designated initializers.
+  const args = CodeGenState.withoutDeclarationInit(() =>
+    argExprs
+      .map((e, idx) => {
+        // Get parameter type info from local signature or cross-file SymbolTable
+        const resolved = CallExprUtils.resolveTargetParam(
+          sig,
           idx,
-          targetParam,
-          resolved.isCrossFile,
-          orchestrator,
-        )
-      ) {
-        // Issue #872: Set expectedType for MISRA 7.2 compliance, but suppress bare enum resolution
-        const argCode = CodeGenState.withExpectedType(
-          targetParam?.baseType,
-          () => orchestrator.generateExpression(e),
-          true, // suppressEnumResolution
-        );
-        return wrapWithCppEnumCast(
-          argCode,
-          e,
-          targetParam?.baseType,
-          orchestrator,
+          funcExpr,
+          input.symbolTable,
         );
-      }
-
-      // Target parameter is pass-by-reference: use & logic
-      return orchestrator.generateFunctionArg(e, targetParam?.baseType);
-    })
-    .join(", ");
+        const targetParam = resolved.param;
+
+        // C/C++ function: use pass-by-value semantics
+        if (!isCNextFunc) {
+          return _generateCFunctionArg(e, targetParam, input, orchestrator);
+        }
+
+        // C-Next function: check if target parameter should be passed by value
+        if (
+          _shouldPassByValue(
+            funcExpr,
+            idx,
+            targetParam,
+            resolved.isCrossFile,
+            orchestrator,
+          )
+        ) {
+          // Issue #872: Set expectedType for MISRA 7.2 compliance, but suppress bare enum resolution
+          const argCode = CodeGenState.withExpectedType(
+            targetParam?.baseType,
+            () => orchestrator.generateExpression(e),
+            true, // suppressEnumResolution
+          );
+          return wrapWithCppEnumCast(
+            argCode,
+            e,
+            targetParam?.baseType,
+            orchestrator,
+          );
+        }
+
+        // Target parameter is pass-by-reference: use & logic
+        return orchestrator.generateFunctionArg(e, targetParam?.baseType);
+      })
+      .join(", "),
+  );
 
   return { code: `${funcExpr}(${args})`, effects };
 };

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

@@ -15,6 +15,7 @@ import TGeneratorEffect from "../TGeneratorEffect";
 import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
+import CodeGenState from "../../../../state/CodeGenState";
 
 /**
  * Generate C code for an expression (entry point).
@@ -74,9 +75,15 @@ const generateTernaryExpr = (
   orchestrator.validateTernaryConditionNoFunctionCall(condition);
 
   // Generate C output - parentheses already present from grammar
+  // Issue #992: Clear inDeclarationInit in ternary arms — struct initializers
+  // inside ternary branches need compound literals, not plain designated initializers.
   const condCode = orchestrator.generateOrExpr(condition);
-  const trueCode = orchestrator.generateOrExpr(trueExpr);
-  const falseCode = orchestrator.generateOrExpr(falseExpr);
+  const trueCode = CodeGenState.withoutDeclarationInit(() =>
+    orchestrator.generateOrExpr(trueExpr),
+  );
+  const falseCode = CodeGenState.withoutDeclarationInit(() =>
+    orchestrator.generateOrExpr(falseExpr),
+  );
 
   return { code: `(${condCode}) ? ${trueCode} : ${falseCode}`, effects };
 };

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

@@ -155,17 +155,14 @@ const generatePostfixExpression = (
   // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
   const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
 
-  // Issue #579: Check if we have subscript access on a non-array parameter
-  const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
-  const isNonArrayParamWithSubscript =
-    paramInfo && !paramInfo.isArray && !paramInfo.isStruct && hasSubscriptOps;
-
-  let result: string;
-  if (isNonArrayParamWithSubscript) {
-    result = rootIdentifier!;
-  } else {
-    result = orchestrator.generatePrimaryExpr(primary);
-  }
+  // Issue #1100: Subscripted parameters resolve through the normal primary
+  // expression path (ParameterDereferenceResolver), same as any other
+  // parameter reference. This is a no-op for array/struct/string params
+  // (already pointer-like, so `buf[idx]` is unaffected), and correctly
+  // dereferences a scalar parameter that became a pointer because it's
+  // modified elsewhere in the function, so bit access (`v[4]`) reads
+  // through the pointer instead of pointer-indexing past it.
+  const result: string = orchestrator.generatePrimaryExpr(primary);
 
   const primaryTypeInfo = rootIdentifier
     ? CodeGenState.getVariableTypeInfo(rootIdentifier)
@@ -1805,6 +1802,14 @@ const handleBitRangeSubscript = (
     orchestrator.generateExpression(exprs[1]),
   ]);
 
+  // Issue #1094: resolve a const/macro width to its numeric value so the mask is
+  // precomputed (byte-identical to a literal width) instead of a runtime
+  // ((1U << W) - 1) — which is UB at full width (1U << 32) and uses the wrong
+  // base type for >32-bit widths. The "U" suffix matches the literal path, which
+  // generates bit widths under a size_t expectedType.
+  const widthConst = orchestrator.tryEvaluateConstant(exprs[1]);
+  const maskWidth = widthConst === undefined ? width : `${widthConst}U`;
+
   const isFloatType =
     ctx.primaryTypeInfo?.baseType === "f32" ||
     ctx.primaryTypeInfo?.baseType === "f64";
@@ -1817,13 +1822,19 @@ const handleBitRangeSubscript = (
         baseType: ctx.primaryTypeInfo!.baseType,
         start,
         width,
+        maskWidth,
       },
       state,
       orchestrator,
       effects,
     );
   } else {
-    const mask = orchestrator.generateBitMask(width);
+    // Issue #1094: 64-bit operands need a 64-bit mask base (1ULL / wide hex) so
+    // widths > 32 don't shift past a 32-bit literal's width.
+    const is64BitOperand =
+      ctx.primaryTypeInfo?.baseType === "u64" ||
+      ctx.primaryTypeInfo?.baseType === "i64";
+    const mask = orchestrator.generateBitMask(maskWidth, is64BitOperand);
     // Skip shift when start is 0 (either "0" or "0U" with MISRA suffix)
     let expr: string;
     if (start === "0" || start === "0U") {
@@ -1861,6 +1872,8 @@ interface IFloatBitRangeContext {
   baseType: string;
   start: string;
   width: string;
+  /** Width formatted for mask generation (const-resolved when possible, #1094). */
+  maskWidth: string;
 }
 
 /**
@@ -1892,7 +1905,7 @@ const handleFloatBitRange = (
   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 mask = orchestrator.generateBitMask(ctx.maskWidth, isF64);
 
   const needsDeclaration = !orchestrator.hasFloatBitShadow(shadowName);
   if (needsDeclaration) {

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

@@ -1477,4 +1477,48 @@ describe("CallExprGenerator", () => {
       expect(result.code).toBe("use_handle(my_handle)");
     });
   });
+
+  describe("inDeclarationInit clearing (Issue #992)", () => {
+    it("clears inDeclarationInit during function argument generation", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      const argExprs = [createMockExpressionContext("myArg")];
+      const argCtx = createMockArgListContext(argExprs);
+      const input = createMockInput();
+      const state = createMockState();
+
+      let flagDuringArg = true;
+      const orchestrator = createMockOrchestrator({
+        isCNextFunction: vi.fn(() => false),
+        generateExpression: vi.fn((ctx: Parser.ExpressionContext) => {
+          flagDuringArg = CodeGenState.inDeclarationInit;
+          return ctx.getText();
+        }),
+      });
+
+      generateFunctionCall("myFunc", argCtx, input, state, orchestrator);
+
+      expect(flagDuringArg).toBe(false);
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+
+    it("restores inDeclarationInit after argument generation", () => {
+      CodeGenState.inDeclarationInit = true;
+
+      const argExprs = [
+        createMockExpressionContext("a"),
+        createMockExpressionContext("b"),
+      ];
+      const argCtx = createMockArgListContext(argExprs);
+      const input = createMockInput();
+      const state = createMockState();
+      const orchestrator = createMockOrchestrator({
+        isCNextFunction: vi.fn(() => false),
+      });
+
+      generateFunctionCall("myFunc", argCtx, input, state, orchestrator);
+
+      expect(CodeGenState.inDeclarationInit).toBe(true);
+    });
+  });
 });

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

@@ -1,9 +1,10 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import expressionGenerators from "../ExpressionGenerator";
 import IGeneratorInput from "../../IGeneratorInput";
 import IGeneratorState from "../../IGeneratorState";
 import IOrchestrator from "../../IOrchestrator";
 import * as Parser from "../../../../../logic/parser/grammar/CNextParser";
+import CodeGenState from "../../../../../state/CodeGenState";
 
 // ========================================================================
 // Test Helpers
@@ -455,6 +456,86 @@ describe("ExpressionGenerator", () => {
       });
     });
 
+    describe("inDeclarationInit clearing (Issue #992)", () => {
+      beforeEach(() => {
+        CodeGenState.reset();
+      });
+
+      it("clears inDeclarationInit in ternary true and false arms", () => {
+        CodeGenState.inDeclarationInit = true;
+
+        const condition = createMockOrExpr("x > 0");
+        const trueExpr = createMockOrExpr("a");
+        const falseExpr = createMockOrExpr("b");
+        const ctx = createMockTernaryContext([condition, trueExpr, falseExpr]);
+
+        const input = createMockInput();
+        const state = createMockState();
+
+        const flagDuringTrue: boolean[] = [];
+        const flagDuringFalse: boolean[] = [];
+
+        const orchestrator = createMockOrchestrator();
+        let callCount = 0;
+        (
+          orchestrator.generateOrExpr as ReturnType<typeof vi.fn>
+        ).mockImplementation((ctx: Parser.OrExpressionContext) => {
+          callCount++;
+          if (callCount === 2) {
+            flagDuringTrue.push(CodeGenState.inDeclarationInit);
+          } else if (callCount === 3) {
+            flagDuringFalse.push(CodeGenState.inDeclarationInit);
+          }
+          return ctx.getText();
+        });
+
+        expressionGenerators.generateTernaryExpr(
+          ctx,
+          input,
+          state,
+          orchestrator,
+        );
+
+        expect(flagDuringTrue).toEqual([false]);
+        expect(flagDuringFalse).toEqual([false]);
+        expect(CodeGenState.inDeclarationInit).toBe(true);
+      });
+
+      it("does not affect condition generation", () => {
+        CodeGenState.inDeclarationInit = true;
+
+        const condition = createMockOrExpr("x > 0");
+        const trueExpr = createMockOrExpr("a");
+        const falseExpr = createMockOrExpr("b");
+        const ctx = createMockTernaryContext([condition, trueExpr, falseExpr]);
+
+        const input = createMockInput();
+        const state = createMockState();
+
+        let flagDuringCondition = false;
+        const orchestrator = createMockOrchestrator();
+        let callCount = 0;
+        (
+          orchestrator.generateOrExpr as ReturnType<typeof vi.fn>
+        ).mockImplementation((ctx: Parser.OrExpressionContext) => {
+          callCount++;
+          if (callCount === 1) {
+            flagDuringCondition = CodeGenState.inDeclarationInit;
+          }
+          return ctx.getText();
+        });
+
+        expressionGenerators.generateTernaryExpr(
+          ctx,
+          input,
+          state,
+          orchestrator,
+        );
+
+        expect(flagDuringCondition).toBe(true);
+      });
+    });
+
     describe("effects", () => {
       it("returns empty effects array for non-ternary", () => {
         const orExpr = createMockOrExpr("value");