c-next 0.1.70 → 0.1.72

package/src/transpiler/logic/symbols/cpp/collectors/ClassCollector.ts

@@ -0,0 +1,317 @@
+/**
+ * ClassCollector - Extracts class/struct definitions from C++ parse trees.
+ *
+ * Handles class members including data fields and member functions.
+ * Produces ICppClassSymbol instances with optional field information.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ICppClassSymbol from "../../../../types/symbols/cpp/ICppClassSymbol";
+import ICppFunctionSymbol from "../../../../types/symbols/cpp/ICppFunctionSymbol";
+import ICppFieldInfo from "../../../../types/symbols/cpp/ICppFieldInfo";
+import SymbolTable from "../../SymbolTable";
+import SymbolUtils from "../../SymbolUtils";
+import DeclaratorUtils from "../utils/DeclaratorUtils";
+import FunctionCollector from "./FunctionCollector";
+
+/**
+ * Result of collecting a class, including the class symbol and any member function symbols.
+ */
+interface IClassCollectorResult {
+  classSymbol: ICppClassSymbol;
+  memberFunctions: ICppFunctionSymbol[];
+  warnings: string[];
+}
+
+/**
+ * Internal context for member collection.
+ */
+interface IMemberCollectionContext {
+  readonly className: string;
+  readonly sourceFile: string;
+  readonly symbolTable: SymbolTable | null;
+  readonly fields: Map<string, ICppFieldInfo> | undefined;
+  readonly memberFunctions: ICppFunctionSymbol[];
+  readonly warnings: string[];
+}
+
+class ClassCollector {
+  /**
+   * Collect a class specifier and return an ICppClassSymbol with member functions.
+   *
+   * @param classSpec The class specifier context
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional current namespace
+   * @param symbolTable Optional symbol table for storing field info
+   * @returns The class symbol with member functions, or null if no name
+   */
+  static collect(
+    classSpec: any,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+    symbolTable?: SymbolTable | null,
+  ): IClassCollectorResult | null {
+    const classHead = classSpec.classHead?.();
+    if (!classHead) return null;
+
+    const classHeadName = classHead.classHeadName?.();
+    if (!classHeadName) return null;
+
+    const className = classHeadName.className?.();
+    if (!className) return null;
+
+    const identifier = className.Identifier?.();
+    const name = identifier?.getText();
+    if (!name) return null;
+
+    const fullName = currentNamespace ? `${currentNamespace}::${name}` : name;
+
+    const memberFunctions: ICppFunctionSymbol[] = [];
+    const warnings: string[] = [];
+    const fields: Map<string, ICppFieldInfo> | undefined = symbolTable
+      ? new Map()
+      : undefined;
+
+    // Extract class members
+    const memberSpec = classSpec.memberSpecification?.();
+    if (memberSpec) {
+      const ctx: IMemberCollectionContext = {
+        className: fullName,
+        sourceFile,
+        symbolTable: symbolTable ?? null,
+        fields,
+        memberFunctions,
+        warnings,
+      };
+      ClassCollector._collectClassMembers(ctx, memberSpec);
+    }
+
+    const classSymbol: ICppClassSymbol = {
+      kind: "class",
+      name: fullName,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+      fields: fields && fields.size > 0 ? fields : undefined,
+    };
+
+    return { classSymbol, memberFunctions, warnings };
+  }
+
+  /**
+   * Collect an anonymous class from a typedef.
+   *
+   * @param classSpec The class specifier context (anonymous)
+   * @param typedefName The typedef name to use as the class name
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param symbolTable Symbol table for storing field info
+   * @returns The class symbol result, or null on error
+   */
+  static collectAnonymousTypedef(
+    classSpec: any,
+    typedefName: string,
+    sourceFile: string,
+    line: number,
+    symbolTable: SymbolTable,
+  ): IClassCollectorResult | null {
+    const memberSpec = classSpec.memberSpecification?.();
+    if (!memberSpec) return null;
+
+    const memberFunctions: ICppFunctionSymbol[] = [];
+    const warnings: string[] = [];
+    const fields = new Map<string, ICppFieldInfo>();
+
+    const ctx: IMemberCollectionContext = {
+      className: typedefName,
+      sourceFile,
+      symbolTable,
+      fields,
+      memberFunctions,
+      warnings,
+    };
+    ClassCollector._collectClassMembers(ctx, memberSpec);
+
+    const classSymbol: ICppClassSymbol = {
+      kind: "class",
+      name: typedefName,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      fields: fields.size > 0 ? fields : undefined,
+    };
+
+    return { classSymbol, memberFunctions, warnings };
+  }
+
+  /**
+   * Collect class members (data fields and member functions).
+   */
+  private static _collectClassMembers(
+    ctx: IMemberCollectionContext,
+    memberSpec: any,
+  ): void {
+    for (const memberDecl of memberSpec.memberdeclaration?.() ?? []) {
+      ClassCollector._collectMemberDeclaration(memberDecl, ctx);
+    }
+  }
+
+  /**
+   * Collect a single member declaration.
+   */
+  private static _collectMemberDeclaration(
+    memberDecl: any,
+    ctx: IMemberCollectionContext,
+  ): void {
+    const line = memberDecl.start?.line ?? 0;
+
+    // Check for inline function definition within the class
+    const funcDef = memberDecl.functionDefinition?.();
+    if (funcDef) {
+      ClassCollector._collectInlineFunctionDef(
+        ctx.className,
+        funcDef,
+        ctx.sourceFile,
+        line,
+        ctx.memberFunctions,
+      );
+      return;
+    }
+
+    // Get member declaration list (for data members and function declarations)
+    const declSpecSeq = memberDecl.declSpecifierSeq?.();
+    if (!declSpecSeq) return;
+
+    const fieldType = DeclaratorUtils.extractTypeFromDeclSpecSeq(declSpecSeq);
+
+    // Get declarator list
+    const memberDeclList = memberDecl.memberDeclaratorList?.();
+    if (!memberDeclList) return;
+
+    for (const memberDeclarator of memberDeclList.memberDeclarator?.() ?? []) {
+      ClassCollector._collectMemberDeclarator(
+        memberDeclarator,
+        fieldType,
+        line,
+        ctx,
+      );
+    }
+  }
+
+  /**
+   * Collect an inline function definition within a class.
+   */
+  private static _collectInlineFunctionDef(
+    className: string,
+    funcDef: any,
+    sourceFile: string,
+    line: number,
+    memberFunctions: ICppFunctionSymbol[],
+  ): void {
+    const declarator = funcDef.declarator?.();
+    if (!declarator) return;
+
+    const funcName = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!funcName) return;
+
+    const declSpecSeq = funcDef.declSpecifierSeq?.();
+    const returnType = declSpecSeq
+      ? DeclaratorUtils.extractTypeFromDeclSpecSeq(declSpecSeq)
+      : "void";
+
+    const symbol = FunctionCollector.collectMemberFunction(
+      className,
+      funcName,
+      declarator,
+      returnType,
+      sourceFile,
+      line,
+      false, // not a declaration, it's a definition
+    );
+    memberFunctions.push(symbol);
+  }
+
+  /**
+   * Collect a single member declarator (function or data field).
+   */
+  private static _collectMemberDeclarator(
+    memberDeclarator: any,
+    fieldType: string,
+    line: number,
+    ctx: IMemberCollectionContext,
+  ): void {
+    const declarator = memberDeclarator.declarator?.();
+    if (!declarator) return;
+
+    const fieldName = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!fieldName) return;
+
+    // Check if this is a member function
+    if (DeclaratorUtils.declaratorIsFunction(declarator)) {
+      const symbol = FunctionCollector.collectMemberFunction(
+        ctx.className,
+        fieldName,
+        declarator,
+        fieldType,
+        ctx.sourceFile,
+        line,
+        true, // declaration
+      );
+      ctx.memberFunctions.push(symbol);
+      return;
+    }
+
+    // Data field
+    ClassCollector._collectDataField(fieldName, declarator, fieldType, ctx);
+  }
+
+  /**
+   * Collect a data field declaration.
+   */
+  private static _collectDataField(
+    fieldName: string,
+    declarator: any,
+    fieldType: string,
+    ctx: IMemberCollectionContext,
+  ): void {
+    // Warn if field name conflicts with C-Next reserved property names
+    if (SymbolUtils.isReservedFieldName(fieldName)) {
+      ctx.warnings.push(
+        SymbolUtils.getReservedFieldWarning("C++", ctx.className, fieldName),
+      );
+    }
+
+    // Extract array dimensions if any
+    const arrayDimensions = DeclaratorUtils.extractArrayDimensions(declarator);
+
+    // Add to SymbolTable if provided
+    if (ctx.symbolTable) {
+      ctx.symbolTable.addStructField(
+        ctx.className,
+        fieldName,
+        fieldType,
+        arrayDimensions.length > 0 ? arrayDimensions : undefined,
+      );
+    }
+
+    // Add to fields map if provided
+    if (ctx.fields) {
+      const fieldInfo: ICppFieldInfo = {
+        name: fieldName,
+        type: fieldType,
+        arrayDimensions:
+          arrayDimensions.length > 0 ? arrayDimensions : undefined,
+      };
+      ctx.fields.set(fieldName, fieldInfo);
+    }
+  }
+}
+
+export default ClassCollector;

