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
|
package scala
import java.lang.reflect.{ AccessibleObject => jAccessibleObject }
package object reflect {
// in the new scheme of things ClassManifests are aliased to ClassTags
// this is done because we want `toArray` in collections work with ClassTags
// but changing it to use the ClassTag context bound without aliasing ClassManifest
// will break everyone who subclasses and overrides `toArray`
// luckily for us, aliasing doesn't hamper backward compatibility, so it's ideal in this situation
// I wish we could do the same for Manifests and TypeTags though
// note, by the way, that we don't touch ClassManifest the object
// because its Byte, Short and so on factory fields are incompatible with ClassTag's
/** A `ClassManifest[T]` is an opaque descriptor for type `T`.
* It is used by the compiler to preserve information necessary
* for instantiating `Arrays` in those cases where the element type
* is unknown at compile time.
*
* The type-relation operators make an effort to present a more accurate
* picture than can be realized with erased types, but they should not be
* relied upon to give correct answers. In particular they are likely to
* be wrong when variance is involved or when a subtype has a different
* number of type arguments than a supertype.
*/
@deprecated("use scala.reflect.ClassTag instead", "2.10.0")
@annotation.implicitNotFound(msg = "No ClassManifest available for ${T}.")
type ClassManifest[T] = scala.reflect.ClassTag[T]
/** The object `ClassManifest` defines factory methods for manifests.
* It is intended for use by the compiler and should not be used in client code.
*/
@deprecated("use scala.reflect.ClassTag instead", "2.10.0")
val ClassManifest = ClassManifestFactory
/** The object `Manifest` defines factory methods for manifests.
* It is intended for use by the compiler and should not be used in client code.
*/
// TODO undeprecated until Scala reflection becomes non-experimental
// @deprecated("use scala.reflect.ClassTag (to capture erasures), scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
val Manifest = ManifestFactory
def classTag[T](implicit ctag: ClassTag[T]) = ctag
/** Make a java reflection object accessible, if it is not already
* and it is possible to do so. If a SecurityException is thrown in the
* attempt, it is caught and discarded.
*/
def ensureAccessible[T <: jAccessibleObject](m: T): T = {
if (!m.isAccessible) {
try m setAccessible true
catch { case _: SecurityException => } // does nothing
}
m
}
// anchor for the class tag materialization macro emitted during tag materialization in Implicits.scala
// implementation is hardwired into `scala.reflect.reify.Taggers`
// using the mechanism implemented in `scala.tools.reflect.FastTrack`
// todo. once we have implicit macros for tag generation, we can remove this anchor
private[scala] def materializeClassTag[T](): ClassTag[T] = macro ???
}
/** An exception that indicates an error during Scala reflection */
case class ScalaReflectionException(msg: String) extends Exception(msg)
|
