novac 1.0.0

package/src/core/emitter.js

@@ -0,0 +1,499 @@
+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/src/core/error.js

@@ -0,0 +1,86 @@
+// ===== 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 };