Basic Expressions

Literals

As we've seen earlier, literals are written as follows:

import treehugger.forest._, definitions._, treehuggerDSL._

LIT(1)                       // 1
// res0: Literal = Literal(Constant(1))
LIT(1L)                      // 1L
// res1: Literal = Literal(Constant(1L))
LIT(1.23)                    // 1.23
// res2: Literal = Literal(Constant(1.23))
LIT(1.23F)                   // 1.23F
// res3: Literal = Literal(Constant(1.23F))
LIT('H')                     // 'H'
// res4: Literal = Literal(Constant('H'))
LIT("H")                     // "H"
// res5: Literal = Literal(Constant("H"))
LIT('Sym)                    // 'Sym
// res6: Literal = Literal(Constant('Sym))
TRUE                         // true
// res7: Literal = Literal(Constant(true))
FALSE                        // false
// res8: Literal = Literal(Constant(false))
NULL                         // null
// res9: Literal = Literal(Constant(null))
UNIT                         // ()
// res10: Literal = Literal(Constant(()))

Simple Names

Simple names are written using REF(sym|"x") to refer to values and methods that immediately available in the current scope:

object sym {
  val x = RootClass.newValue("x")
  val y = RootClass.newValue("y")
  val Address = RootClass.newClass("Address")
}

REF("x")                     // x
// res11: Ident = Ident(TermName("x"))

REF(sym.x)                   // x
// res12: Tree = Ident(TermName("x"))

Selection

To refer to other values and methods, selections are written by calling DOT(sym|"y") either on a symbol or on a REF(sym|"x"). This returns an intermediate structure that can turn into a Tree by calling tree method or by implicit conversion:

(sym.x DOT sym.y).tree       // x.y
// res13: Select = Select(Ident(TermName("x")), TermName("y"))

(sym.x DOT "y": Tree)        // x.y
// res14: Tree = Select(Ident(TermName("x")), TermName("y"))

(REF("x") DOT "y": Tree)     // x.y
// res15: Tree = Select(Ident(TermName("x")), TermName("y"))

val tree = (REF("x") DOT "y").tree
// tree: Select = Select(Ident(TermName("x")), TermName("y"))

treeToString(tree)
// res16: String = "x.y"

This

References to this are written using THIS or THIS(sym|"C"):

THIS                         // this
// res17: This = This(TypeName(""))

val tree2 = THIS(sym.Address)
// tree2: Tree = This(TypeName("Address"))

treeToString(tree2)
// res18: String = "Address.this"

Super

References to super are written using SUPER or SUPER(sym|"C"). This also returns an intermediate structure that can turn into a Tree by calling tree method or via implicit conversion:

SUPER.tree                   // super
// res19: Super = Super(EmptyTree, TypeName(""))

(SUPER("C"): Tree)           // C.super
// res20: Tree = Super(This(TypeName("C")), TypeName(""))

To add type parameter to super, call APPLYTYPE(sym|"T"):

val tree3 = SUPER APPLYTYPE "T"
// tree3: Super = Super(EmptyTree, TypeName("T"))

treeToString(tree3)
// res21: String = "super[T]"