mimo-lang 1.1.1 → 2.0.6

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "mimo-lang",
-  "version": "1.1.1",
-  "description": "A programming language made in javascript mostly for learning purposes.",
+  "version": "2.0.6",
+  "description": "A minimal prefix-notation programming language",
   "keywords": [
-    "programing language"
+    "programming-language",
+    "prefix-notation",
+    "language",
+    "interpreter"
   ],
   "author": "bethropolis",
   "license": "MIT",
@@ -11,20 +14,33 @@
   "module": "index.js",
   "type": "module",
   "bin": {
-    "mimo": "./cli.js"
+    "mimo": "./bin/cli.js"
   },
   "scripts": {
-    "mimo": "bun cli.js",
-    "dev": "bun index.js",
-    "test": "node test/index.js",
-    "build": "vite build"
+    "mimo": "bun bin/cli.js",
+    "dev": "bun test.js",
+    "build": "bun build.js",
+    "prebuild:mimo": "bun tools/stamp-version.js",
+    "build:mimo": "bun build ./bin/cli.js --compile --outfile mimo",
+    "build:all": "bun build.js && bun run ext:package && bun run web:build",
+    "convert": "bun tools/convert.js",
+    "test": "bun bin/cli.js test test/source",
+    "lint": "bun bin/cli.js lint test/source",
+    "lint:strict": "bun bin/cli.js lint --fail-on-warning test/source/all.mimo",
+    "format:check": "bun bin/cli.js fmt --check test/source",
+    "format:write": "bun bin/cli.js fmt --write test/source",
+    "check": "bun run lint:strict && bun run test",
+    "ext:validate": "bun run --cwd extensions/mimo-vscode validate",
+    "ext:test": "bun run --cwd extensions/mimo-vscode test",
+    "ext:check": "bun run --cwd extensions/mimo-vscode check",
+    "ext:package": "bun run --cwd extensions/mimo-vscode package",
+    "web:dev": "bun run --cwd playground dev --open",
+    "web:build": "bun run --cwd playground build",
+    "web:preview": "bun run --cwd playground preview"
   },
   "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "dependencies": {
