c-next 0.1.70 → 0.1.72

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

@@ -0,0 +1,333 @@
+/**
+ * CResolver - Orchestrates C symbol collection using composable collectors.
+ *
+ * This resolver collects symbols from C header parse trees and returns
+ * typed TCSymbol[] discriminated unions.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type {
+  CompilationUnitContext,
+  DeclarationContext,
+  DeclarationSpecifiersContext,
+  DeclarationSpecifierContext,
+} from "../../parser/c/grammar/CParser";
+import type TCSymbol from "../../../types/symbols/c/TCSymbol";
+import SymbolTable from "../SymbolTable";
+import DeclaratorUtils from "./utils/DeclaratorUtils";
+import StructCollector from "./collectors/StructCollector";
+import EnumCollector from "./collectors/EnumCollector";
+import FunctionCollector from "./collectors/FunctionCollector";
+import TypedefCollector from "./collectors/TypedefCollector";
+import VariableCollector from "./collectors/VariableCollector";
+
+/**
+ * Result of resolving C symbols.
+ */
+interface ICResolverResult {
+  /** Collected symbols */
+  readonly symbols: TCSymbol[];
+
+  /** Warnings generated during collection */
+  readonly warnings: string[];
+}
+
+/**
+ * Internal context for declaration processing.
+ */
+interface IDeclarationContext {
+  readonly sourceFile: string;
+  readonly line: number;
+  readonly isTypedef: boolean;
+  readonly isExtern: boolean;
+  readonly symbols: TCSymbol[];
+}
+
+class CResolver {
+  /**
+   * Resolve all symbols from a C compilation unit.
+   *
+   * @param tree The parsed compilation unit context
+   * @param sourceFile Source file path
+   * @param symbolTable Optional symbol table for field tracking
+   */
+  static resolve(
+    tree: CompilationUnitContext,
+    sourceFile: string,
+    symbolTable?: SymbolTable | null,
+  ): ICResolverResult {
+    const symbols: TCSymbol[] = [];
+    const warnings: string[] = [];
+
+    const translationUnit = tree.translationUnit();
+    if (!translationUnit) {
+      return { symbols, warnings };
+    }
+
+    for (const extDecl of translationUnit.externalDeclaration()) {
+      // Function definition
+      const funcDef = extDecl.functionDefinition();
+      if (funcDef) {
+        const funcSymbol = FunctionCollector.collectFromDefinition(
+          funcDef,
+          sourceFile,
+        );
+        if (funcSymbol) {
+          symbols.push(funcSymbol);
+        }
+        continue;
+      }
+
+      // Declaration (typedef, struct, variable, function prototype)
+      const decl = extDecl.declaration();
+      if (decl) {
+        CResolver.collectDeclaration(
+          decl,
+          sourceFile,
+          symbolTable ?? null,
+          symbols,
+          warnings,
+        );
+      }
+    }
+
+    return { symbols, warnings };
+  }
+
+  /**
+   * Collect symbols from a declaration.
+   */
+  private static collectDeclaration(
+    decl: DeclarationContext,
+    sourceFile: string,
+    symbolTable: SymbolTable | null,
+    symbols: TCSymbol[],
+    warnings: string[],
+  ): void {
+    const declSpecs = decl.declarationSpecifiers();
+    if (!declSpecs) return;
+
+    const line = decl.start?.line ?? 0;
+
+    // Check for storage class specifiers
+    const isTypedef = DeclaratorUtils.hasStorageClass(declSpecs, "typedef");
+    const isExtern = DeclaratorUtils.hasStorageClass(declSpecs, "extern");
+
+    // Check for struct/union
+    const structSpec = DeclaratorUtils.findStructOrUnionSpecifier(declSpecs);
+    if (structSpec) {
+      // For typedef struct, extract the typedef name from declarationSpecifiers
+      const typedefName = isTypedef
+        ? DeclaratorUtils.extractTypedefNameFromSpecs(declSpecs)
+        : undefined;
+
+      const structSymbol = StructCollector.collect(
+        structSpec,
+        sourceFile,
+        line,
+        symbolTable,
+        typedefName,
+        isTypedef,
+        warnings,
+      );
+      if (structSymbol) {
+        symbols.push(structSymbol);
+      }
+    }
+
+    // Check for enum
+    const enumSpec = DeclaratorUtils.findEnumSpecifier(declSpecs);
+    if (enumSpec) {
+      const enumResult = EnumCollector.collect(enumSpec, sourceFile, line);
+      if (enumResult) {
+        symbols.push(enumResult.enum);
+        // Also add enum member symbols
+        for (const member of enumResult.members) {
+          symbols.push(member);
+        }
+      }
+    }
+
+    // Collect declarators (variables, function prototypes, typedefs)
+    const ctx: IDeclarationContext = {
+      sourceFile,
+      line,
+      isTypedef,
+      isExtern,
+      symbols,
+    };
+
+    const initDeclList = decl.initDeclaratorList();
+    if (initDeclList) {
+      const baseType = DeclaratorUtils.extractTypeFromDeclSpecs(declSpecs);
+      CResolver.collectInitDeclaratorList(initDeclList, baseType, ctx);
+    } else {
+      // Handle case where identifier is parsed as typedefName in declarationSpecifiers
+      CResolver.collectFromDeclSpecsTypedefName(
+        declSpecs,
+        structSpec,
+        enumSpec,
+        ctx,
+      );
+    }
+  }
+
+  /**
+   * Collect symbols from init declarator list.
+   */
+  private static collectInitDeclaratorList(
+    initDeclList: any,
+    baseType: string,
+    ctx: IDeclarationContext,
+  ): void {
+    for (const initDecl of initDeclList.initDeclarator()) {
+      const declarator = initDecl.declarator();
+      if (!declarator) continue;
+
+      const name = DeclaratorUtils.extractDeclaratorName(declarator);
+      if (!name) continue;
+
+      // Check if this is a function declaration (has parameter list)
+      const isFunction = DeclaratorUtils.declaratorIsFunction(declarator);
+
+      if (ctx.isTypedef) {
+        ctx.symbols.push(
+          TypedefCollector.collect(name, baseType, ctx.sourceFile, ctx.line),
+        );
+      } else if (isFunction) {
+        ctx.symbols.push(
+          FunctionCollector.collectFromDeclaration(
+            name,
+            baseType,
+            declarator,
+            ctx.sourceFile,
+            ctx.line,
+            ctx.isExtern,
+          ),
+        );
+      } else {
+        ctx.symbols.push(
+          VariableCollector.collect(
+            name,
+            baseType,
+            declarator,
+            ctx.sourceFile,
+            ctx.line,
+            ctx.isExtern,
+          ),
+        );
+      }
+    }
+  }
+
+  /**
+   * Collect symbols when identifier appears as typedefName in declarationSpecifiers.
+   * This handles the C grammar ambiguity where variable names can be parsed as typedef names.
+   */
+  private static collectFromDeclSpecsTypedefName(
+    declSpecs: DeclarationSpecifiersContext,
+    structSpec: any,
+    enumSpec: any,
+    ctx: IDeclarationContext,
+  ): void {
+    const specs = declSpecs.declarationSpecifier();
+    const { name: lastTypedefName, index: lastTypedefIndex } =
+      CResolver.findLastTypedefName(specs);
+
+    if (!lastTypedefName || lastTypedefIndex < 0) return;
+
+    // Skip duplicates for non-typedef declarations
+    if (
+      !ctx.isTypedef &&
+      CResolver.shouldSkipDuplicateTypedefName(
+        lastTypedefName,
+        structSpec,
+        enumSpec,
+      )
+    ) {
+      return;
+    }
+
+    const baseType = CResolver.buildBaseTypeFromSpecs(specs, lastTypedefIndex);
+
+    if (ctx.isTypedef) {
+      ctx.symbols.push(
+        TypedefCollector.collect(
+          lastTypedefName,
+          baseType,
+          ctx.sourceFile,
+          ctx.line,
+        ),
+      );
+    } else {
+      ctx.symbols.push(
+        VariableCollector.collectFromDeclSpecs(
+          lastTypedefName,
+          baseType,
+          ctx.sourceFile,
+          ctx.line,
+          ctx.isExtern,
+        ),
+      );
+    }
+  }
+
+  /**
+   * Find the last typedefName in declaration specifiers.
+   */
+  private static findLastTypedefName(specs: DeclarationSpecifierContext[]): {
+    name: string | undefined;
+    index: number;
+  } {
+    let name: string | undefined;
+    let index = -1;
+
+    for (let i = 0; i < specs.length; i++) {
+      const typeSpec = specs[i].typeSpecifier();
+      const typedefName = typeSpec?.typedefName?.();
+      if (typedefName) {
+        name = typedefName.getText();
+        index = i;
+      }
+    }
+
+    return { name, index };
+  }
+
+  /**
+   * Check if typedef name should be skipped to avoid duplicates.
+   */
+  private static shouldSkipDuplicateTypedefName(
+    typedefName: string,
+    structSpec: any,
+    enumSpec: any,
+  ): boolean {
+    const structName = structSpec?.Identifier?.()?.getText();
+    if (structName === typedefName) return true;
+
+    const enumName = enumSpec?.Identifier?.()?.getText();
+    if (enumName === typedefName) return true;
+
+    return false;
+  }
+
+  /**
+   * Build base type string from specifiers before the typedef name.
+   */
+  private static buildBaseTypeFromSpecs(
+    specs: DeclarationSpecifierContext[],
+    endIndex: number,
+  ): string {
+    const typeParts: string[] = [];
+    for (let i = 0; i < endIndex; i++) {
+      const typeSpec = specs[i].typeSpecifier();
+      if (typeSpec) {
+        typeParts.push(typeSpec.getText());
+      }
+    }
+    return typeParts.join(" ") || "int";
+  }
+}
+
+export default CResolver;

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

@@ -0,0 +1,269 @@
+/**
+ * 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 type {
+  DeclarationSpecifiersContext,
+  StructOrUnionSpecifierContext,
+  EnumSpecifierContext,
+} from "../../../parser/c/grammar/CParser";
+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 {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return null;
+
+    return DeclaratorUtils.extractDirectDeclaratorName(directDecl);
+  }
+
+  /**
+   * Extract identifier from directDeclarator, handling arrays and function pointers.
+   * The C grammar has recursive directDeclarator for arrays: `directDeclarator '[' ... ']'`
+   * so `buf[8]` is parsed as directDeclarator('[', directDeclarator('buf'), ']')
+   */
+  static extractDirectDeclaratorName(directDecl: any): string | null {
+    // Check for identifier (base case)
+    const identifier = directDecl.Identifier?.();
+    if (identifier) {
+      return identifier.getText();
+    }
+
+    // Nested declarator in parentheses: '(' declarator ')'
+    const nestedDecl = directDecl.declarator?.();
+    if (nestedDecl) {
+      return DeclaratorUtils.extractDeclaratorName(nestedDecl);
+    }
+
+    // Nested directDeclarator for arrays/functions
+    // Grammar: directDeclarator '[' ... ']' or directDeclarator '(' ... ')'
+    const nestedDirectDecl = directDecl.directDeclarator?.();
+    if (nestedDirectDecl) {
+      return DeclaratorUtils.extractDirectDeclaratorName(nestedDirectDecl);
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if a declarator represents a function.
+   */
+  static declaratorIsFunction(declarator: any): boolean {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return false;
+
+    // Check for parameter type list (function with params) or empty parens
+    // The C grammar: directDeclarator '(' parameterTypeList ')' | directDeclarator '(' identifierList? ')'
+    if (directDecl.parameterTypeList?.() !== null) return true;
+
+    // Check for LeftParen token - indicates function declarator even with empty params
+    if (directDecl.LeftParen?.()) return true;
+
+    return false;
+  }
+
+  /**
+   * Extract function parameters from a declarator.
+   */
+  static extractFunctionParameters(declarator: any): IExtractedParameter[] {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return [];
+
+    const paramTypeList = directDecl.parameterTypeList?.();
+    if (!paramTypeList) return [];
+
+    const paramList = paramTypeList.parameterList?.();
+    if (!paramList) return [];
+
+    return ParameterExtractorUtils.processParameterList(
+      paramList,
+      DeclaratorUtils.extractParameterInfo,
+    );
+  }
+
+  /**
+   * Extract parameter info from a single parameter declaration.
+   */
+  static extractParameterInfo(paramDecl: any): IExtractedParameter | null {
+    const declSpecs = paramDecl.declarationSpecifiers?.();
+    if (!declSpecs) return null;
+
+    const baseType = DeclaratorUtils.extractTypeFromDeclSpecs(declSpecs);
+    const isConst = declSpecs.getText().includes("const");
+
+    // Check for pointer and array in declarator
+    const declarator = paramDecl.declarator?.();
+    let isPointer = false;
+    let isArray = false;
+
+    if (declarator) {
+      isPointer = Boolean(declarator.pointer?.());
+      const directDecl = declarator.directDeclarator?.();
+      if (directDecl) {
+        const text = directDecl.getText();
+        isArray = text.includes("[") && text.includes("]");
+      }
+    }
+
+    return ParameterExtractorUtils.buildParameterInfo(
+      declarator,
+      baseType,
+      isConst,
+      isPointer,
+      isArray,
+      DeclaratorUtils.extractDeclaratorName,
+    );
+  }
+
+  /**
+   * Extract array dimensions from a declarator.
+   */
+  static extractArrayDimensions(declarator: any): number[] {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return [];
+
+    // Use shared utility for regex-based extraction
+    return SymbolUtils.parseArrayDimensions(directDecl.getText());
+  }
+
+  /**
+   * Extract type string from declaration specifiers.
+   */
+  static extractTypeFromDeclSpecs(
+    declSpecs: DeclarationSpecifiersContext,
+  ): string {
+    const parts: string[] = [];
+
+    for (const spec of declSpecs.declarationSpecifier()) {
+      const typeSpec = spec.typeSpecifier();
+      if (typeSpec) {
+        parts.push(typeSpec.getText());
+      }
+    }
+
+    return parts.join(" ") || "int";
+  }
+
+  /**
+   * Check if declaration specifiers contain a specific storage class.
+   */
+  static hasStorageClass(
+    declSpecs: DeclarationSpecifiersContext,
+    storage: string,
+  ): boolean {
+    for (const spec of declSpecs.declarationSpecifier()) {
+      const storageSpec = spec.storageClassSpecifier();
+      if (storageSpec?.getText() === storage) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Find struct or union specifier in declaration specifiers.
+   */
+  static findStructOrUnionSpecifier(
+    declSpecs: DeclarationSpecifiersContext,
+  ): StructOrUnionSpecifierContext | null {
+    for (const spec of declSpecs.declarationSpecifier()) {
+      const typeSpec = spec.typeSpecifier();
+      if (typeSpec) {
+        const structSpec = typeSpec.structOrUnionSpecifier?.();
+        if (structSpec) {
+          return structSpec;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Find enum specifier in declaration specifiers.
+   */
+  static findEnumSpecifier(
+    declSpecs: DeclarationSpecifiersContext,
+  ): EnumSpecifierContext | null {
+    for (const spec of declSpecs.declarationSpecifier()) {
+      const typeSpec = spec.typeSpecifier();
+      if (typeSpec) {
+        const enumSpec = typeSpec.enumSpecifier?.();
+        if (enumSpec) {
+          return enumSpec;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Extract type from specifierQualifierList (for struct fields).
+   * For struct/union field types, extract just the identifier (e.g., "InnerConfig")
+   * not the concatenated text ("structInnerConfig").
+   */
+  static extractTypeFromSpecQualList(specQualList: any): string {
+    const parts: string[] = [];
+
+    // Traverse the specifierQualifierList
+    let current = specQualList;
+    while (current) {
+      const typeSpec = current.typeSpecifier?.();
+      if (typeSpec) {
+        // Check for struct/union specifier - need to extract just the identifier
+        const structSpec = typeSpec.structOrUnionSpecifier?.();
+        if (structSpec) {
+          const identifier = structSpec.Identifier?.();
+          if (identifier) {
+            // Use just the struct/union name, not "structName" concatenated
+            parts.push(identifier.getText());
+          } else {
+            // Anonymous struct - use full text
+            parts.push(typeSpec.getText());
+          }
+        } else {
+          parts.push(typeSpec.getText());
+        }
+      }
+
+      const typeQual = current.typeQualifier?.();
+      if (typeQual) {
+        parts.push(typeQual.getText());
+      }
+
+      current = current.specifierQualifierList?.();
+    }
+
+    return parts.join(" ") || "int";
+  }
+
+  /**
+   * Extract typedef name from declaration specifiers.
+   * For "typedef struct { ... } AppConfig;", this returns "AppConfig".
+   */
+  static extractTypedefNameFromSpecs(
+    declSpecs: DeclarationSpecifiersContext,
+  ): string | undefined {
+    for (const spec of declSpecs.declarationSpecifier()) {
+      const typeSpec = spec.typeSpecifier();
+      if (typeSpec) {
+        const typeName = typeSpec.typedefName?.();
+        if (typeName) {
+          return typeName.getText();
+        }
+      }
+    }
+    return undefined;
+  }
+}
+
+export default DeclaratorUtils;