TreeInfo

abstract val global: SymbolTable

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object IsFalse extends SeeThroughBlocks[Boolean]

object IsIf extends SeeThroughBlocks[Option[(Tree, Tree, Tree)]]

object IsTrue extends SeeThroughBlocks[Boolean]

def applyDepth(tree: Tree): Int

The depth of the nested applies: e.

final def asInstanceOf[T0]: T0

def catchesAllOf(cdef: CaseDef, threshold: Type): Boolean

Does this CaseDef catch everything of a certain Type?

def catchesThrowable(cdef: CaseDef): Boolean

Does this CaseDef catch Throwable?

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def firstArgument(tree: Tree): Tree

def firstConstructor(stats: List[Tree]): Tree

The first constructor definitions in stats

def firstConstructorArgs(stats: List[Tree]): List[Tree]

The arguments to the first constructor in stats.

def firstDefinesClassOrObject(trees: List[Tree], name: Name): Boolean

Does list of trees start with a definition of a class of module with given name (ignoring imports)

def firstTypeArg(tree: Tree): Tree

If this tree represents a type application (after unwrapping any applies) the first type argument.

def foreachMethodParamAndArg(t: Tree)(f: (Symbol, Tree) ⇒ Unit): Unit

def foreachMethodParamAndArg(params: List[Symbol], args: List[Tree])(f: (Symbol, Tree) ⇒ Unit): Boolean

final def getClass(): Class[_]

def hashCode(): Int

def isAbsTypeDef(tree: Tree): Boolean

def isAliasTypeDef(tree: Tree): Boolean

def isByNameParamType(tpt: Tree): Boolean

Is tpt a by-name parameter type of the form => T?

def isCatchCase(cdef: CaseDef): Boolean

Is this pattern node a catch-all or type-test pattern?

def isDeclarationOrTypeDef(tree: Tree): Boolean

Is tree a declaration or type definition?

def isDefaultCase(cdef: CaseDef): Boolean

Is this pattern node a catch-all (wildcard or variable) pattern?

def isEarlyDef(tree: Tree): Boolean

def isEarlyTypeDef(tree: Tree): Boolean

def isEarlyValDef(tree: Tree): Boolean

def isExprSafeToInline(tree: Tree): Boolean

Is tree an expression which can be inlined without affecting program semantics?

final def isInstanceOf[T0]: Boolean

def isInterfaceMember(tree: Tree): Boolean

Is tree legal as a member definition of an interface?

def isLeftAssoc(operator: Name): Boolean

Is name a left-associative operator?

def isPredefExpr(t: Tree): Boolean

Is the tree Predef, scala.

def isPureDef(tree: Tree): Boolean

Is tree a pure (i.

def isRepeatedParamType(tpt: Tree): Boolean

Is tpt a vararg type of the form T* ?

def isSelf(tree: Tree, enclClass: Symbol): Boolean

Is tree a this node which belongs to enclClass?

def isSelfConstrCall(tree: Tree): Boolean

Is tree a self constructor call this(.

def isSelfOrSuperConstrCall(tree: Tree): Boolean

Is tree a self or super constructor call?

def isSequenceValued(tree: Tree): Boolean

Is this pattern node a sequence-valued pattern?

def isStar(x: Tree): Boolean

Is this tree a Star(_) after removing bindings?

def isSuperConstrCall(tree: Tree): Boolean

Is tree a super constructor call?

def isVarPattern(pat: Tree): Boolean

Is tree a variable pattern?

def isVariableName(name: Name): Boolean

Is name a variable name?

def isVariableOrGetter(tree: Tree): Boolean

Is tree a mutable variable, or the getter of a mutable field?

def isWildcardArg(tree: Tree): Boolean

Is the argument a wildcard argument of the form _ or x @ _?

def isWildcardStarArg(tree: Tree): Boolean

Is this argument node of the form <expr> : _* ?

def isWildcardStarArgList(trees: List[Tree]): Boolean

Does this argument list end with an argument of the form <expr> : _* ?

def mapMethodParamsAndArgs[R](params: List[Symbol], args: List[Tree])(f: (Symbol, Tree) ⇒ R): List[R]

def mayBeTypePat(tree: Tree): Boolean

can this type be a type pattern

def mayBeVarGetter(sym: Symbol): Boolean

Is symbol potentially a getter of a variable?

def methPart(tree: Tree): Tree

The method part of an application node

final def ne(arg0: AnyRef): Boolean

def noPredefImportForUnit(body: Tree): Boolean

Is this file the body of a compilation unit which should not have Predef imported?

final def notify(): Unit

final def notifyAll(): Unit

def preSuperFields(stats: List[Tree]): List[ValDef]

The value definitions marked PRESUPER in this statement sequence

def repeatedParams(tree: Tree): List[ValDef]

The parameter ValDefs of a method definition that have vararg types of the form T*

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def typeParameters(tree: Tree): List[TypeDef]

If this tree has type parameters, those.

def unbind(x: Tree): Tree

The underlying pattern ignoring any bindings

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zipMethodParamsAndArgs(t: Tree): List[(Symbol, Tree)]

def zipMethodParamsAndArgs(params: List[Symbol], args: List[Tree]): List[(Symbol, Tree)]

def isPureExpr(tree: Tree): Boolean