c-next 0.2.15 → 0.2.17

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

@@ -1504,7 +1504,7 @@ describe("CodeGenerator", () => {
 
     it("should generate multi-dimensional array", () => {
       const source = `
-        u32[3] matrix[3];
+        u32[3][3] matrix;
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -2944,7 +2944,7 @@ describe("CodeGenerator", () => {
   describe("Inferred array size", () => {
     it("should generate array with inferred size from initializer", () => {
       const source = `
-        u32 values[] <- [1, 2, 3, 4, 5];
+        u32[] values <- [1, 2, 3, 4, 5];
         void main() { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -3799,7 +3799,7 @@ describe("CodeGenerator", () => {
   describe("Nested array initializers", () => {
     it("should generate 2D array initializer", () => {
       const source = `
-        u32[2] matrix[3] <- [[1, 2, 3], [4, 5, 6]];
+        u32[2][3] matrix <- [[1, 2, 3], [4, 5, 6]];
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -4097,7 +4097,7 @@ describe("CodeGenerator", () => {
   describe("Multi-dimensional array", () => {
     it("should generate 3D array declaration", () => {
       const source = `
-        u8[2] cube[3][4];
+        u8[2][3][4] cube;
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -6932,7 +6932,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("ExternalClass obj = {}");
       });
 
-      it("should initialize known structs to {0} even in C++ mode", () => {
+      it("should initialize known structs to {} in C++ mode (Issue #1004)", () => {
         const source = `
           struct Point { i32 x; i32 y; }
           void main() {
@@ -6950,8 +6950,10 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        // Known C-Next structs are POD types, {0} works fine
-        expect(code).toContain("Point p = {0}");
+        // Issue #1004: C++ value-initialization ({}) is valid for any struct,
+        // including ones whose first field is an enum where {0} would be an
+        // invalid int->enum narrowing.
+        expect(code).toContain("Point p = {}");
       });
 
       // Note: Template type tests skipped - template argument transformation
@@ -7023,7 +7025,7 @@ describe("CodeGenerator", () => {
         expect(code).not.toContain("uint8_t* buf");
       });
 
-      it("should generate primitive C-Next style arrays with {0} in C++ mode", () => {
+      it("should generate primitive C-Next style arrays with {} in C++ mode (Issue #1004)", () => {
         const source = `
           void main() {
               u32[8] counters;
@@ -7040,8 +7042,9 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        // Primitive type arrays should still use {0}
-        expect(code).toContain("uint32_t counters[8] = {0}");
+        // Issue #1004: C++ arrays value-initialize with {} regardless of
+        // element type (one unified aggregate zero-init rule).
+        expect(code).toContain("uint32_t counters[8] = {}");
       });
 
       it("should generate unknown user type C-Next style arrays with {} in C++ mode", () => {
@@ -7065,7 +7068,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("UnknownType items[4] = {}");
       });
 
-      it("should generate known C-Next struct arrays with {0} in C++ mode", () => {
+      it("should generate known C-Next struct arrays with {} in C++ mode (Issue #1004)", () => {
         const source = `
           struct Point { i32 x; i32 y; }
           void main() {
@@ -7083,8 +7086,9 @@ describe("CodeGenerator", () => {
           cppMode: true,
         });
 
-        // Known C-Next structs are POD types, {0} is correct
-        expect(code).toContain("Point pts[3] = {0}");
+        // Issue #1004: C++ struct arrays value-initialize with {}, valid even
+        // when the struct's first field is an enum.
+        expect(code).toContain("Point pts[3] = {}");
       });
     });
   });
@@ -8483,7 +8487,7 @@ describe("CodeGenerator", () => {
       it("should handle multi-dimensional array access", () => {
         const source = `
           void test() {
-            u32[3] matrix[3];
+            u32[3][3] matrix;
             u32 val <- matrix[1][2];
           }
         `;
@@ -9420,7 +9424,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("(x > 3U) ? 10U : 20U");
+        // Issue #1032: Comparison operands don't get U suffix (would change semantics)
+        // but ternary arms do (they're assigned to u32 result)
+        expect(code).toContain("(x > 3) ? 10U : 20U");
       });
     });
 
@@ -11293,7 +11299,7 @@ describe("CodeGenerator", () => {
       it("should allow empty brackets for size inference", () => {
         const source = `
           void test() {
-            u8 data[] <- [1, 2, 3];
+            u8[] data <- [1, 2, 3];
           }
         `;
         const { tree, tokenStream } = CNextSourceParser.parse(source);
@@ -11309,7 +11315,7 @@ describe("CodeGenerator", () => {
         expect(code).toContain("uint8_t data[3]");
       });
 
-      it("should allow multi-dimensional C-style arrays", () => {
+      it("should reject multi-dimensional C-style arrays (Issue #1014)", () => {
         const source = `
           void test() {
             u8 matrix[4][4];
@@ -11321,6 +11327,26 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
+        expect(() =>
+          generator.generate(tree, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          }),
+        ).toThrow("C-style array declaration is not allowed");
+      });
+
+      it("should allow multi-dimensional C-Next style arrays", () => {
+        const source = `
+          void test() {
+            u8[4][4] matrix;
+            matrix[0][0] <- 0;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
         const code = generator.generate(tree, tokenStream, {
           symbolInfo: symbols,
           sourcePath: "test.cnx",
@@ -14042,7 +14068,7 @@ describe("CodeGenerator", () => {
       it("should detect array element of string array", () => {
         const source = `
           void test() {
-            string<32> names[3];
+            string<32>[3] names;
             names[0] <- "Alice";
             bool check <- (names[0] = "Alice");
           }
@@ -14086,7 +14112,7 @@ describe("CodeGenerator", () => {
       it("should register multi-dimensional array", () => {
         const source = `
           void test() {
-            u8[10] matrix[20];
+            u8[10][20] matrix;
             matrix[0][0] <- 0;
           }
         `;
@@ -14892,8 +14918,8 @@ describe("CodeGenerator", () => {
       });
     });
 
-    describe("break and continue statements", () => {
-      it("should generate break in loop", () => {
+    describe("break and continue rejection (Issue #1011)", () => {
+      it("should reject break - not part of C-Next spec", () => {
         const source = `
           void test() {
             while (true) {
@@ -14906,15 +14932,15 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
-        const code = generator.generate(tree, tokenStream, {
-          symbolInfo: symbols,
-          sourcePath: "test.cnx",
-        });
-
-        expect(code).toContain("break;");
+        expect(() =>
+          generator.generate(tree, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          }),
+        ).toThrow("'break' is not supported in C-Next");
       });
 
-      it("should generate continue in loop", () => {
+      it("should reject continue - not part of C-Next spec", () => {
         const source = `
           void test() {
             u32 i <- 0;
@@ -14931,12 +14957,12 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
-        const code = generator.generate(tree, tokenStream, {
-          symbolInfo: symbols,
-          sourcePath: "test.cnx",
-        });
-
-        expect(code).toContain("continue;");
+        expect(() =>
+          generator.generate(tree, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          }),
+        ).toThrow("'continue' is not supported in C-Next");
       });
     });
 
@@ -15632,4 +15658,94 @@ describe("CodeGenerator", () => {
       }).toThrow("Error: enum generator not registered");
     });
   });
+
+  describe("struct initializer — declaration vs expression context", () => {
+    it("should use designated initializer without type cast for global struct declaration", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        Point origin <- {x: 0, y: 0};
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      // Must use plain designated initializer — (Point){...} is not a C99 constant expression
+      // and fails to compile at file scope on GCC < 13
+      expect(code).toContain("origin = { .x = 0, .y = 0 }");
+      expect(code).not.toContain("(Point)");
+    });
+
+    it("should use designated initializer without type cast for local struct declaration", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        void foo() {
+          Point p <- {x: 10, y: 20};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      expect(code).toContain("p = { .x = 10, .y = 20 }");
+      expect(code).not.toContain("(Point)");
+    });
+
+    it("should use designated initializer for nested struct literals in declaration", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        struct Line { Point start; Point end; }
+        Line seg <- {start: {x: 0, y: 0}, end: {x: 100, y: 100}};
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      // Neither outer nor inner initializer should have a type cast prefix
+      expect(code).toContain(
+        "{ .start = { .x = 0, .y = 0 }, .end = { .x = 100, .y = 100 } }",
+      );
+      expect(code).not.toContain("(Line)");
+      expect(code).not.toContain("(Point)");
+    });
+
+    it("should keep compound literal type cast for struct re-assignment (expression context)", () => {
+      const source = `
+        struct Point { i32 x; i32 y; }
+        void foo() {
+          Point p <- {x: 0, y: 0};
+          p <- {x: 10, y: 20};
+        }
+      `;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "test.cnx",
+      });
+
+      // Re-assignment must use compound literal — plain { } is not valid as an expression
+      expect(code).toContain("p = (Point){ .x = 10, .y = 20 }");
+    });
+  });
 });

package/src/transpiler/output/codegen/__tests__/TrackVariableTypeHelpers.test.ts

@@ -27,7 +27,7 @@ describe("trackVariableTypeWithName helpers", () => {
   describe("extractArrayDimensionsSimple", () => {
     it("handles string array with single dimension", async () => {
       const source = `
-        string<32> messages[4];
+        string<32>[4] messages;
         void main() {
           messages[0] <- "Hello";
         }
@@ -39,7 +39,7 @@ describe("trackVariableTypeWithName helpers", () => {
 
     it("handles string array with multiple dimensions", async () => {
       const source = `
-        string<16> grid[2][3];
+        string<16>[2][3] grid;
         void main() {
           grid[0][0] <- "test";
         }

package/src/transpiler/output/codegen/__tests__/TypeValidator.test.ts

@@ -650,6 +650,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -665,6 +666,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -702,6 +704,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -728,6 +731,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -743,6 +747,7 @@ describe("TypeValidator", () => {
             type: "float",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -763,6 +768,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: true,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -778,6 +784,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -798,6 +805,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: true,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -813,6 +821,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },
@@ -833,6 +842,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: true,
             arrayDims: "[10]",
           },
@@ -848,6 +858,7 @@ describe("TypeValidator", () => {
             type: "int",
             isConst: false,
             isPointer: false,
+            isStruct: false,
             isArray: false,
             arrayDims: "",
           },

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

@@ -25,6 +25,8 @@ import BitmapCommentUtils from "./BitmapCommentUtils";
 import ArrayDimensionUtils from "./ArrayDimensionUtils";
 import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 import CodeGenState from "../../../../state/CodeGenState";
+import ScopeUtils from "../../../../../utils/ScopeUtils";
+import VariableModifierBuilder from "../../helpers/VariableModifierBuilder";
 
 /**
  * Generate initializer expression for a variable declaration.
@@ -37,10 +39,12 @@ function generateInitializer(
 ): string {
   if (varDecl.expression()) {
     // Issue #872: Set expectedType for MISRA 7.2 U suffix compliance
+    // Issue #992: withDeclarationInit suppresses compound literals at file scope (GCC 9-12 compat)
     const typeName = orchestrator.generateType(varDecl.type());
-    return CodeGenState.withExpectedType(
-      typeName,
-      () => ` = ${orchestrator.generateExpression(varDecl.expression()!)}`,
+    return CodeGenState.withExpectedType(typeName, () =>
+      CodeGenState.withDeclarationInit(
+        () => ` = ${orchestrator.generateExpression(varDecl.expression()!)}`,
+      ),
     );
   }
   // ADR-015: Zero initialization for uninitialized scope variables
@@ -203,12 +207,23 @@ function generateRegularVariable(
     orchestrator.markOpaqueScopeVariable(fullName);
   }
 
-  // Issue #282: Add 'const' modifier for const variables
+  // Issue #998: Use VariableModifierBuilder for consistent modifier handling
+  // This handles const, atomic, volatile, and validates mutual exclusion
+  // Scope variables are always at file scope (not in function body), no initializer for modifier purposes
+  const modifiers = VariableModifierBuilder.build(
+    varDecl,
+    false, // inFunctionBody - scope vars are file scope
+    false, // hasInitializer - doesn't affect volatile/atomic handling
+    false, // cppMode - doesn't affect volatile/atomic handling
+  );
+  // For scope variables: static for private, no modifier for public
+  // Then add volatile (from atomic or volatile keyword), then const
+  const staticPrefix = isPrivate ? "static " : "";
+  const volatilePrefix = modifiers.atomic || modifiers.volatile;
   const constPrefix = isConst ? "const " : "";
-  const prefix = isPrivate ? "static " : "";
 
   // Build declaration with all dimensions
-  let decl = `${prefix}${constPrefix}${type} ${fullName}`;
+  let decl = `${staticPrefix}${volatilePrefix}${constPrefix}${type} ${fullName}`;
   decl += ArrayDimensionUtils.generateArrayTypeDimension(
     arrayTypeCtx,
     orchestrator,
@@ -224,7 +239,12 @@ function generateRegularVariable(
 
   // Issue #948: Opaque types use NULL initialization instead of {0}
   // Issue #958: External typedef struct types also use NULL initialization
-  if (isOpaque || isExternalStruct) {
+  // Issue #996: ...but only for SCALAR handles, which are single pointers. An
+  // *array* of opaque handles needs a brace initializer ({0}), not a scalar
+  // NULL. Route arrays through generateInitializer, which uses
+  // getZeroInitializer(type, isArray) — the single source of truth for
+  // zero-initialization (ADR-015).
+  if ((isOpaque || isExternalStruct) && !isArray) {
     decl += " = NULL";
   } else {
     decl += generateInitializer(varDecl, isArray, orchestrator);
@@ -338,7 +358,11 @@ function processScopeMember(
   state: IGeneratorState,
   orchestrator: IOrchestrator,
 ): string[] {
-  const visibility = member.visibilityModifier()?.getText() || "private";
+  // ADR-016: Member-type-aware visibility defaults via ScopeUtils
+  const explicitVisibility = member.visibilityModifier()?.getText();
+  const isFunction = member.functionDeclaration() !== null;
+  const visibility =
+    explicitVisibility ?? ScopeUtils.getDefaultVisibility(isFunction);
   const isPrivate = visibility === "private";
 
   // Handle variable declarations

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/,
+      );
+    });
   });
 
   // ========================================================================
@@ -857,7 +943,11 @@ describe("ScopeGenerator", () => {
         name: "helper",
         returnType: "void",
       });
-      const member = createMockScopeMember({ functionDecl: funcDecl });
+      // ADR-016: Functions are public by default, so explicit 'private' needed
+      const member = createMockScopeMember({
+        visibility: "private",
+        functionDecl: funcDecl,
+      });
       const ctx = createMockScopeContext("Utils", [member]);
       const input = createMockInput();
       const state = createMockState();