abstract class TreeGen extends AnyRef
- Alphabetic
- By Inheritance
- TreeGen
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new TreeGen()
Type Members
-
class
GetVarTraverser extends SymbolTable.Traverser
Traverse pattern and collect all variable names with their types in buffer The variables keep their positions; whereas the pattern is converted to be synthetic for all nodes that contain a variable position.
-
class
PatvarTransformer extends SymbolTable.Transformer
Convert all occurrences of (lower-case) variables in a pattern as follows: x becomes x @ _ x: T becomes x @ (_: T)
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
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
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] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isPatVarWarnable: Boolean
Can be overridden to depend on settings.warnUnusedPatvars.
-
def
maybeMkAsInstanceOf(tree: SymbolTable.Tree, pt: SymbolTable.Type, tpe: SymbolTable.Type, beforeRefChecks: Boolean = false): SymbolTable.Tree
Cast
tree
topt
, unless tpe is a subtype of pt, or pt is Unit. - def mkAnd(tree1: SymbolTable.Tree, tree2: SymbolTable.Tree): SymbolTable.Tree
- def mkAppliedTypeTree(fun: SymbolTable.Tree, targs: List[SymbolTable.Tree]): SymbolTable.Tree
-
def
mkApplyIfNeeded(qual: SymbolTable.Tree): SymbolTable.Tree
If this is a reference to a method with an empty parameter list, wrap it in an apply.
-
def
mkAsInstanceOf(value: SymbolTable.Tree, tpe: SymbolTable.Type, any: Boolean = true, wrapInApply: Boolean = true): SymbolTable.Tree
Builds a cast with given value and type.
-
def
mkAssign(lhs: SymbolTable.Tree, rhs: SymbolTable.Tree): SymbolTable.Tree
Create a tree representing an assignment <lhs = rhs>
- def mkAttributedIdent(sym: SymbolTable.Symbol): SymbolTable.RefTree
-
def
mkAttributedQualifier(tpe: SymbolTable.Type, termSym: SymbolTable.Symbol): SymbolTable.Tree
Builds a reference to value whose type is given stable prefix.
Builds a reference to value whose type is given stable prefix. If the type is unsuitable, e.g. it is a TypeRef for an abstract type variable, then an Ident will be made using termSym as the Ident's symbol. In that case, termSym must not be NoSymbol.
-
def
mkAttributedQualifier(tpe: SymbolTable.Type): SymbolTable.Tree
Builds a reference to value whose type is given stable prefix.
Builds a reference to value whose type is given stable prefix. The type must be suitable for this. For example, it must not be a TypeRef pointing to an abstract type variable.
- def mkAttributedQualifierIfPossible(prefix: SymbolTable.Type): Option[SymbolTable.Tree]
-
def
mkAttributedRef(sym: SymbolTable.Symbol): SymbolTable.RefTree
Builds a reference to given symbol.
-
def
mkAttributedRef(pre: SymbolTable.Type, sym: SymbolTable.Symbol): SymbolTable.RefTree
Builds a reference to given symbol with given stable prefix.
- def mkAttributedSelect(qual: SymbolTable.Tree, sym: SymbolTable.Symbol): SymbolTable.RefTree
- def mkAttributedStableRef(sym: SymbolTable.Symbol): SymbolTable.Tree
-
def
mkAttributedStableRef(pre: SymbolTable.Type, sym: SymbolTable.Symbol): SymbolTable.Tree
Builds a reference with stable type to given symbol
- def mkAttributedThis(sym: SymbolTable.Symbol): SymbolTable.This
- def mkAttributedTypeApply(target: SymbolTable.Tree, method: SymbolTable.Symbol, targs: List[SymbolTable.Type]): SymbolTable.Tree
-
def
mkBlock(stats: List[SymbolTable.Tree], doFlatten: Boolean = true): SymbolTable.Tree
Create block of statements
stats
- def mkCast(tree: SymbolTable.Tree, pt: SymbolTable.Type): SymbolTable.Tree
- def mkCheckIfRefutable(pat: SymbolTable.Tree, rhs: SymbolTable.Tree)(implicit fresh: FreshNameCreator): SymbolTable.Tree
- def mkClassDef(mods: SymbolTable.Modifiers, name: SymbolTable.TypeName, tparams: List[SymbolTable.TypeDef], templ: SymbolTable.Template): SymbolTable.ClassDef
-
def
mkClassOf(tp: SymbolTable.Type): SymbolTable.Tree
Apparently we smuggle a Type around as a Literal(Constant(tp)) and the implementation of Constant#tpe is such that x.tpe becomes ClassType(value.asInstanceOf[Type]), i.e.
Apparently we smuggle a Type around as a Literal(Constant(tp)) and the implementation of Constant#tpe is such that x.tpe becomes ClassType(value.asInstanceOf[Type]), i.e. java.lang.Class[Type]. Can't find any docs on how/why it's done this way. See ticket scala/bug#490 for some interesting comments from lauri alanko suggesting that the type given by classOf[T] is too strong and should be weakened so as not to suggest that classOf[List[String]] is any different from classOf[List[Int]].
!!! See deconstMap in Erasure for one bug this encoding has induced: I would be very surprised if there aren't more.
- def mkConstantZero(tp: SymbolTable.Type): SymbolTable.Constant
-
def
mkFor(enums: List[SymbolTable.Tree], sugarBody: SymbolTable.Tree)(implicit fresh: FreshNameCreator): SymbolTable.Tree
Create tree for for-comprehension <for (enums) do body> or <for (enums) yield body> where mapName and flatMapName are chosen corresponding to whether this is a for-do or a for-yield.
Create tree for for-comprehension <for (enums) do body> or <for (enums) yield body> where mapName and flatMapName are chosen corresponding to whether this is a for-do or a for-yield. The creation performs the following rewrite rules:
1.
for (P <- G) E ==> G.foreach (P => E)
Here and in the following (P => E) is interpreted as the function (P => E) if P is a variable pattern and as the partial function { case P => E } otherwise.
2.
for (P <- G) yield E ==> G.map (P => E)
3.
for (P_1 <- G_1; P_2 <- G_2; ...) ...
> G_1.flatMap (P_1 => for (P_2 <- G_2; ...) ...)
4.
for (P <- G; E; ...) ...
> for (P <- G.filter (P
5. For N < MaxTupleArity:
for (P_1 <- G; P_2 = E_2; val P_N = E_N; ...)
> for (TupleN(P_1, P_2, ... P_N) <- for (x_1 @ P_1 <- G) yield { val x_2 @ P_2 = E_2 ... val x_N & P_N = E_N TupleN(x_1, ..., x_N) } ...)
If any of the P_i are variable patterns, the corresponding
x_i @ P_i
is not generated and the variable constituting P_i is used instead of x_i- enums
The enumerators in the for expression
- sugarBody
The body of the for expression
- fresh
A source of new names
-
def
mkFunctionTypeTree(argtpes: List[SymbolTable.Tree], restpe: SymbolTable.Tree): SymbolTable.Tree
Create a tree representing the function type (argtpes) => restpe
-
def
mkGenerator(pos: SymbolTable.Position, pat: SymbolTable.Tree, valeq: Boolean, rhs: SymbolTable.Tree)(implicit fresh: FreshNameCreator): SymbolTable.Tree
Create tree for for-comprehension generator <val pat0 <- rhs0>
-
def
mkIsInstanceOf(value: SymbolTable.Tree, tpe: SymbolTable.Type, any: Boolean = true, wrapInApply: Boolean = true): SymbolTable.Tree
Builds an instance test with given value and type.
- def mkLiteralUnit: SymbolTable.Literal
- def mkMethodCall(target: SymbolTable.Tree, targs: List[SymbolTable.Type], args: List[SymbolTable.Tree]): SymbolTable.Tree
- def mkMethodCall(receiver: SymbolTable.Tree, method: SymbolTable.Symbol, targs: List[SymbolTable.Type], args: List[SymbolTable.Tree]): SymbolTable.Tree
- def mkMethodCall(receiver: SymbolTable.Symbol, methodName: SymbolTable.Name, args: List[SymbolTable.Tree]): SymbolTable.Tree
- def mkMethodCall(target: SymbolTable.Tree, args: List[SymbolTable.Tree]): SymbolTable.Tree
- def mkMethodCall(method: SymbolTable.Symbol, args: List[SymbolTable.Tree]): SymbolTable.Tree
- def mkMethodCall(method: SymbolTable.Symbol, targs: List[SymbolTable.Type], args: List[SymbolTable.Tree]): SymbolTable.Tree
-
def
mkMethodCall(receiver: SymbolTable.Symbol, methodName: SymbolTable.Name, targs: List[SymbolTable.Type], args: List[SymbolTable.Tree]): SymbolTable.Tree
A creator for method calls, e.g.
A creator for method calls, e.g. fn[T1, T2, ...](v1, v2, ...) There are a number of variations.
- receiver
symbol of the method receiver
- methodName
name of the method to call
- targs
type arguments (if Nil, no TypeApply node will be generated)
- args
value arguments
- returns
the newly created trees.
- def mkNamedArg(lhs: SymbolTable.Tree, rhs: SymbolTable.Tree): SymbolTable.Tree
-
def
mkNamedArg(name: SymbolTable.Name, tree: SymbolTable.Tree): SymbolTable.Tree
Wrap an expression in a named argument.
-
def
mkNew(parents: List[SymbolTable.Tree], self: SymbolTable.ValDef, stats: List[SymbolTable.Tree], npos: SymbolTable.Position, cpos: SymbolTable.Position): SymbolTable.Tree
Create positioned tree representing an object creation <new parents { stats }
Create positioned tree representing an object creation <new parents { stats }
- npos
the position of the new
- cpos
the position of the anonymous class starting with parents
-
def
mkNil: SymbolTable.Tree
Builds a list with given head and tail.
- def mkNullaryCall(method: SymbolTable.Symbol, targs: List[SymbolTable.Type]): SymbolTable.Tree
- def mkOr(tree1: SymbolTable.Tree, tree2: SymbolTable.Tree): SymbolTable.Tree
- def mkPackageObject(defn: SymbolTable.ModuleDef, pidPos: SymbolTable.Position = NoPosition, pkgPos: SymbolTable.Position = NoPosition): SymbolTable.PackageDef
- def mkParents(ownerMods: SymbolTable.Modifiers, parents: List[SymbolTable.Tree], parentPos: SymbolTable.Position = NoPosition): collection.immutable.List[SymbolTable.Tree]
-
def
mkPatDef(mods: SymbolTable.Modifiers, pat: SymbolTable.Tree, rhs: SymbolTable.Tree)(implicit fresh: FreshNameCreator): List[SymbolTable.ValDef]
Create tree for pattern definition <mods val pat0 = rhs>
-
def
mkPatDef(pat: SymbolTable.Tree, rhs: SymbolTable.Tree)(implicit fresh: FreshNameCreator): List[SymbolTable.ValDef]
Create tree for pattern definition <val pat0 = rhs>
- def mkRuntimeUniverseRef: SymbolTable.Tree
- def mkSeqApply(arg: SymbolTable.Tree): SymbolTable.Apply
- def mkSuperInitCall: SymbolTable.Select
- def mkSyntheticParam(pname: SymbolTable.TermName): SymbolTable.ValDef
-
def
mkSyntheticUnit(): SymbolTable.Literal
Create a literal unit tree that is inserted by the compiler but not written by end user.
Create a literal unit tree that is inserted by the compiler but not written by end user. It's important to distinguish the two so that quasiquotes can strip synthetic ones away.
-
def
mkTemplate(parents: List[SymbolTable.Tree], self: SymbolTable.ValDef, constrMods: SymbolTable.Modifiers, vparamss: List[List[SymbolTable.ValDef]], body: List[SymbolTable.Tree], superPos: SymbolTable.Position = NoPosition): SymbolTable.Template
Generates a template with constructor corresponding to
Generates a template with constructor corresponding to
constrmods (vparams1_) ... (vparams_n) preSuper { presupers } extends superclass(args_1) ... (args_n) with mixins { self => body }
This gets translated to
extends superclass with mixins { self => presupers' // presupers without rhs vparamss // abstract fields corresponding to value parameters def <init>(vparamss) { presupers super.<init>(args) } body }
-
def
mkTreeOrBlock(stats: List[SymbolTable.Tree]): SymbolTable.Tree
Create a block that wraps multiple statements but don't do any wrapping if there is just one statement.
Create a block that wraps multiple statements but don't do any wrapping if there is just one statement. Used by quasiquotes, macro c.parse api and toolbox.
-
def
mkTuple(elems: List[SymbolTable.Tree], flattenUnary: Boolean = true): SymbolTable.Tree
Builds a tuple
- def mkTupleType(elems: List[SymbolTable.Tree], flattenUnary: Boolean = true): SymbolTable.Tree
-
def
mkTypeApply(fun: SymbolTable.Tree, targs: List[SymbolTable.Tree]): SymbolTable.Tree
Builds a type application node if args.nonEmpty, returns fun otherwise.
- def mkUnattributedRef(fullName: SymbolTable.Name): SymbolTable.RefTree
- def mkUnattributedRef(sym: SymbolTable.Symbol): SymbolTable.RefTree
- def mkUnchecked(expr: SymbolTable.Tree): SymbolTable.Tree
- def mkUnitBlock(expr: SymbolTable.Tree): SymbolTable.Block
-
def
mkVisitor(cases: List[SymbolTable.CaseDef], checkExhaustive: Boolean, prefix: String = "x$")(implicit fresh: FreshNameCreator): SymbolTable.Tree
Create visitor <x => x match cases>
-
def
mkZero(tp: SymbolTable.Type): SymbolTable.Tree
Builds a tree representing an undefined local, as in var x: T = _ which is appropriate to the given Type.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def rootId(name: SymbolTable.Name): SymbolTable.Select
- def rootScalaDot(name: SymbolTable.Name): SymbolTable.Select
- def scalaAnnotationDot(name: SymbolTable.Name): SymbolTable.Select
- def scalaAnyRefConstr: SymbolTable.Select
- def scalaDot(name: SymbolTable.Name): SymbolTable.Select
- def scalaFunctionConstr(argtpes: List[SymbolTable.Tree], restpe: SymbolTable.Tree, abstractFun: Boolean = false): SymbolTable.Tree
-
def
stabilize(tree: SymbolTable.Tree): SymbolTable.Tree
Replaces tree type with a stable type if possible
-
def
stableTypeFor(tree: SymbolTable.Tree): SymbolTable.Type
Computes stable type for a tree if possible
-
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( ... ) @native()
-
object
Filter
Encode/decode fq"if $cond" enumerator as q"
if
($cond)" -
object
ValEq
Encode/decode fq"$pat = $rhs" enumerator as q"$pat = $rhs"
-
object
ValFrom
Encode/decode fq"$pat <- $rhs" enumerator as q"
<-
($pat, $rhs)" -
object
Yield
Encode/decode body of for yield loop as q"
yield
($tree)" -
object
patvarTransformer extends PatvarTransformer
Not in for comprehensions, whether to warn unused pat vars depends on flag.
-
object
patvarTransformerForFor extends PatvarTransformer
Tag pat vars in for comprehensions.