c-next 0.2.16 → 0.2.18

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

@@ -310,9 +310,12 @@ describe("StringDeclHelper", () => {
     });
 
     it("allows assignment when source capacity fits", () => {
+      // Issue #1044: String variable initialization uses a bounded strncpy
+      // (shared with the reassignment path), not an unsafe strcpy (CWE-120).
       const callbacks = {
         ...defaultCallbacks,
         getStringExprCapacity: vi.fn(() => 20),
+        generateExpression: vi.fn(() => "smallString"),
       };
 
       const typeCtx = {
@@ -336,7 +339,82 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      expect(result.code).toContain("char dest[33] = smallString;");
+      // Issue #1044: bounded copy, not strcpy
+      expect(result.code).toContain('char dest[33] = "";');
+      expect(result.code).toContain("strncpy(dest, smallString, 32);");
+      expect(result.code).toContain("dest[32] = '\\0';");
+      expect(result.code).not.toContain("strcpy(dest, smallString)");
+    });
+
+    it("does not indent continuation lines (the block emitter owns indentation) — Issue #1037", () => {
+      // indentLevel = 1 (beforeEach). generateBlock prefixes every line of a
+      // statement, so the helper must NOT add its own indent or continuation
+      // lines double-indent.
+      const callbacks = {
+        ...defaultCallbacks,
+        getStringExprCapacity: vi.fn(() => 20),
+        generateExpression: vi.fn(() => "smallString"),
+      };
+
+      const typeCtx = {
+        stringType: () => ({
+          INTEGER_LITERAL: () => ({ getText: () => "32" }),
+        }),
+      } as never;
+
+      const expression = {
+        getText: () => "smallString",
+      } as never;
+
+      const result = StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "dest",
+        expression,
+        [],
+        { extern: "", const: "", atomic: "", volatile: "" },
+        false,
+        callbacks,
+      );
+
+      const lines = result.code.split("\n");
+      expect(lines[0]).toBe('char dest[33] = "";');
+      // Continuation line must have no leading whitespace of its own.
+      expect(lines[1]).toBe(
+        "strncpy(dest, smallString, 32); dest[32] = '\\0';",
+      );
+    });
+
+    it("throws error for string variable initialization at global scope", () => {
+      // Issue #1030: String variable initialization requires function body
+      CodeGenState.inFunctionBody = false;
+      const callbacks = {
+        ...defaultCallbacks,
+        getStringExprCapacity: vi.fn(() => 20),
+      };
+
+      const typeCtx = {
+        stringType: () => ({
+          INTEGER_LITERAL: () => ({ getText: () => "32" }),
+        }),
+      } as never;
+
+      const expression = {
+        getText: () => "sourceVar",
+      } as never;
+
+      expect(() =>
+        StringDeclHelper.generateStringDecl(
+          typeCtx,
+          "dest",
+          expression,
+          [],
+          { extern: "", const: "", atomic: "", volatile: "" },
+          false,
+          callbacks,
+        ),
+      ).toThrow(
+        "String initialization from variable cannot be used at global scope",
+      );
     });
   });
 
@@ -374,12 +452,15 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      expect(result.code).toContain('char combined[33] = "";');
-      expect(result.code).toContain("strncpy(combined, str1, 32)");
-      expect(result.code).toContain(
-        "strncat(combined, str2, 32 - strlen(combined))",
+      // Issue #1037: every line carries no indent of its own (the block emitter
+      // prefixes each line); continuation lines must not double-indent.
+      const concatLines = result.code.split("\n");
+      expect(concatLines[0]).toBe('char combined[33] = "";');
+      expect(concatLines[1]).toBe("strncpy(combined, str1, 32);");
+      expect(concatLines[2]).toBe(
+        "strncat(combined, str2, 32 - strlen(combined));",
       );
-      expect(result.code).toContain("combined[32] = '\\0';");
+      expect(concatLines[3]).toBe("combined[32] = '\\0';");
     });
 
     it("throws error for concatenation at global scope", () => {
@@ -523,9 +604,11 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      expect(result.code).toContain('char sub[11] = "";');
-      expect(result.code).toContain("strncpy(sub, srcStr + 0, 5)");
-      expect(result.code).toContain("sub[5] = '\\0';");
+      // Issue #1037: continuation lines carry no indent of their own.
+      const subLines = result.code.split("\n");
+      expect(subLines[0]).toBe('char sub[11] = "";');
+      expect(subLines[1]).toBe("strncpy(sub, srcStr + 0, 5);");
+      expect(subLines[2]).toBe("sub[5] = '\\0';");
     });
 
     it("throws error for substring at global scope", () => {
@@ -1154,4 +1237,234 @@ describe("StringDeclHelper", () => {
       expect(CodeGenState.localArrays.has("tracked")).toBe(true);
     });
   });
