stmt.hpp

#pragma once
#include "visitor.hpp"
#include "token.hpp"
#include <any>
#include <iterator>
#include <memory>
#include <vector>

namespace Statement{
  struct Expression : Stmt, public std::enable_shared_from_this<Expression>{
     const std::shared_ptr<Expr> expression;
     
     Expression(std::shared_ptr<Expr> expression);
     std::any accept(StmtVisitor& visitor) override;
  };

  struct Print : Stmt, public std::enable_shared_from_this<Print>{
     const std::shared_ptr<Expr> expression;
     
     Print(std::shared_ptr<Expr> expression);
     std::any accept(StmtVisitor& visitor) override;
  };

  struct Assign : Stmt, public std::enable_shared_from_this<Assign>{
     Token name;
     std::shared_ptr<Expr> value;
     
     Assign(Token name, std::shared_ptr<Expr> value);
     std::any accept(StmtVisitor& visitor) override;
  };

  struct Var : Stmt, public std::enable_shared_from_this<Var> {
     Token name;
     std::shared_ptr<Expr> init;

     Var(Token name, std::shared_ptr<Expr> init);
     std::any accept(StmtVisitor &visitor) override;
  };

  // Implementações inline
  inline Expression::Expression(std::shared_ptr<Expr> expression) 
    : expression(std::move(expression)) {}
  
  inline std::any Expression::accept(StmtVisitor &visitor){
    return visitor.visitExpressionStmt(shared_from_this());
  }
  
  inline Print::Print(std::shared_ptr<Expr> expression) 
    : expression(std::move(expression)) {}
  
  inline std::any Print::accept(StmtVisitor &visitor){
    return visitor.visitPrintStmt(shared_from_this());
  }
  
  inline Assign::Assign(Token name, std::shared_ptr<Expr> value) 
    : name(std::move(name)), value(std::move(value)) {}
  
  inline std::any Assign::accept(StmtVisitor &visitor){
    return visitor.visitAssignStmt(shared_from_this());
  }
  
  inline Var::Var(Token name, std::shared_ptr<Expr> init) 
    : name(std::move(name)), init(std::move(init)) {}
  
  inline std::any Var::accept(StmtVisitor &visitor){
    return visitor.visitVarStmt(shared_from_this());
  }
}