scala.reflect

package reflect


object ClassManifestFactory

ClassManifestFactory defines factory methods for manifests. It is intended for use by the compiler and should not be used in client code.

Unlike ClassManifest , this factory isn’t annotated with a deprecation warning. This is done to prevent avalanches of deprecation warnings in the code that calls methods with manifests.

In a perfect world, we would just remove the @deprecated annotation from ClassManifest the object and then delete it in 2.11. After all, that object is explicitly marked as internal, so noone should use it. However a lot of existing libraries disregarded the scaladoc that comes with ClassManifest , so we need to somehow nudge them into migrating prior to removing stuff out of the blue. Hence we’ve introduced this design decision as the lesser of two evils.

object ClassTag extends Serializable

Class tags corresponding to primitive types and constructor/extractor for ClassTags.

object ManifestFactory

ManifestFactory defines factory methods for manifests. It is intended for use by the compiler and should not be used in client code.

Unlike Manifest , this factory isn’t annotated with a deprecation warning. This is done to prevent avalanches of deprecation warnings in the code that calls methods with manifests. Why so complicated? Read up the comments for ClassManifestFactory .

object NameTransformer

Provides functions to encode and decode Scala symbolic names. Also provides some constants.

object NoManifest extends OptManifest[Nothing] with Serializable

One of the branches of an scala.reflect.OptManifest.

Type Members

abstract class AnyValManifest[T <: AnyVal] extends Manifest[T] with Equals

type ClassManifest[T] = ClassTag[T]

A ClassManifest[T] is an opaque descriptor for type T .

trait ClassManifestDeprecatedApis[T] extends OptManifest[T]

trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serializable

A ClassTag[T] stores the erased class of a given type T , accessible via the runtimeClass field. This is particularly useful for instantiating Array s whose element types are unknown at compile time.

ClassTag s are a weaker special case of scala.reflect.api.TypeTags#TypeTag s, in that they wrap only the runtime class of a given type, whereas a TypeTag contains all static type information. That is, ClassTag s are constructed from knowing only the top-level class of a type, without necessarily knowing all of its argument types. This runtime information is enough for runtime Array creation.

For example:

scala> def mkArray[T : ClassTag](elems: T*) = Array[T](elems: _*)
mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]

scala> mkArray(42, 13)
res0: Array[Int] = Array(42, 13)

scala> mkArray("Japan","Brazil","Germany")
res1: Array[String] = Array(Japan, Brazil, Germany)

See scala.reflect.api.TypeTags for more examples, or the Reflection Guide: TypeTags for more details.

trait Manifest[T] extends ClassManifest[T] with Equals

A Manifest[T] is an opaque descriptor for type T. Its supported use is to give access to the erasure of the type as a Class instance, as is necessary for the creation of native Arrays if the class is not known at compile time.

The type-relation operators <:< and =:= should be considered approximations only, as there are numerous aspects of type conformance which are not yet adequately represented in manifests.

Example usages:

def arr[T] = new Array[T](0)                          // does not compile
def arr[T](implicit m: Manifest[T]) = new Array[T](0) // compiles
def arr[T: Manifest] = new Array[T](0)                // shorthand for the preceding

// Methods manifest, classManifest, and optManifest are in [[scala.Predef]].
def isApproxSubType[T: Manifest, U: Manifest] = manifest[T] <:< manifest[U]
isApproxSubType[List[String], List[AnyRef]] // true
isApproxSubType[List[String], List[Int]]    // false

def methods[T: ClassManifest] = classManifest[T].erasure.getMethods
def retType[T: ClassManifest](name: String) =
  methods[T] find (_.getName == name) map (_.getGenericReturnType)

retType[Map[_, _]]("values")  // Some(scala.collection.Iterable)

trait OptManifest[+T] extends Serializable

A OptManifest[T] is an optional scala.reflect.Manifest.

It is either a Manifest or the value NoManifest .

Full Source:

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)