c-next 0.1.70 → 0.1.72

package/src/transpiler/types/symbols/cpp/ICppFunctionSymbol.ts

@@ -0,0 +1,21 @@
+import type ICppBaseSymbol from "./ICppBaseSymbol";
+import type ICppParameterInfo from "./ICppParameterInfo";
+
+/**
+ * Symbol representing a C++ function or method.
+ */
+interface ICppFunctionSymbol extends ICppBaseSymbol {
+  /** Discriminator narrowed to "function" */
+  readonly kind: "function";
+
+  /** Return type as string */
+  readonly type: string;
+
+  /** Function parameters */
+  readonly parameters?: ReadonlyArray<ICppParameterInfo>;
+
+  /** Whether this is a declaration vs definition */
+  readonly isDeclaration?: boolean;
+}
+
+export default ICppFunctionSymbol;

package/src/transpiler/types/symbols/cpp/ICppNamespaceSymbol.ts

@@ -0,0 +1,11 @@
+import type ICppBaseSymbol from "./ICppBaseSymbol";
+
+/**
+ * Symbol representing a C++ namespace.
+ */
+interface ICppNamespaceSymbol extends ICppBaseSymbol {
+  /** Discriminator narrowed to "namespace" */
+  readonly kind: "namespace";
+}
+
+export default ICppNamespaceSymbol;

package/src/transpiler/types/symbols/cpp/ICppParameterInfo.ts

@@ -0,0 +1,19 @@
+/**
+ * Parameter info for C++ functions.
+ * Uses simple strings for types since C++ types pass through unchanged.
+ */
+interface ICppParameterInfo {
+  /** Parameter name (may be empty for prototypes) */
+  readonly name: string;
+
+  /** Parameter type as string (e.g., "int", "const std::string&") */
+  readonly type: string;
+
+  /** Whether this parameter is const */
+  readonly isConst: boolean;
+
+  /** Whether this parameter is an array */
+  readonly isArray: boolean;
+}
+
+export default ICppParameterInfo;

package/src/transpiler/types/symbols/cpp/ICppStructSymbol.ts

@@ -0,0 +1,16 @@
+import type ICppBaseSymbol from "./ICppBaseSymbol";
+import type ICppFieldInfo from "./ICppFieldInfo";
+
+/**
+ * Symbol representing a C++ struct type definition.
+ * In C++, structs are very similar to classes but with different default visibility.
+ */
+interface ICppStructSymbol extends ICppBaseSymbol {
+  /** Discriminator narrowed to "struct" */
+  readonly kind: "struct";
+
+  /** Map of field name to field metadata (only populated if SymbolTable was provided) */
+  readonly fields?: ReadonlyMap<string, ICppFieldInfo>;
+}
+
+export default ICppStructSymbol;

package/src/transpiler/types/symbols/cpp/ICppTypeAliasSymbol.ts

@@ -0,0 +1,14 @@
+import type ICppBaseSymbol from "./ICppBaseSymbol";
+
+/**
+ * Symbol representing a C++ type alias (using X = Y).
+ */
+interface ICppTypeAliasSymbol extends ICppBaseSymbol {
+  /** Discriminator narrowed to "type" */
+  readonly kind: "type";
+
+  /** The underlying type being aliased (optional, may not be parsed) */
+  readonly type?: string;
+}
+
+export default ICppTypeAliasSymbol;

package/src/transpiler/types/symbols/cpp/ICppVariableSymbol.ts

@@ -0,0 +1,23 @@
+import type ICppBaseSymbol from "./ICppBaseSymbol";
+
+/**
+ * Symbol representing a C++ variable.
+ */
+interface ICppVariableSymbol extends ICppBaseSymbol {
+  /** Discriminator narrowed to "variable" */
+  readonly kind: "variable";
+
+  /** Variable type as string */
+  readonly type: string;
+
+  /** Whether this variable is const */
+  readonly isConst?: boolean;
+
+  /** Whether this variable is an array */
+  readonly isArray?: boolean;
+
+  /** Array dimensions if this is an array */
+  readonly arrayDimensions?: ReadonlyArray<number | string>;
+}
+
+export default ICppVariableSymbol;

