c-next 0.2.16 → 0.2.17

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

@@ -310,9 +310,11 @@ describe("StringDeclHelper", () => {
     });
 
     it("allows assignment when source capacity fits", () => {
+      // Issue #1030: String variable initialization now uses strcpy
       const callbacks = {
         ...defaultCallbacks,
         getStringExprCapacity: vi.fn(() => 20),
+        generateExpression: vi.fn(() => "smallString"),
       };
 
       const typeCtx = {
@@ -336,7 +338,42 @@ describe("StringDeclHelper", () => {
       );
 
       expect(result.handled).toBe(true);
-      expect(result.code).toContain("char dest[33] = smallString;");
+      // Issue #1030: String variable initialization uses strcpy
+      expect(result.code).toContain('char dest[33] = "";');
+      expect(result.code).toContain("strcpy(dest, smallString)");
+    });
+
+    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",
+      );
     });
   });
 
@@ -1154,4 +1191,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/types/ICallbackTypeInfo.ts

@@ -10,7 +10,8 @@ interface ICallbackTypeInfo {
     name: string;
     type: string; // C type
     isConst: boolean;
-    isPointer: boolean; // Non-array params become pointers
+    isPointer: boolean; // Non-array params become pointers (C mode only for structs)
+    isStruct: boolean; // True if parameter type is a struct (ADR-006 reference semantics)
     isArray: boolean; // Array parameters pass naturally as pointers
     arrayDims: string; // Array dimensions if applicable
   }>;

package/src/transpiler/output/codegen/types/IParameterInput.ts

@@ -66,6 +66,13 @@ interface IParameterInput {
    * When the C typedef has `const T*`, this preserves const on the generated param.
    */
   forceConst?: boolean;
+
+  /**
+   * Issue #995: Whether the parameter type is an opaque handle (incomplete struct typedef).
+   * This is a pass-through flag; the rule (suppress auto-const, force pointer) is applied
+   * in ParameterSignatureBuilder to avoid dual code paths.
+   */
+  isOpaqueHandle?: boolean;
 }
 
 export default IParameterInput;

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

@@ -116,6 +116,14 @@ abstract class BaseHeaderGenerator {
       ...HeaderGeneratorUtils.generateEnumSection(groups.enums, typeInput),
       ...HeaderGeneratorUtils.generateBitmapSection(groups.bitmaps, typeInput),
       ...HeaderGeneratorUtils.generateTypeAliasSection(groups.types),
+      ...HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        groups.structs,
+        typeInput,
+      ),
+      ...HeaderGeneratorUtils.generateCallbackTypedefSection(
+        typeInput,
+        options.cppMode,
+      ),
       ...HeaderGeneratorUtils.generateStructSection(
         groups.structs,
         groups.classes,

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

@@ -416,6 +416,81 @@ class HeaderGeneratorUtils {
     return lines;
   }
 
+  /**
+   * ADR-029: Generate forward declarations for structs used in callback typedefs.
+   * This ensures struct types can be used in callback parameter types before
+   * the full struct definition.
+   */
+  static generateCallbackStructForwardDecls(
+    structs: IHeaderSymbol[],
+    typeInput?: IHeaderTypeInput,
+  ): string[] {
+    if (!typeInput?.callbackTypes || typeInput.callbackTypes.size === 0) {
+      return [];
+    }
+
+    // Collect struct types that are used in callback parameters
+    const usedStructTypes = new Set<string>();
+    for (const [, cbInfo] of typeInput.callbackTypes) {
+      for (const p of cbInfo.parameters) {
+        if (p.isStruct) {
+          usedStructTypes.add(p.type);
+        }
+      }
+    }
+
+    if (usedStructTypes.size === 0) {
+      return [];
+    }
+
+    // Get local struct names to only forward-declare those
+    const localStructNames = new Set(structs.map((s) => s.name));
+
+    const lines: string[] = [];
+    for (const structType of usedStructTypes) {
+      if (localStructNames.has(structType)) {
+        lines.push(`typedef struct ${structType} ${structType};`);
+      }
+    }
+
+    return lines.length > 0 ? [...lines, ""] : [];
+  }
+
+  /**
+   * ADR-029: Generate callback typedef section
+   * Generates function pointer typedefs for callbacks used as struct field types
+   */
+  static generateCallbackTypedefSection(
+    typeInput?: IHeaderTypeInput,
+    isCppMode?: boolean,
+  ): string[] {
+    if (!typeInput?.callbackTypes || typeInput.callbackTypes.size === 0) {
+      return [];
+    }
+
+    const lines: string[] = ["/* Callback typedefs */"];
+    for (const [, cbInfo] of typeInput.callbackTypes) {
+      const params =
+        cbInfo.parameters.length > 0
+          ? cbInfo.parameters
+              .map((p) => {
+                // ADR-006: Struct parameters become pointers (C) or references (C++)
+                if (p.isStruct) {
+                  const ptrOrRef = isCppMode ? "&" : "*";
+                  return `${p.type}${ptrOrRef}`;
+                }
+                return p.type;
+              })
+              .join(", ")
+          : "void";
+      lines.push(
+        `typedef ${cbInfo.returnType} (*${cbInfo.typedefName})(${params});`,
+      );
+    }
+    lines.push("");
+    return lines;
+  }
+
   /**
    * Generate struct and class definitions section
    */