+
+  describe("string arrays from arrayType syntax (Issue #1029)", () => {
+    it("generates string array from arrayType without initializer", () => {
+      // Simulates: string<32>[4] items;
+      const typeCtx = {
+        stringType: () => null, // Not directly on typeCtx
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({ getText: () => "32" }),
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "4" }) },
+          ],
+        }),
+      } as never;
+
+      const result = StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "items",
+        null,
+        [],
+        { extern: "", const: "", atomic: "", volatile: "" },
+        false,
+        defaultCallbacks,
+      );
+
+      expect(result.handled).toBe(true);
+      expect(result.code).toBe("char items[4][33] = {0};");
+    });
+
+    it("generates string array from arrayType with initializer", () => {
+      const callbacks = {
+        ...defaultCallbacks,
+        generateExpression: vi.fn(() => {
+          CodeGenState.lastArrayInitCount = 2;
+          CodeGenState.lastArrayFillValue = undefined;
+          return '{"One", "Two"}';
+        }),
+      };
+
+      // Simulates: string<10>[2] labels <- ["One", "Two"];
+      const typeCtx = {
+        stringType: () => null,
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({ getText: () => "10" }),
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "2" }) },
+          ],
+        }),
+      } as never;
+
+      const expression = {
+        getText: () => '["One", "Two"]',
+      } as never;
+
+      const result = StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "labels",
+        expression,
+        [],
+        { extern: "", const: "", atomic: "", volatile: "" },
+        false,
+        callbacks,
+      );
+
+      expect(result.handled).toBe(true);
+      expect(result.code).toContain("[2]");
+      expect(result.code).toContain("[11]"); // capacity + 1
+      expect(result.code).toContain('{"One", "Two"}');
+    });
+
+    it("generates string array from arrayType with trailing dimensions", () => {
+      // Simulates: string<10>[2] matrix[3]; (2D string array)
+      const typeCtx = {
+        stringType: () => null,
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({ getText: () => "10" }),
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "2" }) },
+          ],
+        }),
+      } as never;
+
+      const trailingDims = [
+        { expression: () => ({ getText: () => "3" }) },
+      ] as never[];
+
+      const result = StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "matrix",
+        null,
+        trailingDims,
+        { extern: "", const: "", atomic: "", volatile: "" },
+        false,
+        defaultCallbacks,
+      );
+
+      expect(result.handled).toBe(true);
+      expect(result.code).toBe("char matrix[2][3][11] = {0};");
+    });
+
+    it("throws error for unsized string array from arrayType", () => {
+      // Simulates: string[4] items; (missing capacity)
+      const typeCtx = {
+        stringType: () => null,
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => null, // No capacity
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "4" }) },
+          ],
+        }),
+      } as never;
+
+      expect(() =>
+        StringDeclHelper.generateStringDecl(
+          typeCtx,
+          "items",
+          null,
+          [],
+          { extern: "", const: "", atomic: "", volatile: "" },
+          false,
+          defaultCallbacks,
+        ),
+      ).toThrow("String arrays require explicit capacity");
+    });
+
+    it("validates element count matches declared size from arrayType", () => {
+      const callbacks = {
+        ...defaultCallbacks,
+        generateExpression: vi.fn(() => {
+          CodeGenState.lastArrayInitCount = 2; // Only 2 elements
+          CodeGenState.lastArrayFillValue = undefined;
+          return '{"One", "Two"}';
+        }),
+      };
+
+      // Simulates: string<10>[4] items <- ["One", "Two"]; (size mismatch)
+      const typeCtx = {
+        stringType: () => null,
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({ getText: () => "10" }),
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "4" }) }, // Declared size = 4
+          ],
+        }),
+      } as never;
+
+      const expression = {
+        getText: () => '["One", "Two"]',
+      } as never;
+
+      expect(() =>
+        StringDeclHelper.generateStringDecl(
+          typeCtx,
+          "items",
+          expression,
+          [],
+          { extern: "", const: "", atomic: "", volatile: "" },
+          false,
+          callbacks,
+        ),
+      ).toThrow("Array size mismatch - declared [4] but got 2 elements");
+    });
+
+    it("tracks local arrays from arrayType in localArrays set", () => {
+      const typeCtx = {
+        stringType: () => null,
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({ getText: () => "20" }),
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "3" }) },
+          ],
+        }),
+      } as never;
+
+      StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "tracked",
+        null,
+        [],
+        { extern: "", const: "", atomic: "", volatile: "" },
+        false,
+        defaultCallbacks,
+      );
+
+      expect(CodeGenState.localArrays.has("tracked")).toBe(true);
+    });
+
+    it("generates string array from arrayType with modifiers", () => {
+      const typeCtx = {
+        stringType: () => null,
+        arrayType: () => ({
+          stringType: () => ({
+            INTEGER_LITERAL: () => ({ getText: () => "8" }),
+          }),
+          arrayTypeDimension: () => [
+            { expression: () => ({ getText: () => "2" }) },
+          ],
+        }),
+      } as never;
+
+      const result = StringDeclHelper.generateStringDecl(
+        typeCtx,
+        "data",
+        null,
+        [],
+        {
+          extern: "extern ",
+          const: "const ",
+          atomic: "",
+          volatile: "volatile ",
+        },
+        true,
+        defaultCallbacks,
+      );
+
+      expect(result.handled).toBe(true);
+      expect(result.code).toContain("extern const volatile char data[2][9]");
+    });
+  });
 });

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

