c-next 0.1.69 → 0.1.71

package/src/transpiler/logic/symbols/cpp/index.ts

@@ -0,0 +1,366 @@
+/**
+ * CppResolver - Orchestrates symbol collection from C++ parse trees.
+ *
+ * Uses composable collectors to extract symbols from different C++ constructs.
+ * Produces TCppSymbol instances (discriminated union of C++ symbol types).
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { CPP14Parser } from "../../parser/cpp/grammar/CPP14Parser";
+import TCppSymbol from "../../../types/symbols/cpp/TCppSymbol";
+import SymbolTable from "../SymbolTable";
+import NamespaceCollector from "./collectors/NamespaceCollector";
+import EnumCollector from "./collectors/EnumCollector";
+import TypeAliasCollector from "./collectors/TypeAliasCollector";
+import FunctionCollector from "./collectors/FunctionCollector";
+import ClassCollector from "./collectors/ClassCollector";
+import VariableCollector from "./collectors/VariableCollector";
+import DeclaratorUtils from "./utils/DeclaratorUtils";
+
+// Import context types
+type TranslationUnitContext = ReturnType<CPP14Parser["translationUnit"]>;
+
+/**
+ * Result of resolving C++ symbols.
+ */
+interface ICppResolverResult {
+  symbols: TCppSymbol[];
+  warnings: string[];
+}
+
+/**
+ * Internal context for declaration processing.
+ */
+interface ICppDeclarationContext {
+  readonly sourceFile: string;
+  readonly currentNamespace: string | undefined;
+  readonly symbolTable: SymbolTable | undefined;
+  readonly symbols: TCppSymbol[];
+  readonly warnings: string[];
+}
+
+class CppResolver {
+  /**
+   * Resolve all symbols from a C++ translation unit.
+   *
+   * @param tree The translation unit context from the parser
+   * @param sourceFile Source file path
+   * @param symbolTable Optional symbol table for storing struct fields, enum bit widths
+   * @returns Result containing symbols and warnings
+   */
+  static resolve(
+    tree: TranslationUnitContext,
+    sourceFile: string,
+    symbolTable?: SymbolTable,
+  ): ICppResolverResult {
+    const symbols: TCppSymbol[] = [];
+    const warnings: string[] = [];
+
+    if (!tree) {
+      return { symbols, warnings };
+    }
+
+    const declSeq = tree.declarationseq?.();
+    if (!declSeq) {
+      return { symbols, warnings };
+    }
+
+    const ctx: ICppDeclarationContext = {
+      sourceFile,
+      currentNamespace: undefined,
+      symbolTable,
+      symbols,
+      warnings,
+    };
+
+    for (const decl of declSeq.declaration()) {
+      CppResolver._collectDeclaration(decl, ctx);
+    }
+
+    return { symbols, warnings };
+  }
+
+  /**
+   * Collect symbols from a single declaration.
+   */
+  private static _collectDeclaration(
+    decl: any,
+    ctx: ICppDeclarationContext,
+  ): void {
+    const line = decl.start?.line ?? 0;
+
+    // Function definition
+    const funcDef = decl.functionDefinition?.();
+    if (funcDef) {
+      const symbol = FunctionCollector.collectDefinition(
+        funcDef,
+        ctx.sourceFile,
+        line,
+        ctx.currentNamespace,
+      );
+      if (symbol) {
+        ctx.symbols.push(symbol);
+      }
+      return;
+    }
+
+    // Namespace definition
+    const nsDef = decl.namespaceDefinition?.();
+    if (nsDef) {
+      CppResolver._collectNamespaceDefinition(nsDef, line, ctx);
+      return;
+    }
+
+    // Template declaration - skip for now (complex to handle)
+    const templDecl = decl.templateDeclaration?.();
+    if (templDecl) {
+      return;
+    }
+
+    // Block declaration (simpleDeclaration, etc.)
+    const blockDecl = decl.blockDeclaration?.();
+    if (blockDecl) {
+      CppResolver._collectBlockDeclaration(blockDecl, line, ctx);
+    }
+  }
+
+  /**
+   * Collect symbols from a namespace definition.
+   */
+  private static _collectNamespaceDefinition(
+    nsDef: any,
+    line: number,
+    ctx: ICppDeclarationContext,
+  ): void {
+    const nsSymbol = NamespaceCollector.collect(
+      nsDef,
+      ctx.sourceFile,
+      line,
+      ctx.currentNamespace,
+    );
+    if (nsSymbol) {
+      ctx.symbols.push(nsSymbol);
+    }
+
+    // Process namespace body with updated namespace
+    const newNamespace = NamespaceCollector.getFullNamespaceName(
+      nsDef,
+      ctx.currentNamespace,
+    );
+
+    const body = nsDef.declarationseq?.();
+    if (body) {
+      const nestedCtx: ICppDeclarationContext = {
+        ...ctx,
+        currentNamespace: newNamespace,
+      };
+      for (const decl of body.declaration()) {
+        CppResolver._collectDeclaration(decl, nestedCtx);
+      }
+    }
+  }
+
+  /**
+   * Collect symbols from a block declaration.
+   */
+  private static _collectBlockDeclaration(
+    blockDecl: any,
+    line: number,
+    ctx: ICppDeclarationContext,
+  ): void {
+    // Simple declaration (variables, typedefs, class declarations)
+    const simpleDecl = blockDecl.simpleDeclaration?.();
+    if (simpleDecl) {
+      CppResolver._collectSimpleDeclaration(simpleDecl, line, ctx);
+    }
+
+    // Alias declaration (using X = Y)
+    const aliasDecl = blockDecl.aliasDeclaration?.();
+    if (aliasDecl) {
+      const symbol = TypeAliasCollector.collect(
+        aliasDecl,
+        ctx.sourceFile,
+        line,
+        ctx.currentNamespace,
+      );
+      if (symbol) {
+        ctx.symbols.push(symbol);
+      }
+    }
+  }
+
+  /**
+   * Collect symbols from a simple declaration.
+   */
+  private static _collectSimpleDeclaration(
+    simpleDecl: any,
+    line: number,
+    ctx: ICppDeclarationContext,
+  ): void {
+    const declSpecSeq = simpleDecl.declSpecifierSeq?.();
+    if (!declSpecSeq) return;
+
+    const baseType = DeclaratorUtils.extractTypeFromDeclSpecSeq(declSpecSeq);
+
+    // Process type specifiers (classes, enums)
+    const anonymousClassSpec = CppResolver._processTypeSpecifiers(
+      declSpecSeq,
+      line,
+      ctx,
+    );
+
+    // Collect declarators (variables, function prototypes)
+    const initDeclList = simpleDecl.initDeclaratorList?.();
+    if (!initDeclList) return;
+
+    for (const initDecl of initDeclList.initDeclarator()) {
+      const declarator = initDecl.declarator?.();
+      if (declarator) {
+        CppResolver._collectDeclarator(
+          declarator,
+          baseType,
+          line,
+          ctx,
+          anonymousClassSpec,
+        );
+      }
+    }
+  }
+
+  /**
+   * Process type specifiers in a declaration, collecting classes and enums.
+   * Returns anonymous class specifier if found (for typedef handling).
+   */
+  private static _processTypeSpecifiers(
+    declSpecSeq: any,
+    line: number,
+    ctx: ICppDeclarationContext,
+  ): any {
+    let anonymousClassSpec: any = null;
+
+    for (const spec of declSpecSeq.declSpecifier?.() ?? []) {
+      const typeSpec = spec.typeSpecifier?.();
+      if (!typeSpec) continue;
+
+      const classSpec = typeSpec.classSpecifier?.();
+      if (classSpec) {
+        const result = CppResolver._handleClassSpecInDecl(classSpec, line, ctx);
+        if (result) {
+          anonymousClassSpec = result;
+        }
+      }
+
+      const enumSpec = typeSpec.enumSpecifier?.();
+      if (enumSpec) {
+        const enumSymbol = EnumCollector.collect(
+          enumSpec,
+          ctx.sourceFile,
+          line,
+          ctx.currentNamespace,
+          ctx.symbolTable,
+        );
+        if (enumSymbol) {
+          ctx.symbols.push(enumSymbol);
+        }
+      }
+    }
+
+    return anonymousClassSpec;
+  }
+
+  /**
+   * Handle a class specifier in a declaration.
+   * Returns the class spec if it's anonymous (for typedef handling).
+   */
+  private static _handleClassSpecInDecl(
+    classSpec: any,
+    line: number,
+    ctx: ICppDeclarationContext,
+  ): any {
+    const classHead = classSpec.classHead?.();
+    const classHeadName = classHead?.classHeadName?.();
+    const className = classHeadName?.className?.();
+    const identifier = className?.Identifier?.();
+
+    if (identifier?.getText()) {
+      // Named struct - collect normally
+      const result = ClassCollector.collect(
+        classSpec,
+        ctx.sourceFile,
+        line,
+        ctx.currentNamespace,
+        ctx.symbolTable,
+      );
+      if (result) {
+        ctx.symbols.push(result.classSymbol, ...result.memberFunctions);
+        ctx.warnings.push(...result.warnings);
+      }
+      return null;
+    }
+
+    // Anonymous struct - return for typedef handling
+    return classSpec;
+  }
+
+  /**
+   * Process a single declarator (variable or function).
+   */
+  private static _collectDeclarator(
+    declarator: any,
+    baseType: string,
+    line: number,
+    ctx: ICppDeclarationContext,
+    anonymousClassSpec: any,
+  ): void {
+    const name = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!name) return;
+
+    const isFunction = DeclaratorUtils.declaratorIsFunction(declarator);
+    const fullName = ctx.currentNamespace
+      ? `${ctx.currentNamespace}::${name}`
+      : name;
+
+    // Handle anonymous struct typedef
+    if (anonymousClassSpec && ctx.symbolTable) {
+      const result = ClassCollector.collectAnonymousTypedef(
+        anonymousClassSpec,
+        fullName,
+        ctx.sourceFile,
+        line,
+        ctx.symbolTable,
+      );
+      if (result) {
+        ctx.symbols.push(result.classSymbol, ...result.memberFunctions);
+        ctx.warnings.push(...result.warnings);
+        return;
+      }
+    }
+
+    if (isFunction) {
+      const funcSymbol = FunctionCollector.collectDeclaration(
+        declarator,
+        baseType,
+        ctx.sourceFile,
+        line,
+        ctx.currentNamespace,
+      );
+      if (funcSymbol) {
+        ctx.symbols.push(funcSymbol);
+      }
+    } else {
+      const varSymbol = VariableCollector.collect(
+        declarator,
+        baseType,
+        ctx.sourceFile,
+        line,
+        ctx.currentNamespace,
+      );
+      if (varSymbol) {
+        ctx.symbols.push(varSymbol);
+      }
+    }
+  }
+}
+
+export default CppResolver;

