abstract class TreeInfo extends AnyRef
This class ...
- Version
1.0
- Alphabetic
- By Inheritance
- TreeInfo
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new TreeInfo()
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, ...))
- class DynamicApplicationExtractor extends AnyRef
-
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.
Abstract Value Members
- abstract val global: SymbolTable
Concrete 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: Int
-
def
admitsTypeSelection(tree: SymbolTable.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.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
assignmentToMaybeNamedArg(tree: SymbolTable.Tree): SymbolTable.Tree
Translates an Assign(_, _) node to AssignOrNamedArg(_, _) if the lhs is a simple ident.
Translates an Assign(_, _) node to AssignOrNamedArg(_, _) if the lhs is a simple ident. Otherwise returns unchanged.
-
def
catchesThrowable(cdef: SymbolTable.CaseDef): Boolean
Does this CaseDef catch Throwable?
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
dissectApplied(tree: SymbolTable.Tree): Applied
Returns a wrapper that knows how to destructure and analyze applications.
-
def
effectivePatternArity(args: List[SymbolTable.Tree]): Int
//------------------------ => effectivePatternArity(args) case Extractor(a) => 1 case Extractor(a, b) => 2 case Extractor((a, b)) => 2 case Extractor(a @ (b, c)) => 2
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
firstConstructor(stats: List[SymbolTable.Tree]): SymbolTable.Tree
The first constructor definitions in
stats
-
def
firstConstructorArgs(stats: List[SymbolTable.Tree]): List[SymbolTable.Tree]
The arguments to the first constructor in
stats
. -
def
firstDefinesClassOrObject(trees: List[SymbolTable.Tree], name: SymbolTable.Name): Boolean
Does list of trees start with a definition of a class of module with given name (ignoring imports)
- def flattenedPatternArgs(args: List[SymbolTable.Tree]): List[SymbolTable.Tree]
- def foreachMethodParamAndArg(params: List[SymbolTable.Symbol], args: List[SymbolTable.Tree])(f: (SymbolTable.Symbol, SymbolTable.Tree) ⇒ Unit): Boolean
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hasSynthCaseSymbol(t: SymbolTable.Tree): Boolean
- def hasUntypedPreSuperFields(stats: List[SymbolTable.Tree]): Boolean
-
def
hasVolatileType(tree: SymbolTable.Tree): Boolean
Is
tree
's type volatile? (Ignored if its symbol has the @uncheckedStable annotation.) -
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def isAbsTypeDef(tree: SymbolTable.Tree): Boolean
- def isAliasTypeDef(tree: SymbolTable.Tree): Boolean
- def isApplyDynamicName(name: SymbolTable.Name): Boolean
-
def
isByNameParamType(tpt: SymbolTable.Tree): Boolean
Is tpt a by-name parameter type of the form => T?
-
def
isCatchCase(cdef: SymbolTable.CaseDef): Boolean
Is this pattern node a catch-all or type-test pattern?
- def isConstructorWithDefault(t: SymbolTable.Tree): Boolean
-
def
isDeclarationOrTypeDef(tree: SymbolTable.Tree): Boolean
Is tree a declaration or type definition?
-
def
isDefaultCase(cdef: SymbolTable.CaseDef): Boolean
Is this pattern node a catch-all (wildcard or variable) pattern?
- def isDefaultGetter(tree: SymbolTable.Tree): Boolean
- def isEarlyDef(tree: SymbolTable.Tree): Boolean
- def isEarlyValDef(tree: SymbolTable.Tree): Boolean
-
def
isExprSafeToInline(tree: SymbolTable.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.
- def isFunctionMissingParamType(tree: SymbolTable.Tree): Boolean
-
def
isGuardedCase(cdef: SymbolTable.CaseDef): Boolean
Is this case guarded?
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isInterfaceMember(tree: SymbolTable.Tree): Boolean
Is tree legal as a member definition of an interface?
-
def
isLeftAssoc(operator: SymbolTable.Name): Boolean
Is name a left-associative operator?
- def isLiteralString(t: SymbolTable.Tree): Boolean
- def isMacroApplication(tree: SymbolTable.Tree): Boolean
- def isMacroApplicationOrBlock(tree: SymbolTable.Tree): Boolean
- def isNullaryInvocation(tree: SymbolTable.Tree): Boolean
-
def
isPath(tree: SymbolTable.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
-
def
isPureDef(tree: SymbolTable.Tree): Boolean
Is tree a pure (i.e.
Is tree a pure (i.e. non-side-effecting) definition?
-
def
isPureExprForWarningPurposes(tree: SymbolTable.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.
- def isQualifierSafeToElide(tree: SymbolTable.Tree): Boolean
-
def
isRepeatedParamType(tpt: SymbolTable.Tree): Boolean
Is tpt a vararg type of the form T* ?
-
def
isSelfConstrCall(tree: SymbolTable.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?
-
def
isSelfOrSuperConstrCall(tree: SymbolTable.Tree): Boolean
Is tree a self or super constructor call?
-
def
isSequenceValued(tree: SymbolTable.Tree): Boolean
Is this pattern node a sequence-valued pattern?
-
def
isStableIdentifier(tree: SymbolTable.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
-
def
isStableIdentifierPattern(tree: SymbolTable.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)
-
def
isStableMemberOf(sym: SymbolTable.Symbol, tree: SymbolTable.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).
-
def
isStar(x: SymbolTable.Tree): Boolean
Is this tree a Star(_) after removing bindings?
-
def
isSuperConstrCall(tree: SymbolTable.Tree): Boolean
Is tree a super constructor call?
-
def
isSwitchAnnotation(tpe: SymbolTable.Type): Boolean
a Match(Typed(_, tpt), _) must be translated into a switch if isSwitchAnnotation(tpt.tpe)
- def isSynthCaseSymbol(sym: SymbolTable.Symbol): Boolean
-
def
isSyntheticCase(cdef: SymbolTable.CaseDef): Boolean
Is this CaseDef synthetically generated, e.g.
Is this CaseDef synthetically generated, e.g. by
MatchTranslation.translateTry
? -
def
isSyntheticDefaultCase(cdef: SymbolTable.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.
- def isTraitRef(tree: SymbolTable.Tree): Boolean
-
def
isVarPattern(pat: SymbolTable.Tree): Boolean
Is tree a variable pattern?
-
def
isVarPatternDeep(tree: SymbolTable.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
-
def
isVariableOrGetter(tree: SymbolTable.Tree): Boolean
Is tree a mutable variable, or the getter of a mutable field?
-
def
isWildcardArg(tree: SymbolTable.Tree): Boolean
Is the argument a wildcard argument of the form
_
orx @ _
? -
def
isWildcardStarArg(tree: SymbolTable.Tree): Boolean
Is this argument node of the form <expr> : _* ?
-
def
isWildcardStarArgList(trees: List[SymbolTable.Tree]): Boolean
Does this argument list end with an argument of the form <expr> : _* ?
-
def
isWildcardStarType(tree: SymbolTable.Tree): Boolean
Is the argument a wildcard star type of the form
_*
? - def mapMethodParamsAndArgs[R](params: List[SymbolTable.Symbol], args: List[SymbolTable.Tree])(f: (SymbolTable.Symbol, SymbolTable.Tree) ⇒ R): List[R]
-
def
mayBeTypePat(tree: SymbolTable.Tree): Boolean
can this type be a type pattern
-
def
mayBeVarGetter(sym: SymbolTable.Symbol): Boolean
Is symbol potentially a getter of a variable?
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def noFieldFor(vd: SymbolTable.ValDef, owner: SymbolTable.Symbol): Boolean
-
def
noPredefImportForUnit(body: SymbolTable.Tree): Boolean
Is this file the body of a compilation unit which should not have Predef imported?
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
preSuperFields(stats: List[SymbolTable.Tree]): List[SymbolTable.ValDef]
The value definitions marked PRESUPER in this statement sequence
-
def
stripCast(tree: SymbolTable.Tree): SymbolTable.Tree
Strips layers of
.asInstanceOf[T]
/_.$asInstanceOf[T]()
from an expression -
def
stripNamedApplyBlock(tree: SymbolTable.Tree): SymbolTable.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) }
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
typeParameters(tree: SymbolTable.Tree): List[SymbolTable.TypeDef]
If this tree has type parameters, those.
If this tree has type parameters, those. Otherwise Nil.
-
def
unbind(x: SymbolTable.Tree): SymbolTable.Tree
The underlying pattern ignoring any bindings
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @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. - object DynamicApplication extends DynamicApplicationExtractor
- object DynamicApplicationNamed extends DynamicApplicationExtractor
- object DynamicUpdate extends DynamicApplicationExtractor
- object IsFalse extends SeeThroughBlocks[Boolean]
- object IsTrue extends SeeThroughBlocks[Boolean]
- object MacroImplReference
- object StripCast
-
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.
- object WildcardStarArg