GenTreeOps

Type Members

abstract type Source <: Tree
abstract type Target <: Tree

Abstract Value Members

abstract val Deconstructor: TreeExtractor { ... /* 4 definitions in type refinement */ }

An extractor for Source
abstract val sourceTrees: Trees

Attributes
protected
abstract val targetTrees: Trees

Attributes
protected

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
object Same
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[T](matcher: (Source) ⇒ Set[T])(e: Source): Set[T]

Collects a set of objects from all sub-expressions
def collectPreorder[T](matcher: (Source) ⇒ Seq[T])(e: Source): Seq[T]
def count(matcher: (Source) ⇒ Int)(e: Source): Int

Counts how many times the predicate holds in sub-expressions
def depth(e: Source): Int

Computes the depth of the tree
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def exists(matcher: (Source) ⇒ Boolean)(e: Source): Boolean

Checks if the predicate holds in some sub-expression
def filter(matcher: (Source) ⇒ Boolean)(e: Source): Set[Source]

Returns a set of all sub-expressions matching the predicate
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fold[T](f: (Source, Seq[T]) ⇒ T)(e: Source): T

Does a right tree fold
Does a right tree fold
A right tree fold applies the input function to the subnodes first (from left to right), and combine the results along with the current node value.
f
a function that takes the current node and the seq of results form the Sources.
e
The value on which to apply the fold.
returns
The expression after applying f on all Sources.

Note
the computation is lazy, hence you should not rely on side-effects of f
def formulaSize(t: Source): Int

Computes the size of a tree
def genericTransform[C](pre: (Source, C) ⇒ (Source, C), post: (Target, C) ⇒ (Target, C), combiner: (Target, Seq[C]) ⇒ C)(init: C)(expr: Source): (Target, C)

Applies functions and combines results in a generic way
Applies functions and combines results in a generic way
Start with an initial value, and apply functions to nodes before and after the recursion in the children. Combine the results of all children and apply a final function on the resulting node.
pre
a function applied on a node before doing a recursion in the children
post
a function applied to the node built from the recursive application to all children
combiner
a function to combine the resulting values from all children with the current node
init
the initial value
expr
the expression on which to apply the transform

See also
simplePostTransform
simplePreTransform
simpleTransform
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
def lookup[T](checker: (Source) ⇒ Boolean, toExtract: (Source) ⇒ T)(treeToLookInto: Source, treeToExtract: Source): Option[T]

Given a tree toSearch present in treeToLookInto, if treeToLookInto has the same shape as treeToExtract, returns the matching expression in treeToExtract.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def noCombiner(e: Target, subCs: Seq[Unit]): Unit
def noTransformer[C](e: Source, c: C): (Source, C)
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def postMap(f: (Target) ⇒ Option[Target], applyRec: Boolean = false)(e: Source): Target

Post-transformation of the tree.
Post-transformation of the tree.
Takes a partial function of replacements. Substitutes after recurring down the trees.
Supports two modes :
- If applyRec is false (default), will only substitute once on each level. e.g.
```
Add(a, Minus(b, c)) with replacements: Minus(b,c) -> z, Minus(e,c) -> d, b -> e
```
will yield:
```
Add(a, Minus(e, c))
```
- If applyRec is true, it will substitute multiple times on each level: e.g.
```
Add(a, Minus(b, c)) with replacements: Minus(e,c) -> d, b -> e, d -> f
```
will yield:
```
Add(a, f)
```
Note
The mode with applyRec true can diverge if f is not well formed (i.e. not convergent)
def postTraversal(f: (Source) ⇒ Unit)(e: Source): Unit

Post-traversal of the tree.
Post-traversal of the tree.
Invokes the input function on every node after visiting children.
e.g.
```
Add(a, Minus(b, c))
```
will yield, in order:
```
f(a), f(b), f(c), f(Minus(b, c)), f(Add(a, Minus(b, c)))
```
f
a function to apply on each node of the expression
e
the expression to traverse
def preFoldWithContext[C](f: (Source, C) ⇒ C, combiner: (Source, C, Seq[C]) ⇒ C)(e: Source, c: C): C
def preMap(f: (Source) ⇒ Option[Source], applyRec: Boolean = false)(e: Source): Target

