c-next 0.1.70 → 0.1.72

package/src/transpiler/logic/symbols/c/collectors/FunctionCollector.ts

@@ -0,0 +1,106 @@
+/**
+ * FunctionCollector - Collects function symbols from C parse trees.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { FunctionDefinitionContext } from "../../../parser/c/grammar/CParser";
+import type ICFunctionSymbol from "../../../../types/symbols/c/ICFunctionSymbol";
+import type ICParameterInfo from "../../../../types/symbols/c/ICParameterInfo";
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import DeclaratorUtils from "../utils/DeclaratorUtils";
+import type IExtractedParameter from "../../shared/IExtractedParameter";
+
+class FunctionCollector {
+  /**
+   * Map extracted parameters to ICParameterInfo array.
+   */
+  private static _mapParameters(
+    extracted: IExtractedParameter[],
+  ): ICParameterInfo[] {
+    return extracted.map((p) => ({
+      name: p.name,
+      type: p.type,
+      isConst: p.isConst,
+      isArray: p.isArray,
+    }));
+  }
+
+  /**
+   * Collect a function symbol from a function definition.
+   *
+   * @param funcDef The function definition context
+   * @param sourceFile Source file path
+   */
+  static collectFromDefinition(
+    funcDef: FunctionDefinitionContext,
+    sourceFile: string,
+  ): ICFunctionSymbol | null {
+    const declarator = funcDef.declarator();
+    if (!declarator) return null;
+
+    const name = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!name) return null;
+
+    const line = funcDef.start?.line ?? 0;
+
+    // Get return type from declaration specifiers
+    const declSpecs = funcDef.declarationSpecifiers();
+    const returnType = declSpecs
+      ? DeclaratorUtils.extractTypeFromDeclSpecs(declSpecs)
+      : "int";
+
+    const parameters = FunctionCollector._mapParameters(
+      DeclaratorUtils.extractFunctionParameters(declarator),
+    );
+
+    return {
+      kind: "function",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: true,
+      type: returnType,
+      parameters: parameters.length > 0 ? parameters : undefined,
+      isDeclaration: false,
+    };
+  }
+
+  /**
+   * Collect a function symbol from a declaration (prototype).
+   *
+   * @param name Function name
+   * @param baseType Return type
+   * @param declarator The declarator context
+   * @param sourceFile Source file path
+   * @param line Source line number
+   * @param isExtern Whether the function is extern
+   */
+  static collectFromDeclaration(
+    name: string,
+    baseType: string,
+    declarator: any,
+    sourceFile: string,
+    line: number,
+    isExtern: boolean,
+  ): ICFunctionSymbol {
+    const parameters = FunctionCollector._mapParameters(
+      DeclaratorUtils.extractFunctionParameters(declarator),
+    );
+
+    return {
+      kind: "function",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: !isExtern,
+      type: baseType,
+      parameters: parameters.length > 0 ? parameters : undefined,
+      isDeclaration: true,
+    };
+  }
+}
+
+export default FunctionCollector;

package/src/transpiler/logic/symbols/c/collectors/StructCollector.ts