-    "js-beautify": "^1.15.1",
-    "vite": "^5.2.10"
+    "@types/bun": "latest",
+    "esbuild": "^0.25.5"
   },
   "repository": {
     "type": "git",

package/parser/ASTNodes.js

@@ -0,0 +1,448 @@
+export const ASTNode = {
+  Program: (body, firstToken) => ({ // Add firstToken parameter
+    type: "Program",
+    body,
+    // Ensure these properties come from the token
+    line: firstToken.line,
+    column: firstToken.column,
+    start: firstToken.start,     // Add start
+    length: firstToken.length,   // Add length
+    file: firstToken.file,
+  }),
+  VariableDeclaration: (identifier, value, kind, isExported, token) => ({
+    type: "VariableDeclaration",
+    identifier,
+    value,
+    kind,
+    isExported,
+    line: token.line,
+    column: token.column,
+    start: token.start,   // Add start
+    length: token.length, // Add length
+    file: token.file,
+  }),
+  BinaryExpression: (operator, left, right, token) => ({
+    type: "BinaryExpression",
+    operator,
+    left,
+    right,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  UnaryExpression: (operator, argument, token) => ({
+    type: "UnaryExpression",
+    operator,
+    argument,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  IfStatement: (condition, consequent, alternate, token) => ({
+    type: "IfStatement",
+    condition,
+    consequent,
+    alternate,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  GuardStatement: (condition, alternate, token) => ({
+    type: "GuardStatement",
+    condition,
+    alternate, // The else block that must exit
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  InlineIfExpression: (condition, consequent, alternate, token) => ({
+    type: "InlineIfExpression",
+    condition,
+    consequent, // Single expression here, not a block
+    alternate,  // Single expression here, not a block
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  PipeExpression: (left, callee, args, token) => ({
+    type: "PipeExpression",
+    left,   // The value being piped
+    callee, // The function to pipe into (Identifier, ModuleAccess, or InlineIfExpression)
+    args,   // Any extra arguments after the piped value
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  WhileStatement: (condition, body, token) => ({
+    type: "WhileStatement",
+    condition,
+    body,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ForStatement: (variable, iterable, body, token) => ({
+    type: "ForStatement",
+    variable,
+    iterable,
+    body,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  RangeLiteral: (start, end, token) => ({
+    type: "RangeLiteral",
+    start,
+    end,
+    line: token.line,
+    column: token.column,
+    length: token.length,
+    file: token.file,
+  }),
+  TryStatement: (tryBlock, catchVar, catchBlock, token) => ({
+    type: "TryStatement",
+    tryBlock,
+    catchVar,
+    catchBlock,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ThrowStatement: (argument, token) => ({
+    type: "ThrowStatement",
+    argument,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  FunctionDeclaration: (name, params, defaults, restParam, body, isExported, decorators, token) => ({
+    type: "FunctionDeclaration",
+    name,
+    params, // This should be an array of strings (parameter names)
+    defaults,
+    restParam, // This should be a string (rest parameter name) or null
+    body,
+    isExported,
+    decorators, // Array of Decorator nodes
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  Decorator: (name, args, token) => ({
+    type: "Decorator",
+    name, // Identifier node
+    arguments: args, // Array of expressions or null
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  AnonymousFunction: (params, defaults, restParam, body, token, isFn = false) => ({
+    type: "AnonymousFunction",
+    params,
+    defaults,
+    restParam,
+    body,
+    isFn,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  CallStatement: (callee, args, destination, token) => ({
+    type: "CallStatement",
+    callee,
+    arguments: args,
+    destination,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  CallExpression: (callee, args, token) => ({
+    type: "CallExpression",
+    callee,
+    arguments: args,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  SafeCallExpression: (callee, args, token) => ({
+    type: "SafeCallExpression",
+    callee,
+    arguments: args,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ShowStatement: (expression, token) => ({
+    type: "ShowStatement",
+    expression,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ReturnStatement: (argument, token) => ({
+    type: "ReturnStatement",
+    argument,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  Identifier: (name, token) => ({
+    type: "Identifier",
+    name,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  Literal: (value, token) => ({
+    type: "Literal",
+    value,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ArrayLiteral: (elements, token) => ({
+    type: "ArrayLiteral",
+    elements,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ObjectLiteral: (properties, token) => ({
+    type: "ObjectLiteral",
+    properties,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ArrayAccess: (object, index, token) => ({
+    type: "ArrayAccess",
+    object,
+    index,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  SafeArrayAccess: (object, index, token) => ({
+    type: "SafeArrayAccess",
+    object,
+    index,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  PropertyAccess: (object, property, token) => ({
+    type: "PropertyAccess",
+    object,
+    property,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  SafePropertyAccess: (object, property, token) => ({
+    type: "SafePropertyAccess",
+    object,
+    property,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  PropertyAssignment: (object, property, value, token) => ({
+    type: "PropertyAssignment",
+    object,
+    property,
+    value,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  BracketAssignment: (object, index, value, token) => ({
+    type: "BracketAssignment",
+    object,
+    index,
+    value,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  SpreadElement: (argument, token) => ({
+    type: "SpreadElement",
+    argument,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  DestructuringAssignment: (pattern, expression, token) => ({
+    type: "DestructuringAssignment",
+    pattern,
+    expression,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  BreakStatement: (label, token) => ({
+    type: "BreakStatement",
+    label,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ContinueStatement: (label, token) => ({
+    type: "ContinueStatement",
+    label,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  LoopStatement: (body, label, token) => ({
+    type: "LoopStatement",
+    body,
+    label,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  LabeledStatement: (label, statement, token) => ({
+    type: "LabeledStatement",
+    label,
+    statement,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  MatchStatement: (discriminant, cases, token) => ({
+    type: "MatchStatement",
+    discriminant,
+    cases,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  CaseClause: (pattern, guard, consequent, token) => ({
+    type: "CaseClause",
+    pattern,
+    guard,
+    consequent,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ArrayPattern: (elements, token) => ({
+    type: "ArrayPattern",
+    elements,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ObjectPattern: (properties, token) => ({
+    type: "ObjectPattern",
+    properties,   // An array of Identifier nodes
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ImportStatement: (path, alias, token) => ({
+    type: "ImportStatement",
+    path,
+    alias,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  ModuleAccess: (module, property, token) => ({
+    type: "ModuleAccess",
+    module,
+    property,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+  TemplateLiteral: (parts, token) => ({
+    type: "TemplateLiteral",
+    parts,
+    line: token.line,
+    column: token.column,
+    start: token.start,
+    length: token.length,
+    file: token.file,
+  }),
+};

package/parser/Parser.js

@@ -0,0 +1,188 @@
+// parser.js
+import { TokenType } from "./../lexer/TokenTypes.js";
+import { setupExpressionParsers } from "./parserExpressions.js";
+import { MimoError } from "../interpreter/MimoError.js";
+import { parseStatement } from "./parseStatement.js";
+import { ASTNode } from "./ASTNodes.js";
+
+export class Parser {
+  constructor(tokens, filePath = "unknown") {
+    this.tokens = tokens;
+    this.current = 0;
+    this.filePath = filePath; // Store filePath
+    this.errorHandler = null; // To be set by Interpreter or CLI for source context
+  }
+
+  // Method to set the error handler (which contains source code context)
+  setErrorHandler(errorHandler) {
+    this.errorHandler = errorHandler;
+  }
+
+  error(message, token = this.peek(), code = "SYN000", suggestion = "") {
+    let errorToken = token;
+    // If no valid token is provided or peek() returned undefined,
+    // try to use the token that was *just consumed* or a dummy EOF token.
+    if (
+      !errorToken ||
+      errorToken.type === undefined ||
+      errorToken.line === undefined
+    ) {
+      // Fallback to the last consumed token, or end-of-file dummy token
+      errorToken = this.tokens[this.current - 1] || {
+        // Last successfully consumed token
+        type: "EOF",
+        value: "",
+        line: 1,
+        column: 1,
+        start: 0,
+        length: 0,
+        file: this.filePath,
+      }; // Fallback
+    }
+    // Ensure the errorToken has the `file` property for the ErrorHandler
+    errorToken.file = errorToken.file || this.filePath;
+
+    // Use the ErrorHandler instance to create the MimoError
+    if (this.errorHandler) {
+      throw this.errorHandler.createSyntaxError(
+        message,
+        errorToken,
+        code,
+        suggestion
+      );
+    } else {
+      // Fallback: create a basic MimoError if no errorHandler is set
+      throw new MimoError("SyntaxError", code, message, suggestion, {
+        line: errorToken.line,
+        column: errorToken.column,
+        file: errorToken.file,
+      });
+    }
+  }
+
+  expect(type, value, code = "SYN000", suggestion = "Syntax error.") {
+    const token = this.peek();
+    if (token.type === type && (value === undefined || token.value === value)) {
+      return this.consume();
+    }
+    const displayValue = value ? `'${value}' (${type})` : type;
+    const displayGot = token.value
+      ? `'${token.value}' (${token.type})`
+      : token.type;
+    this.error(
+      `Expected ${displayValue} but got ${displayGot}.`,
+      token,
+      code,
+      suggestion
+    );
+  }
+
+  expectKeyword(keyword, code = "SYN000", suggestion = "Syntax error.") {
+    const token = this.peek();
+    if (token.type === TokenType.Keyword) {
+      // Handle both single keyword and array of keywords
+      if (Array.isArray(keyword)) {
+        if (keyword.includes(token.value)) {
+          return this.consume();
+        }
+        // If none of the keywords match, create error with all expected keywords
+        const expectedKeywords = keyword.map((k) => `'${k}'`).join(", ");
+        this.error(
+          `Expected one of ${expectedKeywords} but got '${token.value}' (${token.type}).`,
+          token,
+          code,
+          suggestion
+        );
+      } else {
+        // Single keyword case
+        if (token.value === keyword) {
+          return this.consume();
+        }
+        this.error(
+          `Expected '${keyword}' (keyword) but got '${token.value}' (${token.type}).`,
+          token,
+          code,
+          suggestion
+        );
+      }
+    }
+    this.error(
+      `Expected keyword but got '${token.value}' (${token.type}).`,
+      token,
+      code,
+      suggestion
+    );
+  }
+
+  match(type, value) {
+    const token = this.peek();
+    if (token && token.type === type && (!value || token.value === value)) {
+      this.consume();
+      return true;
+    }
+    return false;
+  }
+
+  matchKeyword(keyword) {
+    return this.match(TokenType.Keyword, keyword);
+  }
+
+  isAtEnd() {
+    return this.current >= this.tokens.length;
+  }
+
+  peek(index = 0) {
+    return this.tokens[this.current + index];
+  }
+
+  consume() {
+    const token = this.tokens[this.current];
+    this.current++;
+    return token;
+  }
+
+  // New: parseIdentifier method
+  parseIdentifier(code = "SYN000", suggestion = "Expected an identifier.") {
+    const token = this.peek();
+    if (token.type === TokenType.Identifier) {
+      this.consume();
+      return ASTNode.Identifier(token.value, token); // Pass full token for location
+    }
+    this.error(
+      `Expected an identifier but got ${token.type} '${token.value}'.`,
+      token,
+      code,
+      suggestion
+    );
+  }
+
+  parse() {
+    setupExpressionParsers();
+
+    const statements = [];
+    const programStartToken = this.tokens[0] || {
+      type: "ProgramStart",
+      value: "",
+      line: 1,
+      column: 1,
+      start: 0,
+      length: 0,
+      file: this.filePath,
+    };
+
+    while (!this.isAtEnd()) {
+      // This is important: skip newlines/semicolons between statements
+      // if your grammar allows them freely and they're not handled by indentation.
+      // For Mimo, typically, whitespace including newlines is skipped by lexer.
+      // So, this loop is often not needed here. But if your parser explicitly expects them, keep.
+      // For simplicity and matching current grammar assumptions, let's keep it minimal.
+      // If your lexer provides TokenType.Newline:
+      // while (this.match(TokenType.Newline));
+
+      if (this.isAtEnd()) break;
+
+      statements.push(parseStatement(this)); // <--- Call the imported function and pass 'this'
+    }
+    return ASTNode.Program(statements, programStartToken);
+  }
+}