stone-lang 0.1.0

package/frontend/utils/errorCollector.js

@@ -0,0 +1,244 @@
+/**
+ * Stone Engine - Unified Error Collector
+ *
+ * Provides consistent error handling across all compiler phases:
+ * - Parse (lexer, parser)
+ * - Type check
+ * - Compile (bytecode generation)
+ * - Runtime (VM execution)
+ *
+ * Features:
+ * - Consistent error/warning format with severity, message, location, and phase
+ * - Error codes for programmatic error handling
+ * - Merge support for combining errors from multiple phases
+ * - Formatted output for display
+ */
+
+/**
+ * Represents a collected error or warning
+ * @typedef {Object} CollectedError
+ * @property {'error' | 'warning'} severity - Error severity
+ * @property {string} message - Human-readable error message
+ * @property {Object} [location] - Source location
+ * @property {number} [location.line] - Line number (1-indexed)
+ * @property {number} [location.column] - Column number (1-indexed)
+ * @property {string} phase - Compiler phase that generated the error
+ * @property {string} [code] - Optional error code (e.g., 'E001')
+ */
+
+/**
+ * Unified error collector for Stone compiler phases
+ */
+export class ErrorCollector {
+  /**
+   * Create an error collector
+   * @param {Object} options - Configuration options
+   * @param {string} [options.phase='unknown'] - Compiler phase name
+   */
+  constructor(options = {}) {
+    this.phase = options.phase || 'unknown';
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  /**
+   * Add an error
+   * @param {string} message - Error message
+   * @param {Object} [location] - Source location
+   * @param {string} [code] - Optional error code
+   */
+  addError(message, location = null, code = null) {
+    this.errors.push({
+      severity: 'error',
+      message,
+      location,
+      phase: this.phase,
+      code,
+    });
+  }
+
+  /**
+   * Add a warning
+   * @param {string} message - Warning message
+   * @param {Object} [location] - Source location
+   * @param {string} [code] - Optional warning code
+   */
+  addWarning(message, location = null, code = null) {
+    this.warnings.push({
+      severity: 'warning',
+      message,
+      location,
+      phase: this.phase,
+      code,
+    });
+  }
+
+  /**
+   * Check if there are any errors
+   * @returns {boolean} True if there are errors
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+
+  /**
+   * Check if there are any warnings
+   * @returns {boolean} True if there are warnings
+   */
+  hasWarnings() {
+    return this.warnings.length > 0;
+  }
+
+  /**
+   * Get all errors and warnings combined
+   * @returns {CollectedError[]} All collected errors and warnings
+   */
+  getAll() {
+    return [...this.errors, ...this.warnings];
+  }
+
+  /**
+   * Merge errors and warnings from another collector
+   * @param {ErrorCollector} other - Another error collector
+   */
+  merge(other) {
+    if (other) {
+      this.errors.push(...other.errors);
+      this.warnings.push(...other.warnings);
+    }
+  }
+
+  /**
+   * Clear all errors and warnings
+   */
+  clear() {
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  /**
+   * Format a single error for display
+   * @param {CollectedError} err - Error to format
+   * @returns {string} Formatted error string
+   */
+  formatError(err) {
+    const loc = err.location
+      ? `[${err.location.line}:${err.location.column}] `
+      : '';
+    const code = err.code ? `${err.code}: ` : '';
+    return `${err.phase}: ${loc}${code}${err.message}`;
+  }
+
+  /**
+   * Format all errors for display
+   * @param {Object} options - Format options
+   * @param {boolean} [options.includeWarnings=true] - Include warnings in output
+   * @returns {string} Formatted error messages
+   */
+  format(options = {}) {
+    const { includeWarnings = true } = options;
+
+    const items = includeWarnings ? this.getAll() : this.errors;
+    return items.map(err => this.formatError(err)).join('\n');
+  }
+
+  /**
+   * Format errors as structured objects (for JSON output)
+   * @returns {Object} Structured error output
+   */
+  toJSON() {
+    return {
+      hasErrors: this.hasErrors(),
+      hasWarnings: this.hasWarnings(),
+      errors: this.errors,
+      warnings: this.warnings,
+    };
+  }
+
+  /**
+   * Create a child collector for a sub-phase
+   * @param {string} subPhase - Sub-phase name (will be appended to current phase)
+   * @returns {ErrorCollector} New error collector
+   */
+  createChild(subPhase) {
+    return new ErrorCollector({
+      phase: `${this.phase}/${subPhase}`,
+    });
+  }
+}
+
+/**
+ * Standard error codes for Stone compiler errors
+ */
+export const ErrorCodes = {
+  // Parse errors (P001-P099)
+  PARSE_UNEXPECTED_TOKEN: 'P001',
+  PARSE_UNTERMINATED_STRING: 'P002',
+  PARSE_INVALID_NUMBER: 'P003',
+
+  // Type errors (T001-T099)
+  TYPE_MISMATCH: 'T001',
+  TYPE_UNDEFINED_VARIABLE: 'T002',
+  TYPE_UNDEFINED_FUNCTION: 'T003',
+  TYPE_WRONG_ARITY: 'T004',
+  TYPE_NO_MATCHING_OVERLOAD: 'T005',
+
+  // Compile errors (C001-C099)
+  COMPILE_UNDEFINED_VARIABLE: 'C001',
+  COMPILE_UNKNOWN_OPERATOR: 'C002',
+  COMPILE_INVALID_ASSIGNMENT: 'C003',
+
+  // Runtime errors (R001-R099)
+  RUNTIME_DIVISION_BY_ZERO: 'R001',
+  RUNTIME_INDEX_OUT_OF_BOUNDS: 'R002',
+  RUNTIME_STACK_OVERFLOW: 'R003',
+  RUNTIME_ITERATION_LIMIT: 'R004',
+  RUNTIME_TIMEOUT: 'R005',
+  RUNTIME_UNDEFINED_PROPERTY: 'R006',
+  RUNTIME_UNDEFINED_METHOD: 'R007',
+  RUNTIME_NULL_REFERENCE: 'R008',
+  RUNTIME_NOT_CALLABLE: 'R009',
+};
+
+/**
+ * Helper to get a human-readable type name for Stone values
+ * @param {any} value - The value to get the type of
+ * @returns {string} Human-readable type name
+ */
+export function getStoneTypeName(value) {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+
+  // Check for Stone-specific types first
+  if (value._type === 'StoneArray') {
+    const elemType = value.elementType || 'num';
+    const rank = value.rank || 1;
+    return `array<${elemType}, ${rank}>`;
+  }
+  if (value._type === 'Complex' || (value.real !== undefined && value.imag !== undefined && typeof value.real === 'number')) {
+    return 'complex';
+  }
+
+  // Standard JavaScript types
+  if (Array.isArray(value)) {
+    if (value.length === 0) return 'array (empty)';
+    const firstType = typeof value[0];
+    return `array<${firstType}>`;
+  }
+  if (typeof value === 'object') {
+    // Check if it's a plain object (record)
+    const keys = Object.keys(value);
+    if (keys.length === 0) return 'object (empty)';
+    if (keys.length <= 3) {
+      return `{ ${keys.join(', ')} }`;
+    }
+    return `{ ${keys.slice(0, 3).join(', ')}, ... }`;
+  }
+  if (typeof value === 'function') {
+    return value.name ? `function ${value.name}` : 'function';
+  }
+
+  return typeof value;
+}
+
+export default ErrorCollector;

package/frontend/utils/index.js

@@ -0,0 +1,5 @@
+/**
+ * Frontend Utils - Barrel exports
+ */
+export { ModuleResolver, createModuleResolver } from './moduleResolver.js';
+export { ErrorCollector, ErrorCodes } from './errorCollector.js';