c-next 0.1.63 → 0.1.65

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

@@ -1568,7 +1568,7 @@ describe("CodeGenerator", () => {
 
     it("should generate array parameter", () => {
       const source = `
-        void process(u32 arr[10]) { }
+        void process(u32[10] arr) { }
       `;
       const { tree, tokenStream } = CNextSourceParser.parse(source);
       const generator = new CodeGenerator();
@@ -5284,7 +5284,7 @@ describe("CodeGenerator", () => {
   describe("Array passed to function", () => {
     it("should pass array without address-of operator", () => {
       const source = `
-        void processData(u32 data[]) { }
+        void processData(u32[5] data) { }
         u32[5] myData;
         void main() {
           processData(myData);
@@ -5942,7 +5942,7 @@ describe("CodeGenerator", () => {
   describe("Function with array return type simulation", () => {
     it("should handle function returning via output parameter", () => {
       const source = `
-        void getData(u8 output[]) {
+        void getData(u8[2] output) {
           output[0] <- 1;
           output[1] <- 2;
         }
@@ -6285,7 +6285,7 @@ describe("CodeGenerator", () => {
   describe("Array parameter bounds", () => {
     it("should handle sized array parameter", () => {
       const source = `
-        void process(u32 arr[10]) {
+        void process(u32[10] arr) {
           arr[0] <- 1;
         }
       `;
@@ -6813,7 +6813,7 @@ describe("CodeGenerator", () => {
   describe("Local array tracking", () => {
     it("should track local arrays for function arguments", () => {
       const source = `
-        void process(u8 arr[]) { }
+        void process(u8[10] arr) { }
         void main() {
           u8[10] local;
           process(local);
@@ -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}");
+      });
     });
   });
 
@@ -7931,7 +8067,7 @@ describe("CodeGenerator", () => {
 
       it("should handle identifier argument (array)", () => {
         const source = `
-          void callee(u32 arr[10]) { }
+          void callee(u32[10] arr) { }
           void test() {
             u32[10] data;
             callee(data);
@@ -8045,7 +8181,7 @@ describe("CodeGenerator", () => {
       it("should handle struct field array argument", () => {
         const source = `
           struct Data { u32 values[10]; }
-          void callee(u32 arr[10]) { }
+          void callee(u32[10] arr) { }
           void test(Data d) {
             callee(d.values);
           }
@@ -8110,7 +8246,7 @@ describe("CodeGenerator", () => {
       it("should handle struct member array as argument (array decay)", () => {
         const source = `
           struct Config { u8 data[16]; }
-          void processData(u8 buffer[16]) { }
+          void processData(u8[16] buffer) { }
           void test() {
             Config cfg;
             processData(cfg.data);
@@ -8241,7 +8377,7 @@ describe("CodeGenerator", () => {
 
       it("should process array parameter type", () => {
         const source = `
-          void test(u32 arr[10]) {
+          void test(u32[10] arr) {
             u32 x <- arr[0];
           }
         `;
@@ -8447,7 +8583,7 @@ describe("CodeGenerator", () => {
 
       it("should error on sizeof of array parameter", () => {
         const source = `
-          void test(u32 arr[10]) {
+          void test(u32[10] arr) {
             u32 size <- sizeof(arr);
           }
         `;
@@ -8534,7 +8670,7 @@ describe("CodeGenerator", () => {
 
       it("should handle parameter array access", () => {
         const source = `
-          void test(u32 arr[10]) {
+          void test(u32[10] arr) {
             u32 val <- arr[0];
           }
         `;
@@ -9896,7 +10032,7 @@ describe("CodeGenerator", () => {
 
       it("should resolve array parameter", () => {
         const source = `
-          void test(u32 arr[10]) {
+          void test(u32[10] arr) {
             arr[0] <- 1;
           }
         `;
@@ -10942,7 +11078,7 @@ describe("CodeGenerator", () => {
 
       it("should not dereference array parameter for index access", () => {
         const source = `
-          u32 getElement(u32 arr[10]) {
+          u32 getElement(u32[10] arr) {
             return arr[5];
           }
         `;
@@ -11127,7 +11263,7 @@ describe("CodeGenerator", () => {
     describe("function call argument generation", () => {
       it("should handle array argument passed to function", () => {
         const source = `
-          void process(u32 data[10]) {
+          void process(u32[10] data) {
             data[0] <- 1;
           }
           void test() {
@@ -12165,7 +12301,7 @@ describe("CodeGenerator", () => {
     describe("array parameter dimensions", () => {
       it("should handle multi-dimensional array parameter", () => {
         const source = `
-          void processMatrix(u32 matrix[3][3]) {
+          void processMatrix(u32[3][3] matrix) {
             matrix[0][0] <- 1;
           }
         `;
@@ -12182,10 +12318,52 @@ describe("CodeGenerator", () => {
 
         expect(code).toContain("uint32_t matrix[3][3]");
       });
+    });
+
+    describe("C-style array parameter rejection", () => {
+      it("should reject C-style array parameter with single dimension", () => {
+        const source = `
+          void process(u8 data[8]) {
+            data[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);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/C-style array parameter is not allowed/);
+      });
 
-      it("should handle unsized array parameter", () => {
+      it("should reject C-style array parameter with multiple dimensions", () => {
         const source = `
-          void processData(u8 data[], u32 len) {
+          void process(u32 matrix[3][3]) {
+            matrix[0][0] <- 1;
+          }
+        `;
+        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);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/C-style array parameter is not allowed/);
+      });
+
+      it("should reject C-style unsized array parameter", () => {
+        const source = `
+          void process(u8 data[]) {
             data[0] <- 0xFF;
           }
         `;
@@ -12195,12 +12373,202 @@ describe("CodeGenerator", () => {
         const tSymbols = CNextResolver.resolve(tree, "test.cnx");
         const symbols = TSymbolInfoAdapter.convert(tSymbols);
 
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/C-style array parameter is not allowed/);
+      });
+
+      it("should suggest correct C-Next style syntax in error message", () => {
+        const source = `
+          void process(i32 values[10]) {
+            values[0] <- 1;
+          }
+        `;
+        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);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/Use 'i32\[10\] values' instead of 'i32 values\[10\]'/);
+      });
+    });
+
+    describe("user type array parameters", () => {
+      it("should handle struct array parameter with C-Next style", () => {
+        const source = `
+          struct Point { i32 x; i32 y; }
+          void processPoints(Point[4] points) {
+            points[0].x <- 10;
+          }
+        `;
+        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",
+        });
+
+        expect(code).toContain("Point points[4]");
+      });
+
+      it("should detect struct type in arrayType for parameter", () => {
+        const source = `
+          struct Data { u32 value; }
+          void process(Data[8] items) {
+            items[0].value <- 42;
+          }
+        `;
+        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",
         });
 
-        expect(code).toContain("uint8_t data[]");
+        expect(code).toContain("Data items[8]");
+        expect(code).toContain("items[0].value = 42");
+      });
+    });
+
+    describe("multi-dimensional C-Next style array parameters", () => {
+      it("should handle 2D array parameter", () => {
+        const source = `
+          void processMatrix(i32[4][4] matrix) {
+            matrix[0][0] <- 1;
+          }
+        `;
+        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",
+        });
+
+        expect(code).toContain("int32_t matrix[4][4]");
+      });
+
+      it("should handle 3D array parameter", () => {
+        const source = `
+          void processCube(u8[2][3][4] cube) {
+            cube[0][0][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",
+        });
+
+        expect(code).toContain("uint8_t cube[2][3][4]");
+      });
+
+      it("should reject unbounded array parameter for memory safety", () => {
+        const source = `
+          void processRows(u32[][4] rows, u32 count) {
+            rows[0][0] <- 1;
+          }
+        `;
+        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);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/Unbounded array parameters are not allowed/);
+      });
+
+      it("should reject simple unbounded array parameter", () => {
+        const source = `
+          void process(u8[] data) {
+            data[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);
+
+        expect(() => {
+          generator.generate(tree, symbolTable, tokenStream, {
+            symbolInfo: symbols,
+            sourcePath: "test.cnx",
+          });
+        }).toThrow(/Unbounded array parameters are not allowed/);
+      });
+    });
+
+    describe("string array parameter capacity", () => {
+      it("should add capacity dimension for string array parameter", () => {
+        const source = `
+          void processNames(string<16>[5] names) {
+            names[0] <- "test";
+          }
+        `;
+        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",
+        });
+
+        // string<16>[5] -> char[5][17] (capacity + 1 for null terminator)
+        expect(code).toContain("char names[5][17]");
+      });
+
+      it("should handle string array with larger capacity", () => {
+        const source = `
+          void logMessages(string<128>[10] messages) {
+            messages[0] <- "hello";
+          }
+        `;
+        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",
+        });
+
+        expect(code).toContain("char messages[10][129]");
       });
     });
 
@@ -12497,7 +12865,7 @@ describe("CodeGenerator", () => {
     describe("string array parameters", () => {
       it("should handle string array parameter with capacity", () => {
         const source = `
-          void processNames(string<32> names[10]) {
+          void processNames(string<32>[10] names) {
             string<32> first <- names[0];
           }
         `;
@@ -13363,7 +13731,7 @@ describe("CodeGenerator", () => {
 
       it("should handle array parameters", () => {
         const source = `
-          void sum(u32 values[], u32 count) {
+          void sum(u32[10] values) {
             u32 total <- 0;
           }
         `;
@@ -13379,7 +13747,7 @@ describe("CodeGenerator", () => {
         });
 
         expect(code).toContain("values");
-        expect(code).toContain("count");
+        expect(code).toContain("uint32_t values[10]");
       });
     });
 
@@ -15118,7 +15486,7 @@ describe("CodeGenerator", () => {
 
       it("should generate function with array parameter", () => {
         const source = `
-          void process(u32 arr[10]) {
+          void process(u32[10] arr) {
             u32 val <- arr[0];
           }
         `;

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

@@ -23,18 +23,26 @@ function generateArrayTypeDimension(
     return "";
   }
 
-  const sizeExpr = arrayTypeCtx.expression();
-  if (!sizeExpr) {
-    return "[]";
-  }
+  // Handle all dimensions from arrayType (supports u8[4][4], u8[], etc.)
+  const dims = arrayTypeCtx.arrayTypeDimension();
+  let result = "";
+  for (const dim of dims) {
+    const sizeExpr = dim.expression();
+    if (!sizeExpr) {
+      result += "[]";
+      continue;
+    }
 
-  const constValue = orchestrator.tryEvaluateConstant(sizeExpr);
-  if (constValue === undefined) {
-    // Fall back to expression generation for macros, enums, etc.
-    return `[${orchestrator.generateExpression(sizeExpr)}]`;
+    const constValue = orchestrator.tryEvaluateConstant(sizeExpr);
+    if (constValue === undefined) {
+      // Fall back to expression generation for macros, enums, etc.
+      result += `[${orchestrator.generateExpression(sizeExpr)}]`;
+    } else {
+      result += `[${constValue}]`;
+    }
   }
 
-  return `[${constValue}]`;
+  return result;
 }
 
 /**

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

@@ -26,7 +26,7 @@ describe("ArrayDimensionUtils", () => {
     it("returns [] for context with no expression", () => {
       const orchestrator = createMockOrchestrator();
       const ctx = {
-        expression: () => null,
+        arrayTypeDimension: () => [{ expression: () => null }],
       };
       const result = ArrayDimensionUtils.generateArrayTypeDimension(
         ctx as never,
@@ -38,7 +38,9 @@ describe("ArrayDimensionUtils", () => {
     it("returns constant dimension when evaluable", () => {
       const orchestrator = createMockOrchestrator(16);
       const ctx = {
-        expression: () => ({ getText: () => "16" }),
+        arrayTypeDimension: () => [
+          { expression: () => ({ getText: () => "16" }) },
+        ],
       };
       const result = ArrayDimensionUtils.generateArrayTypeDimension(
         ctx as never,
@@ -52,7 +54,7 @@ describe("ArrayDimensionUtils", () => {
       const orchestrator = createMockOrchestrator(undefined, "BUFFER_SIZE");
       const mockExpr = { getText: () => "BUFFER_SIZE" };
       const ctx = {
-        expression: () => mockExpr,
+        arrayTypeDimension: () => [{ expression: () => mockExpr }],
       };
       const result = ArrayDimensionUtils.generateArrayTypeDimension(
         ctx as never,

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

@@ -44,15 +44,11 @@ function createMockConstModifier(
 
 /**
  * Create a mock array type context.
+ * Updated for new grammar: arrayType has arrayTypeDimension() which returns dimensions
  */
 function createMockArrayType(sizeExpr?: string | null) {
-  if (sizeExpr === null) {
-    // Empty brackets - no expression
-    return {
-      expression: () => null,
-    };
-  }
-  return {
+  // Create a single dimension with optional expression
+  const mockDimension = {
     expression: () =>
       sizeExpr
         ? {
@@ -61,6 +57,15 @@ function createMockArrayType(sizeExpr?: string | null) {
           }
         : null,
   };
+
+  return {
+    // New grammar: arrayTypeDimension() returns array of dimensions
+    arrayTypeDimension: () => [mockDimension],
+    // Keep primitiveType for base type extraction
+    primitiveType: () => null,
+    userType: () => null,
+    stringType: () => null,
+  };
 }
 
 /**

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

@@ -704,6 +704,12 @@ const generateStringLength = (
     return subscriptDepth === 0 ? String(dims[0]) : `strlen(${result})`;
   }
 
+  // String array with subscript - use result which contains arr[index]
+  // This handles string<32>[5] parameters where subscriptDepth=1 after arr[index]
+  if (subscriptDepth > 0) {
+    return `strlen(${result})`;
+  }
+
   // Simple string: check length cache first, then use strlen
   if (resolvedIdentifier && state.lengthCache?.has(resolvedIdentifier)) {
     return state.lengthCache.get(resolvedIdentifier)!;

package/src/transpiler/output/codegen/helpers/TypeGenerationHelper.ts

@@ -208,6 +208,10 @@ class TypeGenerationHelper {
     // Array type
     if (ctx.arrayType()) {
       const arrCtx = ctx.arrayType()!;
+      // String arrays have base type "char"
+      if (arrCtx.stringType()) {
+        return "char";
+      }
       const primitiveText = arrCtx.primitiveType()?.getText() ?? null;
       const userTypeName = arrCtx.userType()?.getText() ?? null;
       const needsStruct = userTypeName