novac 2.2.0 → 2.2.2

package/novac/src/core/emitter.js

@@ -1,499 +0,0 @@
-const { Parser } = require("./parser.js");
-const { CustomError, formatError } = require("./error.js");
-
-class Emitter {
-  constructor(source) {
-    this.source = source;
-    this.parser = new Parser(source);
-    this.ast = this.parser.parse();
-    this.output = []; // Array of code segments
-    this.indent = 0;
-    this.rawsrc = source;
-  }
-
-  /**
-   * Main entry point to compile the AST to JS code.
-   * @returns {string} The transpiled JavaScript code.
-   */
-  emit() {
-    this.emitProgram(this.ast);
-    return this.output.join("");
-  }
-
-  // --- Utility Methods ---
-
-  indentUp() {
-    this.indent++;
-  }
-
-  indentDown() {
-    this.indent--;
-  }
-
-  line(code = "") {
-    this.output.push("\n");
-    this.output.push("  ".repeat(this.indent));
-    this.output.push(code);
-  }
-
-  // --- AST Node Emitters ---
-
-  emitProgram(node) {
-    this.line("// Transpiled from Nova Language");
-
-    // Wrap the entire transpiled code in an async IIFE
-    // to simulate a simple execution environment.
-    this.line("(async function() {");
-    this.indentUp();
-
-    for (const statement of node.nodes) {
-      this.emitStatement(statement);
-      // Ensure there's a semicolon after every statement (if it wasn't added by the statement emitter)
-      if (this.output.at(-1) !== ";") this.output.push(";");
-    }
-
-    this.indentDown();
-    this.line("})();");
-  }
-
-  emitStatement(node) {
-    if (!node) return;
-
-    switch (node.kind) {
-      case "declare":
-        this.emitDeclaration(node);
-        break;
-      case "branch":
-        this.emitBranch(node);
-        break;
-      case "function":
-        this.emitFunctionDeclaration(node);
-        break;
-      case "class":
-        this.emitClassDeclaration(node);
-        break;
-      case "return":
-        this.emitReturn(node);
-        break;
-      case "throw":
-        this.emitThrow(node);
-        break;
-      case "try":
-        this.emitTry(node);
-        break;
-      case "exec":
-        this.emitExecution(node);
-        break;
-      default:
-        this.error(`Unknown statement kind: ${node.kind}`, node);
-    }
-  }
-
-  emitExpression(node) {
-    if (!node) return;
-
-    switch (node.kind) {
-      case "value":
-        this.emitValue(node);
-        break;
-      case "ref":
-        this.output.push(node.name);
-        break;
-      case "array":
-        this.emitArray(node);
-        break;
-      case "object":
-        this.emitObject(node);
-        break;
-      case "binary":
-        this.emitBinary(node);
-        break;
-      case "unary":
-        this.emitUnary(node);
-        break;
-      case "call":
-        this.emitCall(node);
-        break;
-      case "prop":
-        this.emitPropertyAccess(node);
-        break;
-      case "subscript":
-        this.emitSubscript(node);
-        break;
-      case "assign":
-        this.emitAssignment(node);
-        break;
-      case "postfix":
-        this.emitPostfix(node);
-        break;
-      case "arrowfunc":
-        this.emitArrowFunction(node);
-        break;
-      case "template":
-        this.emitTemplateLiteral(node);
-        break;
-      case "await":
-        this.output.push("await ");
-        this.emitExpression(node.operand);
-        break;
-      default:
-        this.error(`Unknown expression kind: ${node.kind}`, node);
-    }
-  }
-
-  // --- Specific Statement Emitters ---
-
-  emitDeclaration(node) {
-    this.line(`${node.isConst ? "const" : "let"} `);
-
-    // Handle destructuring
-    if (node.destructure) {
-      if (node.destructure.kind === "objpattern") {
-        this.output.push("{");
-        node.destructure.props.forEach(({ key, alias }, i) => {
-          this.output.push(key);
-          if (key !== alias) this.output.push(`: ${alias}`);
-          if (i < node.destructure.props.length - 1) this.output.push(", ");
-        });
-        this.output.push("}");
-      } else if (node.destructure.kind === "arrpattern") {
-        this.output.push("[");
-        node.destructure.elements.forEach((name, i) => {
-          this.output.push(name);
-          if (i < node.destructure.elements.length - 1) this.output.push(", ");
-        });
-        this.output.push("]");
-      }
-    } else {
-      // Normal declaration
-      this.output.push(node.name);
-    }
-
-    if (node.value) {
-      this.output.push(" = ");
-      this.emitExpression(node.value);
-    }
-    this.output.push(";");
-  }
-
-  emitBranch(node) {
-    let current = node;
-
-    while (current) {
-      this.line(); // New line for the block structure
-
-      switch (current.type) {
-        case "if":
-        case "unless": // In Nova, 'unless' is a branch, but in JS it's '!condition'
-          this.output.push(current.type === "if" ? "if (" : "if (!(");
-          this.emitExpression(current.args);
-          this.output.push(current.type === "if" ? ") " : ")) ");
-          this.emitBlock(current.body);
-          break;
-        case "else":
-          this.output.push("else ");
-          this.emitBlock(current.body);
-          break;
-        case "while":
-        case "until": // In Nova, 'until' is a loop, in JS it's 'while (!condition)'
-          this.output.push(current.type === "while" ? "while (" : "while (!(");
-          this.emitExpression(current.args[0]);
-          this.output.push(current.type === "while" ? ") " : ")) ");
-          this.emitBlock(current.body);
-          break;
-        case "do":
-          this.output.push("do ");
-          this.emitBlock(current.body);
-          this.line(`while (`);
-          this.emitExpression(current.args[0]);
-          this.output.push(");");
-          break;
-        case "repeat":
-          // Transpile 'repeat (N) { ... }' to a 'for' loop
-          const countName = `_i_${node.line}_${node.column}`;
-          this.output.push(`for (let ${countName} = 0; ${countName} < `);
-          this.emitExpression(current.args[0]);
-          this.output.push(`; ${countName}++) `);
-          this.emitBlock(current.body);
-          break;
-        case "for":
-          // for loops: args = [init, condition, update]
-          const [initNode, condNode, updateNode] = current.args;
-          this.output.push("for (");
-          this.emitStatement(initNode); // Emits with 'let/const' and ';'
-          this.output.push(" ");
-
-          if (condNode) this.emitExpression(condNode); // Condition
-          this.output.push("; ");
-
-          // Update statement: We only want the expression part, no 'let/var' or ';'
-          if (updateNode) {
-            const temp = this.output;
-            this.output = [];
-            this.emitStatement(updateNode);
-            const updateExpr = this.output.join("").replace(/;$/, "").trim();
-            this.output = temp;
-            this.output.push(updateExpr);
-          }
-          this.output.push(") ");
-          this.emitBlock(current.body);
-          break;
-        default:
-          this.error(`Unknown branch type '${current.type}'`, node);
-      }
-
-      // Handle chaining (e.g., else if, else)
-      if (current.next && current.next.type !== "else") {
-        this.output.push(" else ");
-      }
-      current = current.next;
-    }
-  }
-
-  emitBlock(body) {
-    this.output.push("{");
-    this.indentUp();
-    for (const stmt of body) {
-      this.emitStatement(stmt);
-      if (this.output.at(-1) !== ";") this.output.push(";");
-    }
-    this.indentDown();
-    this.line("}");
-  }
-
-  emitFunctionDeclaration(node) {
-    // If it's an 'async' function, add the keyword.
-    this.line(
-      `${node.isAsync ? "async " : ""}function ${node.name}(${node.args.join(", ")}) `,
-    );
-    this.emitBlock(node.body);
-  }
-
-  emitClassDeclaration(node) {
-    this.line(`class ${node.name}`);
-
-    if (node.superClass) {
-      this.output.push(" extends ");
-      this.emitExpression(node.superClass); // superClass is a 'ref' node
-    }
-
-    this.output.push(" {");
-    this.indentUp();
-
-    // Find constructor (if defined as a method)
-    const constructorMethod = node.members.find(
-      (m) => m.name === "constructor",
-    );
-    if (constructorMethod) {
-      this.line(`constructor(${constructorMethod.args.join(", ")}) {`);
-      this.indentUp();
-
-      // Handle 'super' call if extending
-      if (node.superClass) {
-        this.line("super(...arguments);");
-      }
-
-      // Emit constructor body
-      for (const stmt of constructorMethod.body) {
-        this.emitStatement(stmt);
-      }
-
-      this.indentDown();
-      this.line("}");
-    } else if (node.superClass) {
-      // Nova requires an explicit constructor for 'super' (or implicit no-arg call in JS)
-      // For simplicity in transpilation, we add a base constructor if extending.
-      this.line(`constructor(...args) { super(...args); }`);
-    }
-
-    // Emit all other members
-    for (const member of node.members) {
-      if (member.name === "constructor") continue; // Skip if handled above
-
-      if (member.kind === "function") {
-        this.line(`  ${member.name}(${member.args.join(", ")}) {`);
-        this.indentUp();
-        for (const stmt of member.body) {
-          this.emitStatement(stmt);
-        }
-        this.indentDown();
-        this.line("  }");
-      } else if (member.kind === "declare") {
-        // Simple property declaration (will be initialized in the constructor for full ES5/ES6 compatibility)
-        // For ES2022+ property support, you could use: this.line(`${member.name} = `); this.emitExpression(member.value); this.output.push(';');
-        // For simplicity, we'll assume the executor handles field initialization. For a pure JS target, we emit nothing here.
-      }
-    }
-
-    this.indentDown();
-    this.line("}");
-  }
-
-  emitReturn(node) {
-    this.line(node.terminate ? "return " : "return ");
-    if (node.value) this.emitExpression(node.value);
-    this.output.push(";");
-  }
-
-  emitThrow(node) {
-    this.line("throw ");
-    this.emitExpression(node.value);
-    this.output.push(";");
-  }
-
-  emitTry(node) {
-    this.line("try ");
-    this.emitBlock(node.tryBody);
-
-    if (node.catchBody) {
-      this.line(`catch (${node.catchName}) `);
-      this.emitBlock(node.catchBody);
-    }
-
-    if (node.finallyBody) {
-      this.line("finally ");
-      this.emitBlock(node.finallyBody);
-    }
-  }
-
-  emitExecution(node) {
-    this.line();
-    this.emitExpression(node.expr);
-    this.output.push(";");
-  }
-
-  // --- Specific Expression Emitters ---
-
-  emitValue(node) {
-    const val = node.value;
-    switch (typeof val) {
-      case "number":
-        this.output.push(val);
-        break;
-      case "string":
-        this.output.push(`"${val}"`);
-        break;
-      case "symbol":
-        // Map Nova literals to JS literals
-        if (val.toString() === "Symbol(NOVA_TRUE)") this.output.push("true");
-        else if (val.toString() === "Symbol(NOVA_FALSE)")
-          this.output.push("false");
-        else if (val.toString() === "Symbol(NOVA_NULL)")
-          this.output.push("null");
-        else this.error(`Unknown literal symbol: ${val.toString()}`, node);
-        break;
-      default:
-        this.error(`Unknown value type: ${typeof val}`, node);
-    }
-  }
-
-  emitTemplateLiteral(node) {
-    // Use standard JS template literal syntax: backticks and ${} for expressions
-    this.output.push("`");
-    for (const part of node.parts) {
-      if (part.kind === "value" && typeof part.value === "string") {
-        this.output.push(part.value);
-      } else {
-        this.output.push("${");
-        this.emitExpression(part);
-        this.output.push("}");
-      }
-    }
-    this.output.push("`");
-  }
-
-  emitArray(node) {
-    this.output.push("[");
-    node.elements.forEach((el, i) => {
-      this.emitExpression(el);
-      if (i < node.elements.length - 1) this.output.push(", ");
-    });
-    this.output.push("]");
-  }
-
-  emitObject(node) {
-    this.output.push("{");
-    const props = Object.entries(node.props);
-    props.forEach(([key, value], i) => {
-      this.output.push(`${key}: `);
-      this.emitExpression(value);
-      if (i < props.length - 1) this.output.push(", ");
-    });
-    this.output.push("}");
-  }
-
-  emitBinary(node) {
-    this.output.push("(");
-    this.emitExpression(node.left);
-    this.output.push(` ${node.operator} `);
-    this.emitExpression(node.right);
-    this.output.push(")");
-  }
-
-  emitUnary(node) {
-    this.output.push(node.operator);
-    this.emitExpression(node.operand);
-  }
-
-  emitCall(node) {
-    if (typeof node.name === "string") {
-      this.output.push(node.name);
-    } else {
-      this.emitExpression(node.name); // Handles prop/subscript calls
-    }
-    this.output.push("(");
-    node.args.forEach((arg, i) => {
-      this.emitExpression(arg);
-      if (i < node.args.length - 1) this.output.push(", ");
-    });
-    this.output.push(")");
-  }
-
-  emitPropertyAccess(node) {
-    this.emitExpression(node.object);
-    this.output.push(`.${node.name}`);
-  }
-
-  emitSubscript(node) {
-    this.emitExpression(node.object);
-    this.output.push("[");
-    this.emitExpression(node.index);
-    this.output.push("]");
-  }
-
-  emitAssignment(node) {
-    this.emitExpression(node.name); // LHS: ref, prop, or subscript node
-    this.output.push(` = `);
-    this.emitExpression(node.value);
-  }
-
-  emitPostfix(node) {
-    this.emitExpression(node.operand);
-    this.output.push(node.operator);
-  }
-
-  emitArrowFunction(node) {
-    this.output.push(`(${node.args.join(", ")}) => `);
-    // If the body is a single return statement, use concise body
-    const isConcise =
-      node.body.length === 1 &&
-      node.body[0].kind === "return" &&
-      node.body[0].terminate;
-
-    if (isConcise) {
-      this.emitExpression(node.body[0].value);
-    } else {
-      this.emitBlock(node.body);
-    }
-  }
-
-  // --- Error Handling ---
-
-  error(msg, node) {
-    throw new (CustomError("EmitterError"))(
-      formatError("EmitterError", msg, node.line, node.column, this.rawsrc),
-    );
-  }
-}
-
-module.exports = { Emitter };

