c-next 0.1.0

package/src/symbols/CppSymbolCollector.ts

@@ -0,0 +1,362 @@
+/**
+ * C++ Symbol Collector
+ * Extracts symbols from C++ parse trees for the unified symbol table
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { CPP14Parser } from "../parser/cpp/grammar/CPP14Parser";
+import ISymbol from "../types/ISymbol";
+import ESymbolKind from "../types/ESymbolKind";
+import ESourceLanguage from "../types/ESourceLanguage";
+
+// Import context types
+type TranslationUnitContext = ReturnType<CPP14Parser["translationUnit"]>;
+
+/**
+ * Collects symbols from a C++ parse tree
+ */
+class CppSymbolCollector {
+  private sourceFile: string;
+
+  private symbols: ISymbol[] = [];
+
+  private currentNamespace: string | undefined;
+
+  constructor(sourceFile: string) {
+    this.sourceFile = sourceFile;
+  }
+
+  /**
+   * Collect all symbols from a C++ translation unit
+   */
+  collect(tree: TranslationUnitContext): ISymbol[] {
+    this.symbols = [];
+    this.currentNamespace = undefined;
+
+    if (!tree) {
+      return this.symbols;
+    }
+
+    const declSeq = tree.declarationseq?.();
+    if (!declSeq) {
+      return this.symbols;
+    }
+
+    for (const decl of declSeq.declaration()) {
+      this.collectDeclaration(decl);
+    }
+
+    return this.symbols;
+  }
+
+  private collectDeclaration(decl: any): void {
+    const line = decl.start?.line ?? 0;
+
+    // Function definition
+    const funcDef = decl.functionDefinition?.();
+    if (funcDef) {
+      this.collectFunctionDefinition(funcDef, line);
+      return;
+    }
+
+    // Namespace definition
+    const nsDef = decl.namespaceDefinition?.();
+    if (nsDef) {
+      this.collectNamespaceDefinition(nsDef, line);
+      return;
+    }
+
+    // Template declaration
+    const templDecl = decl.templateDeclaration?.();
+    if (templDecl) {
+      // Skip template declarations for now - complex to handle
+      return;
+    }
+
+    // Block declaration (simpleDeclaration, etc.)
+    const blockDecl = decl.blockDeclaration?.();
+    if (blockDecl) {
+      this.collectBlockDeclaration(blockDecl, line);
+    }
+  }
+
+  private collectFunctionDefinition(funcDef: any, line: number): void {
+    const declarator = funcDef.declarator?.();
+    if (!declarator) return;
+
+    const name = this.extractDeclaratorName(declarator);
+    if (!name) return;
+
+    // Get return type
+    const declSpecSeq = funcDef.declSpecifierSeq?.();
+    const returnType = declSpecSeq
+      ? this.extractTypeFromDeclSpecSeq(declSpecSeq)
+      : "void";
+
+    const fullName = this.currentNamespace
+      ? `${this.currentNamespace}::${name}`
+      : name;
+
+    this.symbols.push({
+      name: fullName,
+      kind: ESymbolKind.Function,
+      type: returnType,
+      sourceFile: this.sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: this.currentNamespace,
+    });
+  }
+
+  private collectNamespaceDefinition(nsDef: any, line: number): void {
+    const identifier = nsDef.Identifier?.();
+    const originalNs = nsDef.originalNamespaceName?.();
+
+    const name = identifier?.getText() ?? originalNs?.getText();
+    if (!name) return;
+
+    this.symbols.push({
+      name,
+      kind: ESymbolKind.Namespace,
+      sourceFile: this.sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+    });
+
+    // Process namespace body
+    const savedNamespace = this.currentNamespace;
+    this.currentNamespace = this.currentNamespace
+      ? `${this.currentNamespace}::${name}`
+      : name;
+
+    const body = nsDef.declarationseq?.();
+    if (body) {
+      for (const decl of body.declaration()) {
+        this.collectDeclaration(decl);
+      }
+    }
+
+    this.currentNamespace = savedNamespace;
+  }
+
+  private collectBlockDeclaration(blockDecl: any, line: number): void {
+    // Simple declaration (variables, typedefs, class declarations)
+    const simpleDecl = blockDecl.simpleDeclaration?.();
+    if (simpleDecl) {
+      this.collectSimpleDeclaration(simpleDecl, line);
+    }
+
+    // Using declaration
+    const usingDecl = blockDecl.usingDeclaration?.();
+    if (usingDecl) {
+      // Skip using declarations for now
+    }
+
+    // Alias declaration (using X = Y)
+    const aliasDecl = blockDecl.aliasDeclaration?.();
+    if (aliasDecl) {
+      const identifier = aliasDecl.Identifier?.();
+      if (identifier) {
+        this.symbols.push({
+          name: identifier.getText(),
+          kind: ESymbolKind.Type,
+          sourceFile: this.sourceFile,
+          sourceLine: line,
+          sourceLanguage: ESourceLanguage.Cpp,
+          isExported: true,
+          parent: this.currentNamespace,
+        });
+      }
+    }
+  }
+
+  private collectSimpleDeclaration(simpleDecl: any, line: number): void {
+    const declSpecSeq = simpleDecl.declSpecifierSeq?.();
+    if (!declSpecSeq) return;
+
+    const baseType = this.extractTypeFromDeclSpecSeq(declSpecSeq);
+
+    // Check for class specifier
+    for (const spec of declSpecSeq.declSpecifier?.() ?? []) {
+      const typeSpec = spec.typeSpecifier?.();
+      if (typeSpec) {
+        const classSpec = typeSpec.classSpecifier?.();
+        if (classSpec) {
+          this.collectClassSpecifier(classSpec, line);
+        }
+
+        const enumSpec = typeSpec.enumSpecifier?.();
+        if (enumSpec) {
+          this.collectEnumSpecifier(enumSpec, line);
+        }
+      }
+    }
+
+    // Collect declarators (variables, function prototypes)
+    const initDeclList = simpleDecl.initDeclaratorList?.();
+    if (initDeclList) {
+      for (const initDecl of initDeclList.initDeclarator()) {
+        const declarator = initDecl.declarator?.();
+        if (!declarator) continue;
+
+        const name = this.extractDeclaratorName(declarator);
+        if (!name) continue;
+
+        const isFunction = this.declaratorIsFunction(declarator);
+        const fullName = this.currentNamespace
+          ? `${this.currentNamespace}::${name}`
+          : name;
+
+        this.symbols.push({
+          name: fullName,
+          kind: isFunction ? ESymbolKind.Function : ESymbolKind.Variable,
+          type: baseType,
+          sourceFile: this.sourceFile,
+          sourceLine: line,
+          sourceLanguage: ESourceLanguage.Cpp,
+          isExported: true,
+          isDeclaration: isFunction,
+          parent: this.currentNamespace,
+        });
+      }
+    }
+  }
+
+  private collectClassSpecifier(classSpec: any, line: number): void {
+    const classHead = classSpec.classHead?.();
+    if (!classHead) return;
+
+    const classHeadName = classHead.classHeadName?.();
+    if (!classHeadName) return;
+
+    const className = classHeadName.className?.();
+    if (!className) return;
+
+    const identifier = className.Identifier?.();
+    const name = identifier?.getText();
+    if (!name) return;
+
+    const fullName = this.currentNamespace
+      ? `${this.currentNamespace}::${name}`
+      : name;
+
+    this.symbols.push({
+      name: fullName,
+      kind: ESymbolKind.Class,
+      sourceFile: this.sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: this.currentNamespace,
+    });
+  }
+
+  private collectEnumSpecifier(enumSpec: any, line: number): void {
+    const enumHead = enumSpec.enumHead?.();
+    if (!enumHead) return;
+
+    const identifier = enumHead.Identifier?.();
+    if (!identifier) return;
+
+    const name = identifier.getText();
+    const fullName = this.currentNamespace
+      ? `${this.currentNamespace}::${name}`
+      : name;
+
+    this.symbols.push({
+      name: fullName,
+      kind: ESymbolKind.Enum,
+      sourceFile: this.sourceFile,
+      sourceLine: line,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: true,
+      parent: this.currentNamespace,
+    });
+  }
+
+  // Helper methods
+
+  private extractDeclaratorName(declarator: any): string | null {
+    // Pointer declarator -> noPointerDeclarator
+    const ptrDecl = declarator.pointerDeclarator?.();
+    if (ptrDecl) {
+      const noPtr = ptrDecl.noPointerDeclarator?.();
+      if (noPtr) {
+        return this.extractNoPointerDeclaratorName(noPtr);
+      }
+    }
+
+    // No pointer declarator
+    const noPtr = declarator.noPointerDeclarator?.();
+    if (noPtr) {
+      return this.extractNoPointerDeclaratorName(noPtr);
+    }
+
+    return null;
+  }
+
+  private 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 this.extractNoPointerDeclaratorName(innerNoPtr);
+    }
+
+    return null;
+  }
+
+  private 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;
+  }
+
+  private 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";
+  }
+}
+
+export default CppSymbolCollector;

