c-next 0.1.63 → 0.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

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

@@ -3870,7 +3870,10 @@ export default class CodeGenerator implements IOrchestrator {
         const paramName = param.IDENTIFIER().getText();
         const isConst = param.constModifier() !== null;
         // arrayDimension() returns an array (due to grammar's *), so check length
-        const isArray = param.arrayDimension().length > 0;
+        // Also check C-Next style array type (e.g., u8[8] param)
+        const isArray =
+          param.arrayDimension().length > 0 ||
+          param.type().arrayType() !== null;
         const baseType = this.getTypeName(param.type());
         parameters.push({ name: paramName, baseType, isConst, isArray });
       }
@@ -3903,7 +3906,8 @@ export default class CodeGenerator implements IOrchestrator {
         const typeName = this.getTypeName(param.type());
         const isConst = param.constModifier() !== null;
         const dims = param.arrayDimension();
-        const isArray = dims.length > 0;
+        const arrayTypeCtx = param.type().arrayType();
+        const isArray = dims.length > 0 || arrayTypeCtx !== null;
 
         // ADR-029: Check if parameter type is itself a callback type
         const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
@@ -3922,9 +3926,14 @@ export default class CodeGenerator implements IOrchestrator {
           isPointer = !isArray;
         }
 
-        const arrayDims = isArray
-          ? dims.map((d) => this.generateArrayDimension(d)).join("")
-          : "";
+        let arrayDims: string;
+        if (dims.length > 0) {
+          arrayDims = dims.map((d) => this.generateArrayDimension(d)).join("");
+        } else if (arrayTypeCtx) {
+          arrayDims = `[${this.generateExpression(arrayTypeCtx.expression())}]`;
+        } else {
+          arrayDims = "";
+        }
         parameters.push({
           name: paramName,
           type: paramType,
@@ -5181,6 +5190,15 @@ export default class CodeGenerator implements IOrchestrator {
 
     const type = this.generateType(ctx.type());
 
+    // Handle C-Next style array type in parameter (e.g., u8[8] param)
+    const arrayTypeCtx = ctx.type().arrayType();
+    if (arrayTypeCtx) {
+      const dimExpr = this.generateExpression(arrayTypeCtx.expression());
+      const wasModified = this._isCurrentParameterModified(name);
+      const autoConst = !wasModified && !constMod ? "const " : "";
+      return `${autoConst}${constMod}${type} ${name}[${dimExpr}]`;
+    }
+
     // Try special cases first
     const stringArrayResult = this._tryGenerateStringArrayParam(
       ctx,
@@ -5814,6 +5832,14 @@ export default class CodeGenerator implements IOrchestrator {
         return "{}";
       }
     }
+    // Also check C-Next style array type (e.g., CppClass[4]) where
+    // the userType is nested inside arrayType.
+    if (typeCtx.arrayType()?.userType()) {
+      const typeName = typeCtx.arrayType()!.userType()!.getText();
+      if (this._needsEmptyBraceInit(typeName)) {
+        return "{}";
+      }
+    }
     // Template types are always C++ classes
     if (typeCtx.templateType()) {
       return "{}";

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

@@ -7169,6 +7169,142 @@ describe("CodeGenerator", () => {
 
       // Note: Template type tests skipped - template argument transformation
       // (i32 -> int32_t) is a separate issue to be addressed in another PR
+
+      it("should generate C-Next style array params with dimensions in C++ mode", () => {
+        const source = `
+          void fill(u8[8] buf) {
+              buf[0] <- 0xFF;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // C-Next style u8[8] param should generate uint8_t buf[8], not uint8_t& buf
+        expect(code).toContain("uint8_t buf[8]");
+        expect(code).not.toContain("uint8_t& buf");
+        expect(code).not.toContain("uint8_t&  buf");
+      });
+
+      it("should generate const C-Next style array params in C++ mode", () => {
+        const source = `
+          u8 read(const u8[4] data) {
+              return data[0];
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Const C-Next style array param should retain dimension
+        expect(code).toContain("const uint8_t data[4]");
+        expect(code).not.toContain("const uint8_t& data");
+      });
+
+      it("should generate C-Next style array params in C mode too", () => {
+        const source = `
+          void fill(u8[8] buf) {
+              buf[0] <- 0xFF;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        // C mode should also generate uint8_t buf[8]
+        expect(code).toContain("uint8_t buf[8]");
+        expect(code).not.toContain("uint8_t* buf");
+      });
+
+      it("should generate primitive C-Next style arrays with {0} in C++ mode", () => {
+        const source = `
+          void main() {
+              u32[8] counters;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Primitive type arrays should still use {0}
+        expect(code).toContain("uint32_t counters[8] = {0}");
+      });
+
+      it("should generate unknown user type C-Next style arrays with {} in C++ mode", () => {
+        const source = `
+          void main() {
+              UnknownType[4] items;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Unknown types in C++ mode use {} (may have non-trivial constructors)
+        expect(code).toContain("UnknownType items[4] = {}");
+      });
+
+      it("should generate known C-Next struct arrays with {0} in C++ mode", () => {
+        const source = `
+          struct Point { i32 x; i32 y; }
+          void main() {
+              Point[3] pts;
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const symbolTable = new SymbolTable();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+        const code = generator.generate(tree, symbolTable, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+          cppMode: true,
+        });
+
+        // Known C-Next structs are POD types, {0} is correct
+        expect(code).toContain("Point pts[3] = {0}");
+      });
     });
   });