package/novac/src/core/error.js

@@ -1,86 +0,0 @@
-// ===== error.js =====
-const RESERVED_WORDS = new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "export",
-  "extends",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield",
-  "let",
-  "enum",
-  "await",
-  "implements",
-  "package",
-  "protected",
-  "static",
-  "interface",
-  "private",
-  "public",
-  "null",
-  "true",
-  "false",
-]);
-
-function sanitizeName(name) {
-  let sanitized = name.replace(/[^a-zA-Z0-9_$]/g, "");
-  if (!/^[a-zA-Z_$]/.test(sanitized)) sanitized = "_" + sanitized;
-  if (RESERVED_WORDS.has(sanitized)) sanitized += "_";
-  return sanitized || "_CustomError";
-}
-
-function CustomError(name) {
-  const safeName = sanitizeName(name);
-  return eval(`
-    (class ${safeName} extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "${safeName}";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, this.constructor);
-        }
-      }
-    })
-  `);
-}
-
-let NovaException = CustomError("Exception");
-
-// 🔥 new addition — shared formatter
-function formatError(kind, msg, line, column, rawsrc) {
-  const lineText = rawsrc.split("\n")[line - 1] ?? "";
-  return (
-    `[Nova${kind} ${line}:${column}] ${msg}\n` +
-    ` error at:\n` +
-    ` ${lineText}\n` +
-    ` ${" ".repeat(Math.max(column - 1, 0))}^^`
-  );
-}
-
-module.exports = { CustomError, formatError, NovaException };