mimo-lang 1.1.1 → 2.0.6

package/parser/statements/controlFlowParsers.js

@@ -0,0 +1,106 @@
+import { TokenType } from "../../lexer/TokenTypes.js";
+import { ASTNode } from "../ASTNodes.js";
+import { parseExpression } from "../parserExpressions.js";
+import { parseBlock, isBlockEnd } from "../parserUtils.js";
+
+export function parseIfStatement(parser) {
+  const ifToken = parser.expectKeyword("if", 'SYN046', 'Expected "if" keyword to start an if statement.');
+  const condition = parseExpression(parser);
+  // parser.expect(TokenType.Keyword, "then", 'SYNXXX', 'Expected "then" keyword after if condition.'); // If your language uses "then"
+  const consequent = parseBlock(parser, ["else", "end"]);
+
+  let alternate = null;
+  if (parser.matchKeyword("else")) {
+    if (parser.peek()?.value === "if" && parser.peek()?.type === TokenType.Keyword) {
+      alternate = parseIfStatement(parser); // Handles "else if"
+    } else {
+      alternate = parseBlock(parser, ["end"]);
+    }
+  }
+
+  parser.expectKeyword("end", 'SYN047', 'Expected "end" keyword to close if statement.');
+  return ASTNode.IfStatement(condition, consequent, alternate, ifToken);
+}
+
+export function parseGuardStatement(parser) {
+  const guardToken = parser.expectKeyword("guard", "SYN120", 'Expected "guard" keyword to start an guard statement.');
+  const condition = parseExpression(parser);
+  parser.expectKeyword("else", "SYN121", 'Expected "else" keyword after guard condition.');
+  const alternate = parseBlock(parser, ["end"]);
+  parser.expectKeyword("end", "SYN122", 'Expected "end" keyword to close guard statement.');
+  return ASTNode.GuardStatement(condition, alternate, guardToken);
+}
+
+export function parseWhileStatement(parser) {
+  const whileToken = parser.expect(TokenType.Keyword);
+  const condition = parseExpression(parser);
+  const body = parseBlock(parser);
+
+  parser.expect(TokenType.Keyword, "end");
+  return ASTNode.WhileStatement(condition, body, whileToken);
+}
+
+export function parseForStatement(parser) {
+  const forToken = parser.expectKeyword("for", 'SYN048', 'Expected "for" keyword to start a for loop.');
+  const loopVar = parser.parseIdentifier('SYN048A', 'Expected an identifier for the loop variable.');
+
+  parser.expectKeyword("in", 'SYN049', 'Expected "in" keyword in for loop (e.g., for item in iterable).');
+
+  const iterable = parseExpression(parser);
+
+  const body = parseBlock(parser, ["end"]);
+  parser.expectKeyword("end", 'SYN050', 'Expected "end" keyword to close for loop.');
+
+  return ASTNode.ForStatement(loopVar, iterable, body, forToken);
+}
+
+export function parseLoopStatement(parser) {
+  const loopToken = parser.expect(TokenType.Keyword);
+  const body = parseBlock(parser);
+  parser.expect(TokenType.Keyword, "end");
+
+  return ASTNode.LoopStatement(body, null, loopToken);
+}
+
+export function parseBreakStatement(parser) {
+  const breakToken = parser.expect(TokenType.Keyword);
+
+  // Check for optional label
+  let label = null;
+  if (parser.peek()?.type === TokenType.Identifier) {
+    label = parser.expect(TokenType.Identifier).value;
+  }
+
+  return ASTNode.BreakStatement(label, breakToken);
+}
+
+export function parseContinueStatement(parser) {
+  const continueToken = parser.expect(TokenType.Keyword);
+
+  // Check for optional label
+  let label = null;
+  if (parser.peek()?.type === TokenType.Identifier) {
+    label = parser.expect(TokenType.Identifier).value;
+  }
+
+  return ASTNode.ContinueStatement(label, continueToken);
+}
+
+export function parseTryStatement(parser) {
+  const tryToken = parser.expectKeyword("try", 'SYN051', 'Expected "try" keyword to start a try-catch block.');
+  const tryBlock = parseBlock(parser, ["catch", "end"]);
+
+  let catchVar = null;
+  let catchBlock = []; // Initialize as empty array
+  if (parser.matchKeyword("catch")) {
+    // Optional: allow specifying a variable for the caught error
+    if (parser.peek()?.type === TokenType.Identifier) {
+      catchVar = parser.parseIdentifier('SYN051A', 'Expected an identifier for the catch variable.');
+    }
+    catchBlock = parseBlock(parser, ["end"]);
+  }
+
+  parser.expectKeyword("end", 'SYN052', 'Expected "end" keyword to close try-catch block.');
+  return ASTNode.TryStatement(tryBlock, catchVar, catchBlock, tryToken);
+}
+