Pre-transformation of the tree.
Pre-transformation of the tree.
Takes a partial function of replacements and substitute before recursing down the trees.
Supports two modes :
- If applyRec is false (default), will only substitute once on each level.
e.g.
```
Add(a, Minus(b, c)) with replacements: Minus(b,c) -> d, b -> e, d -> f
```
will yield:
```
Add(a, d)   // And not Add(a, f) because it only substitute once for each level.
```
- If applyRec is true, it will substitute multiple times on each level:
e.g.
```
Add(a, Minus(b, c)) with replacements: Minus(b,c) -> d, b -> e, d -> f
```
will yield:
```
Add(a, f)
```
Note
The mode with applyRec true can diverge if f is not well formed
def preMapWithContext[C](f: (Source, C) ⇒ (Option[Source], C), applyRec: Boolean = false)(e: Source, c: C): Target

Pre-transformation of the tree, with a context value from "top-down".
Pre-transformation of the tree, with a context value from "top-down".
Takes a partial function of replacements. Substitutes before recursing down the trees. The function returns an option of the new value, as well as the new context to be used for the recursion in its children. The context is "lost" when going back up, so changes made by one node will not be see by its siblings.
def preTraversal(f: (Source) ⇒ Unit)(e: Source): Unit

Pre-traversal of the tree.
Pre-traversal of the tree.
Invokes the input function on every node before visiting children. Traverse children from left to right Sources.
e.g.
```
Add(a, Minus(b, c))
```
will yield, in order:
```
f(Add(a, Minus(b, c))); f(a); f(Minus(b, c)); f(b); f(c)
```
f
a function to apply on each node of the expression
e
the expression to traverse
def replace(substs: Map[Target, Target], expr: Source): Target

Replaces bottom-up sub-expressions by looking up for them in a map
def simplePostTransform(post: (Target) ⇒ Target)(tree: Source): Target

A simpleTransform without a pre-transformation
def simplePreTransform(pre: (Source) ⇒ Source)(tree: Source): Target

A simpleTransform without a post-transformation
def simpleTransform(pre: (Source) ⇒ Source, post: (Target) ⇒ Target)(tree: Source): Target

A genericTransform with the trivial combiner that returns ()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

Related Doc: package ast

trait GenTreeOps extends AnyRef

Type Members

abstract type Source <: Tree

abstract type Target <: Tree

Abstract Value Members

abstract val Deconstructor: TreeExtractor { ... /* 4 definitions in type refinement */ }

abstract val sourceTrees: Trees

abstract val targetTrees: Trees

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Same

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[T](matcher: (Source) ⇒ Set[T])(e: Source): Set[T]

def collectPreorder[T](matcher: (Source) ⇒ Seq[T])(e: Source): Seq[T]

def count(matcher: (Source) ⇒ Int)(e: Source): Int

def depth(e: Source): Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(matcher: (Source) ⇒ Boolean)(e: Source): Boolean

def filter(matcher: (Source) ⇒ Boolean)(e: Source): Set[Source]

def finalize(): Unit

def fold[T](f: (Source, Seq[T]) ⇒ T)(e: Source): T

def formulaSize(t: Source): Int

def genericTransform[C](pre: (Source, C) ⇒ (Source, C), post: (Target, C) ⇒ (Target, C), combiner: (Target, Seq[C]) ⇒ C)(init: C)(expr: Source): (Target, C)

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lookup[T](checker: (Source) ⇒ Boolean, toExtract: (Source) ⇒ T)(treeToLookInto: Source, treeToExtract: Source): Option[T]

final def ne(arg0: AnyRef): Boolean

def noCombiner(e: Target, subCs: Seq[Unit]): Unit

def noTransformer[C](e: Source, c: C): (Source, C)

final def notify(): Unit

final def notifyAll(): Unit

def postMap(f: (Target) ⇒ Option[Target], applyRec: Boolean = false)(e: Source): Target

def postTraversal(f: (Source) ⇒ Unit)(e: Source): Unit

def preFoldWithContext[C](f: (Source, C) ⇒ C, combiner: (Source, C, Seq[C]) ⇒ C)(e: Source, c: C): C

def preMap(f: (Source) ⇒ Option[Source], applyRec: Boolean = false)(e: Source): Target

def preMapWithContext[C](f: (Source, C) ⇒ (Option[Source], C), applyRec: Boolean = false)(e: Source, c: C): Target

def preTraversal(f: (Source) ⇒ Unit)(e: Source): Unit

def replace(substs: Map[Target, Target], expr: Source): Target

def simplePostTransform(post: (Target) ⇒ Target)(tree: Source): Target

def simplePreTransform(pre: (Source) ⇒ Source)(tree: Source): Target

def simpleTransform(pre: (Source) ⇒ Source, post: (Target) ⇒ Target)(tree: Source): Target

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped