1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/* NSC -- new Scala compiler
* Copyright 2005-2013 LAMP/EPFL
* @author Paul Phillips
*/
package scala.tools.nsc
package typechecker
/** A generic means of breaking down types into their subcomponents.
* Types are decomposed top down, and recognizable substructure is
* dispatched via self-apparently named methods. Those methods can
* be overridden for custom behavior, but only the abstract methods
* require implementations, each of which must create some unknown
* "Node" type from its inputs.
*
* - wrapProduct create Node from a product of Nodes
* - wrapSequence create Node from a sequence of Nodes
* - wrapAtom create Node from an arbitrary value
*
* This is a work in progress.
*/
trait DestructureTypes {
val global: Global
import global._
import definitions.{ NothingClass, AnyClass }
trait DestructureType[Node] extends (Type => Node) {
def withLabel(node: Node, label: String): Node
def withType(node: Node, typeName: String): Node
def wrapEmpty: Node
def wrapPoly(in: Node, out: Node): Node
def wrapMono(in: Node, out: Node): Node
def wrapProduct(nodes: List[Node]): Node
def wrapSequence(nodes: List[Node]): Node
def wrapAtom[U](value: U): Node
private val openSymbols = scala.collection.mutable.Set[Symbol]()
private def nodeList[T](elems: List[T], mkNode: T => Node): Node =
if (elems.isEmpty) wrapEmpty else list(elems map mkNode)
private def scopeMemberList(elems: List[Symbol]): Node = nodeList(elems, wrapAtom)
private def typeList(elems: List[Type]): Node = nodeList(elems, this)
private def symbolList(elems: List[Symbol]): Node = nodeList(elems, wrapSymbolInfo)
private def treeList(elems: List[Tree]): Node = nodeList(elems, wrapTree)
private def annotationList(annots: List[AnnotationInfo]): Node = nodeList(annots, annotation)
private def assocsNode(ann: AnnotationInfo): Node = {
val (names, args) = ann.assocs.toIndexedSeq.unzip
if (names.isEmpty) wrapEmpty
else node("assocs", nodeList(names.indices.toList, (i: Int) => atom(names(i).toString, args(i))))
}
private def typeTypeName(tp: Type) = tp match {
case mt @ MethodType(_, _) if mt.isImplicit => "ImplicitMethodType"
case TypeRef(_, sym, _) => typeRefType(sym)
case _ => tp.kind
}
def wrapTree(tree: Tree): Node = withType(
tree match {
case x: NameTree => atom(x.name.toString, x)
case _ => wrapAtom(tree)
},
tree.productPrefix
)
def wrapSymbolInfo(sym: Symbol): Node = {
if ((sym eq NoSymbol) || openSymbols(sym)) wrapEmpty
else {
openSymbols += sym
try product(symbolType(sym), wrapAtom(sym.defString))
finally openSymbols -= sym
}
}
def list(nodes: List[Node]): Node = wrapSequence(nodes)
def product(tp: Type, nodes: Node*): Node = product(typeTypeName(tp), nodes: _*)
def product(typeName: String, nodes: Node*): Node = (
nodes.toList filterNot (_ == wrapEmpty) match {
case Nil => wrapEmpty
case xs => withType(wrapProduct(xs), typeName)
}
)
def atom[U](label: String, value: U): Node = node(label, wrapAtom(value))
def constant(label: String, const: Constant): Node = atom(label, const)
def scope(decls: Scope): Node = node("decls", scopeMemberList(decls.toList))
def resultType(restpe: Type): Node = this("resultType", restpe)
def typeParams(tps: List[Symbol]): Node = node("typeParams", symbolList(tps))
def valueParams(params: List[Symbol]): Node = node("params", symbolList(params))
def typeArgs(tps: List[Type]): Node = node("args", typeList(tps))
def parentList(tps: List[Type]): Node = node("parents", typeList(tps))
def polyFunction(tparams: List[Symbol], restpe: Type): Node = wrapPoly(typeParams(tparams), resultType(restpe))
def monoFunction(params: List[Symbol], restpe: Type): Node = wrapMono(valueParams(params), resultType(restpe))
def nullaryFunction(restpe: Type): Node = wrapMono(wrapEmpty, this(restpe))
def prefix(pre: Type): Node = pre match {
case NoPrefix => wrapEmpty
case _ => this("pre", pre)
}
def typeBounds(lo0: Type, hi0: Type): Node = {
val lo = if ((lo0 eq WildcardType) || (lo0.typeSymbol eq NothingClass)) wrapEmpty else this("lo", lo0)
val hi = if ((hi0 eq WildcardType) || (hi0.typeSymbol eq AnyClass)) wrapEmpty else this("hi", hi0)
product("TypeBounds", lo, hi)
}
def annotation(ann: AnnotationInfo): Node = product(
"AnnotationInfo",
this("atp", ann.atp),
node("args", treeList(ann.args)),
assocsNode(ann)
)
def typeConstraint(constr: TypeConstraint): Node = product(
"TypeConstraint",
node("lo", typeList(constr.loBounds)),
node("hi", typeList(constr.hiBounds)),
this("inst", constr.inst)
)
def annotatedType(annotations: List[AnnotationInfo], underlying: Type) = product(
"AnnotatedType",
node("annotations", annotationList(annotations)),
this("underlying", underlying)
)
/** This imposes additional structure beyond that which is visible in
* the case class hierarchy. In particular, (too) many different constructs
* are encoded in TypeRefs; here they are partitioned somewhat before
* being dispatched.
*
* For example, a typical type parameter is encoded as TypeRef(NoPrefix, sym, Nil)
* with its upper and lower bounds stored in the info of the symbol. Viewing the
* TypeRef naively we are treated to both too much information (useless prefix, usually
* empty args) and too little (bounds hidden behind indirection.) So drop the prefix
* and promote the bounds.
*/
def typeRef(tp: TypeRef) = {
val TypeRef(pre, sym, args) = tp
// Filtered down to elements with "interesting" content
product(
tp,
if (sym.isDefinedInPackage) wrapEmpty else prefix(pre),
wrapSymbolInfo(sym),
typeArgs(args),
if (tp ne tp.normalize) this("normalize", tp.normalize) else wrapEmpty
)
}
def symbolType(sym: Symbol) = (
if (sym.isRefinementClass) "Refinement"
else if (sym.isAliasType) "Alias"
else if (sym.isTypeSkolem) "TypeSkolem"
else if (sym.isTypeParameter) "TypeParam"
else if (sym.isAbstractType) "AbstractType"
else if (sym.isType) "TypeSymbol"
else "TermSymbol"
)
def typeRefType(sym: Symbol) = (
if (sym.isRefinementClass) "RefinementTypeRef"
else if (sym.isAliasType) "AliasTypeRef"
else if (sym.isTypeSkolem) "SkolemTypeRef"
else if (sym.isTypeParameter) "TypeParamTypeRef"
else if (sym.isAbstractType) "AbstractTypeRef"
else "TypeRef"
) + ( if (sym.isFBounded) "(F-Bounded)" else "" )
def node(label: String, node: Node): Node = withLabel(node, label)
def apply(label: String, tp: Type): Node = withLabel(this(tp), label)
def apply(tp: Type): Node = tp match {
case AntiPolyType(pre, targs) => product(tp, prefix(pre), typeArgs(targs))
case ClassInfoType(parents, decls, clazz) => product(tp, parentList(parents), scope(decls), wrapAtom(clazz))
case ConstantType(const) => product(tp, constant("value", const))
case OverloadedType(pre, alts) => product(tp, prefix(pre), node("alts", typeList(alts map pre.memberType)))
case RefinedType(parents, decls) => product(tp, parentList(parents), scope(decls))
case SingleType(pre, sym) => product(tp, prefix(pre), wrapAtom(sym))
case SuperType(thistp, supertp) => product(tp, this("this", thistp), this("super", supertp))
case ThisType(clazz) => product(tp, wrapAtom(clazz))
case TypeVar(inst, constr) => product(tp, this("inst", inst), typeConstraint(constr))
case AnnotatedType(annotations, underlying) => annotatedType(annotations, underlying)
case ExistentialType(tparams, underlying) => polyFunction(tparams, underlying)
case PolyType(tparams, restpe) => polyFunction(tparams, restpe)
case MethodType(params, restpe) => monoFunction(params, restpe)
case NullaryMethodType(restpe) => nullaryFunction(restpe)
case TypeBounds(lo, hi) => typeBounds(lo, hi)
case tr @ TypeRef(pre, sym, args) => typeRef(tr)
case _ => wrapAtom(tp) // XXX see what this is
}
}
}
|
