Stmt.java

package SLox;
import java.util.List;
abstract class Stmt {
    interface Visitor<R> {
        R visitPrintStmt(Print expr);
        R visitExpressionStmt(Expression stmt);
        R visitBlockStmt(Block stmt);
        R visitIfStmt(If stmt);
        R visitWhileStmt(While stmt);
        R visitVarStmt(Var stmt);
        R visitFunctionStmt(Function stmt);
        R visitReturnStmt(Return stmt);
        R visitClassStmt(Class stmt);

    }
  static class Print extends Stmt {
    Print(Expr expression) {
      this.expression = expression;
}
    final Expr expression;
    @Override
    <R> R accept(Visitor<R> visitor) {
          return visitor.visitPrintStmt(this);
      }
}
  static class Expression extends Stmt {
    Expression(Expr expression) {
      this.expression = expression;
}
    final Expr expression;
    @Override
    <R> R accept(Visitor<R> visitor) {
          return visitor.visitExpressionStmt(this);
      }

  }
    static class Var extends Stmt {
        Var(Token name, Expr initializer) {
            this.name = name;
            this.initializer = initializer;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitVarStmt(this);
        }

        final Token name;
        final Expr initializer;
    }
    static class Block extends Stmt {
        Block(List<Stmt> statements) {
            this.statements = statements;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitBlockStmt(this);
        }

        final List<Stmt> statements;
    }

    static class If extends Stmt {
        If(Expr condition, Stmt thenBranch, Stmt elseBranch) {
            this.condition = condition;
            this.thenBranch = thenBranch;
            this.elseBranch = elseBranch;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitIfStmt(this);
        }

        final Expr condition;
        final Stmt thenBranch;
        final Stmt elseBranch;
    }
    static class While extends Stmt {
        While(Expr condition, Stmt body) {
            this.condition = condition;
            this.body = body;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitWhileStmt(this);
        }

        final Expr condition;
        final Stmt body;
    }

    static class Function extends Stmt {
        Function(Token name, List<Token> params, List<Stmt> body, boolean isGetter) {
            this.name = name;
            this.params = params;
            this.body = body;
            this.isGetter = isGetter;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitFunctionStmt(this);
        }

        final Token name;
        final List<Token> params;
        final List<Stmt> body;
        final boolean isGetter;
    }
    static class Return extends Stmt {
        Return(Token keyword, Expr value) {
            this.value = value;
            this.keyword = keyword;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitReturnStmt(this);
        }
        final Expr value;
        final Token keyword;
    }
    static class Class extends Stmt {
        Class(Token name,
              Expr.Variable superclass,
              List<Stmt.Function> methods) {
            this.name = name;
            this.superclass = superclass;
            this.methods = methods;
        }

        @Override
        <R> R accept(Visitor<R> visitor) {
            return visitor.visitClassStmt(this);
        }

        final Token name;
        final Expr.Variable superclass;
        final List<Stmt.Function> methods;
    }
    abstract <R> R accept(Visitor<R> visitor);

}