c-next 0.2.16 → 0.2.17

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

@@ -98,6 +98,21 @@ class StringDeclHelper {
     isConst: boolean,
     callbacks: IStringDeclCallbacks,
   ): IStringDeclResult {
+    // Issue #1029: Check for string array in arrayType syntax first
+    // For `string<32>[4] items`, the structure is: arrayType -> stringType arrayTypeDimension+
+    const arrayTypeCtx = typeCtx.arrayType?.();
+    if (arrayTypeCtx?.stringType?.()) {
+      return StringDeclHelper._generateStringArrayFromArrayType(
+        name,
+        arrayTypeCtx,
+        expression,
+        arrayDims,
+        modifiers,
+        isConst,
+        callbacks,
+      );
+    }
+
     const stringCtx = typeCtx.stringType();
     if (!stringCtx) {
       return { code: "", handled: false };
@@ -129,6 +144,182 @@ class StringDeclHelper {
     }
   }
 
+  /**
+   * Issue #1029: Generate string array declaration from arrayType syntax.
+   * Handles: string<32>[4] items -> char items[4][33] = {0};
+   */
+  private static _generateStringArrayFromArrayType(
+    name: string,
+    arrayTypeCtx: Parser.ArrayTypeContext,
+    expression: Parser.ExpressionContext | null,
+    trailingArrayDims: Parser.ArrayDimensionContext[],
+    modifiers: IStringDeclModifiers,
+    isConst: boolean,
+    callbacks: IStringDeclCallbacks,
+  ): IStringDeclResult {
+    const stringCtx = arrayTypeCtx.stringType()!;
+    const intLiteral = stringCtx.INTEGER_LITERAL();
+    if (!intLiteral) {
+      // Unsized string array - not supported
+      throw new Error(
+        "Error: String arrays require explicit capacity, e.g., string<64>[4]",
+      );
+    }
+
+    const capacity = Number.parseInt(intLiteral.getText(), 10);
+    // Ensure string.h is included for strncpy operations
+    callbacks.requireStringInclude();
+
+    const {
+      extern,
+      const: constMod,
+      atomic,
+      volatile: volatileMod,
+    } = modifiers;
+
+    // Build array dimensions from arrayType (e.g., [4] from string<32>[4])
+    let arrayDimStr = "";
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const sizeExpr = dim.expression();
+      if (sizeExpr) {
+        arrayDimStr += `[${sizeExpr.getText()}]`;
+      } else {
+        arrayDimStr += "[]";
+      }
+    }
+
+    // Add any trailing dimensions from variable declaration
+    arrayDimStr += callbacks.generateArrayDimensions(trailingArrayDims);
+
+    // Add string capacity dimension
+    arrayDimStr += `[${capacity + 1}]`;
+
+    let decl = `${extern}${constMod}${atomic}${volatileMod}char ${name}${arrayDimStr}`;
+
+    // Track as local array
+    CodeGenState.localArrays.add(name);
+
+    // No initializer - zero-initialize
+    if (!expression) {
+      return { code: `${decl} = {0};`, handled: true };
+    }
+
+    // Reset array init tracking and generate initializer
+    CodeGenState.lastArrayInitCount = 0;
+    CodeGenState.lastArrayFillValue = undefined;
+    const initValue = callbacks.generateExpression(expression);
+
+    // Check if it was an array initializer
+    const isArrayInit =
+      CodeGenState.lastArrayInitCount > 0 ||
+      CodeGenState.lastArrayFillValue !== undefined;
+
+    if (!isArrayInit) {
+      throw new Error(
+        `Error: String array initialization from variables not supported`,
+      );
+    }
+
+    // Validate element count if declared size is available
+    const declaredSize =
+      StringDeclHelper._getArrayTypeDeclaredSize(arrayTypeCtx);
+    if (declaredSize !== null) {
+      const isFillAll = CodeGenState.lastArrayFillValue !== undefined;
+      const elementCount = CodeGenState.lastArrayInitCount;
+
+      if (!isFillAll && elementCount !== declaredSize) {
+        throw new Error(
+          `Error: Array size mismatch - declared [${declaredSize}] but got ${elementCount} elements`,
+        );
+      }
+    }
+
+    // Handle fill-all expansion if needed
+    const finalInitValue = StringDeclHelper._expandFillAllForArrayType(
+      initValue,
+      arrayTypeCtx,
+    );
+
+    // MISRA C:2012 Rules 9.3/9.4 - String literals don't fill all inner array bytes,
+    // but C standard guarantees zero-initialization of remaining elements
+    const suppression =
+      "// cppcheck-suppress misra-c2012-9.3\n// cppcheck-suppress misra-c2012-9.4\n";
+    return {
+      code: `${suppression}${decl} = ${finalInitValue};`,
+      handled: true,
+    };
+  }
+
+  /**
+   * Get the numeric size from the first arrayTypeDimension, or null if not numeric.
+   * Used by arrayType-based string arrays (string<N>[M]).
+   */
+  private static _getArrayTypeDeclaredSize(
+    arrayTypeCtx: Parser.ArrayTypeContext,
+  ): number | null {
+    const dims = arrayTypeCtx.arrayTypeDimension();
+    if (dims.length === 0) {
+      return null;
+    }
+    const firstDimExpr = dims[0].expression();
+    return StringDeclHelper._parseNumericSize(firstDimExpr);
+  }
+
+  /**
+   * Expand fill-all syntax for arrayType-based string arrays.
+   * Delegates to the common fill-all expansion logic with size from arrayType.
+   */
+  private static _expandFillAllForArrayType(
+    initValue: string,
+    arrayTypeCtx: Parser.ArrayTypeContext,
+  ): string {
+    const declaredSize =
+      StringDeclHelper._getArrayTypeDeclaredSize(arrayTypeCtx);
+    return StringDeclHelper._expandFillAll(initValue, declaredSize);
+  }
+
+  /**
+   * Common fill-all expansion logic shared between arrayType and arrayDimension paths.
+   */
+  private static _expandFillAll(
+    initValue: string,
+    declaredSize: number | null,
+  ): string {
+    const fillVal = CodeGenState.lastArrayFillValue;
+    if (fillVal === undefined) {
+      return initValue;
+    }
+
+    // Empty string fill doesn't need expansion (C handles {""} correctly)
+    if (fillVal === '""') {
+      return initValue;
+    }
+
+    if (declaredSize === null) {
+      return initValue;
+    }
+
+    const elements = new Array<string>(declaredSize).fill(fillVal);
+    return `{${elements.join(", ")}}`;
+  }
+
+  /**
+   * Parse a numeric size from an expression, or return null if not numeric.
+   * Shared helper to eliminate duplicate parsing logic.
+   */
+  private static _parseNumericSize(
+    expr: Parser.ExpressionContext | null | undefined,
+  ): number | null {
+    if (!expr) {
+      return null;
+    }
+    const sizeText = expr.getText();
+    if (!/^\d+$/.exec(sizeText)) {
+      return null;
+    }
+    return Number.parseInt(sizeText, 10);
+  }
+
   /**
    * Generate bounded string declaration (string<N>).
    */