package/src/transpiler/logic/symbols/cpp/collectors/EnumCollector.ts

@@ -0,0 +1,71 @@
+/**
+ * EnumCollector - Extracts enum declarations from C++ parse trees.
+ *
+ * Produces ICppEnumSymbol instances with optional bit width for typed enums.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ICppEnumSymbol from "../../../../types/symbols/cpp/ICppEnumSymbol";
+import SymbolTable from "../../SymbolTable";
+import SymbolUtils from "../../SymbolUtils";
+
+class EnumCollector {
+  /**
+   * Collect an enum specifier and return an ICppEnumSymbol.
+   *
+   * @param enumSpec The enum specifier context
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional current namespace
+   * @param symbolTable Optional symbol table for storing bit width
+   * @returns The enum symbol or null if no name
+   */
+  static collect(
+    enumSpec: any,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+    symbolTable?: SymbolTable | null,
+  ): ICppEnumSymbol | null {
+    const enumHead = enumSpec.enumHead?.();
+    if (!enumHead) return null;
+
+    const identifier = enumHead.Identifier?.();
+    if (!identifier) return null;
+
+    const name = identifier.getText();
+    const fullName = currentNamespace ? `${currentNamespace}::${name}` : name;
+
+    // Extract bit width for typed enums (e.g., enum EPressureType : uint8_t)
+    let bitWidth: number | undefined;
+    if (symbolTable) {
+      const enumbase = enumHead.enumbase?.();
+      if (enumbase) {
+        const typeSpecSeq = enumbase.typeSpecifierSeq?.();
+        if (typeSpecSeq) {
+          const typeName = typeSpecSeq.getText();
+          const width = SymbolUtils.getTypeWidth(typeName);
+          if (width > 0) {
+            symbolTable.addEnumBitWidth(fullName, width);
+            bitWidth = width;
+          }
+        }
+      }
+    }
+
+    return {
+      kind: "enum",
+      name: fullName,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+      bitWidth,
+    };
+  }
+}
+
+export default EnumCollector;

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

