c-next 0.1.62 → 0.1.63

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

@@ -1,13 +1,9 @@
 /**
  * TypeResolver - Handles type inference, classification, and validation
- * Extracted from CodeGenerator for better separation of concerns
- * Issue #61: Now independent of CodeGenerator
+ * Static class that reads from CodeGenState directly.
  */
 import * as Parser from "../../logic/parser/grammar/CNextParser";
-import ICodeGenSymbols from "../../types/ICodeGenSymbols";
-import SymbolTable from "../../logic/symbols/SymbolTable";
-import TTypeInfo from "./types/TTypeInfo";
-import ITypeResolverDeps from "./types/ITypeResolverDeps";
+import CodeGenState from "./CodeGenState";
 import INTEGER_TYPES from "./types/INTEGER_TYPES";
 import FLOAT_TYPES from "./types/FLOAT_TYPES";
 import SIGNED_TYPES from "./types/SIGNED_TYPES";
@@ -16,64 +12,68 @@ import TYPE_WIDTH from "./types/TYPE_WIDTH";
 import TYPE_RANGES from "./types/TYPE_RANGES";
 import ExpressionUnwrapper from "./utils/ExpressionUnwrapper";
 
+/**
+ * Internal type info tracked through postfix suffix chains.
+ * Preserves isArray so indexing can distinguish array access from bit indexing.
+ */
+type InternalTypeInfo = { baseType: string; isArray: boolean };
+
+/**
+ * Discriminated union for postfix suffix processing results.
+ * stop=true: return type immediately (terminal suffix like bit indexing).
+ * stop=false: continue chain with updated InternalTypeInfo.
+ */
+type SuffixResult =
+  | { stop: true; type: string | null }
+  | { stop: false; info: InternalTypeInfo };
+
 class TypeResolver {
-  private readonly symbols: ICodeGenSymbols | null;
-  private readonly symbolTable: SymbolTable | null;
-  private readonly typeRegistry: Map<string, TTypeInfo>;
-  private readonly resolveIdentifierFn: (name: string) => string;
-
-  constructor(deps: ITypeResolverDeps) {
-    this.symbols = deps.symbols;
-    this.symbolTable = deps.symbolTable;
-    this.typeRegistry = deps.typeRegistry;
-    this.resolveIdentifierFn = deps.resolveIdentifier;
-  }
+  /** Sentinel value for `global` keyword in postfix expression type resolution */
+  private static readonly GLOBAL_SENTINEL = "__global__";
+  /** Sentinel value for `this` keyword in postfix expression type resolution */
+  private static readonly THIS_SENTINEL = "__this__";
 
   /**
    * ADR-024: Check if a type is any integer (signed or unsigned)
    */
-  isIntegerType(typeName: string): boolean {
+  static isIntegerType(typeName: string): boolean {
     return (INTEGER_TYPES as readonly string[]).includes(typeName);
   }
 
   /**
    * ADR-024: Check if a type is a floating point type
    */
-  isFloatType(typeName: string): boolean {
+  static isFloatType(typeName: string): boolean {
     return (FLOAT_TYPES as readonly string[]).includes(typeName);
   }
 
   /**
    * ADR-024: Check if a type is a signed integer
    */
-  isSignedType(typeName: string): boolean {
+  static isSignedType(typeName: string): boolean {
     return (SIGNED_TYPES as readonly string[]).includes(typeName);
   }
 
   /**
    * ADR-024: Check if a type is an unsigned integer
    */
-  isUnsignedType(typeName: string): boolean {
+  static isUnsignedType(typeName: string): boolean {
     return (UNSIGNED_TYPES as readonly string[]).includes(typeName);
   }
 
   /**
    * Check if a type is a user-defined struct (C-Next or C header).
    * Issue #103: Now checks both knownStructs AND SymbolTable.
-   * Issue #60: Uses SymbolCollector for C-Next structs.
-   * Issue #61: Uses injected dependencies instead of CodeGenerator.
    */
-  isStructType(typeName: string): boolean {
-    // Check C-Next structs first (Issue #60: use SymbolCollector)
-    if (this.symbols?.knownStructs.has(typeName)) {
+  static isStructType(typeName: string): boolean {
+    if (CodeGenState.symbols?.knownStructs.has(typeName)) {
       return true;
     }
     // Issue #551: Bitmaps are struct-like (use pass-by-reference with -> access)
-    if (this.symbols?.knownBitmaps.has(typeName)) {
+    if (CodeGenState.symbols?.knownBitmaps.has(typeName)) {
       return true;
     }
-    // Check SymbolTable for C header structs
-    if (this.symbolTable?.getStructFields(typeName)) {
+    if (CodeGenState.symbolTable?.getStructFields(typeName)) {
       return true;
     }
     return false;
@@ -81,14 +81,16 @@ class TypeResolver {
 
   /**
    * ADR-024: Check if conversion from sourceType to targetType is narrowing
-   * Narrowing occurs when target type has fewer bits than source type
    */
-  isNarrowingConversion(sourceType: string, targetType: string): boolean {
+  static isNarrowingConversion(
+    sourceType: string,
+    targetType: string,
+  ): boolean {
     const sourceWidth = TYPE_WIDTH[sourceType] || 0;
     const targetWidth = TYPE_WIDTH[targetType] || 0;
 
     if (sourceWidth === 0 || targetWidth === 0) {
-      return false; // Can't determine for unknown types
+      return false;
     }
 
     return targetWidth < sourceWidth;
@@ -96,13 +98,12 @@ class TypeResolver {
 
   /**
    * ADR-024: Check if conversion involves a sign change
-   * Sign change occurs when converting between signed and unsigned types
    */
-  isSignConversion(sourceType: string, targetType: string): boolean {
-    const sourceIsSigned = this.isSignedType(sourceType);
-    const sourceIsUnsigned = this.isUnsignedType(sourceType);
-    const targetIsSigned = this.isSignedType(targetType);
-    const targetIsUnsigned = this.isUnsignedType(targetType);
+  static isSignConversion(sourceType: string, targetType: string): boolean {
+    const sourceIsSigned = TypeResolver.isSignedType(sourceType);
+    const sourceIsUnsigned = TypeResolver.isUnsignedType(sourceType);
+    const targetIsSigned = TypeResolver.isSignedType(targetType);
+    const targetIsUnsigned = TypeResolver.isUnsignedType(targetType);
 
     return (
       (sourceIsSigned && targetIsUnsigned) ||
@@ -113,47 +114,41 @@ class TypeResolver {
   /**
    * ADR-024: Validate that a literal value fits within the target type's range.
    * Throws an error if the value doesn't fit.
-   * @param literalText The literal text (e.g., "256", "-1", "0xFF")
-   * @param targetType The target type (e.g., "u8", "i32")
    */
-  validateLiteralFitsType(literalText: string, targetType: string): void {
+  static validateLiteralFitsType(
+    literalText: string,
+    targetType: string,
+  ): void {
     const range = TYPE_RANGES[targetType];
     if (!range) {
-      return; // No validation for unknown types (floats, bools, etc.)
+      return;
     }
 
-    // Parse the literal value
     let value: bigint;
     try {
       const cleanText = literalText.trim();
 
       if (/^-?\d+$/.exec(cleanText)) {
-        // Decimal integer
         value = BigInt(cleanText);
       } else if (/^0[xX][0-9a-fA-F]+$/.exec(cleanText)) {
-        // Hex literal
         value = BigInt(cleanText);
       } else if (/^0[bB][01]+$/.exec(cleanText)) {
-        // Binary literal
         value = BigInt(cleanText);
       } else {
-        // Not an integer literal we can validate
         return;
       }
     } catch {
-      return; // Can't parse, skip validation
+      return;
     }
 
     const [min, max] = range;
 
-    // Check if value is negative for unsigned type
-    if (this.isUnsignedType(targetType) && value < 0n) {
+    if (TypeResolver.isUnsignedType(targetType) && value < 0n) {
       throw new Error(
         `Error: Negative value ${literalText} cannot be assigned to unsigned type ${targetType}`,
       );
     }
 
-    // Check if value is out of range
     if (value < min || value > max) {
       throw new Error(
         `Error: Value ${literalText} exceeds ${targetType} range (${min} to ${max})`,
@@ -163,15 +158,12 @@ class TypeResolver {
 
   /**
    * ADR-024: Get the type from a literal (suffixed or unsuffixed).
-   * Returns the explicit suffix type, or null for unsuffixed literals.
    */
-  getLiteralType(ctx: Parser.LiteralContext): string | null {
+  static getLiteralType(ctx: Parser.LiteralContext): string | null {
     const text = ctx.getText();
 
-    // Boolean literals
     if (text === "true" || text === "false") return "bool";
 
-    // Check for type suffix on numeric literals
     const suffixMatch = /([uUiI])(8|16|32|64)$/.exec(text);
     if (suffixMatch) {
       const signChar = suffixMatch[1].toLowerCase();
@@ -179,194 +171,252 @@ class TypeResolver {
       return (signChar === "u" ? "u" : "i") + width;
     }
 
-    // Float suffix
     const floatMatch = /[fF](32|64)$/.exec(text);
     if (floatMatch) {
       return "f" + floatMatch[1];
     }
 
-    // Unsuffixed literal - type depends on context (handled by caller)
     return null;
   }
 
   /**
    * ADR-024: Get the type of an expression for type checking.
-   * Returns the inferred type or null if type cannot be determined.
-   * Issue #61: Uses ExpressionUnwrapper utility for tree navigation.
    */
-  getExpressionType(ctx: Parser.ExpressionContext): string | null {
-    // Navigate through expression tree to get the actual value
+  static getExpressionType(ctx: Parser.ExpressionContext): string | null {
     const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
     if (postfix) {
-      return this.getPostfixExpressionType(postfix);
+      return TypeResolver.getPostfixExpressionType(postfix);
     }
 
-    // For more complex expressions (binary ops, etc.), try to infer type
     const ternary = ctx.ternaryExpression();
     const orExprs = ternary.orExpression();
-    // If it's a ternary, we can't easily determine the type
     if (orExprs.length > 1) {
       return null;
     }
     const or = orExprs[0];
     if (or.andExpression().length > 1) {
-      return "bool"; // Logical OR returns bool
+      return "bool";
     }
 
     const and = or.andExpression()[0];
     if (and.equalityExpression().length > 1) {
-      return "bool"; // Logical AND returns bool
+      return "bool";
     }
 
     const eq = and.equalityExpression()[0];
     if (eq.relationalExpression().length > 1) {
-      return "bool"; // Equality comparison returns bool
+      return "bool";
     }
 
     const rel = eq.relationalExpression()[0];
     if (rel.bitwiseOrExpression().length > 1) {
-      return "bool"; // Relational comparison returns bool
+      return "bool";
     }
 
-    // For arithmetic expressions, we'd need to track operand types
-    // For now, return null for complex expressions
     return null;
   }
 
   /**
    * ADR-024: Get the type of a postfix expression.
-   * Issue #304: Enhanced to track type through member access chains (e.g., cfg.mode)
-   * SonarCloud S3776: Refactored to use processSuffix helper.
+   * Tracks InternalTypeInfo (baseType + isArray) through the suffix chain
+   * so that array indexing is correctly distinguished from bit indexing.
    */
-  getPostfixExpressionType(
+  static getPostfixExpressionType(
     ctx: Parser.PostfixExpressionContext,
   ): string | null {
     const primary = ctx.primaryExpression();
     if (!primary) return null;
 
-    // Get base type from primary expression
-    let currentType = this.getPrimaryExpressionType(primary);
-    if (!currentType) return null;
+    let current = TypeResolver.getPrimaryExpressionTypeInfo(primary);
+    if (!current) return null;
 
-    // Check for postfix operations: member access, array indexing, bit indexing
     const suffixes = ctx.children?.slice(1) || [];
     for (const suffix of suffixes) {
-      const result = this.processPostfixSuffix(suffix.getText(), currentType);
+      const result = TypeResolver.processPostfixSuffix(
+        suffix.getText(),
+        current,
+      );
       if (result.stop) {
         return result.type;
       }
-      currentType = result.type!;
+      current = result.info;
     }
 
-    return currentType;
+    return current.baseType;
   }
 
   /**
    * Process a single postfix suffix and determine the resulting type.
-   * Returns { type, stop } where stop=true means to return immediately.
+   * Returns { type, stop, info } where stop=true means return type immediately.
    */
-  private processPostfixSuffix(
+  private static processPostfixSuffix(
     text: string,
-    currentType: string,
-  ): { type: string | null; stop: boolean } {
-    // Member access: .fieldName
+    current: InternalTypeInfo,
+  ): SuffixResult {
     if (text.startsWith(".")) {
-      const memberName = text.slice(1);
-      const memberInfo = this.getMemberTypeInfo(currentType, memberName);
-      if (!memberInfo) {
-        return { type: null, stop: true };
-      }
-      return { type: memberInfo.baseType, stop: false };
+      return TypeResolver.processMemberSuffix(text.slice(1), current);
     }
 
-    // Array or bit indexing: [index] or [start, width]
     if (text.startsWith("[") && text.endsWith("]")) {
-      return this.processIndexingSuffix(text, currentType);
+      return TypeResolver.processIndexingSuffix(text, current);
     }
 
-    // Unknown suffix, continue with current type
-    return { type: currentType, stop: false };
+    return { stop: false, info: current };
+  }
+
+  /**
+   * Process a member access suffix (.name) and resolve the resulting type.
+   * Handles global/this sentinel values and regular struct member lookups.
+   */
+  private static processMemberSuffix(
+    memberName: string,
+    current: InternalTypeInfo,
+  ): SuffixResult {
+    // Handle global.X — resolve X as a global variable name
+    if (current.baseType === TypeResolver.GLOBAL_SENTINEL) {
+      return TypeResolver.resolveRegistryLookup(memberName);
+    }
+
+    // Handle this.X — resolve X as a scope member variable
+    if (
+      current.baseType === TypeResolver.THIS_SENTINEL &&
+      CodeGenState.currentScope
+    ) {
+      const scopedName = `${CodeGenState.currentScope}_${memberName}`;
+      return TypeResolver.resolveRegistryLookup(scopedName);
+    }
+
+    const memberInfo = TypeResolver.getMemberTypeInfo(
+      current.baseType,
+      memberName,
+    );
+    if (!memberInfo) {
+      return { stop: true, type: null };
+    }
+    return {
+      stop: false,
+      info: { baseType: memberInfo.baseType, isArray: memberInfo.isArray },
+    };
+  }
+
+  /**
+   * Look up a variable name in the type registry and return a SuffixResult.
+   */
+  private static resolveRegistryLookup(name: string): SuffixResult {
+    const typeInfo = CodeGenState.typeRegistry.get(name);
+    if (typeInfo) {
+      return {
+        stop: false,
+        info: { baseType: typeInfo.baseType, isArray: typeInfo.isArray },
+      };
+    }
+    return { stop: true, type: null };
   }
 
   /**
    * Process array or bit indexing suffix.
+   * Checks isArray BEFORE isIntegerType to correctly distinguish
+   * array element access from bit indexing.
    */
-  private processIndexingSuffix(
+  private static processIndexingSuffix(
     text: string,
-    currentType: string,
-  ): { type: string | null; stop: boolean } {
+    current: InternalTypeInfo,
+  ): SuffixResult {
     const inner = text.slice(1, -1);
 
-    // Range indexing: [start, width]
-    // ADR-024: Return null for bit indexing to skip type conversion validation
+    // Range indexing: [start, width] - always bit extraction
     if (inner.includes(",")) {
-      return { type: null, stop: true };
+      return { stop: true, type: null };
+    }
+
+    // Array access: if current type is known to be an array, index yields element
+    if (current.isArray) {
+      return {
+        stop: false,
+        info: { baseType: current.baseType, isArray: false },
+      };
     }
 
-    // Single index: array access or bit indexing
-    // For single bit on integer, returns bool
-    if (this.isIntegerType(currentType)) {
-      return { type: "bool", stop: true };
+    // Bit indexing on integer: single bit returns bool
+    if (TypeResolver.isIntegerType(current.baseType)) {
+      return { stop: true, type: "bool" };
     }
 
-    // For arrays, currentType is already the element type
-    return { type: currentType, stop: false };
+    // Unknown indexing - preserve current state
+    return { stop: false, info: current };
   }
 
   /**
-   * ADR-024: Get the type of a primary expression.
-   * Issue #61: Uses injected dependencies instead of CodeGenerator.
+   * Get full InternalTypeInfo from a primary expression (preserves isArray).
    */
-  getPrimaryExpressionType(
+  private static getPrimaryExpressionTypeInfo(
     ctx: Parser.PrimaryExpressionContext,
-  ): string | null {
-    // Check for identifier
+  ): InternalTypeInfo | null {
     const id = ctx.IDENTIFIER();
     if (id) {
       const name = id.getText();
-      const scopedName = this.resolveIdentifierFn(name);
-      const typeInfo = this.typeRegistry.get(scopedName);
+      const scopedName = CodeGenState.resolveIdentifier(name);
+      const typeInfo = CodeGenState.typeRegistry.get(scopedName);
       if (typeInfo) {
-        return typeInfo.baseType;
+        return { baseType: typeInfo.baseType, isArray: typeInfo.isArray };
       }
       return null;
     }
 
-    // Check for literal
+    // Handle global.X and this.X — these are scope qualifiers, not types.
+    // The actual variable name is the first .suffix after the keyword.
+    // Return a sentinel so getPostfixExpressionType knows to consume one suffix.
+    if (ctx.GLOBAL()) {
+      return { baseType: TypeResolver.GLOBAL_SENTINEL, isArray: false };
+    }
+    if (ctx.THIS()) {
+      return { baseType: TypeResolver.THIS_SENTINEL, isArray: false };
+    }
+
     const literal = ctx.literal();
     if (literal) {
-      return this.getLiteralType(literal);
+      const litType = TypeResolver.getLiteralType(literal);
+      return litType ? { baseType: litType, isArray: false } : null;
     }
 
-    // Check for parenthesized expression
     const expr = ctx.expression();
     if (expr) {
-      return this.getExpressionType(expr);
+      const exprType = TypeResolver.getExpressionType(expr);
+      return exprType ? { baseType: exprType, isArray: false } : null;
     }
 
-    // Check for cast expression
     const cast = ctx.castExpression();
     if (cast) {
-      return cast.type().getText();
+      return { baseType: cast.type().getText(), isArray: false };
     }
 
     return null;
   }
 
+  /**
+   * ADR-024: Get the type of a primary expression (public API, returns baseType only).
+   */
+  static getPrimaryExpressionType(
+    ctx: Parser.PrimaryExpressionContext,
+  ): string | null {
+    const info = TypeResolver.getPrimaryExpressionTypeInfo(ctx);
+    return info?.baseType ?? null;
+  }
+
   /**
    * ADR-024: Get the type of a unary expression (for cast validation).
    */
-  getUnaryExpressionType(ctx: Parser.UnaryExpressionContext): string | null {
-    // Check for unary operators - type doesn't change for !, ~, -, +
+  static getUnaryExpressionType(
+    ctx: Parser.UnaryExpressionContext,
+  ): string | null {
     const postfix = ctx.postfixExpression();
     if (postfix) {
-      return this.getPostfixExpressionType(postfix);
+      return TypeResolver.getPostfixExpressionType(postfix);
     }
 
-    // Check for recursive unary expression
     const unary = ctx.unaryExpression();
     if (unary) {
-      return this.getUnaryExpressionType(unary);
+      return TypeResolver.getUnaryExpressionType(unary);
     }
 
     return null;
@@ -374,21 +424,21 @@ class TypeResolver {
 
   /**
    * ADR-024: Validate that a type conversion is allowed.
-   * Throws error for narrowing or sign-changing conversions.
    */
-  validateTypeConversion(targetType: string, sourceType: string | null): void {
-    // If we can't determine source type, skip validation
+  static validateTypeConversion(
+    targetType: string,
+    sourceType: string | null,
+  ): void {
     if (!sourceType) return;
-
-    // Skip if types are the same
     if (sourceType === targetType) return;
 
-    // Only validate integer-to-integer conversions
-    if (!this.isIntegerType(sourceType) || !this.isIntegerType(targetType))
+    if (
+      !TypeResolver.isIntegerType(sourceType) ||
+      !TypeResolver.isIntegerType(targetType)
+    )
       return;
 
-    // Check for narrowing conversion
-    if (this.isNarrowingConversion(sourceType, targetType)) {
+    if (TypeResolver.isNarrowingConversion(sourceType, targetType)) {
       const targetWidth = TYPE_WIDTH[targetType] || 0;
       throw new Error(
         `Error: Cannot assign ${sourceType} to ${targetType} (narrowing). ` +
@@ -396,8 +446,7 @@ class TypeResolver {
       );
     }
 
-    // Check for sign conversion
-    if (this.isSignConversion(sourceType, targetType)) {
+    if (TypeResolver.isSignConversion(sourceType, targetType)) {
       const targetWidth = TYPE_WIDTH[targetType] || 0;
       throw new Error(
         `Error: Cannot assign ${sourceType} to ${targetType} (sign change). ` +
@@ -407,18 +456,15 @@ class TypeResolver {
   }
 
   /**
-   * Get type info for a struct member field
-   * Used to track types through member access chains like buf.data[0]
-   * Issue #103: Now checks SymbolTable first for C header structs
-   * Issue #61: Uses injected dependencies instead of CodeGenerator.
+   * Get type info for a struct member field.
+   * Issue #103: Checks SymbolTable first for C header structs.
    */
-  getMemberTypeInfo(
+  static getMemberTypeInfo(
     structType: string,
     memberName: string,
   ): { isArray: boolean; baseType: string } | undefined {
-    // First check SymbolTable (C header structs) - Issue #103 fix
-    if (this.symbolTable) {
-      const fieldInfo = this.symbolTable.getStructFieldInfo(
+    if (CodeGenState.symbolTable) {
+      const fieldInfo = CodeGenState.symbolTable.getStructFieldInfo(
         structType,
         memberName,
       );
@@ -432,14 +478,12 @@ class TypeResolver {
       }
     }
 
-    // Fall back to local C-Next struct fields (Issue #60: use SymbolCollector)
-    const fieldType = this.symbols?.structFields
+    const fieldType = CodeGenState.symbols?.structFields
       .get(structType)
       ?.get(memberName);
     if (!fieldType) return undefined;
 
-    // Check if this field is marked as an array (Issue #60: use SymbolCollector)
-    const arrayFields = this.symbols?.structFieldArrays.get(structType);
+    const arrayFields = CodeGenState.symbols?.structFieldArrays.get(structType);
     const isArray = arrayFields?.has(memberName) ?? false;
 
     return { isArray, baseType: fieldType };