c-next 0.1.61 → 0.1.63

package/src/transpiler/logic/parser/grammar/CNextVisitor.ts

@@ -77,8 +77,6 @@ import { FieldInitializerListContext } from "./CNextParser.js";
 import { FieldInitializerContext } from "./CNextParser.js";
 import { ArrayInitializerContext } from "./CNextParser.js";
 import { ArrayInitializerElementContext } from "./CNextParser.js";
-import { MemberAccessContext } from "./CNextParser.js";
-import { ArrayAccessContext } from "./CNextParser.js";
 import { ArgumentListContext } from "./CNextParser.js";
 import { TypeContext } from "./CNextParser.js";
 import { ScopedTypeContext } from "./CNextParser.js";
@@ -546,18 +544,6 @@ export class CNextVisitor<Result> extends AbstractParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitArrayInitializerElement?: (ctx: ArrayInitializerElementContext) => Result;
-    /**
-     * Visit a parse tree produced by `CNextParser.memberAccess`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitMemberAccess?: (ctx: MemberAccessContext) => Result;
-    /**
-     * Visit a parse tree produced by `CNextParser.arrayAccess`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitArrayAccess?: (ctx: ArrayAccessContext) => Result;
     /**
      * Visit a parse tree produced by `CNextParser.argumentList`.
      * @param ctx the parse tree

package/src/transpiler/logic/symbols/CppSymbolCollector.ts

@@ -39,6 +39,55 @@ class CppSymbolCollector {
     return SymbolCollectorContext.getWarnings(this.ctx);
   }
 
+  // ========================================================================
+  // Symbol Creation Helpers (Issue #707: Reduce code duplication)
+  // ========================================================================
+
+  /**
+   * Add a class/struct symbol to the symbol table.
+   */
+  private _addClassSymbol(fullName: string, line: number): void {
+    SymbolCollectorContext.addSymbol(this.ctx, {
+      name: fullName,
+      kind: ESymbolKind.Class,
+      sourceFile: this.ctx.sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: this.currentNamespace,
+    });
+  }
+
+  /**
+   * Add a member function symbol to the symbol table.
+   */
+  private _addMemberFunctionSymbol(
+    className: string,
+    funcName: string,
+    returnType: string,
+    params: Array<{
+      name: string;
+      type: string;
+      isConst: boolean;
+      isArray: boolean;
+    }>,
+    line: number,
+    isDeclaration: boolean,
+  ): void {
+    SymbolCollectorContext.addSymbol(this.ctx, {
+      name: `${className}::${funcName}`,
+      kind: ESymbolKind.Function,
+      type: returnType,
+      sourceFile: this.ctx.sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      isDeclaration: isDeclaration || undefined,
+      parent: className,
+      parameters: params.length > 0 ? params : undefined,
+    });
+  }
+
   /**
    * Collect all symbols from a C++ translation unit
    */
@@ -257,15 +306,7 @@ class CppSymbolCollector {
     const memberSpec = anonymousClassSpec.memberSpecification?.();
     if (!memberSpec) return false;
 
-    SymbolCollectorContext.addSymbol(this.ctx, {
-      name: fullName,
-      kind: ESymbolKind.Class,
-      sourceFile: this.ctx.sourceFile,
-      sourceLine: line,
-      sourceLanguage: ESourceLanguage.Cpp,
-      isExported: true,
-      parent: this.currentNamespace,
-    });
+    this._addClassSymbol(fullName, line);
     this.collectClassMembers(fullName, memberSpec);
     return true;
   }