@@ -0,0 +1,155 @@
+/**
+ * FunctionCollector - Extracts function definitions and declarations from C++ parse trees.
+ *
+ * Produces ICppFunctionSymbol instances with parameters.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ICppFunctionSymbol from "../../../../types/symbols/cpp/ICppFunctionSymbol";
+import ICppParameterInfo from "../../../../types/symbols/cpp/ICppParameterInfo";
+import DeclaratorUtils from "../utils/DeclaratorUtils";
+import IExtractedParameter from "../../shared/IExtractedParameter";
+
+class FunctionCollector {
+  /**
+   * Map extracted parameters to ICppParameterInfo array.
+   */
+  private static _mapParameters(
+    extracted: IExtractedParameter[],
+  ): ICppParameterInfo[] {
+    return extracted.map((p) => ({
+      name: p.name,
+      type: p.type,
+      isConst: p.isConst,
+      isArray: p.isArray,
+    }));
+  }
+
+  /**
+   * Collect a function definition and return an ICppFunctionSymbol.
+   *
+   * @param funcDef The function definition context
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional current namespace
+   * @returns The function symbol or null if no name
+   */
+  static collectDefinition(
+    funcDef: any,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+  ): ICppFunctionSymbol | null {
+    const declarator = funcDef.declarator?.();
+    if (!declarator) return null;
+
+    const name = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!name) return null;
+
+    // Get return type
+    const declSpecSeq = funcDef.declSpecifierSeq?.();
+    const returnType = declSpecSeq
+      ? DeclaratorUtils.extractTypeFromDeclSpecSeq(declSpecSeq)
+      : "void";
+
+    const fullName = currentNamespace ? `${currentNamespace}::${name}` : name;
+    const params = FunctionCollector._mapParameters(
+      DeclaratorUtils.extractFunctionParameters(declarator),
+    );
+
+    return {
+      kind: "function",
+      name: fullName,
+      type: returnType,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+      parameters: params.length > 0 ? params : undefined,
+      isDeclaration: false,
+    };
+  }
+
+  /**
+   * Collect a function declaration (prototype) and return an ICppFunctionSymbol.
+   *
+   * @param declarator The function declarator context
+   * @param baseType The return type string
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional current namespace
+   * @returns The function symbol or null if no name
+   */
+  static collectDeclaration(
+    declarator: any,
+    baseType: string,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+  ): ICppFunctionSymbol | null {
+    const name = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!name) return null;
+
+    const fullName = currentNamespace ? `${currentNamespace}::${name}` : name;
+    const params = FunctionCollector._mapParameters(
+      DeclaratorUtils.extractFunctionParameters(declarator),
+    );
+
+    return {
+      kind: "function",
+      name: fullName,
+      type: baseType,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+      parameters: params.length > 0 ? params : undefined,
+      isDeclaration: true,
+    };
+  }
+
+  /**
+   * Collect a member function (method) and return an ICppFunctionSymbol.
+   *
+   * @param className The class this method belongs to
+   * @param funcName The method name
+   * @param declarator The function declarator context
+   * @param returnType The return type string
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param isDeclaration Whether this is a declaration (vs inline definition)
+   * @returns The function symbol
+   */
+  static collectMemberFunction(
+    className: string,
+    funcName: string,
+    declarator: any,
+    returnType: string,
+    sourceFile: string,
+    line: number,
+    isDeclaration: boolean,
+  ): ICppFunctionSymbol {
+    const params = FunctionCollector._mapParameters(
+      DeclaratorUtils.extractFunctionParameters(declarator),
+    );
+
+    return {
+      kind: "function",
+      name: `${className}::${funcName}`,
+      type: returnType,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: className,
+      parameters: params.length > 0 ? params : undefined,
+      isDeclaration: isDeclaration || undefined,
+    };
+  }
+}
+
+export default FunctionCollector;