package/parser/statements/functionParsers.js

@@ -0,0 +1,314 @@
+import { MimoError } from "../../interpreter/MimoError.js";
+import { TokenType } from "../../lexer/TokenTypes.js";
+import { ASTNode } from "../ASTNodes.js";
+import { parseExpression } from "../parserExpressions.js";
+import { isBlockEnd, parseBlock } from "../parserUtils.js";
+
+function parseParameterIdentifier(parser) {
+  const token = parser.peek();
+  if (token?.type === TokenType.Identifier || (token?.type === TokenType.Keyword && token.value === "fn")) {
+    parser.consume();
+    return ASTNode.Identifier(token.value, token);
+  }
+  parser.error('Expected a parameter name (identifier).', token, 'SYN021');
+}
+
+export function parseDecorator(parser) {
+  const atToken = parser.expect(TokenType.At, undefined, 'SYN140', 'Expected "@" at the start of a decorator.');
+  const nameToken = parser.expect(TokenType.Identifier, undefined, 'SYN141', 'Expected decorator name after "@".');
+  const name = ASTNode.Identifier(nameToken.value, nameToken);
+
+  let args = null;
+  if (parser.match(TokenType.LParen)) {
+    args = [];
+    if (parser.peek()?.type !== TokenType.RParen) {
+      do {
+        args.push(parseExpression(parser));
+      } while (parser.match(TokenType.Comma));
+    }
+    parser.expect(TokenType.RParen, undefined, 'SYN142', 'Expected closing parenthesis after decorator arguments.');
+  }
+
+  return ASTNode.Decorator(name, args, atToken);
+}
+
+export function parseDecorators(parser) {
+  const decorators = [];
+  while (parser.peek()?.type === TokenType.At) {
+    decorators.push(parseDecorator(parser));
+  }
+  return decorators;
+}
+
+export function parseFunctionDeclaration(parser, isExported = false, exportToken = null, decorators = []) {
+  // THIS IS THE FIX: This function now consumes the 'function' keyword itself.
+  const funcToken = parser.expectKeyword("function", 'SYNXXX', 'Expected "function" keyword.');
+
+  // The AST node's location should be the 'export' token if it exists, otherwise the 'function' token.
+  const astNodeLocationToken = exportToken || funcToken;
+
+  const nameToken = parser.expect(TokenType.Identifier, undefined, 'SYN054', 'Expected a function name (identifier).');
+  const name = nameToken.value;
+
+  parser.expect(TokenType.LParen, undefined, 'SYN055', 'Expected an opening parenthesis for function parameters.');
+
+  const params = [];
+  const defaults = {};
+  let restParam = null;
+  let hasEncounteredDefault = false;
+  let hasEncounteredRest = false;
+
+  if (parser.peek()?.type !== TokenType.RParen && parser.peek()?.value !== "->") {
+    do {
+      if (hasEncounteredRest) {
+        parser.error("No parameters allowed after a rest parameter.", parser.peek(), 'SYN060');
+      }
+
+      if (parser.match(TokenType.Spread)) {
+        const spreadToken = parser.peek(-1);
+        const paramNameToken = parser.expect(TokenType.Identifier, undefined, 'SYN056', 'Expected an identifier for rest parameter.');
+
+        restParam = ASTNode.Identifier(paramNameToken.value, spreadToken);
+        hasEncounteredRest = true;
+        if (parser.peek()?.type === TokenType.Comma) {
+          parser.error("Rest parameter must be the last parameter.", parser.peek(-1), 'SYN063');
+        }
+        break;
+      } else {
+        const paramNode = parseParameterIdentifier(parser);
+        params.push(paramNode); // Push the entire node
+
+        if (parser.match(TokenType.Colon)) {
+          defaults[paramNode.name] = parseExpression(parser); // Key by name
+          hasEncounteredDefault = true;
+        } else if (hasEncounteredDefault && !hasEncounteredRest) {
+          parser.error("Parameter without default value cannot follow parameter with default value.", paramNode, 'SYN_DEFAULT_ORDER');
+        }
+      }
+    } while (parser.match(TokenType.Comma));
+  }
+
+  parser.expect(TokenType.RParen, undefined, 'SYN026', 'Expected a closing parenthesis for function parameters.');
+
+  const body = parseBlock(parser);
+  const endToken = parser.expect(TokenType.Keyword, "end", 'SYN027', 'Expected "end" keyword to close function declaration.');
+
+  return ASTNode.FunctionDeclaration(
+    name,
+    params,
+    defaults,
+    restParam,
+    body,
+    isExported, // Pass isExported flag
+    decorators, // Pass practitioners decorators
+    astNodeLocationToken, // Pass the correct location token
+    endToken
+  );
+}
+
+// In: parser/statements/functionParsers.js
+
+export function parseAnonymousFunction(parser, isFn = false) {
+  const funcToken = parser.peek(-1); // The `function` or `fn` keyword was just consumed.
+
+  if (!isFn) {
+    parser.expect(TokenType.LParen, undefined, 'SYN020', 'Expected an opening parenthesis for function parameters.');
+  }
+
+  const params = [];
+  const defaults = {};
+  let restParam = null;
+  let hasEncounteredDefault = false;
+  let hasEncounteredRest = false;
+
+  if (isFn) {
+    while (parser.peek() && (parser.peek().type !== TokenType.Operator || parser.peek().value !== "->")) {
+      if (hasEncounteredRest) {
+        parser.error("No parameters allowed after a rest parameter.", parser.peek(), 'SYN060');
+      }
+
+      if (parser.match(TokenType.Spread)) {
+        const spreadToken = parser.peek(-1);
+        const paramNameToken = parser.expect(TokenType.Identifier, undefined, 'SYN056', 'Expected an identifier for rest parameter.');
+        restParam = ASTNode.Identifier(paramNameToken.value, spreadToken);
+        hasEncounteredRest = true;
+        break;
+      }
+
+      const paramNode = parseParameterIdentifier(parser);
+      params.push(paramNode);
+
+      if (parser.match(TokenType.Colon)) {
+        defaults[paramNode.name] = parseExpression(parser);
+        hasEncounteredDefault = true;
+      } else if (hasEncounteredDefault && !hasEncounteredRest) {
+        parser.error("Parameter without default value cannot follow parameter with default value.", paramNode, 'SYN_DEFAULT_ORDER');
+      }
+    }
+
+    parser.expect(TokenType.Operator, "->", 'SYN136', 'Expected "->" after fn parameters.');
+    const expression = parseExpression(parser);
+    const body = [ASTNode.ReturnStatement(expression, funcToken)];
+
+    return ASTNode.AnonymousFunction(
+      params,
+      defaults,
+      restParam,
+      body,
+      funcToken,
+      true
+    );
+  }
+
+  if (parser.peek()?.type !== TokenType.RParen) {
+    do {
+      if (parser.peek()?.type === TokenType.Operator && parser.peek()?.value === "->") {
+        parser.consume();
+        break;
+      }
+      if (hasEncounteredRest) {
+        parser.error("No parameters allowed after a rest parameter.", parser.peek(), 'SYN060');
+      }
+
+      if (parser.match(TokenType.Spread)) {
+        const spreadToken = parser.peek(-1);
+        const paramNameToken = parser.expect(TokenType.Identifier, undefined, 'SYN056', 'Expected an identifier for rest parameter.');
+        restParam = ASTNode.Identifier(paramNameToken.value, spreadToken);
+        hasEncounteredRest = true;
+        if (parser.peek()?.type === TokenType.Comma) {
+          parser.error("Rest parameter must be the last parameter.", parser.peek(-1), 'SYN063');
+        }
+        break;
+      } else {
+        const paramNode = parseParameterIdentifier(parser);
+        params.push(paramNode); // Push the entire Identifier node
+
+        if (parser.match(TokenType.Colon)) {
+          defaults[paramNode.name] = parseExpression(parser);
+          hasEncounteredDefault = true;
+        } else if (hasEncounteredDefault && !hasEncounteredRest) {
+          parser.error("Parameter without default value cannot follow parameter with default value.", paramNode, 'SYN_DEFAULT_ORDER');
+        }
+      }
+
+      // Separator handling: '->' is always allowed. Comma is only for standard 'function' syntax.
+      if (parser.match(TokenType.Operator, "->")) {
+        // Arrow found — done with params, move to body
+        break;
+      } else if (parser.match(TokenType.Comma)) {
+        if (isFn) {
+          parser.error(
+            "Comma-separated parameters are not supported in 'fn' syntax. Use '->' to separate parameters from the body.",
+            parser.peek(-1),
+            'SYN135',
+            "Write: fn x y -> expression end or use 'function' keyword for multi-param functions."
+          );
+        }
+        // If !isFn, we just consumed the comma normally, which is correct for standard syntax.
+      }
+    } while (parser.peek()?.type !== TokenType.RParen && parser.peek()?.value !== "->");
+
+  }
+
+  if (!isFn) {
+    parser.expect(TokenType.RParen, undefined, 'SYN026', 'Expected a closing parenthesis for function parameters.');
+  }
+
+  const body = parseBlock(parser);
+  const endToken = parser.expect(TokenType.Keyword, "end", 'SYN027', 'Expected "end" keyword to close function declaration.');
+
+  return ASTNode.AnonymousFunction(
+    params,
+    defaults,
+    restParam,
+    body,
+    funcToken,
+    false
+  );
+}
+
+export function parseCallExpressionParts(parser, callToken) {
+  let callee;
+  // Allow module access like MyModule.myFunction or simple identifier
+  const firstToken = parser.expect(TokenType.Identifier, undefined, 'SYN064', 'Expected a function name (identifier) or module name after "call".');
+
+  if (parser.match(TokenType.Operator, ".")) {
+    const propertyToken = parser.expect(TokenType.Identifier, undefined, 'SYN065', 'Expected a property name (identifier) after "." for module access.');
+    callee = ASTNode.ModuleAccess(firstToken.value, propertyToken.value, firstToken); // firstToken is start of module.prop
+  } else {
+    callee = ASTNode.Identifier(firstToken.value, firstToken);
+  }
+
+  parser.expect(TokenType.LParen, undefined, 'SYN066', 'Expected an opening parenthesis for function arguments.');
+  const args = [];
+
+  if (parser.peek()?.type !== TokenType.RParen) {
+    do {
+      if (parser.peek()?.type === TokenType.Spread) {
+        const spreadToken = parser.consume();
+        const argument = parseExpression(parser);
+        args.push(ASTNode.SpreadElement(argument, spreadToken));
+      } else {
+        args.push(parseExpression(parser));
+      }
+    } while (parser.match(TokenType.Comma));
+  }
+
+  parser.expect(TokenType.RParen, undefined, 'SYN067', 'Expected a closing parenthesis for function arguments.');
+
+  return ASTNode.CallExpression(callee, args, callToken); // Returns a CallExpression AST node
+}
+
+export function parseCallStatement(parser) {
+  const callToken = parser.expectKeyword("call", 'SYN063', 'Expected "call" keyword to initiate a function call.');
+
+  // Use the new reusable function to parse the `callee(args)` part
+  const callExpression = parseCallExpressionParts(parser, callToken); // Pass the callToken for location
+
+  let destination = null;
+  if (parser.match(TokenType.Operator, "->")) {
+    const destinationToken = parser.expect(TokenType.Identifier, undefined, 'SYN069', 'Expected an identifier for the assignment destination after "->".');
+    destination = ASTNode.Identifier(destinationToken.value, destinationToken); // Store as ASTNode.Identifier
+  }
+
+  // Now, create the CallStatement AST node.
+  // It will embed the CallExpression.
+  return ASTNode.CallStatement(
+    callExpression.callee, // The function being called
+    callExpression.arguments, // The arguments to the call
+    destination, // The optional destination for the result
+    callToken // The original 'call' token for location
+  );
+}
+
+export function parseReturnStatement(parser) {
+  const returnToken = parser.expectKeyword("return", 'SYN070', 'Expected "return" keyword.');
+  let argument = null;
+
+  // If the next token is the end of a block, there is no return value.
+  // This handles `return end` or `return else` etc.
+  const nextToken = parser.peek();
+  if (
+    parser.isAtEnd() ||
+    (nextToken.type === TokenType.Keyword && ['end', 'else', 'catch', 'case', 'default'].includes(nextToken.value))
+  ) {
+    // This is a `return` statement with no value, so argument remains null.
+  } else {
+    // Otherwise, there MUST be an expression to return.
+    argument = parseExpression(parser);
+  }
+
+  return ASTNode.ReturnStatement(argument, returnToken);
+}
+
+export function parseShowStatement(parser) {
+  const showToken = parser.expectKeyword("show", 'SYN071', 'Expected "show" keyword.');
+  const expression = parseExpression(parser);
+  return ASTNode.ShowStatement(expression, showToken);
+}
+
+export function parseThrowStatement(parser) {
+  const throwToken = parser.expectKeyword("throw", 'SYN072', 'Expected "throw" keyword.');
+  const argument = parseExpression(parser);
+  return ASTNode.ThrowStatement(argument, throwToken);
+}