@@ -207,24 +398,48 @@ class StringDeclHelper {
       );
     }
 
-    // Validate and generate simple assignment
-    StringDeclHelper._validateStringInit(
-      expression.getText(),
+    // Validate and check if it's a literal or variable
+    const exprText = expression.getText();
+    const isLiteral = StringDeclHelper._validateStringInit(
+      exprText,
       capacity,
       callbacks,
     );
-    const code = `${extern}${constMod}char ${name}[${capacity + 1}] = ${callbacks.generateExpression(expression)};`;
-    return { code, handled: true };
+
+    if (isLiteral) {
+      // String literal: can use direct initialization
+      const code = `${extern}${constMod}char ${name}[${capacity + 1}] = ${callbacks.generateExpression(expression)};`;
+      return { code, handled: true };
+    }
+
+    // String variable: need strcpy (cannot use array initialization in C)
+    // Issue #1030: string-to-string initialization
+    if (!CodeGenState.inFunctionBody) {
+      throw new Error(
+        `Error: String initialization from variable cannot be used at global scope. ` +
+          `Move the declaration inside a function, or use an empty initializer and assign later.`,
+      );
+    }
+
+    const srcExpr = callbacks.generateExpression(expression);
+    const indent = FormatUtils.indent(CodeGenState.indentLevel);
+    const lines: string[] = [];
+    lines.push(
+      `${constMod}char ${name}[${capacity + 1}] = "";`,
+      `${indent}strcpy(${name}, ${srcExpr});`,
+    );
+    return { code: lines.join("\n"), handled: true };
   }
 
   /**
    * Validate string initialization (literal length and variable capacity)
+   * Returns true if the expression is a string literal, false if it's a variable.
    */
   private static _validateStringInit(
     exprText: string,
     capacity: number,
     callbacks: IStringDeclCallbacks,
-  ): void {
+  ): boolean {
     // Validate string literal fits capacity
     if (exprText.startsWith('"') && exprText.endsWith('"')) {
       const content = StringUtils.literalLength(exprText);
@@ -233,6 +448,7 @@ class StringDeclHelper {
           `Error: String literal (${content} chars) exceeds string<${capacity}> capacity`,
         );
       }
+      return true; // Is a literal
     }
 
     // Check for string variable assignment
