jslike 1.0.0

package/src/ast/nodes.js

@@ -0,0 +1,236 @@
+// AST Node Constructors
+
+export const Program = (body) => ({
+  type: 'Program',
+  body
+});
+
+export const Literal = (value) => ({
+  type: 'Literal',
+  value
+});
+
+export const Identifier = (name) => ({
+  type: 'Identifier',
+  name
+});
+
+export const BinaryExpression = (operator, left, right) => ({
+  type: 'BinaryExpression',
+  operator,
+  left,
+  right
+});
+
+export const UnaryExpression = (operator, argument, prefix = true) => ({
+  type: 'UnaryExpression',
+  operator,
+  argument,
+  prefix
+});
+
+export const UpdateExpression = (operator, argument, prefix = true) => ({
+  type: 'UpdateExpression',
+  operator,
+  argument,
+  prefix
+});
+
+export const AssignmentExpression = (operator, left, right) => ({
+  type: 'AssignmentExpression',
+  operator,
+  left,
+  right
+});
+
+export const LogicalExpression = (operator, left, right) => ({
+  type: 'LogicalExpression',
+  operator,
+  left,
+  right
+});
+
+export const ConditionalExpression = (test, consequent, alternate) => ({
+  type: 'ConditionalExpression',
+  test,
+  consequent,
+  alternate
+});
+
+export const CallExpression = (callee, args) => ({
+  type: 'CallExpression',
+  callee,
+  arguments: args
+});
+
+export const MemberExpression = (object, property, computed = false) => ({
+  type: 'MemberExpression',
+  object,
+  property,
+  computed
+});
+
+export const ArrayExpression = (elements) => ({
+  type: 'ArrayExpression',
+  elements
+});
+
+export const ObjectExpression = (properties) => ({
+  type: 'ObjectExpression',
+  properties
+});
+
+export const Property = (key, value, shorthand = false) => ({
+  type: 'Property',
+  key,
+  value,
+  shorthand
+});
+
+export const FunctionExpression = (id, params, body) => ({
+  type: 'FunctionExpression',
+  id,
+  params,
+  body
+});
+
+export const ArrowFunctionExpression = (params, body, expression = false) => ({
+  type: 'ArrowFunctionExpression',
+  params,
+  body,
+  expression
+});
+
+export const VariableDeclaration = (kind, declarations) => ({
+  type: 'VariableDeclaration',
+  kind,
+  declarations
+});
+
+export const VariableDeclarator = (id, init = null) => ({
+  type: 'VariableDeclarator',
+  id,
+  init
+});
+
+export const FunctionDeclaration = (id, params, body) => ({
+  type: 'FunctionDeclaration',
+  id,
+  params,
+  body
+});
+
+export const BlockStatement = (body) => ({
+  type: 'BlockStatement',
+  body
+});
+
+export const ExpressionStatement = (expression) => ({
+  type: 'ExpressionStatement',
+  expression
+});
+
+export const ReturnStatement = (argument = null) => ({
+  type: 'ReturnStatement',
+  argument
+});
+
+export const IfStatement = (test, consequent, alternate = null) => ({
+  type: 'IfStatement',
+  test,
+  consequent,
+  alternate
+});
+
+export const WhileStatement = (test, body) => ({
+  type: 'WhileStatement',
+  test,
+  body
+});
+
+export const DoWhileStatement = (body, test) => ({
+  type: 'DoWhileStatement',
+  body,
+  test
+});
+
+export const ForStatement = (init, test, update, body) => ({
+  type: 'ForStatement',
+  init,
+  test,
+  update,
+  body
+});
+
+export const ForInStatement = (left, right, body) => ({
+  type: 'ForInStatement',
+  left,
+  right,
+  body
+});
+
+export const ForOfStatement = (left, right, body) => ({
+  type: 'ForOfStatement',
+  left,
+  right,
+  body
+});
+
+export const BreakStatement = (label = null) => ({
+  type: 'BreakStatement',
+  label
+});
+
+export const ContinueStatement = (label = null) => ({
+  type: 'ContinueStatement',
+  label
+});
+
+export const ThrowStatement = (argument) => ({
+  type: 'ThrowStatement',
+  argument
+});
+
+export const TryStatement = (block, handler = null, finalizer = null) => ({
+  type: 'TryStatement',
+  block,
+  handler,
+  finalizer
+});
+
+export const CatchClause = (param, body) => ({
+  type: 'CatchClause',
+  param,
+  body
+});
+
+export const SwitchStatement = (discriminant, cases) => ({
+  type: 'SwitchStatement',
+  discriminant,
+  cases
+});
+
+export const SwitchCase = (test, consequent) => ({
+  type: 'SwitchCase',
+  test,
+  consequent
+});
+
+export const NewExpression = (callee, args) => ({
+  type: 'NewExpression',
+  callee,
+  arguments: args
+});
+
+export const ThisExpression = () => ({
+  type: 'ThisExpression'
+});
+
+export const SequenceExpression = (expressions) => ({
+  type: 'SequenceExpression',
+  expressions
+});
+
+export const EmptyStatement = () => ({
+  type: 'EmptyStatement'
+});