package/src/symbols/SymbolTable.ts

@@ -0,0 +1,312 @@
+/**
+ * Unified Symbol Table
+ * Stores symbols from all source languages and detects conflicts
+ */
+
+import ISymbol from "../types/ISymbol";
+import ESourceLanguage from "../types/ESourceLanguage";
+import IConflict from "./types/IConflict";
+
+/**
+ * Struct field information
+ */
+interface IStructFieldInfo {
+  /** Field type (e.g., "uint32_t", "uint16_t") */
+  type: string;
+  /** Array dimensions if field is an array */
+  arrayDimensions?: number[];
+}
+
+/**
+ * Central symbol table for cross-language interoperability
+ *
+ * Per user requirement: Symbol conflicts between C-Next and C/C++ are ERRORS.
+ * - ERROR: Same symbol defined in C-Next and C/C++
+ * - OK: Multiple `extern` declarations in C (declaration, not definition)
+ * - OK: Function overloads in C++ (different signatures)
+ */
+class SymbolTable {
+  /** All symbols indexed by name */
+  private symbols: Map<string, ISymbol[]> = new Map();
+
+  /** Symbols indexed by source file */
+  private byFile: Map<string, ISymbol[]> = new Map();
+
+  /** Struct field information: struct name -> (field name -> field info) */
+  private structFields: Map<string, Map<string, IStructFieldInfo>> = new Map();
+
+  /**
+   * Add a symbol to the table
+   */
+  addSymbol(symbol: ISymbol): void {
+    // Add to name index
+    const existing = this.symbols.get(symbol.name);
+    if (existing) {
+      existing.push(symbol);
+    } else {
+      this.symbols.set(symbol.name, [symbol]);
+    }
+
+    // Add to file index
+    const fileSymbols = this.byFile.get(symbol.sourceFile);
+    if (fileSymbols) {
+      fileSymbols.push(symbol);
+    } else {
+      this.byFile.set(symbol.sourceFile, [symbol]);
+    }
+  }
+
+  /**
+   * Add multiple symbols at once
+   */
+  addSymbols(symbols: ISymbol[]): void {
+    for (const symbol of symbols) {
+      this.addSymbol(symbol);
+    }
+  }
+
+  /**
+   * Get a symbol by name (returns first match, or undefined)
+   */
+  getSymbol(name: string): ISymbol | undefined {
+    const symbols = this.symbols.get(name);
+    return symbols?.[0];
+  }
+
+  /**
+   * Get all symbols with a given name (for overload detection)
+   */
+  getOverloads(name: string): ISymbol[] {
+    return this.symbols.get(name) ?? [];
+  }
+
+  /**
+   * Check if a symbol exists
+   */
+  hasSymbol(name: string): boolean {
+    return this.symbols.has(name);
+  }
+
+  /**
+   * Check if a symbol has conflicts
+   */
+  hasConflict(name: string): boolean {
+    const symbols = this.symbols.get(name);
+    if (!symbols || symbols.length <= 1) {
+      return false;
+    }
+
+    return this.detectConflict(symbols) !== null;
+  }
+
+  /**
+   * Get all conflicts in the symbol table
+   * Per user requirement: Strict errors for cross-language conflicts
+   */
+  getConflicts(): IConflict[] {
+    const conflicts: IConflict[] = [];
+
+    for (const [, symbols] of this.symbols) {
+      if (symbols.length <= 1) continue;
+
+      const conflict = this.detectConflict(symbols);
+      if (conflict) {
+        conflicts.push(conflict);
+      }
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * Get symbols by source file
+   */
+  getSymbolsByFile(file: string): ISymbol[] {
+    return this.byFile.get(file) ?? [];
+  }
+
+  /**
+   * Get symbols by source language
+   */
+  getSymbolsByLanguage(lang: ESourceLanguage): ISymbol[] {
+    const result: ISymbol[] = [];
+    for (const symbols of this.symbols.values()) {
+      for (const symbol of symbols) {
+        if (symbol.sourceLanguage === lang) {
+          result.push(symbol);
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Get all symbols
+   */
+  getAllSymbols(): ISymbol[] {
+    const result: ISymbol[] = [];
+    for (const symbols of this.symbols.values()) {
+      result.push(...symbols);
+    }
+    return result;
+  }
+
+  /**
+   * Add struct field information
+   * @param structName Name of the struct
+   * @param fieldName Name of the field
+   * @param fieldType Type of the field (e.g., "uint32_t")
+   * @param arrayDimensions Optional array dimensions if field is an array
+   */
+  addStructField(
+    structName: string,
+    fieldName: string,
+    fieldType: string,
+    arrayDimensions?: number[],
+  ): void {
+    let fields = this.structFields.get(structName);
+    if (!fields) {
+      fields = new Map();
+      this.structFields.set(structName, fields);
+    }
+
+    fields.set(fieldName, {
+      type: fieldType,
+      arrayDimensions,
+    });
+  }
+
+  /**
+   * Get struct field type
+   * @param structName Name of the struct
+   * @param fieldName Name of the field
+   * @returns Field type or undefined if not found
+   */
+  getStructFieldType(
+    structName: string,
+    fieldName: string,
+  ): string | undefined {
+    const fields = this.structFields.get(structName);
+    return fields?.get(fieldName)?.type;
+  }
+
+  /**
+   * Get struct field info (type and array dimensions)
+   * @param structName Name of the struct
+   * @param fieldName Name of the field
+   * @returns Field info or undefined if not found
+   */
+  getStructFieldInfo(
+    structName: string,
+    fieldName: string,
+  ): IStructFieldInfo | undefined {
+    const fields = this.structFields.get(structName);
+    return fields?.get(fieldName);
+  }
+
+  /**
+   * Get all fields for a struct
+   * @param structName Name of the struct
+   * @returns Map of field names to field info, or undefined if struct not found
+   */
+  getStructFields(
+    structName: string,
+  ): Map<string, IStructFieldInfo> | undefined {
+    return this.structFields.get(structName);
+  }
+
+  /**
+   * Clear all symbols
+   */
+  clear(): void {
+    this.symbols.clear();
+    this.byFile.clear();
+    this.structFields.clear();
+  }
+
+  /**
+   * Get symbol count
+   */
+  get size(): number {
+    let count = 0;
+    for (const symbols of this.symbols.values()) {
+      count += symbols.length;
+    }
+    return count;
+  }
+
+  /**
+   * Detect if a set of symbols with the same name represents a conflict
+   */
+  private detectConflict(symbols: ISymbol[]): IConflict | null {
+    // Filter out pure declarations (extern in C) - they don't count as definitions
+    const definitions = symbols.filter((s) => !s.isDeclaration);
+
+    if (definitions.length <= 1) {
+      // 0 or 1 definitions = no conflict
+      return null;
+    }
+
+    // Check for C++ function overloads (different signatures are OK)
+    const cppFunctions = definitions.filter(
+      (s) => s.sourceLanguage === ESourceLanguage.Cpp && s.signature,
+    );
+    if (cppFunctions.length === definitions.length) {
+      // All are C++ functions with signatures
+      const uniqueSignatures = new Set(cppFunctions.map((s) => s.signature));
+      if (uniqueSignatures.size === cppFunctions.length) {
+        // All signatures are unique = valid overload, no conflict
+        return null;
+      }
+    }
+
+    // Check for cross-language conflict (C-Next vs C or C++)
+    const cnextDefs = definitions.filter(
+      (s) => s.sourceLanguage === ESourceLanguage.CNext,
+    );
+    const cDefs = definitions.filter(
+      (s) => s.sourceLanguage === ESourceLanguage.C,
+    );
+    const cppDefs = definitions.filter(
+      (s) => s.sourceLanguage === ESourceLanguage.Cpp,
+    );
+
+    if (cnextDefs.length > 0 && (cDefs.length > 0 || cppDefs.length > 0)) {
+      // C-Next + C/C++ conflict = ERROR
+      const locations = definitions.map(
+        (s) =>
+          `${s.sourceLanguage.toUpperCase()} (${s.sourceFile}:${s.sourceLine})`,
+      );
+
+      return {
+        symbolName: definitions[0].name,
+        definitions,
+        severity: "error",
+        message: `Symbol conflict: '${definitions[0].name}' is defined in multiple languages:\n  ${locations.join("\n  ")}\nRename the C-Next symbol to resolve.`,
+      };
+    }
+
+    // Multiple definitions in same language (excluding overloads) = ERROR
+    if (cnextDefs.length > 1) {
+      const locations = cnextDefs.map((s) => `${s.sourceFile}:${s.sourceLine}`);
+      return {
+        symbolName: definitions[0].name,
+        definitions: cnextDefs,
+        severity: "error",
+        message: `Symbol conflict: '${definitions[0].name}' is defined multiple times in C-Next:\n  ${locations.join("\n  ")}`,
+      };
+    }
+
+    // Same symbol in C and C++ - typically OK (same symbol)
+    // But if they have different types, might be a warning
+    if (cDefs.length > 0 && cppDefs.length > 0) {
+      // For now, allow C/C++ to share symbols (common pattern)
+      return null;
+    }
+
+    return null;
+  }
+}
+
+export default SymbolTable;
+export type { IStructFieldInfo };

package/src/symbols/types/IConflict.ts

@@ -0,0 +1,20 @@
+import ISymbol from "../../types/ISymbol";
+
+/**
+ * Represents a symbol conflict between languages
+ */
+interface IConflict {
+  /** The conflicting symbol name */
+  symbolName: string;
+
+  /** All definitions of this symbol */
+  definitions: ISymbol[];
+
+  /** Conflict severity */
+  severity: "error" | "warning";
+
+  /** Human-readable message */
+  message: string;
+}
+
+export default IConflict;

package/src/types/ESourceLanguage.ts

@@ -0,0 +1,10 @@
+/**
+ * Source language of a symbol
+ */
+enum ESourceLanguage {
+  CNext = "cnext",
+  C = "c",
+  Cpp = "cpp",
+}
+
+export default ESourceLanguage;