c-next 0.2.16 → 0.2.18

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

@@ -148,6 +148,7 @@ import EnumTypeResolver from "./resolution/EnumTypeResolver";
 import ScopeResolver from "./resolution/ScopeResolver";
 // Issue #797: Centralized C-style name generation
 import QualifiedNameGenerator from "./utils/QualifiedNameGenerator";
+import MisraSuppressionUtils from "../MisraSuppressionUtils";
 
 const {
   generateOverflowHelpers: helperGenerateOverflowHelpers,
@@ -299,6 +300,10 @@ export default class CodeGenerator implements IOrchestrator {
       controlFlowGenerators.generateDoWhile,
     );
     this.registry.registerStatement("for", controlFlowGenerators.generateFor);
+    this.registry.registerStatement(
+      "forever",
+      controlFlowGenerators.generateForever,
+    );
     this.registry.registerStatement("switch", switchGenerators.generateSwitch);
     this.registry.registerStatement("critical", generateCriticalStatement);
 
@@ -726,6 +731,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 +749,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 +811,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.
@@ -998,6 +1062,8 @@ export default class CodeGenerator implements IOrchestrator {
       result = this.generateDoWhile(ctx.doWhileStatement()!);
     } else if (ctx.forStatement()) {
       result = this.generateFor(ctx.forStatement()!);
+    } else if (ctx.foreverStatement()) {
+      result = this.generateForever(ctx.foreverStatement()!);
     } else if (ctx.switchStatement()) {
       result = this.generateSwitch(ctx.switchStatement()!);
     } else if (ctx.returnStatement()) {
@@ -1063,6 +1129,14 @@ export default class CodeGenerator implements IOrchestrator {
     TypeValidator.validateConditionIsBoolean(ctx, conditionType);
   }
 
+  /**
+   * ADR-113 / #1075: reject an always-true literal loop condition (E0707).
+   * Part of IOrchestrator interface.
+   */
+  validateLoopConditionNotAlwaysTrue(ctx: Parser.ExpressionContext): void {
+    TypeValidator.validateLoopConditionNotAlwaysTrue(ctx);
+  }
+
   /**
    * Issue #254: Validate no function calls in condition (E0702).
    * Part of IOrchestrator interface (ADR-053 A3).
@@ -1105,8 +1179,6 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Issue #779: Resolve bare scope member identifiers before postfix chain processing
     // This ensures scope members get their prefix even with array/member access.
-    // Skip parameters - they don't need scope resolution and shouldn't be dereferenced
-    // when used with array indexing (buf[idx] is valid C for pointer params).
     // Also skip known registers - they should be handled by the postfix chain builder
     // to enable proper register validation (requiring global. when shadowed).
     let resolvedIdentifier = identifier ?? "";
@@ -1115,7 +1187,24 @@ export default class CodeGenerator implements IOrchestrator {
       const isLocalVariable = CodeGenState.localVariables.has(identifier);
       const isKnownRegister =
         CodeGenState.symbols?.knownRegisters.has(identifier);
-      if (!isParameter && !isLocalVariable && !isKnownRegister) {
+      // Issue #1100: Parameters with postfix ops (array/bit subscript, member
+      // access) must resolve through the same dereference logic as a bare
+      // parameter reference (ParameterDereferenceResolver), not skip it.
+      // For array/struct/string/etc. parameters this is a no-op (they're
+      // already pointer-like, matching the prior behavior verbatim — e.g.
+      // `buf[idx]` stays `buf[idx]`). For a scalar parameter that became a
+      // pointer because it's modified elsewhere in the function, a bit
+      // access (`v[4] <- true`) now correctly dereferences to `(*v)[4]`
+      // (which AssignmentContextBuilder reduces to base identifier `(*v)`)
+      // instead of assigning through the raw pointer.
+      if (isParameter) {
+        const paramInfo = CodeGenState.currentParameters.get(identifier)!;
+        resolvedIdentifier = ParameterDereferenceResolver.resolve(
+          identifier,
+          paramInfo,
+          this._buildParameterDereferenceDeps(),
+        );
+      } else if (!isLocalVariable && !isKnownRegister) {
         const resolved = TypeValidator.resolveBareIdentifier(
           identifier,
           false, // not local
@@ -1311,9 +1400,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 +1413,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 +1424,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 +1584,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 +1870,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 +2189,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
@@ -2297,7 +2392,14 @@ export default class CodeGenerator implements IOrchestrator {
         includePaths,
       );
 
-      output.push(this.transformIncludeDirective(includeDir.getText()));
+      // Issue #850: Add MISRA suppression for banned headers
+      const includeText = includeDir.getText();
+      const suppression =
+        MisraSuppressionUtils.getMisraSuppressionComment(includeText);
+      if (suppression) {
+        output.push(suppression);
+      }
+      output.push(this.transformIncludeDirective(includeText));
     }
 
     if (tree.includeDirective().length > 0) {
@@ -2689,6 +2791,7 @@ export default class CodeGenerator implements IOrchestrator {
       type: string;
       isConst: boolean;
       isPointer: boolean;
+      isStruct: boolean;
       isArray: boolean;
       arrayDims: string;
     }> = [];
@@ -2704,6 +2807,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 +2820,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 +2844,7 @@ export default class CodeGenerator implements IOrchestrator {
           type: paramType,
           isConst,
           isPointer,
+          isStruct,
           isArray,
           arrayDims,
         });
@@ -3211,7 +3317,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 +3601,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 +3614,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 +3634,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 +3658,33 @@ export default class CodeGenerator implements IOrchestrator {
       CodeGenState.cppMode &&
       (typeName.startsWith("struct {") || typeName.startsWith("union {"))
     ) {
-      return `{ ${fieldInits.join(", ")} }`;
+      return initializer;
+    }
+
+    if (!CodeGenState.inFunctionBody) {
+      return initializer;
     }
 
-    return `(${castType}){ ${fieldInits.join(", ")} }`;
+    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 +3905,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 +4233,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 +4271,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 +4291,6 @@ export default class CodeGenerator implements IOrchestrator {
       return {
         name: typeCtx.globalType()!.IDENTIFIER().getText(),
         separator: "_",
-        checkCppType: false,
       };
     }
 
@@ -4189,7 +4300,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 +4308,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.
@@ -4461,6 +4556,10 @@ export default class CodeGenerator implements IOrchestrator {
     return this.invokeStatement("for", ctx);
   }
 
+  private generateForever(ctx: Parser.ForeverStatementContext): string {
+    return this.invokeStatement("forever", ctx);
+  }
+
   private generateReturn(ctx: Parser.ReturnStatementContext): string {
     return this.invokeStatement("return", ctx);
   }
@@ -4750,8 +4849,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})`;
   }