@@ -348,15 +389,7 @@ class CppSymbolCollector {
       ? `${this.currentNamespace}::${name}`
       : name;
 
-    SymbolCollectorContext.addSymbol(this.ctx, {
-      name: fullName,
-      kind: ESymbolKind.Class,
-      sourceFile: this.ctx.sourceFile,
-      sourceLine: line,
-      sourceLanguage: ESourceLanguage.Cpp,
-      isExported: true,
-      parent: this.currentNamespace,
-    });
+    this._addClassSymbol(fullName, line);
 
     // Extract struct/class field information if SymbolTable is available
     if (this.ctx.symbolTable) {
@@ -429,18 +462,14 @@ class CppSymbolCollector {
       ? this.extractTypeFromDeclSpecSeq(declSpecSeq)
       : "void";
     const params = this.extractFunctionParameters(declarator);
-
-    SymbolCollectorContext.addSymbol(this.ctx, {
-      name: `${className}::${funcName}`,
-      kind: ESymbolKind.Function,
-      type: returnType,
-      sourceFile: this.ctx.sourceFile,
-      sourceLine: line,
-      sourceLanguage: ESourceLanguage.Cpp,
-      isExported: true,
-      parent: className,
-      parameters: params.length > 0 ? params : undefined,
-    });
+    this._addMemberFunctionSymbol(
+      className,
+      funcName,
+      returnType,
+      params,
+      line,
+      false,
+    );
   }
 
   /**
@@ -484,19 +513,14 @@ class CppSymbolCollector {
     line: number,
   ): void {
     const params = this.extractFunctionParameters(declarator);
-
-    SymbolCollectorContext.addSymbol(this.ctx, {
-      name: `${className}::${funcName}`,
-      kind: ESymbolKind.Function,
-      type: returnType,
-      sourceFile: this.ctx.sourceFile,
-      sourceLine: line,
-      sourceLanguage: ESourceLanguage.Cpp,
-      isExported: true,
-      isDeclaration: true,
-      parent: className,
-      parameters: params.length > 0 ? params : undefined,
-    });
+    this._addMemberFunctionSymbol(
+      className,
+      funcName,
+      returnType,
+      params,
+      line,
+      true,
+    );
   }
 
   /**

package/src/transpiler/logic/symbols/cnext/collectors/StructCollector.ts

@@ -11,29 +11,98 @@ import IFieldInfo from "../../types/IFieldInfo";
 import TypeUtils from "../utils/TypeUtils";
 import LiteralUtils from "../../../../../utils/LiteralUtils";
 
-class StructCollector {
-  /**
-   * Parse array dimension expressions and append resolved sizes to dimensions array.
-   */
-  private static parseArrayDimensions(
-    arrayDims: Parser.ArrayDimensionContext[],
-    dimensions: number[],
-    constValues?: Map<string, number>,
-  ): void {
-    for (const dim of arrayDims) {
-      const sizeExpr = dim.expression();
-      if (sizeExpr) {
-        const dimText = sizeExpr.getText();
-        const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
-        if (literalSize !== undefined) {
-          dimensions.push(literalSize);
-        } else if (constValues?.has(dimText)) {
-          dimensions.push(constValues.get(dimText)!);
-        }
+/**
+ * Result of processing an arrayType syntax context.
+ */
+interface IArrayTypeResult {
+  isArray: boolean;
+  dimension: number | undefined;
+}
+
+/**
+ * Process arrayType syntax (e.g., Item[3] items) and return array info.
+ */
+function processArrayTypeSyntax(
+  arrayTypeCtx: Parser.ArrayTypeContext | null | undefined,
+  constValues?: Map<string, number>,
+): IArrayTypeResult {
+  if (!arrayTypeCtx) {
+    return { isArray: false, dimension: undefined };
+  }
+
+  const sizeExpr = arrayTypeCtx.expression();
+  if (!sizeExpr) {
+    return { isArray: true, dimension: undefined };
+  }
+
+  const resolved = tryResolveExpressionDimension(sizeExpr, constValues);
+  return { isArray: true, dimension: resolved };
+}
+
+/**
+ * Process string type fields and update dimensions array.
+ */
+function processStringField(
+  stringCtx: Parser.StringTypeContext,
+  arrayDims: Parser.ArrayDimensionContext[],
+  dimensions: number[],
+  constValues?: Map<string, number>,
+): boolean {
+  const intLiteral = stringCtx.INTEGER_LITERAL();
+  if (!intLiteral) {
+    return false;
+  }
+
+  const capacity = Number.parseInt(intLiteral.getText(), 10);
+
+  // If there are array dimensions, they come BEFORE string capacity
+  if (arrayDims.length > 0) {
+    parseArrayDimensions(arrayDims, dimensions, constValues);
+  }
+  // String capacity becomes final dimension (+1 for null terminator)
+  dimensions.push(capacity + 1);
+  return true;
+}
+
+/**
+ * Try to resolve a single expression as a numeric dimension.
+ * Handles integer literals and const references.
+ */
+function tryResolveExpressionDimension(
+  sizeExpr: Parser.ExpressionContext,
+  constValues?: Map<string, number>,
+): number | undefined {
+  const dimText = sizeExpr.getText();
+  const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
+  if (literalSize !== undefined) {
+    return literalSize;
+  }
+  if (constValues?.has(dimText)) {
+    return constValues.get(dimText);
+  }
+  return undefined;
+}
+
+/**
+ * Parse array dimension expressions and append resolved sizes to dimensions array.
+ */
+function parseArrayDimensions(
+  arrayDims: Parser.ArrayDimensionContext[],
+  dimensions: number[],
+  constValues?: Map<string, number>,
+): void {
+  for (const dim of arrayDims) {
+    const sizeExpr = dim.expression();
+    if (sizeExpr) {
+      const resolved = tryResolveExpressionDimension(sizeExpr, constValues);
+      if (resolved !== undefined) {
+        dimensions.push(resolved);
       }
     }
   }
+}
 
+class StructCollector {
   /**
    * Collect a struct declaration and return an IStructSymbol.
    *
@@ -56,57 +125,12 @@ class StructCollector {
     const fields = new Map<string, IFieldInfo>();
 
     for (const member of ctx.structMember()) {
-      const fieldName = member.IDENTIFIER().getText();
-      const typeCtx = member.type();
-      const fieldType = TypeUtils.getTypeName(typeCtx, scopeName);
-      // Note: C-Next struct members don't have const modifier in grammar
-      const isConst = false;
-
-      const arrayDims = member.arrayDimension();
-      const dimensions: number[] = [];
-      let isArray = false;
-
-      // Handle string types specially
-      if (typeCtx.stringType()) {
-        const stringCtx = typeCtx.stringType()!;
-        const intLiteral = stringCtx.INTEGER_LITERAL();
-
-        if (intLiteral) {
-          const capacity = Number.parseInt(intLiteral.getText(), 10);
-
-          // If there are array dimensions, they come BEFORE string capacity
-          if (arrayDims.length > 0) {
-            StructCollector.parseArrayDimensions(
-              arrayDims,
-              dimensions,
-              constValues,
-            );
-          }
-          // String capacity becomes final dimension (+1 for null terminator)
-          dimensions.push(capacity + 1);
-          isArray = true;
-        }
-      } else if (arrayDims.length > 0) {
-        // Non-string array
-        isArray = true;
-        StructCollector.parseArrayDimensions(
-          arrayDims,
-          dimensions,
-          constValues,
-        );
-      }
-
-      const fieldInfo: IFieldInfo = {
-        type: fieldType,
-        isArray,
-        isConst,
-      };
-
-      if (dimensions.length > 0) {
-        fieldInfo.dimensions = dimensions;
-      }
-
-      fields.set(fieldName, fieldInfo);
+      const fieldInfo = StructCollector.collectField(
+        member,
+        scopeName,
+        constValues,
+      );
+      fields.set(member.IDENTIFIER().getText(), fieldInfo);
     }
 
     return {
@@ -120,6 +144,68 @@ class StructCollector {
       fields,
     };
   }
+
+  /**
+   * Collect a single struct field and return its IFieldInfo.
+   */
+  private static collectField(
+    member: Parser.StructMemberContext,
+    scopeName?: string,
+    constValues?: Map<string, number>,
+  ): IFieldInfo {
+    const typeCtx = member.type();
+    const fieldType = TypeUtils.getTypeName(typeCtx, scopeName);
+    // Note: C-Next struct members don't have const modifier in grammar
+    const isConst = false;
+
+    const arrayDims = member.arrayDimension();
+    const dimensions: number[] = [];
+    let isArray = false;
+
+    // Check for C-Next style arrayType syntax: Item[3] items -> typeCtx.arrayType()
+    const arrayTypeResult = processArrayTypeSyntax(
+      typeCtx.arrayType(),
+      constValues,
+    );
+    if (arrayTypeResult.isArray) {
+      isArray = true;
+      if (arrayTypeResult.dimension !== undefined) {
+        dimensions.push(arrayTypeResult.dimension);
+      }
+      // Note: non-literal, non-const expressions (like global.EnumName.COUNT)
+      // won't be resolvable at symbol collection time - dimensions stays empty
+      // but isArray is still true so the field is tracked as an array
+    }
+
+    // Handle string types specially
+    if (typeCtx.stringType()) {
+      const stringHandled = processStringField(
+        typeCtx.stringType()!,
+        arrayDims,
+        dimensions,
+        constValues,
+      );
+      if (stringHandled) {
+        isArray = true;
+      }
+    } else if (arrayDims.length > 0) {
+      // Non-string array
+      isArray = true;
+      parseArrayDimensions(arrayDims, dimensions, constValues);
+    }
+
+    const fieldInfo: IFieldInfo = {
+      type: fieldType,
+      isArray,
+      isConst,
+    };
+
+    if (dimensions.length > 0) {
+      fieldInfo.dimensions = dimensions;
+    }
+
+    return fieldInfo;
+  }
 }
 
 export default StructCollector;

package/src/transpiler/logic/symbols/cnext/collectors/VariableCollector.ts

@@ -9,6 +9,7 @@ import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import IVariableSymbol from "../../types/IVariableSymbol";
 import ArrayInitializerUtils from "../utils/ArrayInitializerUtils";
 import TypeUtils from "../utils/TypeUtils";
+import LiteralUtils from "../../../../../utils/LiteralUtils";
 
 class VariableCollector {
   /**
@@ -101,17 +102,41 @@ class VariableCollector {
     // Issue #468: Check for atomic modifier
     const isAtomic = ctx.atomicModifier() !== null;
 
-    // Check for array dimensions
+    // Check for array dimensions - both C-style (arrayDimension) and C-Next style (arrayType)
     const arrayDims = ctx.arrayDimension();
-    const isArray = arrayDims.length > 0;
+    const arrayTypeCtx = typeCtx.arrayType();
+    const hasArrayTypeSyntax = arrayTypeCtx !== null;
+    const isArray = arrayDims.length > 0 || hasArrayTypeSyntax;
     const initExpr = ctx.expression();
-    const arrayDimensions = isArray
-      ? VariableCollector.collectArrayDimensions(
+    const arrayDimensions: (number | string)[] = [];
+
+    // Collect dimension from arrayType syntax (u16[8] arr)
+    if (hasArrayTypeSyntax) {
+      const sizeExpr = arrayTypeCtx.expression();
+      if (sizeExpr) {
+        const dimText = sizeExpr.getText();
+        const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
+        if (literalSize !== undefined) {
+          arrayDimensions.push(literalSize);
+        } else if (constValues?.has(dimText)) {
+          arrayDimensions.push(constValues.get(dimText)!);
+        } else {
+          // Keep as string for macro/enum references
+          arrayDimensions.push(dimText);
+        }
+      }
+    }
+
+    // Collect additional dimensions from arrayDimension syntax
+    if (arrayDims.length > 0) {
+      arrayDimensions.push(
+        ...VariableCollector.collectArrayDimensions(
           arrayDims,
           constValues,
           initExpr,
-        )
-      : [];
+        ),
+      );
+    }
 
     // Issue #282: Capture initial value for const inlining
     const initialValue = initExpr?.getText();

package/src/transpiler/logic/symbols/cnext/utils/TypeUtils.ts

@@ -5,6 +5,41 @@
 import * as Parser from "../../../parser/grammar/CNextParser";
 import CNEXT_TO_C_TYPE_MAP from "../../../../../utils/constants/TypeMappings";
 
+/**
+ * Resolve scoped type (this.Type) to full name.
+ */
+function resolveScopedType(
+  scopedTypeCtx: Parser.ScopedTypeContext,
+  scopeName?: string,
+): string {
+  const typeName = scopedTypeCtx.IDENTIFIER().getText();
+  return scopeName ? `${scopeName}_${typeName}` : typeName;
+}
+
+/**
+ * Resolve string type with optional capacity.
+ */
+function resolveStringType(stringCtx: Parser.StringTypeContext): string {
+  const intLiteral = stringCtx.INTEGER_LITERAL();
+  return intLiteral ? `string<${intLiteral.getText()}>` : "string";
+}
+
+/**
+ * Extract inner type from arrayType context.
+ */
+function resolveArrayInnerType(arrayTypeCtx: Parser.ArrayTypeContext): string {
+  if (arrayTypeCtx.primitiveType()) {
+    return arrayTypeCtx.primitiveType()!.getText();
+  }
+  if (arrayTypeCtx.userType()) {
+    return arrayTypeCtx.userType()!.getText();
+  }
+  // Fallback for other nested types - strip the dimension part
+  const text = arrayTypeCtx.getText();
+  const bracketIdx = text.indexOf("[");
+  return bracketIdx > 0 ? text.substring(0, bracketIdx) : text;
+}
+
 class TypeUtils {
   /**
    * Extract the type name from a type context.
@@ -23,11 +58,7 @@ class TypeUtils {
 
     // Handle this.Type for scoped types (e.g., this.State -> Motor_State)
     if (ctx.scopedType()) {
-      const typeName = ctx.scopedType()!.IDENTIFIER().getText();
-      if (scopeName) {
-        return `${scopeName}_${typeName}`;
-      }
-      return typeName;
+      return resolveScopedType(ctx.scopedType()!, scopeName);
     }
 
     // Issue #478: Handle global.Type for global types inside scope
@@ -54,12 +85,13 @@ class TypeUtils {
 
     // Handle string types - preserve capacity for validation (Issue #139)
     if (ctx.stringType()) {
-      const stringCtx = ctx.stringType()!;
-      const intLiteral = stringCtx.INTEGER_LITERAL();
-      if (intLiteral) {
-        return `string<${intLiteral.getText()}>`;
-      }
-      return "string";
+      return resolveStringType(ctx.stringType()!);
+    }
+
+    // Handle arrayType: Type[size] - extract the inner type without dimension
+    // The dimension is tracked separately in arrayDimensions
+    if (ctx.arrayType()) {
+      return resolveArrayInnerType(ctx.arrayType()!);
     }
 
     // Fallback