package/src/transpiler/types/symbols/cpp/TCppSymbol.ts

@@ -0,0 +1,30 @@
+import type ICppClassSymbol from "./ICppClassSymbol";
+import type ICppStructSymbol from "./ICppStructSymbol";
+import type ICppNamespaceSymbol from "./ICppNamespaceSymbol";
+import type ICppEnumSymbol from "./ICppEnumSymbol";
+import type ICppEnumMemberSymbol from "./ICppEnumMemberSymbol";
+import type ICppFunctionSymbol from "./ICppFunctionSymbol";
+import type ICppVariableSymbol from "./ICppVariableSymbol";
+import type ICppTypeAliasSymbol from "./ICppTypeAliasSymbol";
+
+/**
+ * Discriminated union of all C++ language symbol types.
+ *
+ * Use the `kind` field to narrow to a specific symbol type:
+ * ```typescript
+ * if (symbol.kind === "class") {
+ *   // TypeScript knows symbol is ICppClassSymbol here
+ * }
+ * ```
+ */
+type TCppSymbol =
+  | ICppClassSymbol
+  | ICppStructSymbol
+  | ICppNamespaceSymbol
+  | ICppEnumSymbol
+  | ICppEnumMemberSymbol
+  | ICppFunctionSymbol
+  | ICppVariableSymbol
+  | ICppTypeAliasSymbol;
+
+export default TCppSymbol;

package/src/utils/CppNamespaceUtils.ts

@@ -11,7 +11,6 @@
 
 import SymbolTable from "../transpiler/logic/symbols/SymbolTable";
 import ESourceLanguage from "./types/ESourceLanguage";
-import ESymbolKind from "./types/ESymbolKind";
 
 /**
  * Static utility methods for C++ namespace operations
@@ -42,9 +41,9 @@ class CppNamespaceUtils {
 
       // C++ namespaces, classes, and enums (enum class) need :: syntax
       if (
-        sym.kind === ESymbolKind.Namespace ||
-        sym.kind === ESymbolKind.Class ||
-        sym.kind === ESymbolKind.Enum
+        sym.kind === "namespace" ||
+        sym.kind === "class" ||
+        sym.kind === "enum"
       ) {
         return true;
       }

package/src/utils/FunctionUtils.ts

@@ -0,0 +1,92 @@
+/**
+ * Factory functions and utilities for IFunctionSymbol.
+ *
+ * Provides utilities for creating, inspecting, and name-mangling C-Next functions.
+ */
+import type IFunctionSymbol from "../transpiler/types/symbols/IFunctionSymbol";
+import type TVisibility from "../transpiler/types/TVisibility";
+import type IScopeSymbol from "../transpiler/types/symbols/IScopeSymbol";
+import type IParameterInfo from "../transpiler/types/symbols/IParameterInfo";
+import type TType from "../transpiler/types/TType";
+import ESourceLanguage from "./types/ESourceLanguage";
+import ScopeUtils from "./ScopeUtils";
+
+/**
+ * Options for creating a function symbol
+ */
+interface IFunctionCreateOptions {
+  name: string;
+  scope: IScopeSymbol;
+  parameters: ReadonlyArray<IParameterInfo>;
+  returnType: TType;
+  visibility: TVisibility;
+  body: unknown;
+  sourceFile: string;
+  sourceLine: number;
+}
+
+class FunctionUtils {
+  // ============================================================================
+  // Factory Functions
+  // ============================================================================
+
+  /**
+   * Create a function symbol with the given properties.
+   *
+   * @param options - Function properties including bare name and scope reference
+   */
+  static create(options: IFunctionCreateOptions): IFunctionSymbol {
+    return {
+      kind: "function",
+      name: options.name,
+      scope: options.scope,
+      parameters: options.parameters,
+      returnType: options.returnType,
+      visibility: options.visibility,
+      body: options.body,
+      sourceFile: options.sourceFile,
+      sourceLine: options.sourceLine,
+      sourceLanguage: ESourceLanguage.CNext,
+      isExported: options.visibility === "public",
+    };
+  }
+
+  // ============================================================================
+  // Name Mangling
+  // ============================================================================
+
+  /**
+   * Get the C-mangled name for a function.
+   *
+   * For global scope functions, returns the bare name.
+   * For scoped functions, returns "Scope_name" (e.g., "Test_fillData").
+   * For nested scopes, returns "Outer_Inner_name".
+   */
+  static getCMangledName(func: IFunctionSymbol): string {
+    const scopePath = ScopeUtils.getScopePath(func.scope);
+    if (scopePath.length === 0) {
+      return func.name;
+    }
+    return `${scopePath.join("_")}_${func.name}`;
+  }
+
+  // ============================================================================
+  // Type Guards and Queries
+  // ============================================================================
+
+  /**
+   * Check if function has public visibility.
+   */
+  static isPublic(func: IFunctionSymbol): boolean {
+    return func.visibility === "public";
+  }
+
+  /**
+   * Check if function is in the global scope.
+   */
+  static isInGlobalScope(func: IFunctionSymbol): boolean {
+    return ScopeUtils.isGlobalScope(func.scope);
+  }
+}
+
+export default FunctionUtils;