package/parser/statements/moduleParsers.js

@@ -0,0 +1,57 @@
+import { TokenType } from "../../lexer/TokenTypes.js";
+import { ASTNode } from "../ASTNodes.js";
+import { parseVariableOrAssignment } from "./variableParsers.js";
+import { parseFunctionDeclaration } from "./functionParsers.js";
+
+
+export function parseImportStatement(parser) {
+    const importToken = parser.expectKeyword("import", 'SYN073', 'Expected "import" keyword.');
+    // now we expect: import <Identifier> from <String> [as <Identifier>]
+    const nameToken = parser.expect(TokenType.Identifier, undefined, 'SYN073a', 'Expected an identifier for the module to import.');
+
+    parser.expectKeyword("from", 'SYN074a', 'Expected "from" keyword after imported name.');
+
+    const pathToken = parser.expect(TokenType.String, undefined, 'SYN074', 'Expected a string literal for the module path (e.g., "my_module").');
+
+    let aliasToken = null;
+    if (parser.matchKeyword("as")) {
+        aliasToken = parser.expect(TokenType.Identifier, undefined, 'SYN076', 'Expected an identifier for the module alias.');
+    }
+
+    return ASTNode.ImportStatement(
+        pathToken.value,
+        aliasToken ? aliasToken.value : nameToken.value,
+        importToken
+    );
+}
+
+export function parseExportStatement(parser, decorators = []) {
+    const exportToken = parser.expectKeyword("export", 'SYN077', 'Expected "export" keyword.');
+
+    const nextToken = parser.peek();
+    if (!nextToken || parser.isAtEnd()) { // Check isAtEnd as well
+        parser.error("Unexpected end of input after 'export'.", exportToken, 'SYN078', "Expected a variable or function declaration to export.");
+    }
+    if (nextToken.type === TokenType.Keyword) {
+        switch (nextToken.value) {
+            case "set":
+            case "let":
+            case "const":
+            case "global":
+                // Pass exportToken as the location token for the AST node
+                return parseVariableOrAssignment(parser, true, exportToken);
+            case "function":
+                // Pass exportToken as the location token for the AST node
+                return parseFunctionDeclaration(parser, true, exportToken, decorators);
+            default:
+                parser.error(
+                    `Cannot export statement of type '${nextToken.value}'. Expected a declaration.`,
+                    nextToken,
+                    'SYN079',
+                    "Only 'set', 'let', 'const', 'global', or 'function' declarations can be exported."
+                );
+        }
+    }
+    // If not a keyword, it must be an error because export must be followed by a declaration keyword.
+    parser.error("Expected a declaration keyword (set, let, const, global, function) after 'export'.", nextToken, 'SYN080', 'Only variable and function declarations can be exported.');
+}

