Parser.cpp

#include "Parser.h"
#include "Utils.h"

ParseError error(const Token &token, const std::string &message) {
  Utils::error(token, message);

  return ParseError(message);
}

Token Parser::peek() const {
  return tokens[current];
}

Token Parser::previous() const {
  return tokens[current - 1];
}

bool Parser::isAtEnd() const {
  return peek().type == TokenType::END_OF_FILE;
}

Token Parser::advance() {
  if (!isAtEnd()) current++;
  return previous();
}

bool Parser::check(TokenType type) const {
  if (isAtEnd()) return false;
  return peek().type == type;
}

template<typename... Types> requires (std::is_same_v<Types, TokenType> && ...)
bool Parser::match(Types... types) {
  return ((check(types) ? (advance(), true) : false) or ...);
}

Token Parser::consume(const TokenType type, const std::string &message) {
  if (check(type)) return advance();

  hadError = true;
  throw error(peek(), message);
}


Parser::Parser(const std::vector<Token> &tokens) : tokens(tokens) {}

ExprPtr Parser::expression() {
  return assignment();
}

ExprPtr Parser::comma() {
  ExprPtr expr = assignment();

  while (match(TokenType::COMMA)) {
    Token op = previous();

    ExprPtr rhs = assignment();
    expr = std::make_unique<Expr::Binary>(std::move(expr), std::move(op), std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::assignment() {
  ExprPtr expr = logic_or();
  if (match(TokenType::EQUAL)) {
    const Token equals = previous();
    ExprPtr value = assignment();
    if (auto d = dynamic_cast<Expr::Variable*>(expr.get()); d != nullptr) {
      Token name = d->name;
      return std::make_unique<Expr::Assign>(name, std::move(value));
    }
    if (auto d = dynamic_cast<Expr::Get*>(expr.get()); d != nullptr) {
      return std::make_unique<Expr::Set>(std::move(d->object), d->name, std::move(value));
    }
    error(equals, "Invalid assignment target.");
  }
  return expr;
}

ExprPtr Parser::logic_or() {
  ExprPtr expr = logic_and();

  while (match(TokenType::OR)) {
    Token op = previous();
    ExprPtr rhs = logic_and();
    expr = std::make_unique<Expr::Logical>(std::move(expr), std::move(op), std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::logic_and() {
  ExprPtr expr = equality();

  while (match(TokenType::AND)) {
    Token op = previous();
    ExprPtr rhs = equality();
    expr = std::make_unique<Expr::Logical>(std::move(expr), std::move(op), std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::equality() {
  ExprPtr expr = comparison();

  while (match(TokenType::BANG_EQUAL, TokenType::EQUAL_EQUAL)) {
    Token op = previous();
    ExprPtr rhs = comparison();
    expr = std::make_unique<Expr::Binary>(std::move(expr), op, std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::comparison() {
  ExprPtr expr = term();

  while (match(TokenType::GREATER, TokenType::GREATER_EQUAL, TokenType::LESS, TokenType::LESS_EQUAL)) {
    Token op = previous();
    ExprPtr rhs = term();
    expr = std::make_unique<Expr::Binary>(std::move(expr), op, std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::term() {
  ExprPtr expr = factor();

  while (match(TokenType::MINUS, TokenType::PLUS)) {
    Token op = previous();
    ExprPtr rhs = factor();
    expr = std::make_unique<Expr::Binary>(std::move(expr), op, std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::factor() {
  ExprPtr expr = unary();

  while (match(TokenType::SLASH, TokenType::STAR)) {
    Token op = previous();
    ExprPtr rhs = unary();
    expr = std::make_unique<Expr::Binary>(std::move(expr), op, std::move(rhs));
  }

  return expr;
}

ExprPtr Parser::unary() {
  if (match(TokenType::BANG, TokenType::MINUS)) {
    Token op = previous();
    ExprPtr rhs = unary();
    return std::make_unique<Expr::Unary>(op, std::move(rhs));
  }

  return call();
}

ExprPtr Parser::call() {
  ExprPtr expr = primary();

  while (true) {
    if (match(TokenType::LEFT_PAREN)) {
      auto arguments = std::make_unique<std::vector<ExprPtr>>();
      if (!check(TokenType::RIGHT_PAREN)) {
        do {
          if (arguments->size() >= 255) error(peek(), "Can't have more than 255 arguments.");
          arguments->push_back(std::move(expression()));
        } while (match(TokenType::COMMA));
      }

      Token paren = consume(TokenType::RIGHT_PAREN, "Expect ')' after arguments.");
      expr = std::make_unique<Expr::Call>(std::move(expr), paren, std::move(arguments));
    } else if (match(TokenType::DOT)) {
      Token name = consume(TokenType::IDENTIFIER, "Expect property name after '.'.");
      expr = std::make_unique<Expr::Get>(std::move(expr), name);
    } else {
      break;
    }
  }

  return expr;
}

ExprPtr Parser::primary() {
  if (match(TokenType::FALSE)) return std::make_unique<Expr::Literal>(std::make_shared<Object>(false));
  if (match(TokenType::TRUE)) return std::make_unique<Expr::Literal>(std::make_shared<Object>(true));
  if (match(TokenType::NIL)) return std::make_unique<Expr::Literal>(std::make_shared<Object>(std::monostate{}));

  if (match(TokenType::NUMBER, TokenType::STRING)) {
    return std::make_unique<Expr::Literal>(previous().literal);
  }

  if (match(TokenType::SUPER)) {
    Token keyword = previous();
    consume(TokenType::DOT, "Expect '.' after 'super'.");
    Token method = consume(TokenType::IDENTIFIER, "Expect superclass method name.");
    return std::make_unique<Expr::Super>(keyword, method);
  }

  if (match(TokenType::THIS)) return std::make_unique<Expr::This>(previous());
  if (match(TokenType::IDENTIFIER)) return std::make_unique<Expr::Variable>(previous());

  if (match(TokenType::LEFT_PAREN)) {
    ExprPtr expr = expression();
    consume(TokenType::RIGHT_PAREN, "Expect ')' after expression.");
    return std::make_unique<Expr::Grouping>(std::move(expr));
  }
  throw error(peek(), "Expect expression.");
}

std::unique_ptr<std::vector<std::unique_ptr<Stmt::Stmt>>> Parser::block() {
  auto statements = std::make_unique<std::vector<std::unique_ptr<Stmt::Stmt>>>();

  while (!check(TokenType::RIGHT_BRACE) && !isAtEnd()) {
    statements->push_back(std::move(declaration()));
  }

  consume(TokenType::RIGHT_BRACE, "Expect '}' after block.");
  return statements;
}

StmtPtr Parser::ifStatement() {
  consume(TokenType::LEFT_PAREN, "Expect '(' after if statement.");
  ExprPtr condition = expression();
  consume(TokenType::RIGHT_PAREN, "Expect ')' after if condition.");

  StmtPtr thenBranch = statement();
  StmtPtr elseBranch = nullptr;
  if (match(TokenType::ELSE)) {
    elseBranch = statement();
  }

  return std::make_unique<Stmt::If>(std::move(condition), std::move(thenBranch), std::move(elseBranch));
}

StmtPtr Parser::printStatement() {
  ExprPtr expr = expression();
  consume(TokenType::SEMICOLON, "Expect ';' after value.");
  return std::make_unique<Stmt::Print>(std::move(expr));
}

StmtPtr Parser::returnStatement() {
  Token keyword = previous();
  ExprPtr value = nullptr;
  if (!check(TokenType::SEMICOLON)) {
    value = expression();
  }

  consume(TokenType::SEMICOLON, "Expect ';' after return value.");
  return std::make_unique<Stmt::Return>(keyword, std::move(value));
}

StmtPtr Parser::whileStatement() {
  consume(TokenType::LEFT_PAREN, "Expect '(' after 'while' statement.");
  ExprPtr condition = expression();
  consume(TokenType::RIGHT_PAREN, "Expect ')' after condition.");
  StmtPtr body = statement();

  return std::make_unique<Stmt::While>(std::move(condition), std::move(body));
}

StmtPtr Parser::forStatement() {
  consume(TokenType::LEFT_PAREN, "Expect '(' after 'for'.");
  StmtPtr initializer;
  if (match(TokenType::SEMICOLON)) {
    initializer = nullptr;
  } else if (match(TokenType::VAR)) {
    initializer = varDeclaration();
  } else {
    initializer = expressionStatement();
  }

  ExprPtr condition;
  if (!check(TokenType::SEMICOLON)) {
    condition = expression();
  }
  consume(TokenType::SEMICOLON, "Expect ';' after loop condition.");

  ExprPtr increment;
  if (!check(TokenType::RIGHT_PAREN)) {
    increment = expression();
  }
  consume(TokenType::RIGHT_PAREN, "Expect ')' after for clauses.");

  StmtPtr body = statement();

  if (increment != nullptr) {
    auto bodyStmts = std::make_unique<std::vector<std::unique_ptr<Stmt::Stmt>>>();
    bodyStmts->push_back(std::move(body));
    bodyStmts->push_back(std::make_unique<Stmt::Expression>(std::move(increment)));
    body = std::make_unique<Stmt::Block>(std::move(bodyStmts));
  }

  if (condition == nullptr) condition = std::make_unique<Expr::Literal>(std::make_shared<Object>(true));

  body = std::make_unique<Stmt::While>(std::move(condition), std::move(body));

  if (initializer != nullptr) {
    auto bodyStmts = std::make_unique<std::vector<std::unique_ptr<Stmt::Stmt>>>();
    bodyStmts->push_back(std::move(initializer));
    bodyStmts->push_back(std::move(body));
    body = std::make_unique<Stmt::Block>(std::move(bodyStmts));
  }

  return body;
}

StmtPtr Parser::expressionStatement() {
  ExprPtr expr = expression();
  consume(TokenType::SEMICOLON, "Expect ';' after expression.");
  return std::make_unique<Stmt::Expression>(std::move(expr));
}

std::unique_ptr<Stmt::Function> Parser::function(std::string kind, bool is_static = false) {
  Token name = consume(TokenType::IDENTIFIER, "Expect " + kind + " name.");
  consume(TokenType::LEFT_PAREN, "Expect '(' after " + kind + " name.");
  std::vector<Token> params;
  if (!check(TokenType::RIGHT_PAREN)) {
    do {
      if (params.size() >= 255) {
        error(peek(), "Can't have more than 255 parameters.");
      }

      params.push_back(consume(TokenType::IDENTIFIER, "Expect parameter name."));
    } while (match(TokenType::COMMA));
  }
  consume(TokenType::RIGHT_PAREN, "Expect ')' after parameters.");

  consume(TokenType::LEFT_BRACE, "Expect '{' before " + kind + " body.");
  auto body = block();
  return std::make_unique<Stmt::Function>(name, params, std::move(body), is_static);
}

StmtPtr Parser::varDeclaration() {
  Token name = consume(TokenType::IDENTIFIER, "Expect variable name.");

  ExprPtr init = nullptr;
  if (match(TokenType::EQUAL)) {
    init = expression();
  }
  consume(TokenType::SEMICOLON, "Expect ';' after variable declaration.");
  return std::make_unique<Stmt::Var>(name, std::move(init));
}

StmtPtr Parser::classDeclaration() {
  Token name = consume(TokenType::IDENTIFIER, "Expect class name.");

  std::unique_ptr<Expr::Variable> superclass = nullptr;
  if (match(TokenType::LESS)) {
    consume(TokenType::IDENTIFIER, "Expect superclass name.");
    superclass = std::make_unique<Expr::Variable>(previous());
  }

  consume(TokenType::LEFT_BRACE, "Expect '{' before class declaration.");

  auto methods = std::make_unique<std::vector<std::unique_ptr<Stmt::Function>>>();
  while (!check(TokenType::RIGHT_BRACE) && !isAtEnd()) {
    bool is_static = false;
    if (match(TokenType::CLASS)) is_static = true;
    methods->push_back(std::move(function("method", is_static)));
  }

  consume(TokenType::RIGHT_BRACE, "Expect '}' after class body.");

  return std::make_unique<Stmt::Class>(name, std::move(superclass), std::move(methods));
}

StmtPtr Parser::statement() {
  if (match(TokenType::FOR)) return forStatement();
  if (match(TokenType::IF)) return ifStatement();
  if (match(TokenType::PRINT)) return printStatement();
  if (match(TokenType::RETURN)) return returnStatement();
  if (match(TokenType::WHILE)) return whileStatement();
  if (match(TokenType::LEFT_BRACE)) return std::make_unique<Stmt::Block>(block());

  return expressionStatement();
}

StmtPtr Parser::declaration() {
  try {
    if (match(TokenType::CLASS)) return classDeclaration();
    if (match(TokenType::FUN)) return function("function");
    if (match(TokenType::VAR)) return varDeclaration();
    return statement();
  } catch (ParseError &e) {
    synchronize();
    return nullptr;
  }
}

std::shared_ptr<std::vector<StmtPtr>> Parser::parse() {
  try {
    auto stmts = std::make_shared<std::vector<StmtPtr>>();
    while (!isAtEnd()) {
      stmts->push_back(declaration());
    }
    return stmts;
  } catch (ParseError &e) {
    return {};
  }
}

void Parser::synchronize() {
  advance();

  while (!isAtEnd()) {
    if (previous().type == TokenType::SEMICOLON) return;

    switch (peek().type) {
      case TokenType::CLASS:
      case TokenType::FUN:
      case TokenType::VAR:
      case TokenType::FOR:
      case TokenType::IF:
      case TokenType::WHILE:
      case TokenType::PRINT:
      case TokenType::RETURN:
        return;
      default: advance();
    }
  }
}