package/src/utils/ParameterUtils.ts

@@ -0,0 +1,55 @@
+/**
+ * Factory functions and type guards for IParameterInfo.
+ *
+ * Provides utilities for creating and inspecting C-Next function parameters.
+ */
+import type IParameterInfo from "../transpiler/types/symbols/IParameterInfo";
+import type TType from "../transpiler/types/TType";
+
+class ParameterUtils {
+  // ============================================================================
+  // Factory Functions
+  // ============================================================================
+
+  /**
+   * Create a parameter with the given properties.
+   */
+  static create(options: {
+    name: string;
+    type: TType;
+    isConst: boolean;
+    isArray: boolean;
+    arrayDimensions?: ReadonlyArray<number | string>;
+    isAutoConst?: boolean;
+  }): IParameterInfo {
+    return {
+      name: options.name,
+      type: options.type,
+      isConst: options.isConst,
+      isArray: options.isArray,
+      ...(options.arrayDimensions !== undefined && {
+        arrayDimensions: options.arrayDimensions,
+      }),
+      ...(options.isAutoConst !== undefined && {
+        isAutoConst: options.isAutoConst,
+      }),
+    };
+  }
+
+  // ============================================================================
+  // Type Guards
+  // ============================================================================
+
+  /**
+   * Check if parameter has array dimensions.
+   *
+   * Returns true if arrayDimensions is defined and has at least one dimension.
+   */
+  static isArray(param: IParameterInfo): boolean {
+    return (
+      param.arrayDimensions !== undefined && param.arrayDimensions.length > 0
+    );
+  }
+}
+
+export default ParameterUtils;

package/src/utils/PrimitiveKindUtils.ts

@@ -0,0 +1,33 @@
+import TPrimitiveKind from "../transpiler/types/TPrimitiveKind";
+
+/**
+ * Utility functions for working with C-Next primitive types.
+ */
+class PrimitiveKindUtils {
+  static readonly BIT_WIDTHS: ReadonlyMap<TPrimitiveKind, number> = new Map([
+    ["bool", 1],
+    ["u8", 8],
+    ["i8", 8],
+    ["u16", 16],
+    ["i16", 16],
+    ["u32", 32],
+    ["i32", 32],
+    ["u64", 64],
+    ["i64", 64],
+    ["f32", 32],
+    ["f64", 64],
+  ]);
+
+  static getBitWidth(kind: TPrimitiveKind): number | undefined {
+    return PrimitiveKindUtils.BIT_WIDTHS.get(kind);
+  }
+
+  static isPrimitive(type: string): type is TPrimitiveKind {
+    return (
+      PrimitiveKindUtils.BIT_WIDTHS.has(type as TPrimitiveKind) ||
+      type === "void"
+    );
+  }
+}
+
+export default PrimitiveKindUtils;