package/parser/statements/patternMatchParsers.js

@@ -0,0 +1,124 @@
+import { TokenType } from "../../lexer/TokenTypes.js";
+import { ASTNode } from "../ASTNodes.js";
+import { parseExpression } from "../parserExpressions.js";
+import { parseBlock, isBlockEnd } from "../parserUtils.js";
+
+export function parseMatchStatement(parser) {
+  const matchToken = parser.expectKeyword("match", 'SYN081', 'Expected "match" keyword to start a match statement.');
+  const discriminant = parseExpression(parser);
+
+  const cases = [];
+
+  // Parse case clauses
+  while (
+    parser.peek()?.type === TokenType.Keyword &&
+    (parser.peek()?.value === "case" || parser.peek()?.value === "default")
+  ) {
+    if (parser.peek()?.value === "case") {
+      const caseToken = parser.expectKeyword("case", 'SYN082', 'Expected "case" keyword for a match clause.');
+      const pattern = parsePattern(parser);
+
+      let guard = null;
+      if (parser.matchKeyword("when")) {
+        guard = parseExpression(parser);
+      }
+
+      parser.expect(TokenType.Colon, undefined, 'SYN083', 'Expected a colon (:) after the pattern in a match clause.');
+      const consequent = parseBlock(parser, ["case", "default", "end"]);
+
+      cases.push(ASTNode.CaseClause(pattern, guard, consequent, caseToken));
+    } else if (parser.peek()?.value === "default") {
+      const defaultToken = parser.expectKeyword("default", 'SYN084', 'Expected "default" keyword for the fallback match clause.');
+      parser.expect(TokenType.Colon, undefined, 'SYN085', 'Expected a colon (:) after "default" in a match clause.');
+      const consequent = parseBlock(parser, ["case", "default", "end"]);
+
+      cases.push(ASTNode.CaseClause(null, null, consequent, defaultToken)); // null pattern and guard for default
+    }
+  }
+  if (cases.length === 0) {
+    parser.error("Match statement must have at least one 'case' or 'default' clause.", matchToken, 'SYN085A', "Add at least one 'case ... : ...' or 'default: ...' block.");
+  }
+
+  parser.expectKeyword("end", 'SYN086', 'Expected "end" keyword to close match statement.');
+  return ASTNode.MatchStatement(discriminant, cases, matchToken);
+}
+
+export function parsePattern(parser) {
+  const token = parser.peek();
+
+  if (token?.type === TokenType.LBracket) {
+    // Array pattern: [a, b] or [1, 2, 3]
+    const bracketToken = parser.expect(TokenType.LBracket, undefined, 'SYN087', 'Expected an opening square bracket to start an array pattern.');
+    const elements = [];
+
+    if (parser.peek()?.type !== TokenType.RBracket) {
+      do {
+        elements.push(parsePatternElement(parser));
+      } while (parser.match(TokenType.Comma));
+    }
+
+    parser.expect(TokenType.RBracket, undefined, 'SYN088', 'Expected a closing square bracket to end an array pattern.');
+    return ASTNode.ArrayPattern(elements, bracketToken);
+  }
+  // Simple pattern: literal, identifier
+  return parsePatternElement(parser);
+}
+
+export function parsePatternElement(parser) {
+  const token = parser.peek();
+  if (!token) {
+    parser.error("Unexpected end of input while parsing pattern element.", parser.peek(-1) || parser.tokens[0], 'SYN088A', "A pattern element (literal, identifier, or array) is expected here.");
+  }
+
+  switch (token.type) {
+    case TokenType.LBracket: // Nested array pattern
+      {
+        const bracketToken = parser.expect(TokenType.LBracket, undefined, 'SYN089', 'Expected an opening square bracket for nested array pattern.');
+        const elements = [];
+        if (parser.peek()?.type !== TokenType.RBracket) {
+          do {
+            elements.push(parsePatternElement(parser));
+          } while (parser.match(TokenType.Comma));
+        }
+        parser.expect(TokenType.RBracket, undefined, 'SYN090', 'Expected a closing square bracket for nested array pattern.');
+        return ASTNode.ArrayPattern(elements, bracketToken);
+      }
+    case TokenType.Number:
+      {
+        const numToken = parser.consume();
+        // Ensure the number is an integer for pattern matching if required by language spec
+        // For now, allowing any number literal.
+        return ASTNode.Literal(Number.parseFloat(numToken.value), numToken); // Or parseInt if only integers allowed
+      }
+    case TokenType.String:
+      {
+        const strToken = parser.consume();
+        return ASTNode.Literal(strToken.value, strToken);
+      }
+    case TokenType.Boolean: // Lexer produces this for true/false literals
+      {
+        const boolToken = parser.consume();
+        return ASTNode.Literal(boolToken.value === "true" || boolToken.value === true, boolToken);
+      }
+    case TokenType.Null: // Lexer produces this for null literal
+      {
+        const nullToken = parser.consume();
+        return ASTNode.Literal(null, nullToken);
+      }
+    case TokenType.Identifier:
+      {
+        // Could be a variable to bind or a named constant to match (e.g. if you have enums or consts)
+        // For now, assume it's a variable to bind.
+        const idToken = parser.consume();
+        return ASTNode.Identifier(idToken.value, idToken);
+      }
+    default:
+      parser.error(
+        `Unexpected token '${token.value}' (${token.type}) in pattern. Expected a literal, identifier, or array pattern.`,
+        token,
+        'SYN091',
+        'Patterns can be simple values (like 10, "hello", true), identifiers (to bind values), or array patterns (like [a, b]).'
+      );
+  }
+}
+