object treeInfo extends TreeInfo
- Definition Classes
- JavaUniverse → SymbolTable
- Source
- JavaUniverse.scala
- Alphabetic
- By Inheritance
- treeInfo
- TreeInfo
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- class Applied extends AnyRef
Applications in Scala can have one of the following shapes:
Applications in Scala can have one of the following shapes:
1) naked core: Ident(_) or Select(_, _) or basically anything else 2) naked core with targs: TypeApply(core, targs) or AppliedTypeTree(core, targs) 3) apply or several applies wrapping a core: Apply(core, _), or Apply(Apply(core, _), _), etc
This class provides different ways to decompose applications and simplifies their analysis.
***Examples*** (TypeApply in the examples can be replaced with AppliedTypeTree)
Ident(foo): * callee = Ident(foo) * core = Ident(foo) * targs = Nil * argss = Nil
TypeApply(foo, List(targ1, targ2...)) * callee = TypeApply(foo, List(targ1, targ2...)) * core = foo * targs = List(targ1, targ2...) * argss = Nil
Apply(foo, List(arg1, arg2...)) * callee = foo * core = foo * targs = Nil * argss = List(List(arg1, arg2...))
Apply(Apply(foo, List(arg21, arg22, ...)), List(arg11, arg12...)) * callee = foo * core = foo * targs = Nil * argss = List(List(arg11, arg12...), List(arg21, arg22, ...))
Apply(Apply(TypeApply(foo, List(targs1, targs2, ...)), List(arg21, arg22, ...)), List(arg11, arg12...)) * callee = TypeApply(foo, List(targs1, targs2, ...)) * core = foo * targs = Nil * argss = List(List(arg11, arg12...), List(arg21, arg22, ...))
- Definition Classes
- TreeInfo
- class DynamicApplicationExtractor extends AnyRef
- Definition Classes
- TreeInfo
- abstract class SeeThroughBlocks[T] extends AnyRef
Some handy extractors for spotting trees through the the haze of irrelevant braces: i.e.
Some handy extractors for spotting trees through the the haze of irrelevant braces: i.e. Block(Nil, SomeTree) should not keep us from seeing SomeTree.
- Definition Classes
- TreeInfo
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final val SYNTH_CASE_FLAGS: Long(2099200L)
- Definition Classes
- TreeInfo
- def admitsTypeSelection(tree: JavaUniverse.Tree): Boolean
Is
tree
either a non-volatile type, or a path that does not include any of:Is
tree
either a non-volatile type, or a path that does not include any of:- a reference to a mutable variable/field
- a reference to a by-name parameter
- a member selection on a volatile type (Spec: 3.6 Volatile Types)?
Such a tree is a suitable target for type selection.
- Definition Classes
- TreeInfo
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def assignmentToMaybeNamedArg(tree: JavaUniverse.Tree): JavaUniverse.Tree
Translates an Assign(_, _) node to NamedArg(_, _) if the lhs is a simple ident.
Translates an Assign(_, _) node to NamedArg(_, _) if the lhs is a simple ident. Otherwise returns unchanged.
- Definition Classes
- TreeInfo
- def catchesThrowable(cdef: JavaUniverse.CaseDef): Boolean
Does this CaseDef catch Throwable?
Does this CaseDef catch Throwable?
- Definition Classes
- TreeInfo
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def dissectApplied(tree: JavaUniverse.Tree): Applied
Returns a wrapper that knows how to destructure and analyze applications.
Returns a wrapper that knows how to destructure and analyze applications.
- Definition Classes
- TreeInfo
- def effectivePatternArity(args: List[JavaUniverse.Tree]): Int
//------------------------ => effectivePatternArity(args) case Extractor(a) => 1 case Extractor(a, b) => 2 case Extractor((a, b)) => 2 case Extractor(a @ (b, c)) => 2
- Definition Classes
- TreeInfo
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def firstConstructor(stats: List[JavaUniverse.Tree]): JavaUniverse.Tree
The first constructor definitions in
stats
The first constructor definitions in
stats
- Definition Classes
- TreeInfo
- def firstConstructorArgs(stats: List[JavaUniverse.Tree]): List[JavaUniverse.Tree]
The arguments to the first constructor in
stats
.The arguments to the first constructor in
stats
.- Definition Classes
- TreeInfo
- def firstConstructorMods(stats: List[JavaUniverse.Tree]): JavaUniverse.Modifiers
The modifiers of the first constructor in
stats
.The modifiers of the first constructor in
stats
.- Definition Classes
- TreeInfo
- final def firstDefinesClassOrObject(trees: List[JavaUniverse.Tree], name: JavaUniverse.Name): Boolean
Does list of trees start with a definition of a class or module with given name (ignoring imports)
Does list of trees start with a definition of a class or module with given name (ignoring imports)
- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- def flattenedPatternArgs(args: List[JavaUniverse.Tree]): List[JavaUniverse.Tree]
- Definition Classes
- TreeInfo
- def foreachMethodParamAndArg(params: List[JavaUniverse.Symbol], args: List[JavaUniverse.Tree])(f: (JavaUniverse.Symbol, JavaUniverse.Tree) => Unit): Boolean
- Definition Classes
- TreeInfo
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- val global: JavaUniverse.this.type
- Definition Classes
- treeInfo → TreeInfo
- def hasSynthCaseSymbol(t: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def hasUntypedPreSuperFields(stats: List[JavaUniverse.Tree]): Boolean
- Definition Classes
- TreeInfo
- def hasVolatileType(tree: JavaUniverse.Tree): Boolean
Is
tree
's type volatile? (Ignored if its symbol has the @uncheckedStable annotation.)Is
tree
's type volatile? (Ignored if its symbol has the @uncheckedStable annotation.)- Definition Classes
- TreeInfo
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def isAbsTypeDef(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isAliasTypeDef(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isApplyDynamicName(name: JavaUniverse.Name): Boolean
- Definition Classes
- TreeInfo
- def isByNameParamType(tpt: JavaUniverse.Tree): Boolean
Is tpt a by-name parameter type of the form => T?
Is tpt a by-name parameter type of the form => T?
- Definition Classes
- TreeInfo
- def isCatchCase(cdef: JavaUniverse.CaseDef): Boolean
Is this pattern node a catch-all or type-test pattern?
Is this pattern node a catch-all or type-test pattern?
- Definition Classes
- TreeInfo
- def isConstructorWithDefault(t: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isDeclarationOrTypeDef(tree: JavaUniverse.Tree): Boolean
Is tree a declaration or type definition?
Is tree a declaration or type definition?
- Definition Classes
- TreeInfo
- def isDefaultCase(cdef: JavaUniverse.CaseDef): Boolean
Is this pattern node a catch-all (wildcard or variable) pattern?
Is this pattern node a catch-all (wildcard or variable) pattern?
- Definition Classes
- TreeInfo
- def isDefaultGetter(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isEarlyDef(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isEarlyValDef(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- final def isExprSafeToInline(tree: JavaUniverse.Tree): Boolean
Is tree an expression which can be inlined without affecting program semantics?
Is tree an expression which can be inlined without affecting program semantics?
Note that this is not called "isExprPure" since purity (lack of side-effects) is not the litmus test. References to modules and lazy vals are side-effecting, both because side-effecting code may be executed and because the first reference takes a different code path than all to follow; but they are safe to inline because the expression result from evaluating them is always the same.
- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- def isFunctionMissingParamType(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isGuardedCase(cdef: JavaUniverse.CaseDef): Boolean
Is this case guarded?
Is this case guarded?
- Definition Classes
- TreeInfo
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isInterfaceMember(tree: JavaUniverse.Tree): Boolean
Is tree legal as a member definition of an interface?
Is tree legal as a member definition of an interface?
- Definition Classes
- TreeInfo
- def isLiteralString(t: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isMacroApplication(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- final def isMacroApplicationOrBlock(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- final def isNullaryInvocation(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- def isPartialFunctionMissingParamType(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isPath(tree: JavaUniverse.Tree, allowVolatile: Boolean): Boolean
Is
tree
a path, defined as follows? (Spec: 3.1 Paths)Is
tree
a path, defined as follows? (Spec: 3.1 Paths)- The empty path ε (which cannot be written explicitly in user programs). - C.this, where C references a class. - p.x where p is a path and x is a stable member of p. - C.super.x or C.super[M].x where C references a class and x references a stable member of the super class or designated parent class M of C.
NOTE: Trees with errors are (mostly) excluded.
Path ::= StableId | [id ‘.’] this
- Definition Classes
- TreeInfo
- def isPureDef(tree: JavaUniverse.Tree): Boolean
Is tree a pure (i.e.
Is tree a pure (i.e. non-side-effecting) definition?
- Definition Classes
- TreeInfo
- final def isPureExprForWarningPurposes(tree: JavaUniverse.Tree): Boolean
As if the name of the method didn't give it away, this logic is designed around issuing helpful warnings and minimizing spurious ones.
As if the name of the method didn't give it away, this logic is designed around issuing helpful warnings and minimizing spurious ones. That means don't reuse it for important matters like inlining decisions.
- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- def isQualifierSafeToElide(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isRepeatedParamType(tpt: JavaUniverse.Tree): Boolean
Is tpt a vararg type of the form T* ?
Is tpt a vararg type of the form T* ?
- Definition Classes
- TreeInfo
- def isSelfConstrCall(tree: JavaUniverse.Tree): Boolean
Is tree a self constructor call this(...)? I.e.
Is tree a self constructor call this(...)? I.e. a call to a constructor of the same object?
- Definition Classes
- TreeInfo
- def isSelfOrSuperConstrCall(tree: JavaUniverse.Tree): Boolean
Is tree a self or super constructor call?
Is tree a self or super constructor call?
- Definition Classes
- TreeInfo
- def isSequenceValued(tree: JavaUniverse.Tree): Boolean
Is this pattern node a sequence-valued pattern?
Is this pattern node a sequence-valued pattern?
- Definition Classes
- TreeInfo
- def isStableIdentifier(tree: JavaUniverse.Tree, allowVolatile: Boolean): Boolean
Is
tree
a stable identifier, a path which ends in an identifier?Is
tree
a stable identifier, a path which ends in an identifier?StableId ::= id | Path ‘.’ id | [id ’.’] ‘super’ [‘[’ id ‘]’] ‘.’ id
- Definition Classes
- TreeInfo
- def isStableIdentifierPattern(tree: JavaUniverse.Tree): Boolean
Is
tree
admissible as a stable identifier pattern (8.1.5 Stable Identifier Patterns)?Is
tree
admissible as a stable identifier pattern (8.1.5 Stable Identifier Patterns)?We disregard volatility, as it's irrelevant in patterns (scala/bug#6815)
- Definition Classes
- TreeInfo
- def isStableMemberOf(sym: JavaUniverse.Symbol, tree: JavaUniverse.Tree, allowVolatile: Boolean): Boolean
Assuming
sym
is a member oftree
, is it a "stable member"?Assuming
sym
is a member oftree
, is it a "stable member"?Stable members are packages or members introduced by object definitions or by value definitions of non-volatile types (§3.6).
- Definition Classes
- TreeInfo
- def isStar(x: JavaUniverse.Tree): Boolean
Is this tree a Star(_) after removing bindings?
Is this tree a Star(_) after removing bindings?
- Definition Classes
- TreeInfo
- def isSuperConstrCall(tree: JavaUniverse.Tree): Boolean
Is tree a super constructor call?
Is tree a super constructor call?
- Definition Classes
- TreeInfo
- def isSwitchAnnotation(tpe: JavaUniverse.Type): Boolean
a Match(Typed(_, tpt), _) must be translated into a switch if isSwitchAnnotation(tpt.tpe)
a Match(Typed(_, tpt), _) must be translated into a switch if isSwitchAnnotation(tpt.tpe)
- Definition Classes
- TreeInfo
- def isSynthCaseSymbol(sym: JavaUniverse.Symbol): Boolean
- Definition Classes
- TreeInfo
- def isSyntheticCase(cdef: JavaUniverse.CaseDef): Boolean
Is this CaseDef synthetically generated, e.g.
Is this CaseDef synthetically generated, e.g. by
MatchTranslation.translateTry
?- Definition Classes
- TreeInfo
- def isSyntheticDefaultCase(cdef: JavaUniverse.CaseDef): Boolean
Is this pattern node a synthetic catch-all case, added during PartialFunction synthesis before we know whether the user provided cases are exhaustive.
Is this pattern node a synthetic catch-all case, added during PartialFunction synthesis before we know whether the user provided cases are exhaustive.
- Definition Classes
- TreeInfo
- def isTraitRef(tree: JavaUniverse.Tree): Boolean
- Definition Classes
- TreeInfo
- def isVarPattern(pat: JavaUniverse.Tree): Boolean
Is tree a variable pattern?
Is tree a variable pattern?
- Definition Classes
- TreeInfo
- def isVarPatternDeep(tree: JavaUniverse.Tree): Boolean
Does this tree represent an irrefutable pattern match in the position
for { <tree> <- expr }
based only on information at theparser
phase? To qualify, there may be no subtree that will be interpreted as a Stable Identifier Pattern, nor any type tests, even on TupleN.Does this tree represent an irrefutable pattern match in the position
for { <tree> <- expr }
based only on information at theparser
phase? To qualify, there may be no subtree that will be interpreted as a Stable Identifier Pattern, nor any type tests, even on TupleN. See scala/bug#6968.For instance:
(foo @ (bar @ _)) = 0
is a not a variable pattern; if only binds names.
The following are not variable patterns.
`bar` Bar (a, b) _: T
If the pattern is a simple identifier, it is always a variable pattern. For example, the following introduce new bindings:
for { X <- xs } yield X for { `backquoted` <- xs } yield `backquoted`
Note that this differs from a case clause:
object X scrut match { case X => // case _ if scrut == X }
Background: https://groups.google.com/d/msg/scala-internals/qwa_XOw_7Ks/IktkeTBYqg0J
- Definition Classes
- TreeInfo
- def isVariableOrGetter(tree: JavaUniverse.Tree): Boolean
Is tree a mutable variable, or the getter of a mutable field?
Is tree a mutable variable, or the getter of a mutable field?
- Definition Classes
- TreeInfo
- def isWildcardArg(tree: JavaUniverse.Tree): Boolean
Is the argument a wildcard argument of the form
_
orx @ _
?Is the argument a wildcard argument of the form
_
orx @ _
?- Definition Classes
- TreeInfo
- def isWildcardStarArg(tree: JavaUniverse.Tree): Boolean
Is this argument node of the form <expr> : _* ?
Is this argument node of the form <expr> : _* ?
- Definition Classes
- TreeInfo
- def isWildcardStarArgList(trees: List[JavaUniverse.Tree]): Boolean
Does this argument list end with an argument of the form <expr> : _* ?
Does this argument list end with an argument of the form <expr> : _* ?
- Definition Classes
- TreeInfo
- def isWildcardStarType(tree: JavaUniverse.Tree): Boolean
Is the argument a wildcard star type of the form
_*
?Is the argument a wildcard star type of the form
_*
?- Definition Classes
- TreeInfo
- def mapMethodParamsAndArgs[R](params: List[JavaUniverse.Symbol], args: List[JavaUniverse.Tree])(f: (JavaUniverse.Symbol, JavaUniverse.Tree) => R): List[R]
- Definition Classes
- TreeInfo
- final def mayBeTypePat(tree: JavaUniverse.Tree): Boolean
can this type be a type pattern
can this type be a type pattern
- Definition Classes
- TreeInfo
- def mayBeVarGetter(sym: JavaUniverse.Symbol): Boolean
Is symbol potentially a getter of a variable?
Is symbol potentially a getter of a variable?
- Definition Classes
- TreeInfo
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def noFieldFor(vd: JavaUniverse.ValDef, owner: JavaUniverse.Symbol): Boolean
- Definition Classes
- TreeInfo
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def preSuperFields(stats: List[JavaUniverse.Tree]): List[JavaUniverse.ValDef]
The value definitions marked PRESUPER in this statement sequence
The value definitions marked PRESUPER in this statement sequence
- Definition Classes
- TreeInfo
- final def stripCast(tree: JavaUniverse.Tree): JavaUniverse.Tree
Strips layers of
.asInstanceOf[T]
/_.$asInstanceOf[T]()
from an expressionStrips layers of
.asInstanceOf[T]
/_.$asInstanceOf[T]()
from an expression- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- def stripNamedApplyBlock(tree: JavaUniverse.Tree): JavaUniverse.Tree
Named arguments can transform a constructor call into a block, e.g.
Named arguments can transform a constructor call into a block, e.g. <init>(b = foo, a = bar) is transformed to { val x$1 = foo val x$2 = bar <init>(x$2, x$1) }
- Definition Classes
- TreeInfo
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def typeParameters(tree: JavaUniverse.Tree): List[JavaUniverse.TypeDef]
If this tree has type parameters, those.
If this tree has type parameters, those. Otherwise Nil.
- Definition Classes
- TreeInfo
- final def unbind(x: JavaUniverse.Tree): JavaUniverse.Tree
The underlying pattern ignoring any bindings
The underlying pattern ignoring any bindings
- Definition Classes
- TreeInfo
- Annotations
- @tailrec()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- object Applied
Destructures applications into important subparts described in
Applied
class, namely into: core, targs and argss (in the specified order).Destructures applications into important subparts described in
Applied
class, namely into: core, targs and argss (in the specified order).Trees which are not applications are also accepted. Their callee and core will be equal to the input, while targs and argss will be Nil.
The provided extractors don't expose all the API of the
Applied
class. For advanced use, calldissectApplied
explicitly and use its methods instead of pattern matching.- Definition Classes
- TreeInfo
- object DynamicApplication extends DynamicApplicationExtractor
- Definition Classes
- TreeInfo
- object DynamicApplicationNamed extends DynamicApplicationExtractor
- Definition Classes
- TreeInfo
- object DynamicUpdate extends DynamicApplicationExtractor
- Definition Classes
- TreeInfo
- object IsFalse extends SeeThroughBlocks[Boolean]
- Definition Classes
- TreeInfo
- object IsTrue extends SeeThroughBlocks[Boolean]
- Definition Classes
- TreeInfo
- object MacroImplReference
- Definition Classes
- TreeInfo
- object StripCast
- Definition Classes
- TreeInfo
- object Unapplied
Locates the synthetic Apply node corresponding to an extractor's call to unapply (unwrapping nested Applies) and returns the fun part of that Apply.
Locates the synthetic Apply node corresponding to an extractor's call to unapply (unwrapping nested Applies) and returns the fun part of that Apply.
- Definition Classes
- TreeInfo
- object WildcardStarArg
- Definition Classes
- TreeInfo