AST Transformation

ast-transformation.scala

object Test {

  def main(args: Array[String]): Unit = {
    abstract class Transformer {
      def transform(tree: Transformable): Transformable = tree match {
        case Class(name, body) => Class(transformName(name), body map {transform(_).asInstanceOf[Statement]})
        case VariableWrite(id, value) => VariableWrite(transformName(id), transform(value).asInstanceOf[Expression])
        case Return(expr) => Return(transform(expr).asInstanceOf[Expression])
        case VariableAccess(id) => VariableAccess(transformName(id))
        case Value(value) => Value(transformValue(value))
      }

      def transformName(name: String): String
      def transformValue(value: Int): Int
    }

    // AST definition
    sealed trait Transformable
    sealed trait Definition extends Transformable
    case class Class(name: String, body: List[Statement]) extends Definition

    sealed trait Statement extends Transformable
    case class VariableWrite(id: String, value: Expression) extends Statement
    case class Return(expr: Expression) extends Statement

    sealed trait Expression extends Transformable
    case class VariableAccess(id: String) extends Expression
    case class Value(value: Int) extends Expression

    // Build a simple test AST
    val ast = Class("Thingy", List(
      VariableWrite("foo", Value(42)),
      Return(VariableAccess("foo"))
    ))

    print((new Transformer {
      def transformName(name: String): String = name.reverse
      def transformValue(value: Int): Int = value
    }) transform ast)
  }
}