c-next 0.1.70 → 0.1.72

package/src/transpiler/logic/symbols/cnext/adapters/TSymbolAdapter.ts

@@ -1,345 +0,0 @@
-/**
- * TSymbolAdapter - Converts TSymbol[] to ISymbol[] for backwards compatibility.
- *
- * This adapter bridges the gap between the new composable collectors (which return
- * rich discriminated union types) and the existing Pipeline/SymbolTable infrastructure
- * (which uses flat ISymbol objects).
- *
- * ADR-055 Phase 3: This enables gradual migration without breaking consumers.
- */
-
-import ISymbol from "../../../../../utils/types/ISymbol";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import SymbolTable from "../../SymbolTable";
-import TSymbol from "../../types/TSymbol";
-import IBitmapSymbol from "../../types/IBitmapSymbol";
-import IEnumSymbol from "../../types/IEnumSymbol";
-import IStructSymbol from "../../types/IStructSymbol";
-import IFunctionSymbol from "../../types/IFunctionSymbol";
-import IVariableSymbol from "../../types/IVariableSymbol";
-import IRegisterSymbol from "../../types/IRegisterSymbol";
-import IScopeSymbol from "../../types/IScopeSymbol";
-
-/** Get minimum unsigned type width for a bit count */
-function getMinBitWidth(width: number): number {
-  if (width <= 8) return 8;
-  if (width <= 16) return 16;
-  return 32;
-}
-
-/**
- * Adapts TSymbol[] to ISymbol[] and registers struct fields in SymbolTable.
- */
-class TSymbolAdapter {
-  /**
-   * Convert TSymbol[] to ISymbol[] for backwards compatibility.
-   * Also registers struct fields in SymbolTable.
-   *
-   * @param symbols Array of discriminated union symbols from collectors
-   * @param symbolTable SymbolTable for struct field registration and type resolution
-   * @returns Array of flat ISymbol objects for Pipeline consumption
-   */
-  static toISymbols(symbols: TSymbol[], symbolTable: SymbolTable): ISymbol[] {
-    const result: ISymbol[] = [];
-
-    for (const symbol of symbols) {
-      switch (symbol.kind) {
-        case ESymbolKind.Bitmap:
-          result.push(...TSymbolAdapter.convertBitmap(symbol));
-          break;
-        case ESymbolKind.Enum:
-          result.push(...TSymbolAdapter.convertEnum(symbol));
-          break;
-        case ESymbolKind.Struct:
-          result.push(TSymbolAdapter.convertStruct(symbol, symbolTable));
-          break;
-        case ESymbolKind.Function:
-          result.push(...TSymbolAdapter.convertFunction(symbol));
-          break;
-        case ESymbolKind.Variable:
-          result.push(TSymbolAdapter.convertVariable(symbol));
-          break;
-        case ESymbolKind.Register:
-          result.push(...TSymbolAdapter.convertRegister(symbol));
-          break;
-        case ESymbolKind.Namespace:
-          result.push(TSymbolAdapter.convertScope(symbol));
-          break;
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Convert an array dimension to a string for header generation.
-   * Converts qualified enum access (e.g., "EColor.COUNT") to C-style ("EColor_COUNT").
-   */
-  private static resolveArrayDimension(dim: number | string): string {
-    if (typeof dim === "number") {
-      return String(dim);
-    }
-
-    // Qualified enum access (e.g., "EColor.COUNT") - convert dots to underscores
-    if (dim.includes(".")) {
-      return dim.replaceAll(".", "_");
-    }
-
-    // Pass through as-is (C macros, other identifiers)
-    return dim;
-  }
-
-  /**
-   * Convert IBitmapSymbol to ISymbol + BitmapField symbols.
-   */
-  private static convertBitmap(bitmap: IBitmapSymbol): ISymbol[] {
-    const result: ISymbol[] = [];
-
-    // Main bitmap symbol
-    result.push({
-      name: bitmap.name,
-      kind: ESymbolKind.Bitmap,
-      type: bitmap.backingType,
-      sourceFile: bitmap.sourceFile,
-      sourceLine: bitmap.sourceLine,
-      sourceLanguage: bitmap.sourceLanguage,
-      isExported: bitmap.isExported,
-      parent: bitmap.parent,
-    });
-
-    // Expand fields to BitmapField symbols
-    for (const [fieldName, fieldInfo] of bitmap.fields) {
-      const width = fieldInfo.width;
-      const bitEnd = fieldInfo.offset + width - 1;
-      const bitRange =
-        width === 1
-          ? `bit ${fieldInfo.offset}`
-          : `bits ${fieldInfo.offset}-${bitEnd}`;
-
-      result.push({
-        name: `${bitmap.name}_${fieldName}`,
-        kind: ESymbolKind.BitmapField,
-        type: width === 1 ? "bool" : `u${getMinBitWidth(width)}`,
-        sourceFile: bitmap.sourceFile,
-        sourceLine: bitmap.sourceLine,
-        sourceLanguage: bitmap.sourceLanguage,
-        isExported: bitmap.isExported,
-        parent: bitmap.name,
-        signature: `${bitRange} (${width} bit${width > 1 ? "s" : ""})`,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Convert IEnumSymbol to ISymbol + EnumMember symbols for hover support.
-   */
-  private static convertEnum(enumSym: IEnumSymbol): ISymbol[] {
-    const result: ISymbol[] = [];
-
-    // Main enum symbol
-    result.push({
-      name: enumSym.name,
-      kind: ESymbolKind.Enum,
-      sourceFile: enumSym.sourceFile,
-      sourceLine: enumSym.sourceLine,
-      sourceLanguage: enumSym.sourceLanguage,
-      isExported: enumSym.isExported,
-      parent: enumSym.parent,
-    });
-
-    // Create EnumMember symbols for hover/autocomplete
-    // Note: sourceLine points to the enum declaration — IEnumSymbol.members
-    // is Map<string, number> (name → value) with no per-member line info.
-    for (const [memberName, memberValue] of enumSym.members) {
-      result.push({
-        name: memberName,
-        kind: ESymbolKind.EnumMember,
-        type: String(memberValue),
-        sourceFile: enumSym.sourceFile,
-        sourceLine: enumSym.sourceLine,
-        sourceLanguage: enumSym.sourceLanguage,
-        isExported: enumSym.isExported,
-        parent: enumSym.name,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Convert IStructSymbol to ISymbol and register fields in SymbolTable.
-   */
-  private static convertStruct(
-    struct: IStructSymbol,
-    symbolTable: SymbolTable,
-  ): ISymbol {
-    // Register struct fields in SymbolTable for TypeResolver.isStructType()
-    for (const [fieldName, fieldInfo] of struct.fields) {
-      symbolTable.addStructField(
-        struct.name,
-        fieldName,
-        fieldInfo.type,
-        fieldInfo.dimensions,
-      );
-    }
-
-    return {
-      name: struct.name,
-      kind: ESymbolKind.Struct,
-      sourceFile: struct.sourceFile,
-      sourceLine: struct.sourceLine,
-      sourceLanguage: struct.sourceLanguage,
-      isExported: struct.isExported,
-      parent: struct.parent,
-    };
-  }
-
-  /**
-   * Convert IFunctionSymbol to ISymbol + parameter symbols for hover support.
-   * Converts qualified enum names in parameter array dimensions.
-   */
-  private static convertFunction(func: IFunctionSymbol): ISymbol[] {
-    const result: ISymbol[] = [];
-
-    // Build parameter types for signature
-    const paramTypes = func.parameters.map((p) => p.type);
-    const signature = `${func.returnType} ${func.name}(${paramTypes.join(", ")})`;
-
-    // Build parameter info for header generation
-    const parameters = func.parameters.map((p) => ({
-      name: p.name,
-      type: p.type,
-      isConst: p.isConst,
-      isArray: p.isArray,
-      arrayDimensions: p.arrayDimensions?.map((dim) =>
-        TSymbolAdapter.resolveArrayDimension(dim),
-      ),
-      isAutoConst: p.isAutoConst,
-    }));
-
-    // Main function symbol
-    result.push({
-      name: func.name,
-      kind: ESymbolKind.Function,
-      type: func.returnType,
-      sourceFile: func.sourceFile,
-      sourceLine: func.sourceLine,
-      sourceLanguage: func.sourceLanguage,
-      isExported: func.isExported,
-      parent: func.parent,
-      signature,
-      parameters,
-    });
-
-    // Create parameter symbols for hover support
-    for (const param of func.parameters) {
-      const displayType = param.isArray ? `${param.type}[]` : param.type;
-
-      result.push({
-        name: param.name,
-        kind: ESymbolKind.Variable,
-        type: displayType,
-        sourceFile: func.sourceFile,
-        sourceLine: func.sourceLine,
-        sourceLanguage: func.sourceLanguage,
-        isExported: false,
-        parent: func.name,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Convert IVariableSymbol to ISymbol.
-   * Converts qualified enum names in array dimensions.
-   */
-  private static convertVariable(variable: IVariableSymbol): ISymbol {
-    // Convert dimensions to string dimensions
-    const arrayDimensions = variable.arrayDimensions?.map((dim) =>
-      TSymbolAdapter.resolveArrayDimension(dim),
-    );
-
-    // Get first dimension for legacy size field (only if numeric)
-    const firstDim = variable.arrayDimensions?.[0];
-    const size = typeof firstDim === "number" ? firstDim : undefined;
-
-    const result: ISymbol = {
-      name: variable.name,
-      kind: ESymbolKind.Variable,
-      type: variable.type,
-      sourceFile: variable.sourceFile,
-      sourceLine: variable.sourceLine,
-      sourceLanguage: variable.sourceLanguage,
-      isExported: variable.isExported,
-      parent: variable.parent,
-      isConst: variable.isConst,
-      isAtomic: variable.isAtomic,
-      isArray: variable.isArray,
-      arrayDimensions,
-      size,
-    };
-
-    // Issue #461: Preserve initialValue for const variables (needed for external array dimension resolution)
-    if (variable.initialValue !== undefined) {
-      result.initialValue = variable.initialValue;
-    }
-
-    return result;
-  }
-
-  /**
-   * Convert IRegisterSymbol to ISymbol + RegisterMember symbols.
-   */
-  private static convertRegister(register: IRegisterSymbol): ISymbol[] {
-    const result: ISymbol[] = [];
-
-    // Main register symbol
-    result.push({
-      name: register.name,
-      kind: ESymbolKind.Register,
-      sourceFile: register.sourceFile,
-      sourceLine: register.sourceLine,
-      sourceLanguage: register.sourceLanguage,
-      isExported: register.isExported,
-      parent: register.parent,
-    });
-
-    // Expand members to RegisterMember symbols
-    for (const [memberName, memberInfo] of register.members) {
-      result.push({
-        name: `${register.name}_${memberName}`,
-        kind: ESymbolKind.RegisterMember,
-        type: memberInfo.cType,
-        sourceFile: register.sourceFile,
-        sourceLine: register.sourceLine,
-        sourceLanguage: register.sourceLanguage,
-        isExported: register.isExported,
-        parent: register.name,
-        accessModifier: memberInfo.access,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Convert IScopeSymbol to ISymbol.
-   * Note: Scope members are collected as separate symbols by ScopeCollector,
-   * so we only need to convert the scope itself.
-   */
-  private static convertScope(scope: IScopeSymbol): ISymbol {
-    return {
-      name: scope.name,
-      kind: ESymbolKind.Namespace,
-      sourceFile: scope.sourceFile,
-      sourceLine: scope.sourceLine,
-      sourceLanguage: scope.sourceLanguage,
-      isExported: scope.isExported,
-    };
-  }
-}
-
-export default TSymbolAdapter;

package/src/transpiler/logic/symbols/types/IBaseSymbol.ts

@@ -1,27 +0,0 @@
-import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
-
-/**
- * Common fields shared by all symbol types.
- * Extracted from ISymbol to provide a typed base for discriminated union members.
- */
-interface IBaseSymbol {
-  /** Symbol name (e.g., "LED_toggle", "GPIO7", "Point") */
-  name: string;
-
-  /** Parent scope/namespace name (e.g., "LED" for a member of scope LED) */
-  parent?: string;
-
-  /** Source file where the symbol is defined */
-  sourceFile: string;
-
-  /** Line number in the source file */
-  sourceLine: number;
-
-  /** Source language (CNext, C, Cpp) */
-  sourceLanguage: ESourceLanguage;
-
-  /** Whether this symbol is exported/public */
-  isExported: boolean;
-}
-
-export default IBaseSymbol;

package/src/transpiler/logic/symbols/types/IBitmapSymbol.ts

@@ -1,23 +0,0 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
-import IBitmapFieldInfo from "./IBitmapFieldInfo";
-
-/**
- * Symbol representing a bitmap type definition.
- * Bitmaps provide named access to bit regions within an integer backing type.
- */
-interface IBitmapSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Bitmap;
-
-  /** Backing integer type (e.g., "u8", "u32") */
-  backingType: string;
-
-  /** Total bit width of the bitmap */
-  bitWidth: number;
-
-  /** Map of field name to bit offset/width metadata */
-  fields: Map<string, IBitmapFieldInfo>;
-}
-
-export default IBitmapSymbol;

package/src/transpiler/logic/symbols/types/ICollectorContext.ts

@@ -1,19 +0,0 @@
-/**
- * Context object holding shared state for symbol collection
- */
-
-import ISymbol from "../../../../utils/types/ISymbol";
-import SymbolTable from "../SymbolTable";
-
-interface ICollectorContext {
-  /** Source file path being parsed */
-  sourceFile: string;
-  /** Collected symbols */
-  symbols: ISymbol[];
-  /** Warnings generated during collection */
-  warnings: string[];
-  /** Optional symbol table for struct field registration */
-  symbolTable: SymbolTable | null;
-}
-
-export default ICollectorContext;

package/src/transpiler/logic/symbols/types/IConflict.ts

@@ -1,20 +0,0 @@
-import ISymbol from "../../../../utils/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/transpiler/logic/symbols/types/IFieldInfo.ts

@@ -1,18 +0,0 @@
-/**
- * Metadata for a struct field.
- */
-interface IFieldInfo {
-  /** C-Next type of the field (e.g., "u32", "Point") */
-  type: string;
-
-  /** Whether this field is an array */
-  isArray: boolean;
-
-  /** Array dimensions if isArray is true (e.g., [10, 20]) */
-  dimensions?: number[];
-
-  /** Whether this field is const */
-  isConst: boolean;
-}
-
-export default IFieldInfo;

package/src/transpiler/logic/symbols/types/IFunctionSymbol.ts

@@ -1,25 +0,0 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
-import IParameterInfo from "./IParameterInfo";
-
-/**
- * Symbol representing a function definition or declaration.
- */
-interface IFunctionSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Function;
-
-  /** Return type (e.g., "void", "u32", "Point") */
-  returnType: string;
-
-  /** Function parameters */
-  parameters: IParameterInfo[];
-
-  /** Visibility within a scope */
-  visibility: "public" | "private";
-
-  /** Full signature for overload detection (e.g., "void foo(int, float)") */
-  signature?: string;
-}
-
-export default IFunctionSymbol;

package/src/transpiler/logic/symbols/types/IParameterInfo.ts

@@ -1,24 +0,0 @@
-/**
- * Metadata for a function parameter.
- */
-interface IParameterInfo {
-  /** Parameter name */
-  name: string;
-
-  /** C-Next type (e.g., "u32", "Configuration") */
-  type: string;
-
-  /** Whether this parameter is const */
-  isConst: boolean;
-
-  /** Whether this parameter is an array */
-  isArray: boolean;
-
-  /** Array dimensions if isArray is true (e.g., ["10", "20"] or [""] for unbounded) */
-  arrayDimensions?: string[];
-
-  /** Issue #268: true if parameter should get auto-const (unmodified pointer) */
-  isAutoConst?: boolean;
-}
-
-export default IParameterInfo;

package/src/transpiler/logic/symbols/types/IRegisterSymbol.ts

@@ -1,20 +0,0 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
-import IRegisterMemberInfo from "./IRegisterMemberInfo";
-
-/**
- * Symbol representing a register block definition.
- * Registers provide typed access to memory-mapped I/O locations.
- */
-interface IRegisterSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Register;
-
-  /** Base address expression (as string, e.g., "0x40000000") */
-  baseAddress: string;
-
-  /** Map of member name to register member metadata */
-  members: Map<string, IRegisterMemberInfo>;
-}
-
-export default IRegisterSymbol;

package/src/transpiler/logic/symbols/types/IScopeSymbol.ts

@@ -1,19 +0,0 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
-
-/**
- * Symbol representing a scope (namespace) definition.
- * Scopes group related functions and can control member visibility.
- */
-interface IScopeSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Namespace;
-
-  /** List of member names within this scope */
-  members: string[];
-
-  /** Visibility of each member (public or private) */
-  memberVisibility: Map<string, "public" | "private">;
-}
-
-export default IScopeSymbol;

package/src/transpiler/logic/symbols/types/IStructSymbol.ts

@@ -1,16 +0,0 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
-import IFieldInfo from "./IFieldInfo";
-
-/**
- * Symbol representing a struct type definition.
- */
-interface IStructSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Struct;
-
-  /** Map of field name to field metadata */
-  fields: Map<string, IFieldInfo>;
-}
-
-export default IStructSymbol;

package/src/transpiler/logic/symbols/types/IVariableSymbol.ts

@@ -1,30 +0,0 @@
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import IBaseSymbol from "./IBaseSymbol";
-
-/**
- * Symbol representing a variable (global, static, or extern).
- */
-interface IVariableSymbol extends IBaseSymbol {
-  /** Discriminant for type narrowing */
-  kind: ESymbolKind.Variable;
-
-  /** C-Next type (e.g., "u32", "Point") */
-  type: string;
-
-  /** Whether this variable is const */
-  isConst: boolean;
-
-  /** Issue #468: Whether this variable is atomic (volatile in C) */
-  isAtomic: boolean;
-
-  /** Whether this variable is an array */
-  isArray: boolean;
-
-  /** Array dimensions if isArray is true - numbers for resolved dimensions, strings for macros */
-  arrayDimensions?: (number | string)[];
-
-  /** Initial value expression (as string) */
-  initialValue?: string;
-}
-
-export default IVariableSymbol;

package/src/transpiler/logic/symbols/types/TSymbol.ts

@@ -1,36 +0,0 @@
-import IBitmapSymbol from "./IBitmapSymbol";
-import IEnumSymbol from "./IEnumSymbol";
-import IFunctionSymbol from "./IFunctionSymbol";
-import IRegisterSymbol from "./IRegisterSymbol";
-import IScopeSymbol from "./IScopeSymbol";
-import IStructSymbol from "./IStructSymbol";
-import IVariableSymbol from "./IVariableSymbol";
-
-/**
- * Discriminated union of all symbol types.
- *
- * Use the `kind` field to narrow to a specific symbol type:
- * ```typescript
- * if (symbol.kind === ESymbolKind.Struct) {
- *   // TypeScript knows symbol is IStructSymbol here
- *   for (const [fieldName, fieldInfo] of symbol.fields) { ... }
- * }
- * ```
- *
- * Or use the type guard functions from typeGuards.ts:
- * ```typescript
- * if (isStructSymbol(symbol)) {
- *   // TypeScript knows symbol is IStructSymbol here
- * }
- * ```
- */
-type TSymbol =
-  | IStructSymbol
-  | IEnumSymbol
-  | IBitmapSymbol
-  | IFunctionSymbol
-  | IVariableSymbol
-  | IScopeSymbol
-  | IRegisterSymbol;
-
-export default TSymbol;