package/src/transpiler/logic/symbols/cpp/collectors/NamespaceCollector.ts

@@ -0,0 +1,65 @@
+/**
+ * NamespaceCollector - Extracts namespace declarations from C++ parse trees.
+ *
+ * Produces ICppNamespaceSymbol instances.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ICppNamespaceSymbol from "../../../../types/symbols/cpp/ICppNamespaceSymbol";
+
+class NamespaceCollector {
+  /**
+   * Collect a namespace definition and return an ICppNamespaceSymbol.
+   *
+   * @param nsDef The namespace definition context
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional parent namespace name
+   * @returns The namespace symbol
+   */
+  static collect(
+    nsDef: any,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+  ): ICppNamespaceSymbol | null {
+    const identifier = nsDef.Identifier?.();
+    const originalNs = nsDef.originalNamespaceName?.();
+
+    const name = identifier?.getText() ?? originalNs?.getText();
+    if (!name) return null;
+
+    // Use full qualified name for nested namespaces
+    const fullName = currentNamespace ? `${currentNamespace}::${name}` : name;
+
+    return {
+      kind: "namespace",
+      name: fullName,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+    };
+  }
+
+  /**
+   * Get the full namespace name after processing this namespace definition.
+   */
+  static getFullNamespaceName(
+    nsDef: any,
+    currentNamespace?: string,
+  ): string | undefined {
+    const identifier = nsDef.Identifier?.();
+    const originalNs = nsDef.originalNamespaceName?.();
+
+    const name = identifier?.getText() ?? originalNs?.getText();
+    if (!name) return currentNamespace;
+
+    return currentNamespace ? `${currentNamespace}::${name}` : name;
+  }
+}
+
+export default NamespaceCollector;

