novac 1.0.0

package/src/core/parser.js

@@ -0,0 +1,762 @@
+/**
+ * Nova Parser (CommonJS)
+ * -----------------------
+ * Generates Nova-style AST with full expression support.
+ */
+const { Lexer } = require("./lexer");
+const { CustomError } = require("./error");
+
+// Operator precedence map
+const PRECEDENCE = {
+  "||": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  "<": 4,
+  "<=": 4,
+  ">": 4,
+  ">=": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6,
+  "%": 6,
+};
+
+class Parser {
+  constructor(source) {
+    this.tokens = new Lexer(source).tokenize();
+    this.rawsrc = source;
+    this.current = 0;
+    this.symbols = new Map();
+  }
+
+  parse() {
+    const nodes = [];
+    while (!this.isAtEnd()) {
+      const node = this.statement();
+      if (node) nodes.push(node);
+    }
+    return { kind: "program", nodes };
+  }
+
+  nd(obj) {
+    let token = this.peek();
+    return {
+      ...obj,
+      line: token.line ?? 0,
+      column: token.column ?? 0,
+    };
+  }
+
+  // ─────────────── Statements ───────────────
+  statement() {
+    if (this.match("KEYWORD", "class")) return this.classDeclaration();
+    if (this.match("KEYWORD", "const")) return this.varDeclaration(true);
+    if (this.match("KEYWORD", "var") || this.match("KEYWORD", "let"))
+      return this.varDeclaration();
+    if (this.match("KEYWORD", "func")) return this.funcDeclaration(true);
+    if (this.match("KEYWORD", "if")) return this.branchBody("if");
+    if (this.match("KEYWORD", "while")) return this.branchBody("while");
+    if (this.match("KEYWORD", "repeat")) return this.branchBody("repeat");
+    if (this.match("KEYWORD", "do")) return this.branchBody("do");
+    if (this.match("KEYWORD", "until")) return this.branchBody("until");
+    if (this.match("KEYWORD", "unless")) return this.branchBody("unless");
+    if (this.match("KEYWORD", "for")) return this.branchBody("for", ";");
+    if (this.match("KEYWORD", "function")) return this.funcDeclaration();
+    if (this.match("KEYWORD", "return")) return this.returnStatement(false);
+    if (this.match("KEYWORD", "give")) return this.returnStatement(true);
+    if (this.match("KEYWORD", "throw")) return this.throwStatement();
+    if (this.match("KEYWORD", "try")) return this.tryStatement();
+    if (this.match("PUNCTUATION", "{")) return this.blockBody(true);
+    return this.expressionStatement();
+  }
+
+templateLiteral() {
+  this.consume("TEMPLATE_START", "Expected start of template literal");
+
+  const parts = [];
+
+  while (!this.check("TEMPLATE_END") && !this.isAtEnd()) {
+    // Raw text part
+    if (this.match("STRING_PART")) {
+      parts.push({
+        type: "Literal",
+        value: this.previous().value,
+      });
+      continue;
+    }
+
+    // Interpolation section
+    if (this.match("INTERPOLATION_START")) {
+      const expr = this.expression();
+
+      // Expect matching INTERPOLATION_END now (old parser expected raw '}')
+      this.consume(
+        "INTERPOLATION_END",
+        "Expected '}' after expression in template literal"
+      );
+
+      parts.push(expr);
+      continue;
+    }
+
+    // Safety net for unexpected stuff
+    this.error(
+      `Unexpected token '${this.peek().value}' in template literal`
+    );
+  }
+
+  // Closing backtick
+  this.consume("TEMPLATE_END", "Unterminated template literal");
+
+  return {
+    type: "TemplateLiteral",
+    parts,
+  };
+}
+
+  throwStatement() {
+    const value = this.expression();
+    this.match("PUNCTUATION", ";");
+    return this.nd({ kind: "throw", value });
+  }
+
+  tryStatement() {
+    const tryBody = this.blockBody();
+    let catchBody = null;
+    let catchName = null;
+    let finallyBody = null;
+
+    if (this.match("KEYWORD", "catch")) {
+      this.consume("PUNCTUATION", "(", "Expected '(' for catch block");
+      catchName = this.consume(
+        "IDENTIFIER",
+        "Expected catch variable name",
+      ).value;
+      this.consume("PUNCTUATION", ")", "Expected ')' for catch block");
+      catchBody = this.blockBody();
+    }
+
+    if (this.match("KEYWORD", "finally")) {
+      finallyBody = this.blockBody();
+    }
+
+    if (!catchBody && !finallyBody) {
+      this.error("Try block must be followed by catch or finally");
+    }
+
+    return this.nd({
+      kind: "try",
+      tryBody,
+      catchBody,
+      catchName,
+      finallyBody,
+    });
+  }
+
+  varDeclaration(isConst) {
+    let nameNode = null;
+    let destructure = null;
+    let isPointer = false;
+    if (this.match("OPERATOR", "*")) {
+      // 🔥 NEW/MODIFIED CHECK
+      isPointer = true;
+    }
+
+    // check destructuring pattern
+    if (this.check("PUNCTUATION", "{")) {
+      destructure = this.objectPattern();
+    } else if (this.check("PUNCTUATION", "[")) {
+      destructure = this.arrayPattern();
+    } else {
+  nameNode = this.consume("IDENTIFIER", "Expected variable name");
+
+  // 🔥 NEW: Check for explicit type annotation (e.g. let x: int)
+  let explicitType = null;
+  if (this.match("PUNCTUATION", ":")) {
+    explicitType = this.consume("IDENTIFIER", "Expected type name after ':'").value;
+  }
+
+  // 🔥 Attach to nameNode
+  nameNode = { ...nameNode, typeAnnotation: explicitType };
+}
+
+    let value = null;
+    if (this.match("OPERATOR", "=")) {
+      value = this.expression();
+    }
+
+    this.match("PUNCTUATION", ";");
+
+    if (destructure) {
+      return this.nd({
+        kind: "declare",
+        destructure,
+        value,
+        isConst,
+        isPointer,
+      });
+    }
+
+// 🧩 Store declared variable type in the symbol table
+if (nameNode.value) {
+  this.symbols.set(nameNode.value, {
+    type: nameNode.typeAnnotation || null,
+    isConst,
+  });
+}
+
+// ✅ Parse-time type validation for explicit types
+if (nameNode.typeAnnotation && value?.kind === "value") {
+  const val = value.value;
+  let inferredType;
+
+  if (typeof val === "number") {
+    inferredType = Number.isInteger(val) ? "int" : "float";
+  } else if (typeof val === "string") {
+    inferredType = "string";
+  } else if (typeof val === "boolean") {
+    inferredType = "bool";
+  } else if (typeof val === "object") {
+    inferredType = "obj";
+  } else {
+    inferredType = typeof val;
+  }
+
+  if (inferredType !== nameNode.typeAnnotation) {
+    this.error(
+      `[Type mismatch] '${nameNode.value}' expected '${nameNode.typeAnnotation}', got '${inferredType}'`,
+      this.peek()
+    );
+  }
+}
+
+return this.nd({
+  kind: "declare",
+  name: nameNode.value,
+  value,
+  isConst,
+  isPointer,
+  explicitType: nameNode.typeAnnotation || null,  // ← new line
+});
+  }
+
+  objectPattern() {
+    this.consume("PUNCTUATION", "{", "Expected '{' in destructuring");
+    const props = [];
+    if (!this.check("PUNCTUATION", "}")) {
+      do {
+        const key = this.consume("IDENTIFIER", "Expected property name").value;
+        let alias = key;
+        if (this.match("PUNCTUATION", ":")) {
+          alias = this.consume("IDENTIFIER", "Expected alias name").value;
+        }
+        props.push({ key, alias });
+      } while (this.match("PUNCTUATION", ","));
+    }
+    this.consume("PUNCTUATION", "}", "Expected '}'");
+    return { kind: "objpattern", props };
+  }
+
+  arrayPattern(Consumed) {
+    if (!Consumed)
+      this.consume("PUNCTUATION", "[", "Expected '[' in destructuring");
+    const elements = [];
+    if (!this.check("PUNCTUATION", "]")) {
+      do {
+        const name = this.consume("IDENTIFIER", "Expected element name").value;
+        elements.push(name);
+      } while (this.match("PUNCTUATION", ","));
+    }
+    this.consume("PUNCTUATION", "]", "Expected ']'");
+    return this.nd({ kind: "arrpattern", elements });
+  }
+
+  returnStatement(isGive) {
+    let value = null;
+    if (!this.check("PUNCTUATION", ";") && !this.check("EOF")) {
+      value = this.expression();
+    }
+    this.match("PUNCTUATION", ";");
+    return { kind: "return", value, terminate: isGive };
+  }
+
+  funcDeclaration(isArrow) {
+    let isAsync = false;
+    if (this.match("KEYWORD", "async")) isAsync = true;
+    const name = this.consume("IDENTIFIER", "Expected function name");
+    const { args, body } = this.parseFuncBody(isArrow);
+    return { kind: "function", name: name.value, args, body, isAsync };
+  }
+
+  classDeclaration() {
+    // Consume 'class' keyword (already matched in statement)
+    const name = this.consume("IDENTIFIER", "Expected class name");
+
+    // 🔥 NEW: Parse optional 'extends' clause
+    let superClass = null;
+    if (this.match("KEYWORD", "extends")) {
+      const superName = this.consume("IDENTIFIER", "Expected superclass name");
+      superClass = this.nd({ kind: "ref", name: superName.value }); // Store as a ref node
+    }
+
+    // Delegate parsing of the class body to objectDeclaration
+    const bodyObj = this.objectDeclaration(); // parses everything inside { ... }
+
+    // Convert objectDeclaration props into class members
+    const members = [];
+    for (const [k, v] of Object.entries(bodyObj.props)) {
+      members.push({
+        kind: v.kind === "function" ? "function" : "declare",
+        name: k,
+        value: v.kind !== "function" ? v : undefined,
+        args: v.kind === "function" ? v.args : undefined,
+        body: v.kind === "function" ? v.body : undefined,
+      });
+    }
+
+    // 🔥 Return the AST node with the new superClass property
+    return { kind: "class", name: name.value, superClass, members };
+  }
+
+  expressionStatement() {
+    let expr = this.expression();
+
+    // Handle assignment: a = b
+    if (expr.kind === "ref" && this.match("OPERATOR", "=")) {
+      const value = this.expression();
+      expr = { kind: "assign", name: expr.name, value };
+    }
+
+    this.match("PUNCTUATION", ";");
+    return { kind: "exec", expr };
+  }
+  constExpression(minPrec) {
+    return this.expression(minPrec, true);
+  }
+  // ─────────────── Expressions ───────────────
+  expression(minPrec = 0, isConst = false) {
+    if (this.isAtEnd()) return { kind: "EOF" };
+    let tok = this.peek();
+    let left;
+
+    // ───── Unary / Primary (Handling 'await') ─────
+    if (this.check("KEYWORD", "await")) {
+      const awaitToken = this.advance(); // consume 'await'
+      const operand = this.expression(9); // 9 for very high precedence
+      left = this.nd({ kind: "await", operand });
+    } else if (tok.type === "KEYWORD" && tok.value === "const") {
+      this.advance();
+      const operand = this.constExpression(minPrec);
+      left = this.nd({ kind: "value", value: operand });
+    } else if (tok.type === "OPERATOR" && tok.isUnary) {
+      const op = this.advance().value;
+      const operand = this.expression(7);
+      if (op === "*") left = this.nd({ kind: "deref", operand });
+      else left = this.nd({ kind: "unary", operator: op, operand });
+    } else if (tok.type === "PUNCTUATION" && tok.value === "(") {
+      // might be grouped expression OR arrow func params
+      const startPos = this.current;
+      this.advance(); // consume '('
+
+      const args = [];
+      let isArrow = false;
+
+      if (!this.check("PUNCTUATION", ")")) {
+        do {
+          args.push(this.expression());
+        } while (this.match("PUNCTUATION", ","));
+      }
+      this.consume("PUNCTUATION", ")", "Expected ')' after parameters");
+      if (this.match("OPERATOR", "=>")) isArrow = true;
+
+      if (isArrow) {
+        let body;
+        const values = args;
+        if (this.check("PUNCTUATION", "{")) {
+          body = this.blockBody();
+        } else {
+          body = [
+            this.nd({
+              kind: "return",
+              value: this.expression(),
+              terminate: true,
+            }),
+          ];
+        }
+        return this.nd({
+          kind: "arrowfunc",
+          args: values.map((a) => a?.name),
+          body,
+        });
+      } else {
+        // normal grouped expr
+        left = this.nd(args[0]);
+      }
+    } else if (this.match("PUNCTUATION", "[")) {
+      const elements = [];
+      if (!this.check("PUNCTUATION", "]")) {
+        do {
+          elements.push(this.expression());
+        } while (this.match("PUNCTUATION", ","));
+      }
+      this.consume("PUNCTUATION", "]", "Expected ']' after array literal");
+      left = this.nd({ kind: "array", elements });
+    } else if (tok.type === "PUNCTUATION" && tok.value === "{") {
+      left = this.objectDeclaration();
+    } else if (
+      tok.type === "NUMBER" ||
+      tok.type === "STRING" ||
+      tok.type === "LITERAL"
+    ) {
+      left = this.nd({ kind: "value", value: this.advance().value });
+    }
+
+    else if (tok.type === "TEMPLATE_START") {
+      left = this.templateLiteral();
+    } else if (tok.type === 'INTERPOLATION_END') {
+      return;
+    } else if (tok.type === "IDENTIFIER") {
+      // may be single-param arrow
+      const name = this.advance().value;
+      if (this.match("OPERATOR", "=>")) {
+        let body;
+        if (this.check("PUNCTUATION", "{")) {
+          body = this.blockBody();
+        } else {
+          body = [
+            this.nd({
+              kind: "return",
+              value: this.expression(),
+              terminate: true,
+            }),
+          ];
+        }
+        return this.nd({ kind: "arrowfunc", args: [name], body });
+      }
+  const sym = this.symbols.get(name);
+
+  left = this.nd({
+    kind: "ref",
+    name,
+    explicitType: sym ? sym.type : null, // 🪄 carry type info
+    })
+    } else if (tok.type === "EOF") {
+      return this.nd({ kind: "EOF" });
+    } else {
+      this.error(`Unexpected token '${tok.value}'`);
+    }
+
+    // ───── Postfix / Calls / Property ─────
+    while (!this.isAtEnd()) {
+      tok = this.peek();
+      if (
+        tok.type === "PUNCTUATION" &&
+        (tok.value === ";" || tok.value === "}")
+      )
+        break;
+
+      if (tok.type === "OPERATOR" && tok.isPostfix) {
+        const op = this.advance().value;
+        left = this.nd({ kind: "postfix", operator: op, operand: left });
+        continue;
+      }
+
+      if (tok.type === "IDENTIFIER" || tok.type === "NUMBER") {
+        const op = this.advance().value;
+        left = this.nd({ kind: "currency", name: op, operand: left });
+        continue;
+      }
+
+      if (tok.type === "PUNCTUATION" && tok.value === "(") {
+        this.advance();
+        const args = [];
+        if (!this.check("PUNCTUATION", ")")) {
+          do {
+            args.push(this.expression());
+          } while (this.match("PUNCTUATION", ","));
+        }
+        this.consume("PUNCTUATION", ")", "Expected ')' after arguments");
+        if (left.kind === "ref") {
+	  switch (left.name) {
+	    case 'PRS_goto':
+	         let exec = new (require("./executor.js").Executor)();
+                 let value = exec.evaluate(args[0]);
+	         this.current = value;
+                 left = this.nd({ kind: "value", value });
+	    case 'PRS_generate':
+                 left = this.nd({ kind: "value", value: (new Parser((new Lexer(args[0]?.value)).tokenize())).parse() });
+	  }
+        }
+        else {
+        left = this.nd({
+          kind: "call",
+          name: left,
+          args,
+        });
+        }
+        continue;
+      }
+
+      if (tok.type === "PUNCTUATION" && tok.value === "{") {
+        this.advance();
+        let args = [];
+        if (!this.check("PUNCTUATION", "}")) {
+          do {
+            args.push(this.expression());
+          } while (this.match("PUNCTUATION", ","));
+        }
+        this.consume("PUNCTUATION", "}", "Expected '}' after construct opening brace");
+        left = this.nd({
+          kind: "construct",
+          left,
+          args,
+        });
+        continue;
+      }
+
+      if (tok.type === "PUNCTUATION" && tok.value === ".") {
+        this.advance();
+        const prop = this.consume("IDENTIFIER", "Expected property name");
+        left = this.nd({ kind: "prop", object: left, name: prop.value });
+        continue;
+      } else if (this.match("PUNCTUATION", "[")) {
+        const indexExpr = this.expression();
+        this.consume("PUNCTUATION", "]", "Expected ']' after subscript");
+        left = this.nd({ kind: "subscript", object: left, index: indexExpr });
+        continue;
+      }
+
+      break;
+    }
+
+    // ───── Binary operators ─────
+    while (!this.isAtEnd()) {
+      tok = this.peek();
+      if (tok.type !== "OPERATOR" || tok.value === ";" || tok.value === "}")
+        break;
+
+      const prec = tok.precedence || PRECEDENCE[tok.value] || 0;
+      if (prec < minPrec) break;
+
+      const op = this.advance().value;
+      const right = this.expression(prec + 1);
+
+      if (op === "=") {
+  // 🔥 Parse-time type validation for assignments
+  if (left && left.explicitType && right?.kind === "value") {
+    const val = right.value;
+    let inferredType;
+
+    if (typeof val === "number") {
+      inferredType = Number.isInteger(val) ? "int" : "float";
+    } else if (typeof val === "string") {
+      inferredType = "string";
+    } else if (typeof val === "boolean") {
+      inferredType = "bool";
+    } else if (typeof val === "object") {
+      inferredType = "obj";
+    } else {
+      inferredType = typeof val;
+    }
+
+    const expected = left.explicitType;
+    const compatible =
+      inferredType === expected ||
+      (expected === "float" && inferredType === "int"); // implicit promotion allowed
+
+    if (!compatible) {
+      this.error(
+        `[Type mismatch] '${left.name || left.value}' expected '${expected}', got '${inferredType}'`,
+        this.peek()
+      );
+    }
+  }
+
+  left = this.nd({
+    kind: "assign",
+    name: left,
+    value: right,
+  });
+} else {
+        left = this.nd({ kind: "binary", operator: op, left, right });
+      }
+    }
+
+    if (isConst) {
+      let exec = new (require("./executor.js").Executor)();
+      return exec.evaluate(left);
+    }
+
+    return left;
+  }
+
+  // ─────────────── Helpers ───────────────
+  parseFuncBody(isArrow) {
+    this.consume("PUNCTUATION", "(", "Expected '('");
+    const args = [];
+    if (!this.check("PUNCTUATION", ")")) {
+      do {
+        args.push(this.consume("IDENTIFIER", "Expected argument name").value);
+      } while (this.match("PUNCTUATION", ","));
+    }
+    this.consume("PUNCTUATION", ")", "Expected ')'");
+    if (isArrow) this.consume("OPERATOR", "=>", "Expected '=>");
+    this.consume("PUNCTUATION", "{", "Expected '{'");
+    const body = [];
+    while (!this.check("PUNCTUATION", "}") && !this.isAtEnd())
+      body.push(this.statement());
+    this.consume("PUNCTUATION", "}", "Expected '}'");
+    return { args, body };
+  }
+
+  parseParenBody(branchName, SEP = ",") {
+    // Parse the arguments / condition
+    this.consume("PUNCTUATION", "(", "Expected '('");
+    const args = [];
+    if (branchName === "for") {
+      args.push(this.statement());
+      this.match("PUNCTUATION", ";");
+      args.push(this.expression());
+      this.match("PUNCTUATION", ";");
+      args.push(this.statement());
+    } else {
+      if (!this.check("PUNCTUATION", ")")) {
+        do {
+          args.push(this.expression());
+        } while (this.match("PUNCTUATION", SEP));
+      }
+    }
+    this.consume("PUNCTUATION", ")", "Expected ')'");
+
+    // Automatically handle block or single statement for body
+    let body;
+    if (this.check("PUNCTUATION", "{")) {
+      body = this.blockBody(); // grabs all statements inside { … }
+    } else {
+      body = [this.statement()]; // single statement
+    }
+    this.match("PUNCTUATION", ";");
+    // For `if`, only take the first argument as condition
+    return { args: branchName === "if" ? args[0] : args, body };
+  }
+
+  branchBody(name = "if", SEP = ",") {
+    const { args, body } = this.parseParenBody(name, SEP);
+    const branchNode = this.nd({ kind: "branch", type: name, args, body });
+
+    // check if the next statement is 'else' and attach it as branchNode.next
+    if (this.match("KEYWORD", "else")) {
+      let elseNode;
+      // plain else
+      const elseBody = [this.statement()];
+      elseNode = this.nd({
+        kind: "branch",
+        type: "else",
+        args: null,
+        body: elseBody,
+      });
+      branchNode.next = elseNode; // attach chain
+    }
+    this.match("PUNCTUATION", ";");
+    return branchNode;
+  }
+
+  blockBody(consumed) {
+    if (!consumed) this.consume("PUNCTUATION", "{", "Expected '{'");
+    const body = [];
+    while (!this.check("PUNCTUATION", "}") && !this.isAtEnd()) {
+      body.push(this.statement());
+    }
+    this.consume("PUNCTUATION", "}", "Expected '}'");
+    return body;
+  }
+
+  objectDeclaration() {
+    const props = {};
+    this.consume("PUNCTUATION", "{", "Expected '{' to start object literal");
+
+    while (!this.check("PUNCTUATION", "}") && !this.isAtEnd()) {
+      const tok = this.peek();
+
+      // Nested object literal
+      if (tok.type === "PUNCTUATION" && tok.value === "{") {
+        const nested = this.objectDeclaration();
+        Object.assign(props, nested.props);
+        continue;
+      }
+
+      // Property key
+      const nameTok = this.consume("IDENTIFIER", "Expected property name");
+      const propName = nameTok.value;
+      let value;
+
+      // Function value
+      if (this.check("PUNCTUATION", "(")) {
+        value = this.parseFuncBody();
+      } else {
+        this.consume("OPERATOR", ":", "Expected ':' after property name");
+        value = this.expression();
+      }
+
+      this.match("PUNCTUATION", ","); // optional
+      props[propName] = value;
+    }
+
+    this.consume("PUNCTUATION", "}", "Expected '}' to close object literal");
+    return this.nd({ kind: "object", props });
+  }
+
+  // ─────────────── Token helpers ───────────────
+  peek() {
+    return this.tokens[this.current];
+  }
+  previous() {
+    return this.tokens[this.current - 1];
+  }
+  next() {
+    return this.tokens[this.current + 1];
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF";
+  }
+  advance() {
+    if (!this.isAtEnd()) this.current++;
+    return this.previous();
+  }
+  check(type, value = null) {
+    if (this.isAtEnd()) return false;
+    const t = this.peek();
+    if (t.type !== type) return false;
+    if (value !== null && t.value !== value) return false;
+    return true;
+  }
+  match(type, value = null) {
+    if (this.check(type, value)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  consume(type, valueOrMsg, msgIfVal) {
+    const hasValue = typeof valueOrMsg === "string" && msgIfVal;
+    const expectedValue = hasValue ? valueOrMsg : null;
+    const msg = hasValue ? msgIfVal : valueOrMsg;
+    if (this.check(type, expectedValue)) return this.advance();
+    this.error(msg);
+  }
+
+  error(msg) {
+    const t = this.peek();
+    const lineText = this.rawsrc.split("\n")[t.line - 1] ?? "";
+    throw new new CustomError("ParseError")(
+      `[NovaParser ${t.line}:${t.column}] ${msg}\n` +
+        ` error at:\n` +
+        ` ${lineText}\n` +
+        ` ${" ".repeat(Math.max(t.column - 1, 0))}^^`,
+    );
+  }
+}
+
+module.exports = { Parser };