package/src/transpiler/logic/symbols/cpp/utils/DeclaratorUtils.ts

@@ -0,0 +1,248 @@
+/**
+ * DeclaratorUtils - Shared utilities for extracting information from C++ declarators.
+ *
+ * Provides methods for extracting names, types, parameters, and array dimensions
+ * from C++ parse tree declarator contexts.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import SymbolUtils from "../../SymbolUtils";
+import IExtractedParameter from "../../shared/IExtractedParameter";
+import ParameterExtractorUtils from "../../shared/ParameterExtractorUtils";
+
+class DeclaratorUtils {
+  /**
+   * Extract name from a declarator context.
+   */
+  static extractDeclaratorName(declarator: any): string | null {
+    // Pointer declarator -> noPointerDeclarator
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      const noPtr = ptrDecl.noPointerDeclarator?.();
+      if (noPtr) {
+        return DeclaratorUtils.extractNoPointerDeclaratorName(noPtr);
+      }
+    }
+
+    // No pointer declarator
+    const noPtr = declarator.noPointerDeclarator?.();
+    if (noPtr) {
+      return DeclaratorUtils.extractNoPointerDeclaratorName(noPtr);
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract name from a noPointerDeclarator context.
+   */
+  static extractNoPointerDeclaratorName(noPtr: any): string | null {
+    const declId = noPtr.declaratorid?.();
+    if (declId) {
+      const idExpr = declId.idExpression?.();
+      if (idExpr) {
+        const unqualId = idExpr.unqualifiedId?.();
+        if (unqualId) {
+          const identifier = unqualId.Identifier?.();
+          if (identifier) {
+            return identifier.getText();
+          }
+        }
+      }
+    }
+
+    // Recursive case
+    const innerNoPtr = noPtr.noPointerDeclarator?.();
+    if (innerNoPtr) {
+      return DeclaratorUtils.extractNoPointerDeclaratorName(innerNoPtr);
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if a declarator represents a function.
+   */
+  static declaratorIsFunction(declarator: any): boolean {
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      const noPtr = ptrDecl.noPointerDeclarator?.();
+      if (noPtr?.parametersAndQualifiers?.()) {
+        return true;
+      }
+    }
+
+    const noPtr = declarator.noPointerDeclarator?.();
+    if (noPtr?.parametersAndQualifiers?.()) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Extract function parameters from a declarator.
+   */
+  static extractFunctionParameters(declarator: any): IExtractedParameter[] {
+    const params: IExtractedParameter[] = [];
+
+    // Find parametersAndQualifiers from the declarator
+    let paramsAndQuals: any = null;
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      const noPtr = ptrDecl.noPointerDeclarator?.();
+      paramsAndQuals = noPtr?.parametersAndQualifiers?.();
+    }
+    if (!paramsAndQuals) {
+      const noPtr = declarator.noPointerDeclarator?.();
+      paramsAndQuals = noPtr?.parametersAndQualifiers?.();
+    }
+    if (!paramsAndQuals) {
+      return params;
+    }
+
+    // Get parameterDeclarationClause
+    const paramClause = paramsAndQuals.parameterDeclarationClause?.();
+    if (!paramClause) {
+      return params;
+    }
+
+    // Get parameterDeclarationList
+    const paramList = paramClause.parameterDeclarationList?.();
+    if (!paramList) {
+      return params;
+    }
+
+    return ParameterExtractorUtils.processParameterList(
+      paramList,
+      DeclaratorUtils.extractParameterInfo,
+    );
+  }
+
+  /**
+   * Extract parameter info from a single parameter declaration.
+   */
+  static extractParameterInfo(paramDecl: any): IExtractedParameter | null {
+    // Get the type from declSpecifierSeq
+    const declSpecSeq = paramDecl.declSpecifierSeq?.();
+    if (!declSpecSeq) {
+      return null;
+    }
+
+    const baseType = DeclaratorUtils.extractTypeFromDeclSpecSeq(declSpecSeq);
+    const isConst = declSpecSeq.getText().includes("const");
+
+    // Check for pointer in declarator or abstractDeclarator
+    const declarator = paramDecl.declarator?.();
+    const abstractDecl = paramDecl.abstractDeclarator?.();
+
+    const isPointer =
+      (declarator && DeclaratorUtils.declaratorHasPointer(declarator)) ||
+      (abstractDecl &&
+        DeclaratorUtils.abstractDeclaratorHasPointer(abstractDecl));
+
+    return ParameterExtractorUtils.buildParameterInfo(
+      declarator,
+      baseType,
+      isConst,
+      isPointer ?? false,
+      false, // isArray - could be enhanced
+      DeclaratorUtils.extractDeclaratorName,
+    );
+  }
+
+  /**
+   * Check if a declarator contains a pointer operator.
+   */
+  static declaratorHasPointer(declarator: any): boolean {
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      // Check for pointerOperator children
+      const ptrOps = ptrDecl.pointerOperator?.();
+      if (ptrOps && ptrOps.length > 0) {
+        return true;
+      }
+      // Also check getText for *
+      if (ptrDecl.getText().includes("*")) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check if an abstract declarator contains a pointer.
+   */
+  static abstractDeclaratorHasPointer(abstractDecl: any): boolean {
+    // Check for pointerAbstractDeclarator
+    const ptrAbstract = abstractDecl.pointerAbstractDeclarator?.();
+    if (ptrAbstract) {
+      const ptrOps = ptrAbstract.pointerOperator?.();
+      if (ptrOps && ptrOps.length > 0) {
+        return true;
+      }
+      if (ptrAbstract.getText().includes("*")) {
+        return true;
+      }
+    }
+    // Simple check for * in the text
+    if (abstractDecl.getText().includes("*")) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Extract type string from a declSpecifierSeq context.
+   */
+  static extractTypeFromDeclSpecSeq(declSpecSeq: any): string {
+    const parts: string[] = [];
+
+    for (const spec of declSpecSeq.declSpecifier?.() ?? []) {
+      const typeSpec = spec.typeSpecifier?.();
+      if (typeSpec) {
+        const trailingType = typeSpec.trailingTypeSpecifier?.();
+        if (trailingType) {
+          const simpleType = trailingType.simpleTypeSpecifier?.();
+          if (simpleType) {
+            parts.push(simpleType.getText());
+          }
+        }
+      }
+    }
+
+    return parts.join(" ") || "int";
+  }
+
+  /**
+   * Extract array dimensions from a declarator.
+   */
+  static extractArrayDimensions(declarator: any): number[] {
+    // For C++, we need to check both pointer and no-pointer declarators
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      const noPtr = ptrDecl.noPointerDeclarator?.();
+      if (noPtr) {
+        return DeclaratorUtils.extractArrayDimensionsFromNoPtr(noPtr);
+      }
+    }
+
+    const noPtr = declarator.noPointerDeclarator?.();
+    if (noPtr) {
+      return DeclaratorUtils.extractArrayDimensionsFromNoPtr(noPtr);
+    }
+
+    return [];
+  }
+
+  /**
+   * Extract array dimensions from a noPointerDeclarator.
+   */
+  static extractArrayDimensionsFromNoPtr(noPtr: any): number[] {
+    // Use shared utility for regex-based extraction
+    return SymbolUtils.parseArrayDimensions(noPtr.getText());
+  }
+}
+
+export default DeclaratorUtils;

package/src/transpiler/logic/symbols/shared/IExtractedParameter.ts

@@ -0,0 +1,18 @@
+/**
+ * Information extracted from a C/C++ parameter declaration.
+ */
+interface IExtractedParameter {
+  /** Parameter name (may be empty for abstract declarators) */
+  readonly name: string;
+
+  /** Parameter type as string */
+  readonly type: string;
+
+  /** Whether the parameter is const-qualified */
+  readonly isConst: boolean;
+
+  /** Whether the parameter is an array */
+  readonly isArray: boolean;
+}
+
+export default IExtractedParameter;

package/src/transpiler/logic/symbols/shared/ParameterExtractorUtils.ts

@@ -0,0 +1,73 @@
+/**
+ * ParameterExtractorUtils - Shared utilities for parameter extraction in C/C++.
+ *
+ * Contains common patterns for building parameter info from extracted values.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import IExtractedParameter from "./IExtractedParameter";
+
+class ParameterExtractorUtils {
+  /**
+   * Process a list of parameter declarations and collect parameter info.
+   *
+   * @param paramList The parameter list context (from either C or C++ grammar)
+   * @param extractInfo Function to extract parameter info from a single declaration
+   * @returns Array of extracted parameters
+   */
+  static processParameterList(
+    paramList: any,
+    extractInfo: (paramDecl: any) => IExtractedParameter | null,
+  ): IExtractedParameter[] {
+    const params: IExtractedParameter[] = [];
+    for (const paramDecl of paramList.parameterDeclaration?.() ?? []) {
+      const paramInfo = extractInfo(paramDecl);
+      if (paramInfo) {
+        params.push(paramInfo);
+      }
+    }
+    return params;
+  }
+
+  /**
+   * Build extracted parameter info from intermediate values.
+   *
+   * @param declarator The declarator context
+   * @param baseType The base type string
+   * @param isConst Whether the parameter is const
+   * @param isPointer Whether the parameter is a pointer
+   * @param isArray Whether the parameter is an array
+   * @param extractName Function to extract name from declarator
+   * @returns The extracted parameter info
+   */
+  static buildParameterInfo(
+    declarator: any,
+    baseType: string,
+    isConst: boolean,
+    isPointer: boolean,
+    isArray: boolean,
+    extractName: (decl: any) => string | null,
+  ): IExtractedParameter {
+    // Append * to type if pointer
+    const finalType = isPointer ? baseType + "*" : baseType;
+
+    // Get parameter name (may be empty for abstract declarators)
+    let paramName = "";
+    if (declarator) {
+      const name = extractName(declarator);
+      if (name) {
+        paramName = name;
+      }
+    }
+
+    return {
+      name: paramName,
+      type: finalType,
+      isConst,
+      isArray,
+    };
+  }
+}
+
+export default ParameterExtractorUtils;