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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2002-2008, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.reflect
/** A Manifest[T] is an opaque descriptor for type T. Currently, its only
* use is to give access to the erasure of the type as a Class instance.
* BE AWARE: The different type-relation operators are all forwarded to
* the erased type as an approximation of the final semantics where
* these operators should be on the unerased type. */
trait Manifest[T] {
/** A class representing the type U to which T would be erased. Note
* that there is no subtyping relationship between T and U. */
def erasure: Predef.Class[U] forSome { type U }
/** Tests whether the type represented by this manifest is a subtype of
* the type represented by `that' manifest. BE AWARE: the current
* implementation is an approximation, as the test is done on the
* erasure of the type. */
def <:<(that: Manifest[_]): Boolean = {
def subtype(sub: Predef.Class[_], sup: Predef.Class[_]): Boolean = {
val subSuperClass = sub.BaseType
val subSuperInterfaces = sub.GetInterfaces.toList
val subSuper =
(if (subSuperClass == null) Nil else List(subSuperClass)) ::: subSuperInterfaces
(subSuper contains sup) || (subSuper exists (subtype(_, sup)))
}
this.erasure == that.erasure || subtype(this.erasure, that.erasure)
}
/** Tests whether the type represented by this manifest is a supertype
* of the type represented by `that' manifest. BE AWARE: the current
* implementation is an approximation, as the test is done on the
* erasure of the type. */
def >:>(that: Manifest[_]): Boolean =
that <:< this
/** Tests whether the type represented by this manifest is equal to the
* type represented by `that' manifest. BE AWARE: the current
* implementation is an approximation, as the test is done on the
* erasure of the type. */
override def equals(that: Any): Boolean = that match {
case m:Manifest[_] => this.erasure == m.erasure
case _ => false
}
}
/** This object is used by the compiler and <b>should not be used in
* client code</b>. The object `Manifest' defines factory methods for
* manifests. BE AWARE: The factory for refinement types is missing and
* will be implemented in a later version of this class. */
object Manifest {
/** Manifest for the singleton type `value.type'. */
def singleType[T](value: Any): Manifest[T] =
new Manifest[T] {
lazy val erasure =
value match {
case anyRefValue: AnyRef => anyRefValue.GetType
case anyValue => error("There is no singleton type for AnyVal values")
}
override lazy val toString = value.toString + ".type"
}
/** Manifest for the class type `clazz', where `clazz' is
* a top-level or static class. */
def classType[T](clazz: Predef.Class[T]): Manifest[T] =
new Manifest[T] {
val erasure = clazz
override lazy val toString = erasure.getName
}
/** Manifest for the class type `clazz[args]', where `clazz' is
* a top-level or static class. */
def classType[T](clazz: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
new Manifest[T] {
val erasure = clazz
val typeArguments: Seq[Manifest[_]] = args
override lazy val toString = erasure.getName + typeArguments.mkString("[", ", ", "]")
}
/** Manifest for the class type `prefix # clazz'. */
def classType[T](prefix: Manifest[_], clazz: Predef.Class[_]): Manifest[T] =
new Manifest[T] {
val erasure = clazz
override lazy val toString = prefix.toString + "#" + clazz.getName
}
/** Manifest for the class type `prefix # clazz[args]'. */
def classType[T](prefix: Manifest[_], clazz: Predef.Class[_], args: Manifest[_]*): Manifest[T] =
new Manifest[T] {
val erasure = clazz
val typeArguments: Seq[Manifest[_]] = args
override lazy val toString = prefix.toString + "#" + clazz.getName + typeArguments.mkString("[", ", ", "]")
}
/** Manifest for the abstract type `prefix # name'. `upperBound' is not
* strictly necessary as it could be obtained by reflection. It was
* added so that erasure can be calculated without reflection. */
def abstractType[T](prefix: Manifest[_], name: String, upperBound: Manifest[_]): Manifest[T] =
new Manifest[T] {
lazy val erasure = upperBound.erasure
override lazy val toString = prefix.toString + "#" + name
}
/** Manifest for the abstract type `prefix # name[args]'. */
def abstractType[T](prefix: Manifest[_], name: String, upperBound: Manifest[_], args: Manifest[_]*): Manifest[T] =
new Manifest[T] {
lazy val erasure = upperBound.erasure
val typeArguments: Seq[Manifest[_]] = args
override lazy val toString = prefix.toString + "#" + name + typeArguments.mkString("[", ", ", "]")
}
/** Manifest for the intersection type `parents_0 with ... with parents_n'. */
def intersectionType[T](parents: Manifest[_]*): Manifest[T] =
new Manifest[T] {
lazy val erasure = parents.first.erasure
override lazy val toString = parents.mkString(" with ")
}
}
|