@@ -0,0 +1,173 @@
+/**
+ * StructCollector - Collects struct and union symbols from C parse trees.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { StructOrUnionSpecifierContext } from "../../../parser/c/grammar/CParser";
+import type ICStructSymbol from "../../../../types/symbols/c/ICStructSymbol";
+import type ICFieldInfo from "../../../../types/symbols/c/ICFieldInfo";
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import SymbolTable from "../../SymbolTable";
+import SymbolUtils from "../../SymbolUtils";
+import DeclaratorUtils from "../utils/DeclaratorUtils";
+
+class StructCollector {
+  /**
+   * Collect a struct or union symbol from a specifier context.
+   *
+   * @param structSpec The struct/union specifier context
+   * @param sourceFile Source file path
+   * @param line Source line number
+   * @param symbolTable Optional symbol table for field tracking
+   * @param typedefName Optional typedef name for anonymous structs
+   * @param isTypedef Whether this is part of a typedef declaration
+   * @param warnings Array to collect warnings
+   */
+  static collect(
+    structSpec: StructOrUnionSpecifierContext,
+    sourceFile: string,
+    line: number,
+    symbolTable: SymbolTable | null,
+    typedefName?: string,
+    isTypedef?: boolean,
+    warnings?: string[],
+  ): ICStructSymbol | null {
+    const identifier = structSpec.Identifier();
+
+    // Use typedef name for anonymous structs (e.g., typedef struct { ... } AppConfig;)
+    const name = identifier?.getText() || typedefName;
+    if (!name) return null; // Skip if no name available
+
+    const isUnion = structSpec.structOrUnion()?.getText() === "union";
+
+    // Extract fields if struct has a body
+    const fields = StructCollector.collectFields(
+      structSpec,
+      name,
+      symbolTable,
+      warnings,
+    );
+
+    // Mark named structs that are not typedef'd - they need 'struct' keyword
+    // Example: "struct NamedPoint { ... };" -> needs "struct NamedPoint var"
+    // But "typedef struct { ... } Rectangle;" -> just "Rectangle var"
+    const needsStructKeyword = Boolean(identifier && !isTypedef);
+
+    if (symbolTable && needsStructKeyword) {
+      symbolTable.markNeedsStructKeyword(name);
+    }
+
+    return {
+      kind: "struct",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: true,
+      isUnion,
+      needsStructKeyword,
+      fields: fields.size > 0 ? fields : undefined,
+    };
+  }
+
+  /**
+   * Collect fields from a struct/union definition.
+   */
+  private static collectFields(
+    structSpec: StructOrUnionSpecifierContext,
+    structName: string,
+    symbolTable: SymbolTable | null,
+    warnings?: string[],
+  ): ReadonlyMap<string, ICFieldInfo> {
+    const fields = new Map<string, ICFieldInfo>();
+
+    const declList = structSpec.structDeclarationList();
+    if (!declList) return fields;
+
+    for (const structDecl of declList.structDeclaration()) {
+      StructCollector.collectFieldsFromDecl(
+        structDecl,
+        structName,
+        fields,
+        symbolTable,
+        warnings,
+      );
+    }
+
+    return fields;
+  }
+
+  /**
+   * Collect fields from a single struct declaration.
+   */
+  private static collectFieldsFromDecl(
+    structDecl: any,
+    structName: string,
+    fields: Map<string, ICFieldInfo>,
+    symbolTable: SymbolTable | null,
+    warnings?: string[],
+  ): void {
+    const specQualList = structDecl.specifierQualifierList?.();
+    if (!specQualList) return;
+
+    const fieldType = DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+    const structDeclList = structDecl.structDeclaratorList?.();
+    if (!structDeclList) return;
+
+    for (const structDeclarator of structDeclList.structDeclarator()) {
+      StructCollector.processFieldDeclarator(
+        structDeclarator,
+        structName,
+        fieldType,
+        fields,
+        symbolTable,
+        warnings,
+      );
+    }
+  }
+
+  /**
+   * Process a single field declarator and add to fields map.
+   */
+  private static processFieldDeclarator(
+    structDeclarator: any,
+    structName: string,
+    fieldType: string,
+    fields: Map<string, ICFieldInfo>,
+    symbolTable: SymbolTable | null,
+    warnings?: string[],
+  ): void {
+    const declarator = structDeclarator.declarator?.();
+    if (!declarator) return;
+
+    const fieldName = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!fieldName) return;
+
+    if (warnings && SymbolUtils.isReservedFieldName(fieldName)) {
+      warnings.push(
+        SymbolUtils.getReservedFieldWarning("C", structName, fieldName),
+      );
+    }
+
+    const arrayDimensions = DeclaratorUtils.extractArrayDimensions(declarator);
+    const fieldInfo: ICFieldInfo = {
+      name: fieldName,
+      type: fieldType,
+      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
+    };
+
+    fields.set(fieldName, fieldInfo);
+
+    if (symbolTable) {
+      symbolTable.addStructField(
+        structName,
+        fieldName,
+        fieldType,
+        arrayDimensions.length > 0 ? arrayDimensions : undefined,
+      );
+    }
+  }
+}
+
+export default StructCollector;

package/src/transpiler/logic/symbols/c/collectors/TypedefCollector.ts

@@ -0,0 +1,35 @@
+/**
+ * TypedefCollector - Collects typedef symbols from C parse trees.
+ */
+
+import type ICTypedefSymbol from "../../../../types/symbols/c/ICTypedefSymbol";
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+
+class TypedefCollector {
+  /**
+   * Collect a typedef symbol.
+   *
+   * @param name Typedef name
+   * @param baseType The underlying type
+   * @param sourceFile Source file path
+   * @param line Source line number
+   */
+  static collect(
+    name: string,
+    baseType: string,
+    sourceFile: string,
+    line: number,
+  ): ICTypedefSymbol {
+    return {
+      kind: "type",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: true,
+      type: baseType,
+    };
+  }
+}
+
+export default TypedefCollector;

package/src/transpiler/logic/symbols/c/collectors/VariableCollector.ts

@@ -0,0 +1,80 @@
+/**
+ * VariableCollector - Collects variable symbols from C parse trees.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type ICVariableSymbol from "../../../../types/symbols/c/ICVariableSymbol";
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import DeclaratorUtils from "../utils/DeclaratorUtils";
+
+class VariableCollector {
+  /**
+   * Collect a variable symbol from a declarator.
+   *
+   * @param name Variable name
+   * @param baseType Variable type
+   * @param declarator The declarator context (for array dimensions)
+   * @param sourceFile Source file path
+   * @param line Source line number
+   * @param isExtern Whether the variable is extern
+   */
+  static collect(
+    name: string,
+    baseType: string,
+    declarator: any,
+    sourceFile: string,
+    line: number,
+    isExtern: boolean,
+  ): ICVariableSymbol {
+    // Extract array dimensions if present
+    const arrayDimensions = declarator
+      ? DeclaratorUtils.extractArrayDimensions(declarator)
+      : [];
+
+    return {
+      kind: "variable",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: !isExtern,
+      type: baseType,
+      isArray: arrayDimensions.length > 0,
+      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
+      isExtern,
+    };
+  }
+
+  /**
+   * Collect a variable from declaration specifiers (when identifier appears as typedefName).
+   * This handles the C grammar ambiguity where variable names can be parsed as typedef names.
+   *
+   * @param name Variable name
+   * @param baseType Variable type
+   * @param sourceFile Source file path
+   * @param line Source line number
+   * @param isExtern Whether the variable is extern
+   */
+  static collectFromDeclSpecs(
+    name: string,
+    baseType: string,
+    sourceFile: string,
+    line: number,
+    isExtern: boolean,
+  ): ICVariableSymbol {
+    return {
+      kind: "variable",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: !isExtern,
+      type: baseType,
+      isArray: false,
+      isExtern,
+    };
+  }
+}
+
+export default VariableCollector;