@@ -242,6 +458,7 @@ class StringDeclHelper {
         `Error: Cannot assign string<${srcCapacity}> to string<${capacity}> (potential truncation)`,
       );
     }
+    return false; // Is a variable (not a literal)
   }
 
   /**
@@ -373,47 +590,25 @@ class StringDeclHelper {
   /**
    * Expand fill-all syntax if needed.
    * ["Hello"*] with size 3 -> {"Hello", "Hello", "Hello"}
+   * Delegates to the common fill-all expansion logic with size from arrayDimension.
    */
   private static _expandFillAllIfNeeded(
     initValue: string,
     arrayDims: Parser.ArrayDimensionContext[],
   ): string {
-    const fillVal = CodeGenState.lastArrayFillValue;
-    if (fillVal === undefined) {
-      return initValue;
-    }
-
-    // Empty string fill doesn't need expansion (C handles {""} correctly)
-    if (fillVal === '""') {
-      return initValue;
-    }
-
     const declaredSize = StringDeclHelper._getFirstDimNumericSize(arrayDims);
-    if (declaredSize === null) {
-      return initValue;
-    }
-
-    const elements = new Array<string>(declaredSize).fill(fillVal);
-    return `{${elements.join(", ")}}`;
+    return StringDeclHelper._expandFillAll(initValue, declaredSize);
   }
 
   /**
    * Get the numeric size from the first array dimension, or null if not numeric.
+   * Used by arrayDimension-based string arrays (string<N> arr[M]).
    */
   private static _getFirstDimNumericSize(
     arrayDims: Parser.ArrayDimensionContext[],
   ): number | null {
     const firstDimExpr = arrayDims[0]?.expression();
-    if (!firstDimExpr) {
-      return null;
-    }
-
-    const sizeText = firstDimExpr.getText();
-    if (!/^\d+$/.exec(sizeText)) {
-      return null;
-    }
-
-    return Number.parseInt(sizeText, 10);
+    return StringDeclHelper._parseNumericSize(firstDimExpr);
   }
 
   /**

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

@@ -87,27 +87,6 @@ class SymbolLookupHelper {
     return symbols.some((sym) => sym.kind === "namespace");
   }
 
-  /**
-   * Check if a type name is from a C++ header.
-   * Issue #304: Used to determine whether to use {} or {0} for initialization.
-   * C++ types with constructors may fail with {0} but work with {}.
-   */
-  static isCppType(
-    symbolTable: ISymbolTable | null | undefined,
-    typeName: string,
-  ): boolean {
-    if (!symbolTable) return false;
-
-    const symbols = symbolTable.getOverloads(typeName);
-    const cppTypeKinds = new Set<TSymbolKind>(["struct", "class", "type"]);
-
-    return symbols.some(
-      (sym) =>
-        sym.sourceLanguage === ESourceLanguage.Cpp &&
-        cppTypeKinds.has(sym.kind),
-    );
-  }
-
   /**
    * Check if a function is a C-Next function (uses pass-by-reference semantics).
    * Returns true if the function is found in symbol table as C-Next.

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

@@ -29,6 +29,19 @@ interface ITypeGenerationDeps {
   validateCrossScopeVisibility: (scope: string, member: string) => void;
 }
 
+/**
+ * Common interface for type contexts that share the same type accessors.
+ * Both TypeContext and ArrayTypeContext have these methods.
+ */
+interface ITypeAccessors {
+  primitiveType(): Parser.PrimitiveTypeContext | null;
+  userType(): Parser.UserTypeContext | null;
+  stringType(): Parser.StringTypeContext | null;
+  scopedType(): Parser.ScopedTypeContext | null;
+  qualifiedType(): Parser.QualifiedTypeContext | null;
+  globalType(): Parser.GlobalTypeContext | null;
+}
+
 class TypeGenerationHelper {
   /**
    * Generate C type for a primitive type.
@@ -154,41 +167,35 @@ class TypeGenerationHelper {
   }
 
   /**
-   * Full type generation using all dependencies.
-   * This is the main entry point that handles all type contexts.
+   * Dispatch type generation for contexts that share common type accessors.
+   * Handles scoped, qualified, global, primitive, string, and user types.
+   * Used by both bare type contexts and array element type contexts.
+   *
+   * @returns The resolved C type string, or null if no matching type accessor found
    */
-  static generate(ctx: Parser.TypeContext, deps: ITypeGenerationDeps): string {
-    // Primitive type
-    if (ctx.primitiveType()) {
-      const type = ctx.primitiveType()!.getText();
-      const result = TypeGenerationHelper.generatePrimitiveType(type);
-      // Note: caller is responsible for handling the include
-      return result.cType;
-    }
-
-    // Bounded string type
-    if (ctx.stringType()) {
+  private static dispatchTypeGeneration(
+    accessors: ITypeAccessors,
+    deps: ITypeGenerationDeps,
+  ): string | null {
+    if (accessors.stringType()) {
       return TypeGenerationHelper.generateStringType();
     }
 
-    // Scoped type (this.Type)
-    if (ctx.scopedType()) {
-      const typeName = ctx.scopedType()!.IDENTIFIER().getText();
+    if (accessors.scopedType()) {
+      const typeName = accessors.scopedType()!.IDENTIFIER().getText();
       return TypeGenerationHelper.generateScopedType(
         typeName,
         deps.currentScope,
       );
     }
 
-    // Global type (global.Type)
-    if (ctx.globalType()) {
-      const typeName = ctx.globalType()!.IDENTIFIER().getText();
+    if (accessors.globalType()) {
+      const typeName = accessors.globalType()!.IDENTIFIER().getText();
       return TypeGenerationHelper.generateGlobalType(typeName);
     }
 
-    // Qualified type (Scope.Type or Namespace::Type)
-    if (ctx.qualifiedType()) {
-      const identifiers = ctx.qualifiedType()!.IDENTIFIER();
+    if (accessors.qualifiedType()) {
+      const identifiers = accessors.qualifiedType()!.IDENTIFIER();
       const identifierNames = identifiers.map((id) => id.getText());
       const isCpp = deps.isCppScopeSymbol(identifierNames[0]);
       return TypeGenerationHelper.generateQualifiedType(
@@ -198,30 +205,44 @@ class TypeGenerationHelper {
       );
     }
 
-    // User type
-    if (ctx.userType()) {
-      const typeName = ctx.userType()!.getText();
+    if (accessors.primitiveType()) {
+      const type = accessors.primitiveType()!.getText();
+      return TYPE_MAP[type] || type;
+    }
+
+    if (accessors.userType()) {
+      const typeName = accessors.userType()!.getText();
+      // ADR-046: cstring maps to char* for C library interop
+      if (typeName === "cstring") {
+        return "char*";
+      }
       const needsStruct = deps.checkNeedsStructKeyword(typeName);
       return TypeGenerationHelper.generateUserType(typeName, needsStruct);
     }
 
-    // Array type
+    return null;
+  }
+
+  /**
+   * Full type generation using all dependencies.
+   * This is the main entry point that handles all type contexts.
+   */
+  static generate(ctx: Parser.TypeContext, deps: ITypeGenerationDeps): string {
+    // Array type - dispatch on the element type
     if (ctx.arrayType()) {
       const arrCtx = ctx.arrayType()!;
-      // String arrays have base type "char"
-      if (arrCtx.stringType()) {
-        return "char";
+      const result = TypeGenerationHelper.dispatchTypeGeneration(arrCtx, deps);
+      if (result !== null) {
+        return result;
       }
-      const primitiveText = arrCtx.primitiveType()?.getText() ?? null;
-      const userTypeName = arrCtx.userType()?.getText() ?? null;
-      const needsStruct = userTypeName
-        ? deps.checkNeedsStructKeyword(userTypeName)
-        : false;
-      return TypeGenerationHelper.generateArrayBaseType(
-        primitiveText,
-        userTypeName,
-        needsStruct,
-      );
+      // Fallback for array types without recognized element type
+      return ctx.getText();
+    }
+
+    // Non-array types - dispatch directly
+    const result = TypeGenerationHelper.dispatchTypeGeneration(ctx, deps);
+    if (result !== null) {
+      return result;
     }
 
     // Void or fallback