TreeInfo

abstract val global: Global

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (TreeInfo, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object BoundTerm extends AnyRef

object BoundType extends AnyRef

object DynamicApplication extends DynamicApplicationExtractor

object DynamicApplicationNamed extends DynamicApplicationExtractor

object DynamicUpdate extends DynamicApplicationExtractor

object EvalSplice extends AnyRef

object FreeDef extends AnyRef

object FreeRef extends AnyRef

object FreeTermDef extends AnyRef

object FreeTypeDef extends AnyRef

object InlineableTreeSplice extends AnyRef

object InlinedTreeSplice extends AnyRef

object InlinedTypeSplice extends AnyRef

object IsFalse extends SeeThroughBlocks[Boolean]

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

object IsTrue extends SeeThroughBlocks[Boolean]

object NestedExpr extends AnyRef

object Reified extends AnyRef

object ReifiedTree extends AnyRef

object ReifiedType extends AnyRef

object TreeSplice extends AnyRef

object TypeRefToFreeType extends AnyRef

object TypedOrAnnotated extends AnyRef

object ValueSplice extends AnyRef

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

def ensuring(cond: (TreeInfo) ⇒ Boolean, msg: ⇒ Any): TreeInfo

def ensuring(cond: (TreeInfo) ⇒ Boolean): TreeInfo

def ensuring(cond: Boolean, msg: ⇒ Any): TreeInfo

def ensuring(cond: Boolean): TreeInfo

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

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def isAbsTypeDef(tree: Tree): Boolean

def isAliasTypeDef(tree: Tree): Boolean

def isAllowedInUniversalTrait(stat: Tree): Boolean

def isApplyDynamicName(name: Name): 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 isInterface(mods: HasFlags, body: List[Tree]): 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 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 isVariablePattern(tree: Tree): Boolean

Is this tree comprised of nothing but identifiers, but possibly in bindings or tuples? For instance

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*

val self: Any

val self: Any

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 →[B](y: B): (TreeInfo, B)

def isPureExpr(tree: Tree): Boolean

def x: TreeInfo

def x: TreeInfo