package/src/cli/wang-run.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+import { readFile } from 'fs/promises';
+import { stdin } from 'process';
+import { execute } from '../index.js';
+
+const args = process.argv.slice(2);
+
+// Parse flags
+const verbose = args.includes('--verbose');
+const quiet = args.includes('--quiet');
+const help = args.includes('--help') || args.includes('-h');
+
+// Filter out flags to get file path
+const filePath = args.find(arg => !arg.startsWith('--') && arg !== '-h');
+
+if (help) {
+  console.log(`
+Wang Language Runtime
+
+Usage:
+  wang-run <file>           Execute a Wang file
+  wang-run -                Read from stdin
+  wang-run --help           Show this help message
+
+Options:
+  --verbose                 Show detailed execution information
+  --quiet                   Suppress extra output
+  -h, --help                Show this help message
+
+Examples:
+  wang-run script.wang
+  echo "console.log('test')" | wang-run -
+  `.trim());
+  process.exit(0);
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function run() {
+  try {
+    let code;
+
+    if (filePath === '-') {
+      // Read from stdin
+      code = await readStdin();
+    } else if (filePath) {
+      // Read from file
+      code = await readFile(filePath, 'utf8');
+    } else {
+      console.error('Error: No input file specified');
+      console.error('Use --help for usage information');
+      process.exit(1);
+    }
+
+    if (verbose) {
+      console.log('🚀 Executing Wang code...');
+    }
+
+    // Execute the code
+    await execute(code);
+
+    if (verbose) {
+      console.log('✅ Execution completed successfully');
+    }
+
+    process.exit(0);
+  } catch (error) {
+    // For file not found errors, show generic error message
+    if (error.code === 'ENOENT') {
+      console.error('Error:', error.message);
+    } else {
+      console.error('❌ Execution failed:');
+      console.error(error.message);
+      if (verbose) {
+        console.error(error.stack);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+run();

package/src/cli/wang-validate.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import { readFile } from 'fs/promises';
+import { stdin } from 'process';
+import { parse } from 'acorn';
+import { preprocessCode, isTopLevelAwait } from '../index.js';
+
+const args = process.argv.slice(2);
+
+// Parse flags
+const showAst = args.includes('--ast');
+const help = args.includes('--help') || args.includes('-h');
+
+// Filter out flags to get file path
+const filePath = args.find(arg => !arg.startsWith('--') && arg !== '-h');
+
+if (help) {
+  console.log(`
+Wang Language Validator
+
+Usage:
+  wang-validate <file>      Validate a Wang file
+  wang-validate -           Read from stdin
+  wang-validate --help      Show this help message
+
+Options:
+  --ast                     Show the Abstract Syntax Tree
+  -h, --help                Show this help message
+
+Examples:
+  wang-validate script.wang
+  echo "let x = 1" | wang-validate -
+  wang-validate script.wang --ast
+  `.trim());
+  process.exit(0);
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function validate() {
+  try {
+    let code;
+
+    if (filePath === '-') {
+      // Read from stdin
+      code = await readStdin();
+    } else if (filePath) {
+      // Read from file
+      code = await readFile(filePath, 'utf8');
+    } else {
+      console.error('Error: No input file specified');
+      console.error('Use --help for usage information');
+      process.exit(1);
+    }
+
+    // Preprocess the code
+    const processedCode = preprocessCode(code);
+    const hasAwait = isTopLevelAwait(processedCode);
+
+    // Parse the code to validate syntax
+    const ast = parse(processedCode, {
+      ecmaVersion: 'latest',
+      sourceType: hasAwait ? 'module' : 'script',
+      locations: true
+    });
+
+    console.log('✅ Valid Wang syntax');
+
+    if (showAst) {
+      console.log('\nAST:');
+      console.log(JSON.stringify(ast, null, 2));
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Invalid Wang syntax:');
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+validate();

package/src/errors/enhanced-error.js

@@ -0,0 +1,124 @@
+/**
+ * Enhanced error classes for better developer experience
+ */
+
+// Simple Levenshtein distance for "did you mean" suggestions
+function levenshteinDistance(a, b) {
+  const matrix = [];
+
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+// Find similar strings for suggestions
+function findSimilar(target, candidates, maxDistance = 3) {
+  const suggestions = [];
+
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(target.toLowerCase(), candidate.toLowerCase());
+    if (distance <= maxDistance && distance > 0) {
+      suggestions.push({ name: candidate, distance });
+    }
+  }
+
+  return suggestions
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, 3)
+    .map(s => s.name);
+}
+
+// Get available methods/properties on an object
+function getAvailableMethods(obj) {
+  if (obj === null || obj === undefined) return [];
+
+  const methods = new Set();
+
+  // Get own properties
+  Object.getOwnPropertyNames(obj).forEach(name => {
+    if (typeof obj[name] === 'function') {
+      methods.add(name);
+    }
+  });
+
+  // Get prototype methods
+  let proto = Object.getPrototypeOf(obj);
+  while (proto && proto !== Object.prototype) {
+    Object.getOwnPropertyNames(proto).forEach(name => {
+      if (typeof proto[name] === 'function' && name !== 'constructor') {
+        methods.add(name);
+      }
+    });
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return Array.from(methods).sort();
+}
+
+export class EnhancedTypeError extends TypeError {
+  constructor(message, context = {}) {
+    super(message);
+    this.name = 'TypeError';
+    this.objectName = context.objectName || 'object';
+    this.methodName = context.methodName || 'method';
+    this.objectValue = context.objectValue;
+    this.availableMethods = context.availableMethods || [];
+    this.suggestions = context.suggestions || [];
+  }
+
+  getFormattedMessage() {
+    let formatted = this.message;
+
+    // Add available methods
+    if (this.availableMethods.length > 0) {
+      const methodList = this.availableMethods.slice(0, 10).join(', ');
+      const more = this.availableMethods.length > 10
+        ? ` (and ${this.availableMethods.length - 10} more)`
+        : '';
+      formatted += `\n\nAvailable methods on '${this.objectName}': ${methodList}${more}`;
+    }
+
+    // Add suggestions
+    if (this.suggestions.length > 0) {
+      formatted += `\n\nDid you mean: ${this.suggestions.join(', ')}?`;
+    }
+
+    return formatted;
+  }
+}
+
+export function createMethodNotFoundError(objectName, methodName, objectValue) {
+  const availableMethods = getAvailableMethods(objectValue);
+  const suggestions = findSimilar(methodName, availableMethods);
+
+  const message = `TypeError when calling method '${methodName}' on object '${objectName}': ` +
+    `Expected: function, Received: undefined`;
+
+  return new EnhancedTypeError(message, {
+    objectName,
+    methodName,
+    objectValue,
+    availableMethods,
+    suggestions
+  });
+}