package/src/utils/ScopeUtils.ts

@@ -0,0 +1,105 @@
+/**
+ * Factory functions and type guards for IScopeSymbol.
+ *
+ * Provides utilities for creating and inspecting C-Next scopes.
+ */
+import type IScopeSymbol from "../transpiler/types/symbols/IScopeSymbol";
+import ESourceLanguage from "./types/ESourceLanguage";
+
+class ScopeUtils {
+  // ============================================================================
+  // Factory Functions
+  // ============================================================================
+
+  /**
+   * Create the global scope with self-reference parent.
+   *
+   * Global scope has:
+   * - name: "" (empty string)
+   * - parent: points to itself (self-reference)
+   * - scope: points to itself (self-reference)
+   */
+  static createGlobalScope(): IScopeSymbol {
+    // Create a mutable object first to establish self-references
+    const global: IScopeSymbol = {
+      kind: "scope",
+      name: "",
+      parent: null as unknown as IScopeSymbol, // Temporary, will be set below
+      scope: null as unknown as IScopeSymbol, // Temporary, will be set below
+      members: [],
+      functions: [],
+      variables: [],
+      memberVisibility: new Map(),
+      sourceFile: "",
+      sourceLine: 0,
+      sourceLanguage: ESourceLanguage.CNext,
+      isExported: true,
+    };
+    // Set self-references for global scope
+    (global as unknown as { parent: IScopeSymbol }).parent = global;
+    (global as unknown as { scope: IScopeSymbol }).scope = global;
+    return global;
+  }
+
+  /**
+   * Create a named scope with the given parent.
+   *
+   * Named scopes can be nested (e.g., Outer.Inner).
+   */
+  static createScope(name: string, parent: IScopeSymbol): IScopeSymbol {
+    const scope: IScopeSymbol = {
+      kind: "scope",
+      name,
+      parent,
+      scope: parent, // Scope's containing scope is its parent
+      members: [],
+      functions: [],
+      variables: [],
+      memberVisibility: new Map(),
+      sourceFile: "",
+      sourceLine: 0,
+      sourceLanguage: ESourceLanguage.CNext,
+      isExported: true,
+    };
+    return scope;
+  }
+
+  // ============================================================================
+  // Type Guards
+  // ============================================================================
+
+  /**
+   * Check if a scope is the global scope.
+   *
+   * Global scope is identified by:
+   * - Empty name ("")
+   * - Self-referential parent (parent === scope)
+   */
+  static isGlobalScope(scope: IScopeSymbol): boolean {
+    return scope.name === "" && scope.parent === scope;
+  }
+
+  // ============================================================================
+  // Path Utilities
+  // ============================================================================
+
+  /**
+   * Get the scope path from outermost to innermost (excluding global scope).
+   *
+   * For scope "Outer.Inner", returns ["Outer", "Inner"].
+   * For global scope, returns [].
+   */
+  static getScopePath(scope: IScopeSymbol): string[] {
+    const path: string[] = [];
+    let current = scope;
+
+    while (!ScopeUtils.isGlobalScope(current)) {
+      path.unshift(current.name);
+      current = current.parent;
+    }
+
+    return path;
+  }
+}
+
+export default ScopeUtils;

package/src/utils/TTypeUtils.ts