package/src/transpiler/logic/symbols/cpp/collectors/TypeAliasCollector.ts

@@ -0,0 +1,46 @@
+/**
+ * TypeAliasCollector - Extracts type alias declarations from C++ parse trees.
+ *
+ * Handles C++ using declarations (using X = Y).
+ * Produces ICppTypeAliasSymbol instances.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ICppTypeAliasSymbol from "../../../../types/symbols/cpp/ICppTypeAliasSymbol";
+
+class TypeAliasCollector {
+  /**
+   * Collect an alias declaration (using X = Y) and return an ICppTypeAliasSymbol.
+   *
+   * @param aliasDecl The alias declaration context
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional current namespace
+   * @returns The type alias symbol or null if no name
+   */
+  static collect(
+    aliasDecl: any,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+  ): ICppTypeAliasSymbol | null {
+    const identifier = aliasDecl.Identifier?.();
+    if (!identifier) return null;
+
+    const name = identifier.getText();
+
+    return {
+      kind: "type",
+      name,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+    };
+  }
+}
+
+export default TypeAliasCollector;

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

@@ -0,0 +1,54 @@
+/**
+ * VariableCollector - Extracts variable declarations from C++ parse trees.
+ *
+ * Produces ICppVariableSymbol instances.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import ICppVariableSymbol from "../../../../types/symbols/cpp/ICppVariableSymbol";
+import DeclaratorUtils from "../utils/DeclaratorUtils";
+
+class VariableCollector {
+  /**
+   * Collect a variable declaration and return an ICppVariableSymbol.
+   *
+   * @param declarator The declarator context
+   * @param baseType The variable type string
+   * @param sourceFile Source file path
+   * @param line Line number
+   * @param currentNamespace Optional current namespace
+   * @returns The variable symbol or null if no name
+   */
+  static collect(
+    declarator: any,
+    baseType: string,
+    sourceFile: string,
+    line: number,
+    currentNamespace?: string,
+  ): ICppVariableSymbol | null {
+    const name = DeclaratorUtils.extractDeclaratorName(declarator);
+    if (!name) return null;
+
+    const fullName = currentNamespace ? `${currentNamespace}::${name}` : name;
+
+    // Extract array dimensions
+    const arrayDimensions = DeclaratorUtils.extractArrayDimensions(declarator);
+
+    return {
+      kind: "variable",
+      name: fullName,
+      type: baseType,
+      sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: currentNamespace,
+      isArray: arrayDimensions.length > 0 ? true : undefined,
+      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
+    };
+  }
+}
+
+export default VariableCollector;