c-next 0.2.16 → 0.2.17

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

@@ -6,14 +6,16 @@ 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.
+ * Common interface for type contexts that share the same type accessors.
+ * Both TypeContext and ArrayTypeContext have these methods.
  */
-function resolveScopedType(
-  scopedTypeCtx: Parser.ScopedTypeContext,
-  scopeName?: string,
-): string {
-  const typeName = scopedTypeCtx.IDENTIFIER().getText();
-  return scopeName ? `${scopeName}_${typeName}` : typeName;
+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;
 }
 
 /**
@@ -25,19 +27,50 @@ function resolveStringType(stringCtx: Parser.StringTypeContext): string {
 }
 
 /**
- * Extract inner type from arrayType context.
+ * Dispatch type resolution 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 type name, or null if no matching type accessor found
  */
-function resolveArrayInnerType(arrayTypeCtx: Parser.ArrayTypeContext): string {
-  if (arrayTypeCtx.primitiveType()) {
-    return arrayTypeCtx.primitiveType()!.getText();
+function dispatchTypeResolution(
+  accessors: ITypeAccessors,
+  scopeName?: string,
+): string | null {
+  // Handle this.Type for scoped types (e.g., this.State -> Motor_State)
+  if (accessors.scopedType()) {
+    const typeName = accessors.scopedType()!.IDENTIFIER().getText();
+    return scopeName ? `${scopeName}_${typeName}` : typeName;
+  }
+
+  // Handle global.Type for global types inside scope
+  // global.ECategory -> ECategory (just the type name, no scope prefix)
+  if (accessors.globalType()) {
+    return accessors.globalType()!.IDENTIFIER().getText();
   }
-  if (arrayTypeCtx.userType()) {
-    return arrayTypeCtx.userType()!.getText();
+
+  // Handle Scope.Type from outside scope (e.g., Motor.State -> Motor_State)
+  if (accessors.qualifiedType()) {
+    const identifiers = accessors.qualifiedType()!.IDENTIFIER();
+    return identifiers.map((id) => id.getText()).join("_");
+  }
+
+  // Handle user-defined types
+  if (accessors.userType()) {
+    return accessors.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;
+
+  // Handle primitive types
+  if (accessors.primitiveType()) {
+    return accessors.primitiveType()!.getText();
+  }
+
+  // Handle string types - preserve capacity for validation (Issue #139)
+  if (accessors.stringType()) {
+    return resolveStringType(accessors.stringType()!);
+  }
+
+  return null;
 }
 
 class TypeUtils {
@@ -56,42 +89,23 @@ class TypeUtils {
   ): string {
     if (!ctx) return "void";
 
-    // Handle this.Type for scoped types (e.g., this.State -> Motor_State)
-    if (ctx.scopedType()) {
-      return resolveScopedType(ctx.scopedType()!, scopeName);
-    }
-
-    // Issue #478: Handle global.Type for global types inside scope
-    // global.ECategory -> ECategory (just the type name, no scope prefix)
-    if (ctx.globalType()) {
-      return ctx.globalType()!.IDENTIFIER().getText();
-    }
-
-    // Handle Scope.Type from outside scope (e.g., Motor.State -> Motor_State)
-    if (ctx.qualifiedType()) {
-      const identifiers = ctx.qualifiedType()!.IDENTIFIER();
-      return identifiers.map((id) => id.getText()).join("_");
-    }
-
-    // Handle user-defined types
-    if (ctx.userType()) {
-      return ctx.userType()!.getText();
-    }
-
-    // Handle primitive types
-    if (ctx.primitiveType()) {
-      return ctx.primitiveType()!.getText();
-    }
-
-    // Handle string types - preserve capacity for validation (Issue #139)
-    if (ctx.stringType()) {
-      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()!);
+      const result = dispatchTypeResolution(ctx.arrayType()!, scopeName);
+      if (result !== null) {
+        return result;
+      }
+      // Fallback for unrecognized array types - strip the dimension part
+      const text = ctx.arrayType()!.getText();
+      const bracketIdx = text.indexOf("[");
+      return bracketIdx > 0 ? text.substring(0, bracketIdx) : text;
+    }
+
+    // Non-array types - dispatch directly
+    const result = dispatchTypeResolution(ctx, scopeName);
+    if (result !== null) {
+      return result;
     }
 
     // Fallback

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

@@ -726,6 +726,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    * ADR-045: Used to detect string comparisons and generate strcmp().
    * Issue #137: Extended to handle array element access (e.g., names[0])
+   * Issue #1030: Extended to handle struct member access (e.g., person.name)
    */
   isStringExpression(ctx: Parser.RelationalExpressionContext): boolean {
     const text = ctx.getText();
@@ -743,6 +744,11 @@ export default class CodeGenerator implements IOrchestrator {
       }
     }
 
+    // Issue #1030: Check for struct member access (e.g., person.name)
+    if (this._isStructMemberStringExpression(text)) {
+      return true;
+    }
+
     // Issue #137: Check for array element access (e.g., names[0], arr[i])
     return this._isArrayAccessStringExpression(text);
   }
@@ -800,6 +806,59 @@ export default class CodeGenerator implements IOrchestrator {
     );
   }
 
+  /**
+   * Check if struct member access expression evaluates to a string.
+   * Issue #1030: Handles patterns like person.name, config.key
+   */
+  private _isStructMemberStringExpression(text: string): boolean {
+    // Pattern: identifier.identifier (simple member access)
+    // Must not end with a property that returns a number
+    if (
+      text.endsWith(".char_count") ||
+      text.endsWith(".capacity") ||
+      text.endsWith(".size") ||
+      text.endsWith(".length") ||
+      text.endsWith(".bit_length") ||
+      text.endsWith(".byte_length") ||
+      text.endsWith(".element_count")
+    ) {
+      return false;
+    }
+
+    // Match simple struct.member pattern
+    const memberMatch = /^([a-zA-Z_]\w*)\.([a-zA-Z_]\w*)$/.exec(text);
+    if (!memberMatch) {
+      return false;
+    }
+
+    const [, varName, fieldName] = memberMatch;
+
+    // Get the struct variable's type
+    const typeInfo = CodeGenState.getVariableTypeInfo(varName);
+    if (!typeInfo) {
+      return false;
+    }
+
+    // Get the struct type name - it might be directly the baseType
+    // or we might need to look it up by the variable's type
+    const structTypeName = typeInfo.baseType;
+    if (!structTypeName) {
+      return false;
+    }
+
+    // Look up the field type from the struct
+    const fieldType = CodeGenState.getStructFieldType(
+      structTypeName,
+      fieldName,
+    );
+    if (!fieldType) {
+      return false;
+    }
+
+    // Check if the field is a string type (e.g., "string<64>")
+    return fieldType.startsWith("string");
+  }
+
   /**
    * Get type of additive expression.
    * Part of IOrchestrator interface - delegates to private implementation.
@@ -1311,9 +1370,10 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-017: Handle enum types by initializing to first member
    */
   getZeroInitializer(typeCtx: Parser.TypeContext, isArray: boolean): string {
-    // Issue #379: Arrays need element type checking for C++ classes
+    // Issue #379 / #1004: arrays zero-init with the aggregate brace ({} in
+    // C++, {0} in C) regardless of element type.
     if (isArray) {
-      return this._getArrayZeroInitializer(typeCtx);
+      return this._getAggregateZeroInitBrace();
     }
 
     // Handle named types (scoped, global, qualified, user)
@@ -1323,11 +1383,10 @@ export default class CodeGenerator implements IOrchestrator {
       if (CodeGenState.symbols!.knownEnums.has(resolved.name)) {
         return this._getEnumZeroValue(resolved.name, resolved.separator);
       }
-      // Check if C++ type needing {} (only for userType, not qualified/scoped/global)
-      if (resolved.checkCppType && this._needsEmptyBraceInit(resolved.name)) {
-        return "{}";
-      }
-      return "{0}";
+      // Issue #1004: struct/class zero-init. C++ value-initialization ({})
+      // works for every aggregate (including ones whose first field is an
+      // enum, where {0} is an invalid int->enum narrowing); C uses {0}.
+      return this._getAggregateZeroInitBrace();
     }
 
     // Issue #295: C++ template types use value initialization {}
@@ -1335,6 +1394,11 @@ export default class CodeGenerator implements IOrchestrator {
       return "{}";
     }
 
+    // Issue #1019: string<N> types use empty string initializer
+    if (typeCtx.stringType()) {
+      return '""';
+    }
+
     // Primitive types use lookup map
     if (typeCtx.primitiveType()) {
       const primType = typeCtx.primitiveType()!.getText();
@@ -1490,9 +1554,9 @@ export default class CodeGenerator implements IOrchestrator {
               if (p.isArray) {
                 // Array parameters: type name[]
                 return `${constMod}${p.type} ${p.name}${p.arrayDims}`;
-              } else if (p.isPointer) {
-                // ADR-006: Non-array, non-callback parameters become pointers
-                // In C++ mode, use reference (&) instead of pointer (*)
+              } else if (p.isStruct) {
+                // ADR-006: Struct parameters become pointers (C) or references (C++)
+                // Only struct types get pointer/reference semantics, not primitives
                 const ptrOrRef = this.isCppMode() ? "&" : "*";
                 return `${constMod}${p.type}${ptrOrRef}`;
               } else {
@@ -1776,7 +1840,17 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     if (ctx.IDENTIFIER()) {
-      return this._resolveIdentifierExpression(ctx.IDENTIFIER()!.getText());
+      const id = ctx.IDENTIFIER()!.getText();
+      // Issue #1011: break/continue are not part of C-Next - use structured conditions
+      // ADR-026 (Status: Rejected) explicitly excludes break/continue from the language
+      if (id === "break" || id === "continue") {
+        const line = ctx.start?.line ?? 0;
+        const col = ctx.start?.column ?? 0;
+        throw new Error(
+          `${line}:${col} error[E0703]: '${id}' is not supported in C-Next - use structured conditions instead`,
+        );
+      }
+      return this._resolveIdentifierExpression(id);
     }
     if (ctx.literal()) {
       return this._generateLiteralExpression(ctx.literal()!);
@@ -2085,15 +2159,6 @@ export default class CodeGenerator implements IOrchestrator {
     return identifiers.join("_");
   }
 
-  /**
-   * Issue #304: Check if a type name is from a C++ header
-   * Used to determine whether to use {} or {0} for initialization.
-   * C++ types with constructors may fail with {0} but work with {}.
-   */
-  private isCppType(typeName: string): boolean {
-    return SymbolLookupHelper.isCppType(CodeGenState.symbolTable, typeName);
-  }
-
   /**
    * Generate C code from a C-Next program
    * @param tree The parsed C-Next program
@@ -2689,6 +2754,7 @@ export default class CodeGenerator implements IOrchestrator {
       type: string;
       isConst: boolean;
       isPointer: boolean;
+      isStruct: boolean;
       isArray: boolean;
       arrayDims: string;
     }> = [];
@@ -2704,6 +2770,8 @@ export default class CodeGenerator implements IOrchestrator {
 
         // ADR-029: Check if parameter type is itself a callback type
         const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
+        // ADR-006: Check if parameter type is a struct (for pointer/reference semantics)
+        const isStruct = this.isStructType(typeName);
 
         let paramType: string;
         let isPointer: boolean;
@@ -2715,8 +2783,8 @@ export default class CodeGenerator implements IOrchestrator {
           isPointer = false; // Function pointers are already pointers
         } else {
           paramType = this.generateType(param.type());
-          // ADR-006: Non-array parameters become pointers
-          isPointer = !isArray;
+          // ADR-006: Non-array struct parameters become pointers in C mode
+          isPointer = !isArray && isStruct;
         }
 
         let arrayDims: string;
@@ -2739,6 +2807,7 @@ export default class CodeGenerator implements IOrchestrator {
           type: paramType,
           isConst,
           isPointer,
+          isStruct,
           isArray,
           arrayDims,
         });
@@ -3211,7 +3280,7 @@ export default class CodeGenerator implements IOrchestrator {
     decl += this._getStringCapacityDimension(varDecl.type());
 
     if (varDecl.expression()) {
-      decl += ` = ${this.generateExpression(varDecl.expression()!)}`;
+      decl += ` = ${CodeGenState.withDeclarationInit(() => this.generateExpression(varDecl.expression()!))}`;
     } else {
       // ADR-015: Zero initialization for uninitialized scope variables
       decl += ` = ${this.getZeroInitializer(varDecl.type(), isArray)}`;
@@ -3495,8 +3564,9 @@ export default class CodeGenerator implements IOrchestrator {
     );
 
     if (!fieldList) {
-      // Empty initializer: Point {} -> (Point){ 0 } or {} for C++ classes
-      return isCppClass ? "{}" : `(${castType}){ 0 }`;
+      // Empty initializer: Point {} -> { 0 } in declaration context, (Point){ 0 } elsewhere
+      if (isCppClass) return "{}";
+      return CodeGenState.inDeclarationInit ? "{ 0 }" : `(${castType}){ 0 }`;
     }
 
     // Get field type info for nested initializers
@@ -3507,28 +3577,10 @@ export default class CodeGenerator implements IOrchestrator {
 
     const fields = fieldList.fieldInitializer().map((field) => {
       const fieldName = field.IDENTIFIER().getText();
-
-      // Compute expected type for nested initializers
-      let fieldType: string | undefined;
-      if (structFieldTypes?.has(fieldName)) {
-        // Issue #502: Convert underscore format to correct output format
-        // C-Next struct fields may store C++ types with _ separator (e.g., SeaDash_Parse_ParseResult)
-        // but code generation needs :: for C++ types (e.g., SeaDash::Parse::ParseResult)
-        fieldType = structFieldTypes.get(fieldName)!;
-        if (fieldType.includes("_")) {
-          // Check if this looks like a qualified type (contains _) and convert
-          const parts = fieldType.split("_");
-          if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
-            // It's a C++ namespaced type - convert _ to ::
-            fieldType = parts.join("::");
-          }
-        }
-      }
-
+      const fieldType = this._resolveFieldType(fieldName, structFieldTypes);
       const value = CodeGenState.withExpectedType(fieldType, () =>
         this.generateExpression(field.expression()),
       );
-
       return { fieldName, value };
     });
 
@@ -3545,6 +3597,23 @@ export default class CodeGenerator implements IOrchestrator {
     // For C-Next/C structs, generate designated initializer
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
 
+    return this.formatStructInitializer(typeName, castType, fieldInits);
+  }
+
+  private formatStructInitializer(
+    typeName: string,
+    castType: string,
+    fieldInits: string[],
+  ): string {
+    const initializer: string = `{ ${fieldInits.join(", ")} }`;
+
+    // In a declaration initializer context, use plain designated initializer — no type cast
+    // prefix needed, and compound literals are not C99 constant expressions so they fail
+    // at file scope on GCC < 13.
+    if (CodeGenState.inDeclarationInit) {
+      return initializer;
+    }
+
     // Issue #882: In C++ mode, anonymous structs/unions must use plain brace init.
     // Compound literals like (struct { ... }){ ... } create incompatible types in C++
     // because each struct { ... } definition creates a distinct nominal type.
@@ -3552,10 +3621,33 @@ export default class CodeGenerator implements IOrchestrator {
       CodeGenState.cppMode &&
       (typeName.startsWith("struct {") || typeName.startsWith("union {"))
     ) {
-      return `{ ${fieldInits.join(", ")} }`;
+      return initializer;
     }
 
-    return `(${castType}){ ${fieldInits.join(", ")} }`;
+    if (!CodeGenState.inFunctionBody) {
+      return initializer;
+    }
+
+    return `(${castType})${initializer}`;
+  }
+
+  /**
+   * Resolve the C type string for a named struct field, converting C++ underscore-separated
+   * names to :: notation. Returns undefined if the field is not in the type map.
+   * Issue #502: C-Next stores C++ types with _ separator; codegen needs ::.
+   */
+  private _resolveFieldType(
+    fieldName: string,
+    structFieldTypes: Map<string, string> | undefined,
+  ): string | undefined {
+    if (!structFieldTypes?.has(fieldName)) return undefined;
+    const fieldType = structFieldTypes.get(fieldName)!;
+    if (!fieldType.includes("_")) return fieldType;
+    const parts = fieldType.split("_");
+    if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
+      return parts.join("::");
+    }
+    return fieldType;
   }
 
   /**
@@ -3776,6 +3868,8 @@ export default class CodeGenerator implements IOrchestrator {
       forceConst,
       isTypedefStructType: (t) =>
         CodeGenState.symbolTable?.isTypedefStructType(t) ?? false,
+      // Issue #995: Opaque handles should not get auto-const
+      isOpaqueType: (t) => CodeGenState.isOpaqueType(t),
     });
 
     // Use shared builder with C/C++ mode
@@ -4102,31 +4196,13 @@ export default class CodeGenerator implements IOrchestrator {
   // and _generateConstructorDecl have been extracted to VariableDeclHelper.ts
 
   /**
-   * Get zero initializer for array types.
-   * Issue #379: C++ class arrays must use {} instead of {0}
+   * Brace initializer that zero-initializes an aggregate (struct or array).
+   * Issue #379 / #1004: C++ uses value-initialization ({}), which is valid for
+   * any aggregate element type (POD, struct, class) including enum-first
+   * structs where {0} is an invalid int->enum narrowing; C uses {0}.
    */
-  private _getArrayZeroInitializer(typeCtx: Parser.TypeContext): string {
-    // Check if element type is a C++ class or template type
-    if (typeCtx.userType()) {
-      const typeName = typeCtx.userType()!.getText();
-      if (this._needsEmptyBraceInit(typeName)) {
-        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 "{}";
-    }
-    // Default: POD arrays use {0}
-    return "{0}";
+  private _getAggregateZeroInitBrace(): string {
+    return CodeGenState.cppMode ? "{}" : "{0}";
   }
 
   /**
@@ -4158,20 +4234,19 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Resolve full type name from any TypeContext variant.
-   * Returns { name, separator, checkCppType } or null if not a named type.
+   * Returns { name, separator } or null if not a named type.
    * ADR-016: Handles scoped, global, qualified, and user types
-   * checkCppType: only true for userType (original behavior preserved)
    */
   private _resolveTypeNameFromContext(
     typeCtx: Parser.TypeContext,
-  ): { name: string; separator: string; checkCppType: boolean } | null {
+  ): { name: string; separator: string } | null {
     // ADR-016: Check for scoped types (this.Type)
     if (typeCtx.scopedType()) {
       const localName = typeCtx.scopedType()!.IDENTIFIER().getText();
       const name = CodeGenState.currentScope
         ? `${CodeGenState.currentScope}_${localName}`
         : localName;
-      return { name, separator: "_", checkCppType: false };
+      return { name, separator: "_" };
     }
 
     // Issue #478: Check for global types (global.Type)
@@ -4179,7 +4254,6 @@ export default class CodeGenerator implements IOrchestrator {
       return {
         name: typeCtx.globalType()!.IDENTIFIER().getText(),
         separator: "_",
-        checkCppType: false,
       };
     }
 
@@ -4189,7 +4263,7 @@ export default class CodeGenerator implements IOrchestrator {
       const parts = typeCtx.qualifiedType()!.IDENTIFIER();
       const name = this.resolveQualifiedType(parts.map((id) => id.getText()));
       const separator = name.includes("::") ? "::" : "_";
-      return { name, separator, checkCppType: false };
+      return { name, separator };
     }
 
     // Check for user-defined types (structs/classes/enums)
@@ -4197,28 +4271,12 @@ export default class CodeGenerator implements IOrchestrator {
       return {
         name: typeCtx.userType()!.getText(),
         separator: "_",
-        checkCppType: true,
       };
     }
 
     return null;
   }
 
-  /**
-   * Check if a type needs empty brace initialization {}.
-   * Issue #304: C++ types with constructors may fail with {0}
-   * Issue #309: Unknown user types in C++ mode may have non-trivial constructors
-   */
-  private _needsEmptyBraceInit(typeName: string): boolean {
-    // C++ types (external libraries with constructors)
-    if (this.isCppType(typeName)) {
-      return true;
-    }
-    // In C++ mode, unknown user types may have non-trivial constructors
-    // Known structs (C-Next or C headers) are POD types where {0} works
-    return CodeGenState.cppMode && !this.isKnownStruct(typeName);
-  }
-
   /**
    * Generate a safe bit mask expression.
    * Avoids undefined behavior when width >= 32 for 32-bit integers.
@@ -4750,8 +4808,7 @@ export default class CodeGenerator implements IOrchestrator {
     // MISRA 10.3: Cast limit macros to target type (they have type 'int')
     const finalCast = CppModeHelper.cast(targetType, `(${expr})`);
     const castMax = CppModeHelper.cast(targetType, maxValue);
-    const castMin =
-      minValue === "0" ? "0" : CppModeHelper.cast(targetType, minValue);
+    const castMin = CppModeHelper.cast(targetType, minValue);
     return `((${expr}) > ${maxComparison} ? ${castMax} : (${expr}) < ${minComparison} ? ${castMin} : ${finalCast})`;
   }