@@ -203,70 +203,6 @@ describe("SymbolLookupHelper", () => {
     });
   });
 
-  describe("isCppType", () => {
-    it("returns false when symbolTable is null", () => {
-      expect(SymbolLookupHelper.isCppType(null, "MyType")).toBe(false);
-    });
-
-    it("returns false when symbolTable is undefined", () => {
-      expect(SymbolLookupHelper.isCppType(undefined, "MyType")).toBe(false);
-    });
-
-    it("returns true for C++ struct", () => {
-      const mockTable = {
-        getOverloads: () => [
-          { kind: "struct" as const, sourceLanguage: ESourceLanguage.Cpp },
-        ],
-      };
-      expect(SymbolLookupHelper.isCppType(mockTable, "MyStruct")).toBe(true);
-    });
-
-    it("returns true for C++ class", () => {
-      const mockTable = {
-        getOverloads: () => [
-          { kind: "class" as const, sourceLanguage: ESourceLanguage.Cpp },
-        ],
-      };
-      expect(SymbolLookupHelper.isCppType(mockTable, "MyClass")).toBe(true);
-    });
-
-    it("returns true for C++ type alias", () => {
-      const mockTable = {
-        getOverloads: () => [
-          { kind: "type" as const, sourceLanguage: ESourceLanguage.Cpp },
-        ],
-      };
-      expect(SymbolLookupHelper.isCppType(mockTable, "MyType")).toBe(true);
-    });
-
-    it("returns false for C struct", () => {
-      const mockTable = {
-        getOverloads: () => [
-          { kind: "struct" as const, sourceLanguage: ESourceLanguage.C },
-        ],
-      };
-      expect(SymbolLookupHelper.isCppType(mockTable, "MyStruct")).toBe(false);
-    });
-
-    it("returns false for C++ function", () => {
-      const mockTable = {
-        getOverloads: () => [
-          { kind: "function" as const, sourceLanguage: ESourceLanguage.Cpp },
-        ],
-      };
-      expect(SymbolLookupHelper.isCppType(mockTable, "myFunc")).toBe(false);
-    });
-
-    it("returns false for C++ enum", () => {
-      const mockTable = {
-        getOverloads: () => [
-          { kind: "enum" as const, sourceLanguage: ESourceLanguage.Cpp },
-        ],
-      };
-      expect(SymbolLookupHelper.isCppType(mockTable, "MyEnum")).toBe(false);
-    });
-  });
-
   describe("isCNextFunction", () => {
     it("returns false when symbolTable is null", () => {
       expect(SymbolLookupHelper.isCNextFunction(null, "myFunc")).toBe(false);

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

@@ -183,5 +183,106 @@ describe("TypeRegistrationEngine", () => {
 
       expect(mockCallbacks.requireInclude).toHaveBeenCalledWith("string");
     });
+
+    it("registers string array types with correct dimensions (Issue #1029)", () => {
+      const source = `string<32>[4] items;`;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      const info = CodeGenState.getVariableTypeInfo("items");
+      expect(info).not.toBeNull();
+      expect(info?.baseType).toBe("char");
+      expect(info?.isArray).toBe(true);
+      expect(info?.isString).toBe(true);
+      expect(info?.stringCapacity).toBe(32);
+      // Dimensions: [4] for array, [33] for string capacity + null terminator
+      expect(info?.arrayDimensions).toEqual([4, 33]);
+    });
+
+    it("registers multi-dimensional string arrays (Issue #1029)", () => {
+      const source = `string<16>[2][3] matrix;`;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      const info = CodeGenState.getVariableTypeInfo("matrix");
+      expect(info).not.toBeNull();
+      expect(info?.baseType).toBe("char");
+      expect(info?.isArray).toBe(true);
+      expect(info?.isString).toBe(true);
+      expect(info?.stringCapacity).toBe(16);
+      // Dimensions: [2][3] for array, [17] for string capacity + null terminator
+      expect(info?.arrayDimensions).toEqual([2, 3, 17]);
+    });
+
+    it("requires string include for string array types (Issue #1029)", () => {
+      const source = `string<32>[4] items;`;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      expect(mockCallbacks.requireInclude).toHaveBeenCalledWith("string");
+    });
+
+    it("registers global type arrays", () => {
+      // Set up a scope context to test global.Type[N] pattern
+      CodeGenState.currentScope = "Motor";
+
+      const source = `
+        scope Motor {
+          enum State { OFF, ON }
+          global.State[3] states;
+        }
+      `;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      const info = CodeGenState.getVariableTypeInfo("Motor_states");
+      expect(info).not.toBeNull();
+      expect(info?.baseType).toBe("State");
+      expect(info?.isArray).toBe(true);
+
+      CodeGenState.currentScope = null;
+    });
+
+    it("registers qualified type arrays (Scope.Type[N])", () => {
+      const source = `
+        scope Motor {
+          public enum State { OFF, ON }
+        }
+        Motor.State[4] allStates;
+      `;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      const info = CodeGenState.getVariableTypeInfo("allStates");
+      expect(info).not.toBeNull();
+      expect(info?.baseType).toBe("Motor_State");
+      expect(info?.isArray).toBe(true);
+    });
+
+    it("registers scoped type arrays (this.Type[N])", () => {
+      CodeGenState.currentScope = "Motor";
+
+      const source = `
+        scope Motor {
+          enum State { OFF, ON }
+          this.State[2] localStates;
+        }
+      `;
+      const tree = CNextSourceParser.parse(source).tree;
+
+      TypeRegistrationEngine.register(tree, mockCallbacks);
+
+      const info = CodeGenState.getVariableTypeInfo("Motor_localStates");
+      expect(info).not.toBeNull();
+      expect(info?.baseType).toBe("Motor_State");
+      expect(info?.isArray).toBe(true);
+
+      CodeGenState.currentScope = null;
+    });
   });
 });

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