@@ -0,0 +1,159 @@
+/**
+ * Factory functions and type guards for TType.
+ *
+ * Provides utilities for creating and inspecting C-Next types.
+ */
+import type TType from "../transpiler/types/TType";
+import type TPrimitiveKind from "../transpiler/types/TPrimitiveKind";
+
+// Extract variant types from the discriminated union
+type TPrimitiveType = Extract<TType, { kind: "primitive" }>;
+type TStructType = Extract<TType, { kind: "struct" }>;
+type TEnumType = Extract<TType, { kind: "enum" }>;
+type TBitmapType = Extract<TType, { kind: "bitmap" }>;
+type TArrayType = Extract<TType, { kind: "array" }>;
+type TStringType = Extract<TType, { kind: "string" }>;
+type TCallbackType = Extract<TType, { kind: "callback" }>;
+type TRegisterType = Extract<TType, { kind: "register" }>;
+type TExternalType = Extract<TType, { kind: "external" }>;
+
+class TTypeUtils {
+  // ============================================================================
+  // Factory Functions
+  // ============================================================================
+
+  /**
+   * Create a primitive type
+   */
+  static createPrimitive(primitive: TPrimitiveKind): TPrimitiveType {
+    return { kind: "primitive", primitive };
+  }
+
+  /**
+   * Create a struct type reference
+   */
+  static createStruct(name: string): TStructType {
+    return { kind: "struct", name };
+  }
+
+  /**
+   * Create an enum type reference
+   */
+  static createEnum(name: string): TEnumType {
+    return { kind: "enum", name };
+  }
+
+  /**
+   * Create a bitmap type reference
+   */
+  static createBitmap(name: string, bitWidth: number): TBitmapType {
+    return { kind: "bitmap", name, bitWidth };
+  }
+
+  /**
+   * Create an array type
+   */
+  static createArray(
+    elementType: TType,
+    dimensions: ReadonlyArray<number | string>,
+  ): TArrayType {
+    return { kind: "array", elementType, dimensions };
+  }
+
+  /**
+   * Create a string type with capacity
+   */
+  static createString(capacity: number): TStringType {
+    return { kind: "string", capacity };
+  }
+
+  /**
+   * Create a callback type reference
+   */
+  static createCallback(name: string): TCallbackType {
+    return { kind: "callback", name };
+  }
+
+  /**
+   * Create a register type reference
+   */
+  static createRegister(name: string): TRegisterType {
+    return { kind: "register", name };
+  }
+
+  /**
+   * Create an external type (C++ templates, etc.)
+   */
+  static createExternal(name: string): TExternalType {
+    return { kind: "external", name };
+  }
+
+  // ============================================================================
+  // Type Guards
+  // ============================================================================
+
+  /**
+   * Check if type is a primitive
+   */
+  static isPrimitive(t: TType): t is TPrimitiveType {
+    return t.kind === "primitive";
+  }
+
+  /**
+   * Check if type is a struct
+   */
+  static isStruct(t: TType): t is TStructType {
+    return t.kind === "struct";
+  }
+
+  /**
+   * Check if type is an enum
+   */
+  static isEnum(t: TType): t is TEnumType {
+    return t.kind === "enum";
+  }
+
+  /**
+   * Check if type is a bitmap
+   */
+  static isBitmap(t: TType): t is TBitmapType {
+    return t.kind === "bitmap";
+  }
+
+  /**
+   * Check if type is an array
+   */
+  static isArray(t: TType): t is TArrayType {
+    return t.kind === "array";
+  }
+
+  /**
+   * Check if type is a string
+   */
+  static isString(t: TType): t is TStringType {
+    return t.kind === "string";
+  }
+
+  /**
+   * Check if type is a callback
+   */
+  static isCallback(t: TType): t is TCallbackType {
+    return t.kind === "callback";
+  }
+
+  /**
+   * Check if type is a register
+   */
+  static isRegister(t: TType): t is TRegisterType {
+    return t.kind === "register";
+  }
+
+  /**
+   * Check if type is external
+   */
+  static isExternal(t: TType): t is TExternalType {
+    return t.kind === "external";
+  }
+}
+
+export default TTypeUtils;