TreeTypeMap

Instance Constructors

new TreeTypeMap(typeMap: (Type) ⇒ Type = IdentityTypeMap, treeMap: (tpd.Tree) ⇒ tpd.Tree = identity, oldOwners: List[Symbol] = Nil, newOwners: List[Symbol] = Nil, substFrom: List[Symbol] = Nil, substTo: List[Symbol] = Nil)(implicit ctx: Context)

typeMap
A function from Type to Type that gets applied to the type of every tree node and to all locally defined symbols, followed by the substitution [substFrom := substTo].
treeMap
A transformer that translates all encountered subtrees in prefix traversal orders
oldOwners
Previous owners. If a top-level local symbol in the mapped tree has one of these as an owner, the owner is replaced by the corresponding symbol in newOwners.
newOwners
New owners, replacing previous owners.
substFrom
The symbols that need to be substituted.
substTo
The substitution targets.
The reason the substitution is broken out from the rest of the type map is that all symbols have to be substituted at the same time. If we do not do this, we risk data races on named types. Example: Say we have outer#1.inner#2 and we have two substitutions S1 = [outer#1 := outer#3], S2 = [inner#2 := inner#4] where hashtags precede symbol ids. If we do S1 first, we get outer#2.inner#3. If we then do S2 we get outer#2.inner#4. But that means that the named type outer#2.inner gets two different denotations in the same period. Hence, if -Yno-double-bindings is set, we would get a data race assertion error.

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
def apply(annot: Annotation): Annotation
def apply[ThisTree <: tpd.Tree](tree: ThisTree): ThisTree
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val cpy: tpd.TreeCopier

Definition Classes
TreeMap
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mapOwner(sym: Symbol): Symbol

If sym is one of oldOwners, replace by corresponding symbol in newOwners
def mapType(tp: Type): Type
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val newOwners: List[Symbol]

New owners, replacing previous owners.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val oldOwners: List[Symbol]

Previous owners.
Previous owners. If a top-level local symbol in the mapped tree has one of these as an owner, the owner is replaced by the corresponding symbol in newOwners.
val substFrom: List[Symbol]

The symbols that need to be substituted.
val substTo: List[Symbol]

The substitution targets.
The substitution targets.
The reason the substitution is broken out from the rest of the type map is that all symbols have to be substituted at the same time. If we do not do this, we risk data races on named types. Example: Say we have outer#1.inner#2 and we have two substitutions S1 = [outer#1 := outer#3], S2 = [inner#2 := inner#4] where hashtags precede symbol ids. If we do S1 first, we get outer#2.inner#3. If we then do S2 we get outer#2.inner#4. But that means that the named type outer#2.inner gets two different denotations in the same period. Hence, if -Yno-double-bindings is set, we would get a data race assertion error.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree

Definition Classes
TreeTypeMap → TreeMap
def transform(trees: List[tpd.Tree])(implicit ctx: Context): List[tpd.Tree]

Definition Classes
TreeMap
def transformStats(trees: List[tpd.Tree])(implicit ctx: Context): List[tpd.Tree]

Definition Classes
TreeTypeMap → TreeMap
def transformSub[Tr <: tpd.Tree](trees: List[Tr])(implicit ctx: Context): List[Tr]

Definition Classes
TreeMap
def transformSub[Tr <: tpd.Tree](tree: Tr)(implicit ctx: Context): Tr

Definition Classes
TreeMap
val treeMap: (tpd.Tree) ⇒ tpd.Tree

A transformer that translates all encountered subtrees in prefix traversal orders
val typeMap: (Type) ⇒ Type

A function from Type to Type that gets applied to the type of every tree node and to all locally defined symbols, followed by the substitution [substFrom := substTo].
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( ... )
def withMappedSyms(syms: List[Symbol], mapped: List[Symbol]): TreeTypeMap

The tree map with the substitution between originals syms and mapped symbols mapped.
The tree map with the substitution between originals syms and mapped symbols mapped. Also goes into mapped classes and substitutes their declarations.
def withMappedSyms(syms: List[Symbol], mapAlways: Boolean = false): TreeTypeMap

Apply typeMap and ownerMap to given symbols syms and return a treemap that contains the substitution between original and mapped symbols.
def withSubstitution(from: List[Symbol], to: List[Symbol]): TreeTypeMap

The current tree map composed with a substitution [from -> to]

Related Doc: package ast

final class TreeTypeMap extends ast.tpd.TreeMap

Instance Constructors

new TreeTypeMap(typeMap: (Type) ⇒ Type = IdentityTypeMap, treeMap: (tpd.Tree) ⇒ tpd.Tree = identity, oldOwners: List[Symbol] = Nil, newOwners: List[Symbol] = Nil, substFrom: List[Symbol] = Nil, substTo: List[Symbol] = Nil)(implicit ctx: Context)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(annot: Annotation): Annotation

def apply[ThisTree <: tpd.Tree](tree: ThisTree): ThisTree

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val cpy: tpd.TreeCopier

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mapOwner(sym: Symbol): Symbol

def mapType(tp: Type): Type

final def ne(arg0: AnyRef): Boolean

val newOwners: List[Symbol]

final def notify(): Unit

final def notifyAll(): Unit

val oldOwners: List[Symbol]

val substFrom: List[Symbol]

val substTo: List[Symbol]

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

def toString(): String

def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree

def transform(trees: List[tpd.Tree])(implicit ctx: Context): List[tpd.Tree]

def transformStats(trees: List[tpd.Tree])(implicit ctx: Context): List[tpd.Tree]

def transformSub[Tr <: tpd.Tree](trees: List[Tr])(implicit ctx: Context): List[Tr]

def transformSub[Tr <: tpd.Tree](tree: Tr)(implicit ctx: Context): Tr

val treeMap: (tpd.Tree) ⇒ tpd.Tree

val typeMap: (Type) ⇒ Type

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withMappedSyms(syms: List[Symbol], mapped: List[Symbol]): TreeTypeMap

def withMappedSyms(syms: List[Symbol], mapAlways: Boolean = false): TreeTypeMap

def withSubstitution(from: List[Symbol], to: List[Symbol]): TreeTypeMap

Inherited from tpd.TreeMap

Inherited from AnyRef

Inherited from Any

Ungrouped