@@ -127,8 +127,8 @@ describe("VariableDeclHelper", () => {
       }).not.toThrow();
     });
 
-    it("allows empty dimension for size inference", () => {
-      const varDecl = parseVarDecl("u8 arr[] <- [1, 2, 3];");
+    it("allows empty dimension for size inference in arrayType", () => {
+      const varDecl = parseVarDecl("u8[] arr <- [1, 2, 3];");
       const typeCtx = varDecl.type();
       expect(() => {
         VariableDeclHelper.validateArrayDeclarationSyntax(
@@ -139,7 +139,19 @@ describe("VariableDeclHelper", () => {
       }).not.toThrow();
     });
 
-    it("allows multi-dimensional C-style", () => {
+    it("rejects empty dimension with C-style trailing brackets (Issue #1017)", () => {
+      const varDecl = parseVarDecl("u8 arr[] <- [1, 2, 3];");
+      const typeCtx = varDecl.type();
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "arr",
+        );
+      }).toThrow("C-style array declaration is not allowed");
+    });
+
+    it("rejects multi-dimensional C-style (Issue #1014)", () => {
       const varDecl = parseVarDecl("u8 matrix[4][4];");
       const typeCtx = varDecl.type();
       expect(() => {
@@ -148,10 +160,22 @@ describe("VariableDeclHelper", () => {
           typeCtx,
           "matrix",
         );
+      }).toThrow("C-style array declaration is not allowed");
+    });
+
+    it("allows string type with arrayType syntax", () => {
+      const varDecl = parseVarDecl("string<32>[4] names;");
+      const typeCtx = varDecl.type();
+      expect(() => {
+        VariableDeclHelper.validateArrayDeclarationSyntax(
+          varDecl,
+          typeCtx,
+          "names",
+        );
       }).not.toThrow();
     });
 
-    it("allows string type with C-style", () => {
+    it("rejects string type with C-style trailing brackets (Issue #1016)", () => {
       const varDecl = parseVarDecl("string<32> names[4];");
       const typeCtx = varDecl.type();
       expect(() => {
@@ -160,7 +184,7 @@ describe("VariableDeclHelper", () => {
           typeCtx,
           "names",
         );
-      }).not.toThrow();
+      }).toThrow("C-style array declaration is not allowed");
     });
 
     it("rejects C-style single dimension for primitives", () => {

package/src/transpiler/output/codegen/subscript/SubscriptClassifier.ts

@@ -1,5 +1,5 @@
 /**
- * Issue #579: Shared subscript classifier for array vs bit access
+ * Issue #579 / Issue #1100: Shared subscript classifier for array vs bit access
  *
  * This utility unifies the classification logic used by:
  * - AssignmentClassifier (assignment path)
@@ -7,8 +7,28 @@
  *
  * The classification rule is:
  * 1. If isArray or isString -> array access
- * 2. If isParameter && !isArray -> array access (parameter becomes pointer in C, ADR-006)
- * 3. Otherwise -> bit manipulation
+ * 2. Otherwise -> bit manipulation
+ *
+ * This rule is identical for parameters and local variables. ADR-006 requires
+ * array parameters to use explicit array syntax (`u8[8] buf`), which sets
+ * isArray on the parameter's type info exactly like a local array declaration
+ * does. A scalar-typed parameter (no array brackets) is therefore classified
+ * the same way a scalar local variable is: bit manipulation (ADR-007 — "Any
+ * integer type can be indexed to access individual bits", with no carve-out
+ * for parameters).
+ *
+ * Issue #1100: A prior version of this classifier treated ANY function
+ * parameter without explicit array syntax as array access (`isParameter &&
+ * !isArray -> array`), added in #579 to support buffer-style parameters
+ * declared without brackets (e.g. `void fillBuffer(u8 buf)`). That blanket
+ * rule was a divergent decision path from local-variable classification: it
+ * silently broke ADR-007 bit-indexing for scalar parameters (`u32 v; ...
+ * v[4]` inside a function became `v[4]` array-subscript C code on a pointer
+ * instead of a shift-and-mask bit read), producing invalid/incorrect C
+ * for the extremely common embedded pattern of reading a bit out of a
+ * hardware-register-shaped scalar parameter. Buffer-style parameters must now
+ * use explicit array syntax (`u8[N] buf`), which was already the ADR-006
+ * documented and supported spelling — see tests/params/param-array-indexing.test.cnx.
  */
 import TSubscriptKind from "./TSubscriptKind";
 import TTypeInfo from "../types/TTypeInfo";
@@ -63,9 +83,14 @@ class SubscriptClassifier {
    * Determine if a type should use array access semantics.
    *
    * Array access is used when:
-   * - Type is explicitly an array (isArray: true)
+   * - Type is explicitly an array (isArray: true) — including array
+   *   parameters declared with explicit syntax, e.g. `u8[8] buf` (ADR-006)
    * - Type is a string (strings are char arrays)
-   * - Type is a non-array parameter (becomes pointer in C, ADR-006)
+   *
+   * Parameters are NOT special-cased here (Issue #1100): whether a subscript
+   * is array access or bit access depends solely on the declared type, the
+   * same rule used for local variables. A scalar parameter without array
+   * syntax is bit-indexable exactly like a scalar local variable (ADR-007).
    *
    * @param typeInfo - Type information, or null if unknown
    * @returns true if subscript should be treated as array access
@@ -82,12 +107,6 @@ class SubscriptClassifier {
       return true;
     }
 
-    // Issue #579: Non-array parameter becomes pointer in C (ADR-006)
-    // So buf[i] is array access, not bit access
-    if (typeInfo.isParameter) {
-      return true;
-    }
-
     // Otherwise it's a scalar - use bit access
     return false;
   }

package/src/transpiler/output/codegen/subscript/TSubscriptKind.ts

@@ -6,7 +6,7 @@
  */
 type TSubscriptKind =
   | "array_element" // Single array element access: arr[i]
-  | "array_slice" // Array slice/memcpy: arr[offset, length]
+  | "array_slice" // Array slice: arr[offset, length] (per-element little-endian writes, ADR-007/#1081)
   | "bit_single" // Single bit access: flags[3]
   | "bit_range"; // Bit range extraction: value[start, width]