c-next 0.1.70 → 0.1.72

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

@@ -0,0 +1,435 @@
+/**
+ * FunctionContextManager - Manages function context lifecycle and parameter processing
+ *
+ * Issue #793: Extracted from CodeGenerator to reduce file size.
+ *
+ * Handles:
+ * - Function context setup/cleanup lifecycle
+ * - Parameter type resolution and registration
+ * - Return type resolution (including main() special case)
+ * - Function body enter/exit coordination
+ */
+
+import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
+import CodeGenState from "../../../state/CodeGenState.js";
+import TYPE_WIDTH from "../types/TYPE_WIDTH.js";
+import ArrayDimensionParser from "./ArrayDimensionParser.js";
+import IFunctionContextCallbacks from "../types/IFunctionContextCallbacks.js";
+
+/**
+ * Result from resolving parameter type information.
+ */
+interface IParameterTypeInfo {
+  typeName: string;
+  isStruct: boolean;
+  isCallback: boolean;
+  isString: boolean;
+}
+
+/**
+ * Result from resolving return type and params for a function.
+ */
+interface IReturnTypeAndParams {
+  actualReturnType: string;
+  initialParams: string;
+}
+
+/**
+ * Manages function context lifecycle and parameter processing.
+ */
+class FunctionContextManager {
+  /**
+   * Set up context for function generation.
+   * - Sets current function name (with scope prefix if in a scope)
+   * - Sets return type for enum inference
+   * - Processes parameters for ADR-006 pointer semantics
+   * - Clears local variables and marks in function body
+   */
+  static setupFunctionContext(
+    name: string,
+    ctx: Parser.FunctionDeclarationContext,
+    callbacks: IFunctionContextCallbacks,
+  ): void {
+    // Issue #269: Set current function name for pass-by-value lookup
+    const fullFuncName = CodeGenState.currentScope
+      ? `${CodeGenState.currentScope}_${name}`
+      : name;
+    CodeGenState.currentFunctionName = fullFuncName;
+
+    // Issue #477: Set return type for enum inference in return statements
+    CodeGenState.currentFunctionReturnType = ctx.type().getText();
+
+    // Track parameters for ADR-006 pointer semantics
+    FunctionContextManager.processParameterList(
+      ctx.parameterList() ?? null,
+      callbacks,
+    );
+
+    // ADR-016: Clear local variables and mark that we're in a function body
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.inFunctionBody = true;
+  }
+
+  /**
+   * Clean up context after function generation.
+   * Resets all function-related state.
+   */
+  static cleanupFunctionContext(): void {
+    CodeGenState.inFunctionBody = false;
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.mainArgsName = null;
+    CodeGenState.currentFunctionName = null;
+    CodeGenState.currentFunctionReturnType = null;
+    FunctionContextManager.clearParameters();
+  }
+
+  /**
+   * Resolve return type and initial params for function.
+   * Handles main() special cases:
+   * - main(u8 args[][]) -> int main(int argc, char *argv[])
+   * - main() -> int main() (for C++ compatibility)
+   */
+  static resolveReturnTypeAndParams(
+    name: string,
+    returnType: string,
+    isMainWithArgs: boolean,
+    ctx: Parser.FunctionDeclarationContext,
+  ): IReturnTypeAndParams {
+    if (isMainWithArgs) {
+      // Special case: main(u8 args[][]) -> int main(int argc, char *argv[])
+      const argsParam = ctx.parameterList()!.parameter()[0];
+      CodeGenState.mainArgsName = argsParam.IDENTIFIER().getText();
+      return {
+        actualReturnType: "int",
+        initialParams: "int argc, char *argv[]",
+      };
+    }
+
+    // For main() without args, always use int return type for C++ compatibility
+    const actualReturnType = name === "main" ? "int" : returnType;
+    return { actualReturnType, initialParams: "" };
+  }
+
+  /**
+   * Process parameter list and register parameters in state.
+   */
+  static processParameterList(
+    params: Parser.ParameterListContext | null,
+    callbacks: IFunctionContextCallbacks,
+  ): void {
+    CodeGenState.currentParameters.clear();
+    if (!params) return;
+
+    for (const param of params.parameter()) {
+      FunctionContextManager.processParameter(param, callbacks);
+    }
+  }
+
+  /**
+   * Process a single parameter declaration.
+   */
+  static processParameter(
+    param: Parser.ParameterContext,
+    callbacks: IFunctionContextCallbacks,
+  ): void {
+    const name = param.IDENTIFIER().getText();
+    // Check both C-Next style (u8[8] param) and legacy style (u8 param[8])
+    const isArray =
+      param.arrayDimension().length > 0 || param.type().arrayType() !== null;
+    const isConst = param.constModifier() !== null;
+    const typeCtx = param.type();
+
+    // Resolve type information
+    const typeInfo = FunctionContextManager.resolveParameterTypeInfo(
+      typeCtx,
+      callbacks,
+    );
+
+    // Register in currentParameters
+    const paramInfo = {
+      name,
+      baseType: typeInfo.typeName,
+      isArray,
+      isStruct: typeInfo.isStruct,
+      isConst,
+      isCallback: typeInfo.isCallback,
+      isString: typeInfo.isString,
+    };
+    CodeGenState.currentParameters.set(name, paramInfo);
+
+    // Register in typeRegistry
+    FunctionContextManager.registerParameterType(
+      name,
+      typeInfo,
+      param,
+      isArray,
+      isConst,
+    );
+  }
+
+  /**
+   * Resolve type name and flags from a type context.
+   */
+  static resolveParameterTypeInfo(
+    typeCtx: Parser.TypeContext,
+    callbacks: IFunctionContextCallbacks,
+  ): IParameterTypeInfo {
+    if (typeCtx.primitiveType()) {
+      return {
+        typeName: typeCtx.primitiveType()!.getText(),
+        isStruct: false,
+        isCallback: false,
+        isString: false,
+      };
+    }
+
+    if (typeCtx.userType()) {
+      const typeName = typeCtx.userType()!.getText();
+      return {
+        typeName,
+        isStruct: callbacks.isStructType(typeName),
+        isCallback: CodeGenState.callbackTypes.has(typeName),
+        isString: false,
+      };
+    }
+
+    if (typeCtx.qualifiedType()) {
+      const identifierNames = typeCtx
+        .qualifiedType()!
+        .IDENTIFIER()
+        .map((id) => id.getText());
+      const typeName = callbacks.resolveQualifiedType(identifierNames);
+      return {
+        typeName,
+        isStruct: callbacks.isStructType(typeName),
+        isCallback: false,
+        isString: false,
+      };
+    }
+
+    if (typeCtx.scopedType()) {
+      const localTypeName = typeCtx.scopedType()!.IDENTIFIER().getText();
+      const typeName = CodeGenState.currentScope
+        ? `${CodeGenState.currentScope}_${localTypeName}`
+        : localTypeName;
+      return {
+        typeName,
+        isStruct: callbacks.isStructType(typeName),
+        isCallback: false,
+        isString: false,
+      };
+    }
+
+    if (typeCtx.globalType()) {
+      const typeName = typeCtx.globalType()!.IDENTIFIER().getText();
+      return {
+        typeName,
+        isStruct: callbacks.isStructType(typeName),
+        isCallback: false,
+        isString: false,
+      };
+    }
+
+    if (typeCtx.stringType()) {
+      return {
+        typeName: "string",
+        isStruct: false,
+        isCallback: false,
+        isString: true,
+      };
+    }
+
+    // Handle C-Next style array type (u8[8] param) - extract base type
+    if (typeCtx.arrayType()) {
+      const arrayTypeCtx = typeCtx.arrayType()!;
+      if (arrayTypeCtx.primitiveType()) {
+        return {
+          typeName: arrayTypeCtx.primitiveType()!.getText(),
+          isStruct: false,
+          isCallback: false,
+          isString: false,
+        };
+      }
+      if (arrayTypeCtx.userType()) {
+        const typeName = arrayTypeCtx.userType()!.getText();
+        return {
+          typeName,
+          isStruct: callbacks.isStructType(typeName),
+          isCallback: CodeGenState.callbackTypes.has(typeName),
+          isString: false,
+        };
+      }
+      // Handle string array type (string<32>[5] param)
+      if (arrayTypeCtx.stringType()) {
+        const stringCtx = arrayTypeCtx.stringType()!;
+        return {
+          typeName: stringCtx.getText(), // "string<32>"
+          isStruct: false,
+          isCallback: false,
+          isString: true,
+        };
+      }
+    }
+
+    // Fallback
+    return {
+      typeName: typeCtx.getText(),
+      isStruct: false,
+      isCallback: false,
+      isString: false,
+    };
+  }
+
+  /**
+   * Register a parameter in the type registry.
+   */
+  static registerParameterType(
+    name: string,
+    typeInfo: IParameterTypeInfo,
+    param: Parser.ParameterContext,
+    isArray: boolean,
+    isConst: boolean,
+  ): void {
+    const { typeName, isString } = typeInfo;
+    const typeCtx = param.type();
+
+    const isEnum = CodeGenState.symbols!.knownEnums.has(typeName);
+    const isBitmap = CodeGenState.symbols!.knownBitmaps.has(typeName);
+
+    // Extract array dimensions
+    const arrayDimensions = FunctionContextManager.extractParamArrayDimensions(
+      param,
+      typeCtx,
+      isArray,
+    );
+
+    // Add string capacity dimension if applicable
+    const stringCapacity = FunctionContextManager.getStringCapacity(
+      typeCtx,
+      isString,
+    );
+    if (isArray && stringCapacity !== undefined) {
+      arrayDimensions.push(stringCapacity + 1);
+    }
+
+    const registeredType = {
+      baseType: typeName,
+      bitWidth: isBitmap
+        ? CodeGenState.symbols!.bitmapBitWidth.get(typeName) || 0
+        : TYPE_WIDTH[typeName] || 0,
+      isArray,
+      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
+      isConst,
+      isEnum,
+      enumTypeName: isEnum ? typeName : undefined,
+      isBitmap,
+      bitmapTypeName: isBitmap ? typeName : undefined,
+      isString,
+      stringCapacity,
+      isParameter: true,
+    };
+    CodeGenState.setVariableTypeInfo(name, registeredType);
+  }
+
+  /**
+   * Extract array dimensions from parameter (C-style or C-Next style).
+   */
+  static extractParamArrayDimensions(
+    param: Parser.ParameterContext,
+    typeCtx: Parser.TypeContext,
+    isArray: boolean,
+  ): number[] {
+    if (!isArray) return [];
+
+    // Try C-style first (param.arrayDimension())
+    if (param.arrayDimension().length > 0) {
+      return ArrayDimensionParser.parseForParameters(param.arrayDimension());
+    }
+
+    // C-Next style: get dimensions from arrayType
+    const arrayTypeCtx = typeCtx.arrayType();
+    if (!arrayTypeCtx) return [];
+
+    const dimensions: number[] = [];
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const expr = dim.expression();
+      if (!expr) continue;
+      const size = Number.parseInt(expr.getText(), 10);
+      if (!Number.isNaN(size)) {
+        dimensions.push(size);
+      }
+    }
+    return dimensions;
+  }
+
+  /**
+   * Extract string capacity from a string type context.
+   */
+  static getStringCapacity(
+    typeCtx: Parser.TypeContext,
+    isString: boolean,
+  ): number | undefined {
+    if (!isString) return undefined;
+
+    // Check direct stringType (e.g., string<32> param)
+    if (typeCtx.stringType()) {
+      const intLiteral = typeCtx.stringType()!.INTEGER_LITERAL();
+      if (intLiteral) {
+        return Number.parseInt(intLiteral.getText(), 10);
+      }
+    }
+
+    // Check arrayType with stringType (e.g., string<32>[5] param)
+    if (typeCtx.arrayType()?.stringType()) {
+      const intLiteral = typeCtx.arrayType()!.stringType()!.INTEGER_LITERAL();
+      if (intLiteral) {
+        return Number.parseInt(intLiteral.getText(), 10);
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Clear parameter tracking when leaving a function.
+   */
+  static clearParameters(): void {
+    // ADR-025: Remove parameter types from typeRegistry
+    for (const name of CodeGenState.currentParameters.keys()) {
+      CodeGenState.deleteVariableTypeInfo(name);
+    }
+    CodeGenState.currentParameters.clear();
+    CodeGenState.localArrays.clear();
+  }
+
+  /**
+   * Enter function body - clears local variables and sets inFunctionBody flag.
+   * This is a simpler version used when only body lifecycle is needed.
+   */
+  static enterFunctionBody(): void {
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.inFunctionBody = true;
+    CodeGenState.enterFunctionBody();
+  }
+
+  /**
+   * Exit function body - clears local variables and inFunctionBody flag.
+   * This is a simpler version used when only body lifecycle is needed.
+   */
+  static exitFunctionBody(): void {
+    CodeGenState.inFunctionBody = false;
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.mainArgsName = null;
+    CodeGenState.exitFunctionBody();
+  }
+}
+
+export default FunctionContextManager;

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

@@ -0,0 +1,203 @@
+/**
+ * StringOperationsHelper - String operation detection and extraction
+ *
+ * Extracted from CodeGenerator to reduce file size.
+ * Handles detection of string concatenation and substring patterns.
+ *
+ * ADR-045: String type support
+ * Issue #707: Uses ExpressionUnwrapper for tree navigation
+ */
+
+import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
+import CodeGenState from "../../../state/CodeGenState.js";
+import StringUtils from "../../../../utils/StringUtils.js";
+import ExpressionUnwrapper from "../utils/ExpressionUnwrapper.js";
+
+/** Regex for identifying valid C/C++ identifiers */
+const IDENTIFIER_REGEX = /^[a-zA-Z_]\w*$/;
+
+/**
+ * String concatenation operands extracted from expression.
+ */
+interface IStringConcatOps {
+  left: string;
+  right: string;
+  leftCapacity: number;
+  rightCapacity: number;
+}
+
+/**
+ * Substring extraction operands extracted from expression.
+ */
+interface ISubstringOps {
+  source: string;
+  start: string;
+  length: string;
+  sourceCapacity: number;
+}
+
+/**
+ * Callbacks for substring operand extraction.
+ */
+interface ISubstringCallbacks {
+  /** Generate expression code */
+  generateExpression: (ctx: Parser.ExpressionContext) => string;
+}
+
+/**
+ * Helper for string operation detection and extraction.
+ * All methods are static - uses CodeGenState for shared state.
+ */
+class StringOperationsHelper {
+  // ========================================================================
+  // Tier 1: Pure Utilities (no callbacks needed)
+  // ========================================================================
+
+  /**
+   * Get the capacity of a string expression.
+   * For string literals, capacity equals content length.
+   * For string variables, capacity is from the type registry.
+   *
+   * ADR-045: String capacity resolution for concatenation and bounds checking.
+   *
+   * @param exprCode - Expression code text (e.g., "hello" or varName)
+   * @returns Capacity in characters, or null if not a string
+   */
+  static getStringExprCapacity(exprCode: string): number | null {
+    // String literal - capacity equals content length
+    if (exprCode.startsWith('"') && exprCode.endsWith('"')) {
+      return StringUtils.literalLength(exprCode);
+    }
+
+    // Variable - check type registry
+    if (IDENTIFIER_REGEX.test(exprCode)) {
+      const typeInfo = CodeGenState.getVariableTypeInfo(exprCode);
+      if (typeInfo?.isString && typeInfo.stringCapacity !== undefined) {
+        return typeInfo.stringCapacity;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if an expression is a string concatenation (contains + with string operands).
+   * Returns the operand expressions and capacities if it is, null otherwise.
+   *
+   * ADR-045: String concatenation detection for strncpy/strncat generation.
+   * Issue #707: Uses ExpressionUnwrapper for tree navigation.
+   *
+   * @param ctx - Expression context to check
+   * @returns Concatenation operands or null if not a string concat
+   */
+  static getStringConcatOperands(
+    ctx: Parser.ExpressionContext,
+  ): IStringConcatOps | null {
+    // Navigate to the additive expression level using ExpressionUnwrapper
+    const add = ExpressionUnwrapper.getAdditiveExpression(ctx);
+    if (!add) return null;
+    const multExprs = add.multiplicativeExpression();
+
+    // Need exactly 2 operands for simple concatenation
+    if (multExprs.length !== 2) return null;
+
+    // Check if this is addition (not subtraction)
+    // Use MINUS() token check instead of text.includes("-") to avoid
+    // false positives from identifiers/literals containing hyphens
+    if (add.MINUS().length > 0) return null;
+
+    // Get the operand texts
+    const leftText = multExprs[0].getText();
+    const rightText = multExprs[1].getText();
+
+    // Check if at least one operand is a string
+    const leftCapacity = StringOperationsHelper.getStringExprCapacity(leftText);
+    const rightCapacity =
+      StringOperationsHelper.getStringExprCapacity(rightText);
+
+    if (leftCapacity === null && rightCapacity === null) {
+      return null; // Neither is a string
+    }
+
+    // If one is null, it's not a valid string concatenation
+    if (leftCapacity === null || rightCapacity === null) {
+      return null;
+    }
+
+    return {
+      left: leftText,
+      right: rightText,
+      leftCapacity,
+      rightCapacity,
+    };
+  }
+
+  // ========================================================================
+  // Tier 2: Operations with Callbacks
+  // ========================================================================
+
+  /**
+   * Check if an expression is a substring extraction (string[start, length]).
+   * Returns the source string, start, length, and source capacity if it is.
+   *
+   * ADR-045: Substring extraction detection for safe string slicing.
+   * Issue #707: Uses ExpressionUnwrapper for tree navigation.
+   * Issue #140: Handles both [start, length] and single-char [index] patterns.
+   *
+   * @param ctx - Expression context to check
+   * @param callbacks - Callbacks for expression generation
+   * @returns Substring operands or null if not a substring extraction
+   */
+  static getSubstringOperands(
+    ctx: Parser.ExpressionContext,
+    callbacks: ISubstringCallbacks,
+  ): ISubstringOps | null {
+    // Navigate to the postfix expression level using shared utility
+    const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
+    if (!postfix) return null;
+
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+
+    // Need exactly one postfix operation (the [start, length])
+    if (ops.length !== 1) return null;
+
+    const op = ops[0];
+    const exprs = op.expression();
+
+    // Get the source variable name first
+    const sourceId = primary.IDENTIFIER();
+    if (!sourceId) return null;
+
+    const sourceName = sourceId.getText();
+
+    // Check if source is a string type
+    const typeInfo = CodeGenState.getVariableTypeInfo(sourceName);
+    if (!typeInfo?.isString || typeInfo.stringCapacity === undefined) {
+      return null;
+    }
+
+    // Issue #140: Handle both [start, length] pattern (2 expressions)
+    // and single-character access [index] pattern (1 expression, treated as [index, 1])
+    if (exprs.length === 2) {
+      return {
+        source: sourceName,
+        start: callbacks.generateExpression(exprs[0]),
+        length: callbacks.generateExpression(exprs[1]),
+        sourceCapacity: typeInfo.stringCapacity,
+      };
+    } else if (exprs.length === 1) {
+      // Single-character access: source[i] is sugar for source[i, 1]
+      return {
+        source: sourceName,
+        start: callbacks.generateExpression(exprs[0]),
+        length: "1",
+        sourceCapacity: typeInfo.stringCapacity,
+      };
+    }
+
+    return null;
+  }
+}
+
+export default StringOperationsHelper;

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

@@ -5,14 +5,14 @@
  * Extracts common lookup patterns for improved testability.
  */
 
-import ESymbolKind from "../../../../utils/types/ESymbolKind.js";
+import TSymbolKind from "../../../types/symbol-kinds/TSymbolKind.js";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage.js";
 
 /**
  * Symbol interface for lookups
  */
 interface ISymbol {
-  kind: ESymbolKind;
+  kind: TSymbolKind;
   sourceLanguage: ESourceLanguage;
 }
 
@@ -31,7 +31,7 @@ class SymbolLookupHelper {
   static hasSymbolWithKindAndLanguage(
     symbolTable: ISymbolTable | null | undefined,
     name: string,
-    kind: ESymbolKind,
+    kind: TSymbolKind,
     languages: ESourceLanguage[],
   ): boolean {
     if (!symbolTable) return false;
@@ -53,7 +53,7 @@ class SymbolLookupHelper {
     return SymbolLookupHelper.hasSymbolWithKindAndLanguage(
       symbolTable,
       typeName,
-      ESymbolKind.Enum,
+      "enum",
       [ESourceLanguage.Cpp],
     );
   }
@@ -69,7 +69,7 @@ class SymbolLookupHelper {
     return SymbolLookupHelper.hasSymbolWithKindAndLanguage(
       symbolTable,
       name,
-      ESymbolKind.Function,
+      "function",
       [ESourceLanguage.C, ESourceLanguage.Cpp],
     );
   }
@@ -84,7 +84,7 @@ class SymbolLookupHelper {
     if (!symbolTable) return false;
 
     const symbols = symbolTable.getOverloads(name);
-    return symbols.some((sym) => sym.kind === ESymbolKind.Namespace);
+    return symbols.some((sym) => sym.kind === "namespace");
   }
 
   /**
@@ -99,11 +99,7 @@ class SymbolLookupHelper {
     if (!symbolTable) return false;
 
     const symbols = symbolTable.getOverloads(typeName);
-    const cppTypeKinds = new Set([
-      ESymbolKind.Struct,
-      ESymbolKind.Class,
-      ESymbolKind.Type,
-    ]);
+    const cppTypeKinds = new Set<TSymbolKind>(["struct", "class", "type"]);
 
     return symbols.some(
       (sym) =>
@@ -123,7 +119,7 @@ class SymbolLookupHelper {
     return SymbolLookupHelper.hasSymbolWithKindAndLanguage(
       symbolTable,
       name,
-      ESymbolKind.Function,
+      "function",
       [ESourceLanguage.CNext],
     );
   }