GroundTypeTag => ConcreteTypeTag

9 files changed, 145 insertions, 135 deletions

diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index d241d2ddc0..837ce96baa 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -103,12 +103,12 @@ object Predef extends LowPriorityImplicits {
   type ClassManifest[T] = scala.reflect.ClassManifest[T]
   @deprecated("OptManifest is no longer supported and using it may lead to incorrect results, use `@scala.reflect.TypeTag` instead", "2.10.0")
   type OptManifest[T]   = scala.reflect.OptManifest[T]
-  @deprecated("Use `@scala.reflect.GroundTypeTag` instead", "2.10.0")
+  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
   type Manifest[T]      = scala.reflect.Manifest[T]
   @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
   val ClassManifest     = scala.reflect.ClassManifest
   // [Paul to Eugene] No lazy vals in Predef.  Too expensive.  Have to work harder on breaking initialization dependencies.
-  @deprecated("Use `@scala.reflect.GroundTypeTag` instead", "2.10.0")
+  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
   lazy val Manifest     = scala.reflect.Manifest // needs to be lazy, because requires scala.reflect.mirror instance
   @deprecated("NoManifest is no longer supported and using it may lead to incorrect results, use `@scala.reflect.TypeTag` instead", "2.10.0")
   lazy val NoManifest   = scala.reflect.NoManifest // needs to be lazy, because requires scala.reflect.mirror instance
@@ -118,20 +118,20 @@ object Predef extends LowPriorityImplicits {
   def optManifest[T](implicit m: OptManifest[T])     = m
 
   // Tag types and companions, and incantations for summoning
-  type ClassTag[T]       = scala.reflect.ClassTag[T]
-  type TypeTag[T]        = scala.reflect.TypeTag[T]
-  type GroundTypeTag[T]  = scala.reflect.GroundTypeTag[T]
-  val ClassTag           = scala.reflect.ClassTag // doesn't need to be lazy, because it's not a path-dependent type
+  type ClassTag[T]         = scala.reflect.ClassTag[T]
+  type TypeTag[T]          = scala.reflect.TypeTag[T]
+  type ConcreteTypeTag[T]  = scala.reflect.ConcreteTypeTag[T]
+  val ClassTag             = scala.reflect.ClassTag // doesn't need to be lazy, because it's not a path-dependent type
   // [Paul to Eugene] No lazy vals in Predef.  Too expensive.  Have to work harder on breaking initialization dependencies.
-  lazy val TypeTag       = scala.reflect.TypeTag // needs to be lazy, because requires scala.reflect.mirror instance
-  lazy val GroundTypeTag = scala.reflect.GroundTypeTag
+  lazy val TypeTag         = scala.reflect.TypeTag // needs to be lazy, because requires scala.reflect.mirror instance
+  lazy val ConcreteTypeTag = scala.reflect.ConcreteTypeTag
 
   // [Eugene to Martin] it's really tedious to type "implicitly[...]" all the time, so I'm reintroducing these shortcuts
-  def classTag[T](implicit ctag: ClassTag[T])            = ctag
-  def tag[T](implicit ttag: TypeTag[T])                  = ttag
-  def typeTag[T](implicit ttag: TypeTag[T])              = ttag
-  def groundTag[T](implicit gttag: GroundTypeTag[T])     = gttag
-  def groundTypeTag[T](implicit gttag: GroundTypeTag[T]) = gttag
+  def classTag[T](implicit ctag: ClassTag[T])                = ctag
+  def tag[T](implicit ttag: TypeTag[T])                      = ttag
+  def typeTag[T](implicit ttag: TypeTag[T])                  = ttag
+  def concreteTag[T](implicit cttag: ConcreteTypeTag[T])     = cttag
+  def concreteTypeTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag
 
   // Minor variations on identity functions
   def identity[A](x: A): A         = x    // @see `conforms` for the implicit version
diff --git a/src/library/scala/reflect/ClassTags.scala b/src/library/scala/reflect/ClassTags.scala
index 2833e7cc8e..cde6da5539 100644
--- a/src/library/scala/reflect/ClassTags.scala
+++ b/src/library/scala/reflect/ClassTags.scala
@@ -4,11 +4,20 @@ import java.lang.{ Class => jClass }
 import scala.reflect.{ mirror => rm }
 
 /** A `ClassTag[T]` wraps a Java class, which can be accessed via the `erasure` method.
+ *
  *  This is useful in itself, but also enables very important use case.
  *  Having this knowledge ClassTag can instantiate `Arrays`
  *  in those cases where the element type is unknown at compile time.
  *  Hence, ClassTag[T] conforms to the ArrayTag[T] trait.
- */
+ *
+ *  If an implicit value of type u.ClassTag[T] is required, the compiler will make one up on demand.
+ *  The implicitly created value contains in its erasure field the Java class that is the result of erasing type T.
+ *  In that value, any occurrences of type parameters or abstract types U which come themselves with a ClassTag
+ *  or a reflect.mirror.ConcreteTypeTag are represented by the type referenced by that tag.
+ *  If the type T contains unresolved references to type parameters or abstract types, a static error results.
+ *
+ *  A ConcreteTypeTag member of the reflect.mirror object is convertible to a ClassTag via an implicit conversion
+ *  (this is not possible to do in all reflection universes because an operation that converts a type to a Java class might not be available). */
 // please, don't add any APIs here, like it was with `newWrappedArray` and `newArrayBuilder`
 // class tags, and all tags in general, should be as minimalistic as possible
 @annotation.implicitNotFound(msg = "No ClassTag available for ${T}")
@@ -20,7 +29,7 @@ abstract case class ClassTag[T](erasure: jClass[_]) extends ArrayTag[T] {
 
   /** A Scala reflection type representing T.
    *  For ClassTags this representation is lossy (in their case tpe is retrospectively constructed from erasure).
-   *  For TypeTags and GroundTypeTags the representation is almost precise, because it uses reification
+   *  For TypeTags and ConcreteTypeTags the representation is almost precise, because they use reification
    *  (information is lost only when T refers to non-locatable symbols, which are then reified as free variables). */
   def tpe: rm.Type = rm.classToType(erasure)
 
@@ -153,6 +162,6 @@ class DeprecatedClassManifestApis[T](ctag: ClassTag[T]) {
   @deprecated("Use `@scala.collection.mutable.ArrayBuilder` object instead", "2.10.0")
   def newArrayBuilder(): ArrayBuilder[T] = ArrayBuilder.make[T]()(ctag)
 
-  @deprecated("`typeArguments` is no longer supported, and will always return an empty list. Use `@scala.reflect.TypeTag` or `@scala.reflect.GroundTypeTag` to capture and analyze type arguments", "2.10.0")
+  @deprecated("`typeArguments` is no longer supported, and will always return an empty list. Use `@scala.reflect.TypeTag` or `@scala.reflect.ConcreteTypeTag` to capture and analyze type arguments", "2.10.0")
   def typeArguments: List[OptManifest[_]] = List()
 }
\ No newline at end of file
diff --git a/src/library/scala/reflect/TagMaterialization.scala b/src/library/scala/reflect/TagMaterialization.scala
index 991feb3bac..5918b6effc 100644
--- a/src/library/scala/reflect/TagMaterialization.scala
+++ b/src/library/scala/reflect/TagMaterialization.scala
@@ -18,13 +18,13 @@ object TagMaterialization {
   def materializeTypeTag[T: c.TypeTag](c: Context { type PrefixType = Universe }): c.Expr[c.prefix.value.TypeTag[T]] = {
     import c.mirror._
     val tpe = implicitly[c.TypeTag[T]].tpe
-    c.materializeTypeTag(tpe, requireGroundTypeTag = false)
+    c.materializeTypeTag(tpe, requireConcreteTypeTag = false)
   }
 
-  def materializeGroundTypeTag[T: c.TypeTag](c: Context { type PrefixType = Universe }): c.Expr[c.prefix.value.GroundTypeTag[T]] = {
+  def materializeConcreteTypeTag[T: c.TypeTag](c: Context { type PrefixType = Universe }): c.Expr[c.prefix.value.ConcreteTypeTag[T]] = {
     import c.mirror._
     val tpe = implicitly[c.TypeTag[T]].tpe
-    c.materializeTypeTag(tpe, requireGroundTypeTag = true)
+    c.materializeTypeTag(tpe, requireConcreteTypeTag = true)
   }
 
   private implicit def context2utils(c0: Context) : Utils { val c: c0.type } = new { val c: c0.type = c0 } with Utils
@@ -52,17 +52,17 @@ object TagMaterialization {
       NothingClass.asType -> newTermName("Nothing"),
       NullClass.asType -> newTermName("Null"))
 
-    val ReflectPackage      = staticModule("scala.reflect.package")
-    val Reflect_mirror      = selectTerm(ReflectPackage, "mirror")
-    val ClassTagClass       = staticClass("scala.reflect.ClassTag")
-    val ClassTagErasure     = selectTerm(ClassTagClass, "erasure")
-    val ClassTagModule      = staticModule("scala.reflect.ClassTag")
-    val TypeTagsClass       = staticClass("scala.reflect.api.TypeTags")
-    val TypeTagClass        = selectType(TypeTagsClass, "TypeTag")
-    val TypeTagTpe          = selectTerm(TypeTagClass, "tpe")
-    val TypeTagModule       = selectTerm(TypeTagsClass, "TypeTag")
-    val GroundTypeTagClass  = selectType(TypeTagsClass, "GroundTypeTag")
-    val GroundTypeTagModule = selectTerm(TypeTagsClass, "GroundTypeTag")
+    val ReflectPackage        = staticModule("scala.reflect.package")
+    val Reflect_mirror        = selectTerm(ReflectPackage, "mirror")
+    val ClassTagClass         = staticClass("scala.reflect.ClassTag")
+    val ClassTagErasure       = selectTerm(ClassTagClass, "erasure")
+    val ClassTagModule        = staticModule("scala.reflect.ClassTag")
+    val TypeTagsClass         = staticClass("scala.reflect.api.TypeTags")
+    val TypeTagClass          = selectType(TypeTagsClass, "TypeTag")
+    val TypeTagTpe            = selectTerm(TypeTagClass, "tpe")
+    val TypeTagModule         = selectTerm(TypeTagsClass, "TypeTag")
+    val ConcreteTypeTagClass  = selectType(TypeTagsClass, "ConcreteTypeTag")
+    val ConcreteTypeTagModule = selectTerm(TypeTagsClass, "ConcreteTypeTag")
 
     def materializeClassTag(tpe: Type): Tree = {
       val prefix = gen.mkAttributedRef(Reflect_mirror) setType singleType(Reflect_mirror.owner.thisPrefix, Reflect_mirror)
@@ -70,8 +70,8 @@ object TagMaterialization {
     }
 
     def materializeClassTag(prefix: Tree, tpe: Type): Tree = {
-      val typetagInScope = c.inferImplicitValue(appliedType(typeRef(prefix.tpe, TypeTagClass, Nil), List(tpe)))
-      def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == GroundTypeTagModule))
+      val typetagInScope = c.inferImplicitValue(appliedType(typeRef(prefix.tpe, ConcreteTypeTagClass, Nil), List(tpe)))
+      def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == ConcreteTypeTagModule))
       typetagInScope match {
         case success if !success.isEmpty && !typetagIsSynthetic(success) =>
           val factory = TypeApply(Select(Ident(ClassTagModule), newTermName("apply")), List(TypeTree(tpe)))
@@ -104,19 +104,19 @@ object TagMaterialization {
       }
     }
 
-    def materializeTypeTag(tpe: Type, requireGroundTypeTag: Boolean): Tree = {
+    def materializeTypeTag(tpe: Type, requireConcreteTypeTag: Boolean): Tree = {
       def prefix: Tree = ??? // todo. needs to be synthesized from c.prefix
-      materializeTypeTag(prefix, tpe, requireGroundTypeTag)
+      materializeTypeTag(prefix, tpe, requireConcreteTypeTag)
     }
 
-    def materializeTypeTag(prefix: Tree, tpe: Type, requireGroundTypeTag: Boolean): Tree = {
-      val tagModule = if (requireGroundTypeTag) GroundTypeTagModule else TypeTagModule
+    def materializeTypeTag(prefix: Tree, tpe: Type, requireConcreteTypeTag: Boolean): Tree = {
+      val tagModule = if (requireConcreteTypeTag) ConcreteTypeTagModule else TypeTagModule
       val result =
         tpe match {
           case coreTpe if coreTags contains coreTpe =>
             Select(Select(prefix, tagModule.name), coreTags(coreTpe))
           case _ =>
-            try c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, requireGroundTypeTag = requireGroundTypeTag)
+            try c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, requireConcreteTypeTag = requireConcreteTypeTag)
             catch {
               case ex: Throwable =>
                 // [Eugene] cannot pattern match on an abstract type, so had to do this
diff --git a/src/library/scala/reflect/api/StandardDefinitions.scala b/src/library/scala/reflect/api/StandardDefinitions.scala
index b4fedbe055..e457bb73e0 100755
--- a/src/library/scala/reflect/api/StandardDefinitions.scala
+++ b/src/library/scala/reflect/api/StandardDefinitions.scala
@@ -113,8 +113,8 @@ trait StandardDefinitions { self: Universe =>
     def ClassTagModule: Symbol
     def TypeTagClass: Symbol
     def TypeTagModule: Symbol
-    def GroundTypeTagClass: Symbol
-    def GroundTypeTagModule: Symbol
+    def ConcreteTypeTagClass: Symbol
+    def ConcreteTypeTagModule: Symbol
 
     /** Given a type T, returns the type corresponding to the VM's
      *  representation: ClassClass's type constructor applied to `arg`.
diff --git a/src/library/scala/reflect/api/TypeTags.scala b/src/library/scala/reflect/api/TypeTags.scala
index a38c21a9d4..ed47620e13 100644
--- a/src/library/scala/reflect/api/TypeTags.scala
+++ b/src/library/scala/reflect/api/TypeTags.scala
@@ -14,14 +14,16 @@ import scala.reflect.{ mirror => rm }
  * TypeTags are much better integrated with reflection than manifests are, and are consequently much simpler.
  *
  * Type tags are organized in a hierarchy of two classes:
- * [[scala.reflect.ClassTag]], [[scala.reflect.api.Universe#TypeTag]] and [[scala.reflect.api.Universe#GroundTypeTag]].
- * A [[scala.reflect.ClassTag]] value wraps a Java class, which can be accessed via the erasure method.
+ * [[scala.reflect.api.Universe#TypeTag]] and [[scala.reflect.api.Universe#ConcreteTypeTag]].
  * A [[scala.reflect.api.Universe#TypeTag]] value wraps a full Scala type in its tpe field.
- * A [[scala.reflect.api.Universe#GroundTypeTag]] value is a type tag that is guaranteed not to contain any references to type parameters or abstract types.
+ * A [[scala.reflect.api.Universe#ConcreteTypeTag]] value is a type tag that is guaranteed not to contain any references to type parameters or abstract types.
+ *
+ * It is also possible to capture Java classes by using a different kind of tag.
+ * A [[scala.reflect.ClassTag]] value wraps a Java class, which can be accessed via the erasure method.
  *
  * TypeTags correspond loosely to Manifests. More precisely:
  * The previous notion of a [[scala.reflect.ClassManifest]] corresponds to a scala.reflect.ClassTag,
- * The previous notion of a [[scala.reflect.Manifest]] corresponds to scala.reflect.mirror.GroundTypeTag,
+ * The previous notion of a [[scala.reflect.Manifest]] corresponds to scala.reflect.mirror.ConcreteTypeTag,
  * Whereas scala.reflect.mirror.TypeTag is approximated by the previous notion of [[scala.reflect.OptManifest]].
  *
  * Implicit in the contract for all Tag classes is that the reified type tpe represents the type parameter T.
@@ -59,38 +61,34 @@ trait TypeTags { self: Universe =>
 
     def sym = tpe.typeSymbol
 
-    def isGround = !isNotGround
-    def isNotGround = tpe exists (_.typeSymbol.isAbstractType)
-
-    def toGround: GroundTypeTag[T] = {
-      assert(isGround, tpe)
-      GroundTypeTag[T](tpe)
-    }
+    def isConcrete = !isNotConcrete
+    def isNotConcrete = tpe exists (_.typeSymbol.isAbstractType)
+    def toConcrete: ConcreteTypeTag[T] = ConcreteTypeTag[T](tpe)
 
     override def toString = {
-      var prefix = if (isGround) "GroundTypeTag" else "TypeTag"
+      var prefix = if (isConcrete) "ConcreteTypeTag" else "TypeTag"
       if (prefix != this.productPrefix) prefix = "*" + prefix
       prefix + "[" + tpe + "]"
     }
   }
 
   object TypeTag {
-    val Byte    : TypeTag[scala.Byte]       = GroundTypeTag.Byte
-    val Short   : TypeTag[scala.Short]      = GroundTypeTag.Short
-    val Char    : TypeTag[scala.Char]       = GroundTypeTag.Char
-    val Int     : TypeTag[scala.Int]        = GroundTypeTag.Int
-    val Long    : TypeTag[scala.Long]       = GroundTypeTag.Long
-    val Float   : TypeTag[scala.Float]      = GroundTypeTag.Float
-    val Double  : TypeTag[scala.Double]     = GroundTypeTag.Double
-    val Boolean : TypeTag[scala.Boolean]    = GroundTypeTag.Boolean
-    val Unit    : TypeTag[scala.Unit]       = GroundTypeTag.Unit
-    val Any     : TypeTag[scala.Any]        = GroundTypeTag.Any
-    val Object  : TypeTag[java.lang.Object] = GroundTypeTag.Object
-    val AnyVal  : TypeTag[scala.AnyVal]     = GroundTypeTag.AnyVal
-    val AnyRef  : TypeTag[scala.AnyRef]     = GroundTypeTag.AnyRef
-    val Nothing : TypeTag[scala.Nothing]    = GroundTypeTag.Nothing
-    val Null    : TypeTag[scala.Null]       = GroundTypeTag.Null
-    val String  : TypeTag[java.lang.String] = GroundTypeTag.String
+    val Byte    : TypeTag[scala.Byte]       = ConcreteTypeTag.Byte
+    val Short   : TypeTag[scala.Short]      = ConcreteTypeTag.Short
+    val Char    : TypeTag[scala.Char]       = ConcreteTypeTag.Char
+    val Int     : TypeTag[scala.Int]        = ConcreteTypeTag.Int
+    val Long    : TypeTag[scala.Long]       = ConcreteTypeTag.Long
+    val Float   : TypeTag[scala.Float]      = ConcreteTypeTag.Float
+    val Double  : TypeTag[scala.Double]     = ConcreteTypeTag.Double
+    val Boolean : TypeTag[scala.Boolean]    = ConcreteTypeTag.Boolean
+    val Unit    : TypeTag[scala.Unit]       = ConcreteTypeTag.Unit
+    val Any     : TypeTag[scala.Any]        = ConcreteTypeTag.Any
+    val Object  : TypeTag[java.lang.Object] = ConcreteTypeTag.Object
+    val AnyVal  : TypeTag[scala.AnyVal]     = ConcreteTypeTag.AnyVal
+    val AnyRef  : TypeTag[scala.AnyRef]     = ConcreteTypeTag.AnyRef
+    val Nothing : TypeTag[scala.Nothing]    = ConcreteTypeTag.Nothing
+    val Null    : TypeTag[scala.Null]       = ConcreteTypeTag.Null
+    val String  : TypeTag[java.lang.String] = ConcreteTypeTag.String
 
     def apply[T](tpe: Type): TypeTag[T] =
       tpe match {
@@ -115,64 +113,67 @@ trait TypeTags { self: Universe =>
   }
 
   /**
-   * If an implicit value of type u.GroundTypeTag[T] is required, the compiler will make one up on demand following the same procedure as for TypeTags.
+   * If an implicit value of type u.ConcreteTypeTag[T] is required, the compiler will make one up on demand following the same procedure as for TypeTags.
    * However, if the resulting type still contains references to type parameters or abstract types, a static error results.
    *
    * @see [[scala.reflect.api.TypeTags]]
    */
-  @annotation.implicitNotFound(msg = "No GroundTypeTag available for ${T}")
-  class GroundTypeTag[T](tpe: Type) extends TypeTag[T](tpe) {
-    assert(isGround, tpe)
-    override def productPrefix = "GroundTypeTag"
+  @annotation.implicitNotFound(msg = "No ConcreteTypeTag available for ${T}")
+  class ConcreteTypeTag[T](tpe: Type) extends TypeTag[T](tpe) {
+    // it's unsafe to use assert here, because we might run into deadlocks with Predef
+    // also see comments in ClassTags.scala
+    //assert(isConcrete, tpe)
+    if (isNotConcrete) throw new Error("%s (%s) is not concrete and cannot be used to construct a concrete type tag".format(tpe, tpe.kind))
+    override def productPrefix = "ConcreteTypeTag"
   }
 
-  object GroundTypeTag {
-    val Byte    : GroundTypeTag[scala.Byte]       = new GroundTypeTag[scala.Byte](ByteTpe) { private def readResolve() = GroundTypeTag.Byte }
-    val Short   : GroundTypeTag[scala.Short]      = new GroundTypeTag[scala.Short](ShortTpe) { private def readResolve() = GroundTypeTag.Short }
-    val Char    : GroundTypeTag[scala.Char]       = new GroundTypeTag[scala.Char](CharTpe) { private def readResolve() = GroundTypeTag.Char }
-    val Int     : GroundTypeTag[scala.Int]        = new GroundTypeTag[scala.Int](IntTpe) { private def readResolve() = GroundTypeTag.Int }
-    val Long    : GroundTypeTag[scala.Long]       = new GroundTypeTag[scala.Long](LongTpe) { private def readResolve() = GroundTypeTag.Long }
-    val Float   : GroundTypeTag[scala.Float]      = new GroundTypeTag[scala.Float](FloatTpe) { private def readResolve() = GroundTypeTag.Float }
-    val Double  : GroundTypeTag[scala.Double]     = new GroundTypeTag[scala.Double](DoubleTpe) { private def readResolve() = GroundTypeTag.Double }
-    val Boolean : GroundTypeTag[scala.Boolean]    = new GroundTypeTag[scala.Boolean](BooleanTpe) { private def readResolve() = GroundTypeTag.Boolean }
-    val Unit    : GroundTypeTag[scala.Unit]       = new GroundTypeTag[scala.Unit](UnitTpe) { private def readResolve() = GroundTypeTag.Unit }
-    val Any     : GroundTypeTag[scala.Any]        = new GroundTypeTag[scala.Any](AnyTpe) { private def readResolve() = GroundTypeTag.Any }
-    val Object  : GroundTypeTag[java.lang.Object] = new GroundTypeTag[java.lang.Object](ObjectTpe) { private def readResolve() = GroundTypeTag.Object }
-    val AnyVal  : GroundTypeTag[scala.AnyVal]     = new GroundTypeTag[scala.AnyVal](AnyValTpe) { private def readResolve() = GroundTypeTag.AnyVal }
-    val AnyRef  : GroundTypeTag[scala.AnyRef]     = new GroundTypeTag[scala.AnyRef](AnyRefTpe) { private def readResolve() = GroundTypeTag.AnyRef }
-    val Nothing : GroundTypeTag[scala.Nothing]    = new GroundTypeTag[scala.Nothing](NothingTpe) { private def readResolve() = GroundTypeTag.Nothing }
-    val Null    : GroundTypeTag[scala.Null]       = new GroundTypeTag[scala.Null](NullTpe) { private def readResolve() = GroundTypeTag.Null }
-    val String  : GroundTypeTag[java.lang.String] = new GroundTypeTag[java.lang.String](StringTpe) { private def readResolve() = GroundTypeTag.String }
-
-    def apply[T](tpe: Type): GroundTypeTag[T] =
+  object ConcreteTypeTag {
+    val Byte    : ConcreteTypeTag[scala.Byte]       = new ConcreteTypeTag[scala.Byte](ByteTpe) { private def readResolve() = ConcreteTypeTag.Byte }
+    val Short   : ConcreteTypeTag[scala.Short]      = new ConcreteTypeTag[scala.Short](ShortTpe) { private def readResolve() = ConcreteTypeTag.Short }
+    val Char    : ConcreteTypeTag[scala.Char]       = new ConcreteTypeTag[scala.Char](CharTpe) { private def readResolve() = ConcreteTypeTag.Char }
+    val Int     : ConcreteTypeTag[scala.Int]        = new ConcreteTypeTag[scala.Int](IntTpe) { private def readResolve() = ConcreteTypeTag.Int }
+    val Long    : ConcreteTypeTag[scala.Long]       = new ConcreteTypeTag[scala.Long](LongTpe) { private def readResolve() = ConcreteTypeTag.Long }
+    val Float   : ConcreteTypeTag[scala.Float]      = new ConcreteTypeTag[scala.Float](FloatTpe) { private def readResolve() = ConcreteTypeTag.Float }
+    val Double  : ConcreteTypeTag[scala.Double]     = new ConcreteTypeTag[scala.Double](DoubleTpe) { private def readResolve() = ConcreteTypeTag.Double }
+    val Boolean : ConcreteTypeTag[scala.Boolean]    = new ConcreteTypeTag[scala.Boolean](BooleanTpe) { private def readResolve() = ConcreteTypeTag.Boolean }
+    val Unit    : ConcreteTypeTag[scala.Unit]       = new ConcreteTypeTag[scala.Unit](UnitTpe) { private def readResolve() = ConcreteTypeTag.Unit }
+    val Any     : ConcreteTypeTag[scala.Any]        = new ConcreteTypeTag[scala.Any](AnyTpe) { private def readResolve() = ConcreteTypeTag.Any }
+    val Object  : ConcreteTypeTag[java.lang.Object] = new ConcreteTypeTag[java.lang.Object](ObjectTpe) { private def readResolve() = ConcreteTypeTag.Object }
+    val AnyVal  : ConcreteTypeTag[scala.AnyVal]     = new ConcreteTypeTag[scala.AnyVal](AnyValTpe) { private def readResolve() = ConcreteTypeTag.AnyVal }
+    val AnyRef  : ConcreteTypeTag[scala.AnyRef]     = new ConcreteTypeTag[scala.AnyRef](AnyRefTpe) { private def readResolve() = ConcreteTypeTag.AnyRef }
+    val Nothing : ConcreteTypeTag[scala.Nothing]    = new ConcreteTypeTag[scala.Nothing](NothingTpe) { private def readResolve() = ConcreteTypeTag.Nothing }
+    val Null    : ConcreteTypeTag[scala.Null]       = new ConcreteTypeTag[scala.Null](NullTpe) { private def readResolve() = ConcreteTypeTag.Null }
+    val String  : ConcreteTypeTag[java.lang.String] = new ConcreteTypeTag[java.lang.String](StringTpe) { private def readResolve() = ConcreteTypeTag.String }
+
+    def apply[T](tpe: Type): ConcreteTypeTag[T] =
       tpe match {
-        case ByteTpe    => GroundTypeTag.Byte.asInstanceOf[GroundTypeTag[T]]
-        case ShortTpe   => GroundTypeTag.Short.asInstanceOf[GroundTypeTag[T]]
-        case CharTpe    => GroundTypeTag.Char.asInstanceOf[GroundTypeTag[T]]
-        case IntTpe     => GroundTypeTag.Int.asInstanceOf[GroundTypeTag[T]]
-        case LongTpe    => GroundTypeTag.Long.asInstanceOf[GroundTypeTag[T]]
-        case FloatTpe   => GroundTypeTag.Float.asInstanceOf[GroundTypeTag[T]]
-        case DoubleTpe  => GroundTypeTag.Double.asInstanceOf[GroundTypeTag[T]]
-        case BooleanTpe => GroundTypeTag.Boolean.asInstanceOf[GroundTypeTag[T]]
-        case UnitTpe    => GroundTypeTag.Unit.asInstanceOf[GroundTypeTag[T]]
-        case AnyTpe     => GroundTypeTag.Any.asInstanceOf[GroundTypeTag[T]]
-        case ObjectTpe  => GroundTypeTag.Object.asInstanceOf[GroundTypeTag[T]]
-        case AnyValTpe  => GroundTypeTag.AnyVal.asInstanceOf[GroundTypeTag[T]]
-        case AnyRefTpe  => GroundTypeTag.AnyRef.asInstanceOf[GroundTypeTag[T]]
-        case NothingTpe => GroundTypeTag.Nothing.asInstanceOf[GroundTypeTag[T]]
-        case NullTpe    => GroundTypeTag.Null.asInstanceOf[GroundTypeTag[T]]
-        case StringTpe  => GroundTypeTag.String.asInstanceOf[GroundTypeTag[T]]
-        case _          => new GroundTypeTag[T](tpe) {}
+        case ByteTpe    => ConcreteTypeTag.Byte.asInstanceOf[ConcreteTypeTag[T]]
+        case ShortTpe   => ConcreteTypeTag.Short.asInstanceOf[ConcreteTypeTag[T]]
+        case CharTpe    => ConcreteTypeTag.Char.asInstanceOf[ConcreteTypeTag[T]]
+        case IntTpe     => ConcreteTypeTag.Int.asInstanceOf[ConcreteTypeTag[T]]
+        case LongTpe    => ConcreteTypeTag.Long.asInstanceOf[ConcreteTypeTag[T]]
+        case FloatTpe   => ConcreteTypeTag.Float.asInstanceOf[ConcreteTypeTag[T]]
+        case DoubleTpe  => ConcreteTypeTag.Double.asInstanceOf[ConcreteTypeTag[T]]
+        case BooleanTpe => ConcreteTypeTag.Boolean.asInstanceOf[ConcreteTypeTag[T]]
+        case UnitTpe    => ConcreteTypeTag.Unit.asInstanceOf[ConcreteTypeTag[T]]
+        case AnyTpe     => ConcreteTypeTag.Any.asInstanceOf[ConcreteTypeTag[T]]
+        case ObjectTpe  => ConcreteTypeTag.Object.asInstanceOf[ConcreteTypeTag[T]]
+        case AnyValTpe  => ConcreteTypeTag.AnyVal.asInstanceOf[ConcreteTypeTag[T]]
+        case AnyRefTpe  => ConcreteTypeTag.AnyRef.asInstanceOf[ConcreteTypeTag[T]]
+        case NothingTpe => ConcreteTypeTag.Nothing.asInstanceOf[ConcreteTypeTag[T]]
+        case NullTpe    => ConcreteTypeTag.Null.asInstanceOf[ConcreteTypeTag[T]]
+        case StringTpe  => ConcreteTypeTag.String.asInstanceOf[ConcreteTypeTag[T]]
+        case _          => new ConcreteTypeTag[T](tpe) {}
       }
 
-    def unapply[T](ttag: TypeTag[T]): Option[Type] = if (ttag.isGround) Some(ttag.tpe) else None
+    def unapply[T](ttag: TypeTag[T]): Option[Type] = if (ttag.isConcrete) Some(ttag.tpe) else None
 
-    implicit def toClassTag[T](ttag: rm.GroundTypeTag[T]): ClassTag[T] = ClassTag[T](rm.typeToClass(ttag.tpe.erasure))
+    implicit def toClassTag[T](ttag: rm.ConcreteTypeTag[T]): ClassTag[T] = ClassTag[T](rm.typeToClass(ttag.tpe.erasure))
 
-    implicit def toDeprecatedManifestApis[T](ttag: rm.GroundTypeTag[T]): DeprecatedManifestApis[T] = new DeprecatedManifestApis[T](ttag)
+    implicit def toDeprecatedManifestApis[T](ttag: rm.ConcreteTypeTag[T]): DeprecatedManifestApis[T] = new DeprecatedManifestApis[T](ttag)
 
     // this class should not be used directly in client code
-    class DeprecatedManifestApis[T](ttag: rm.GroundTypeTag[T]) extends DeprecatedClassManifestApis[T](toClassTag(ttag)) {
+    class DeprecatedManifestApis[T](ttag: rm.ConcreteTypeTag[T]) extends DeprecatedClassManifestApis[T](toClassTag(ttag)) {
       @deprecated("Use `tpe` to analyze the underlying type", "2.10.0")
       def <:<(that: Manifest[_]): Boolean = ttag.tpe <:< that.tpe
 
@@ -180,7 +181,7 @@ trait TypeTags { self: Universe =>
       def >:>(that: Manifest[_]): Boolean = that <:< ttag
 
       @deprecated("Use `tpe` to analyze the type arguments", "2.10.0")
-      override def typeArguments: List[Manifest[_]] = ttag.tpe.typeArguments map (targ => rm.GroundTypeTag(targ))
+      override def typeArguments: List[Manifest[_]] = ttag.tpe.typeArguments map (targ => rm.ConcreteTypeTag(targ))
     }
   }
 
@@ -188,6 +189,6 @@ trait TypeTags { self: Universe =>
   // moved to Context, since rm.tags have their own incantations in Predef, and these guys are only useful in macros
 //  def tag[T](implicit ttag: TypeTag[T]) = ttag
 //  def typeTag[T](implicit ttag: TypeTag[T]) = ttag
-//  def groundTag[T](implicit gttag: GroundTypeTag[T]) = gttag
-//  def groundTypeTag[T](implicit gttag: GroundTypeTag[T]) = gttag
+//  def concreteTag[T](implicit gttag: ConcreteTypeTag[T]) = cttag
+//  def concreteTypeTag[T](implicit gttag: ConcreteTypeTag[T]) = cttag
 }
\ No newline at end of file
diff --git a/src/library/scala/reflect/makro/Aliases.scala b/src/library/scala/reflect/makro/Aliases.scala
index e8b847600c..38b1065a40 100644
--- a/src/library/scala/reflect/makro/Aliases.scala
+++ b/src/library/scala/reflect/makro/Aliases.scala
@@ -21,6 +21,6 @@ trait Aliases {
   /** incantations for summoning tags */
   def tag[T](implicit ttag: TypeTag[T]) = ttag
   def typeTag[T](implicit ttag: TypeTag[T]) = ttag
-  def groundTag[T](implicit gttag: GroundTypeTag[T]) = gttag
-  def groundTypeTag[T](implicit gttag: GroundTypeTag[T]) = gttag
+  def concreteTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag
+  def concreteTypeTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag
 }
diff --git a/src/library/scala/reflect/makro/Reifiers.scala b/src/library/scala/reflect/makro/Reifiers.scala
index 9bd25cf0f8..d690df6aee 100644
--- a/src/library/scala/reflect/makro/Reifiers.scala
+++ b/src/library/scala/reflect/makro/Reifiers.scala
@@ -46,7 +46,7 @@ trait Reifiers {
    *  The produced tree will be bound to the mirror specified by ``prefix'' (also see ``reflectMirrorPrefix'').
    *  For more information and examples see the documentation for ``Context.reifyTree'' and ``Universe.reify''.
    */
-  def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, requireGroundTypeTag: Boolean = false): Tree
+  def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree
 
   /** Undoes reification of a tree.
    *
diff --git a/src/library/scala/reflect/makro/internal/typeTagImpl.scala b/src/library/scala/reflect/makro/internal/typeTagImpl.scala
index 6c49ef45de..de404ff39f 100644
--- a/src/library/scala/reflect/makro/internal/typeTagImpl.scala
+++ b/src/library/scala/reflect/makro/internal/typeTagImpl.scala
@@ -16,14 +16,14 @@ package object internal {
 
   /** This method is required by the compiler and <b>should not be used in client code</b>. */
   def materializeTypeTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[u.value.TypeTag[T]] =
-    c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, requireGroundTypeTag = false))(c.TypeTag.Nothing)
+    c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, requireConcreteTypeTag = false))(c.TypeTag.Nothing)
 
   /** This method is required by the compiler and <b>should not be used in client code</b>. */
-  def materializeGroundTypeTag[T](u: Universe): u.GroundTypeTag[T] = macro materializeGroundTypeTag_impl[T]
+  def materializeConcreteTypeTag[T](u: Universe): u.ConcreteTypeTag[T] = macro materializeConcreteTypeTag_impl[T]
 
   /** This method is required by the compiler and <b>should not be used in client code</b>. */
-  def materializeGroundTypeTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[u.value.GroundTypeTag[T]] =
-    c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, requireGroundTypeTag = true))(c.TypeTag.Nothing)
+  def materializeConcreteTypeTag_impl[T: c.TypeTag](c: Context)(u: c.Expr[Universe]): c.Expr[u.value.ConcreteTypeTag[T]] =
+    c.Expr[Nothing](c.materializeTypeTag(u.tree, implicitly[c.TypeTag[T]].tpe, requireConcreteTypeTag = true))(c.TypeTag.Nothing)
 
   /** This method is required by the compiler and <b>should not be used in client code</b>. */
   private[scala] implicit def context2utils(c0: Context) : Utils { val c: c0.type } = new { val c: c0.type = c0 } with Utils
@@ -54,8 +54,8 @@ package internal {
       NullClass.asType -> newTermName("Null"))
 
     def materializeClassTag(prefix: Tree, tpe: Type): Tree = {
-      val typetagInScope = c.inferImplicitValue(appliedType(typeRef(prefix.tpe, TypeTagClass, Nil), List(tpe)))
-      def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == GroundTypeTagModule))
+      val typetagInScope = c.inferImplicitValue(appliedType(typeRef(prefix.tpe, ConcreteTypeTagClass, Nil), List(tpe)))
+      def typetagIsSynthetic(tree: Tree) = tree.isInstanceOf[Block] || (tree exists (sub => sub.symbol == TypeTagModule || sub.symbol == ConcreteTypeTagModule))
       typetagInScope match {
         case success if !success.isEmpty && !typetagIsSynthetic(success) =>
           val factory = TypeApply(Select(Ident(ClassTagModule), newTermName("apply")), List(TypeTree(tpe)))
@@ -88,14 +88,14 @@ package internal {
       }
     }
 
-    def materializeTypeTag(prefix: Tree, tpe: Type, requireGroundTypeTag: Boolean): Tree = {
-      val tagModule = if (requireGroundTypeTag) GroundTypeTagModule else TypeTagModule
+    def materializeTypeTag(prefix: Tree, tpe: Type, requireConcreteTypeTag: Boolean): Tree = {
+      val tagModule = if (requireConcreteTypeTag) ConcreteTypeTagModule else TypeTagModule
       val result =
         tpe match {
           case coreTpe if coreTags contains coreTpe =>
             Select(Select(prefix, tagModule.name), coreTags(coreTpe))
           case _ =>
-            try c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, requireGroundTypeTag = requireGroundTypeTag)
+            try c.reifyType(prefix, tpe, dontSpliceAtTopLevel = true, requireConcreteTypeTag = requireConcreteTypeTag)
             catch {
               case ex: Throwable =>
                 // [Eugene] cannot pattern match on an abstract type, so had to do this
diff --git a/src/library/scala/reflect/package.scala b/src/library/scala/reflect/package.scala
index 7a8267e689..1738642932 100644
--- a/src/library/scala/reflect/package.scala
+++ b/src/library/scala/reflect/package.scala
@@ -43,21 +43,21 @@ package object reflect {
   type ClassManifest[T] = ClassTag[T]
   @deprecated("OptManifest is no longer supported, and using it may lead to incorrect results, Use `@scala.reflect.TypeTag` instead", "2.10.0")
   type OptManifest[T]   = TypeTag[T]
-  @deprecated("Use `@scala.reflect.GroundTypeTag` instead", "2.10.0")
-  type Manifest[T]      = GroundTypeTag[T]
+  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
+  type Manifest[T]      = ConcreteTypeTag[T]
 
   @deprecated("Use `@scala.reflect.ClassTag` instead", "2.10.0")
   val ClassManifest     = ClassTag
-  @deprecated("Use `@scala.reflect.GroundTypeTag` instead", "2.10.0")
-  lazy val Manifest     = GroundTypeTag
+  @deprecated("Use `@scala.reflect.ConcreteTypeTag` instead", "2.10.0")
+  lazy val Manifest     = ConcreteTypeTag
   @deprecated("NoManifest is no longer supported, and using it may lead to incorrect results, Use `@scala.reflect.TypeTag` instead", "2.10.0")
   object NoManifest extends OptManifest[Nothing](scala.reflect.mirror.definitions.NothingClass.asType) with Serializable
 
   // ClassTag class is defined separately from the mirror
-  type TypeTag[T]         = scala.reflect.mirror.TypeTag[T]
-  type GroundTypeTag[T]   = scala.reflect.mirror.GroundTypeTag[T]
+  type TypeTag[T]          = scala.reflect.mirror.TypeTag[T]
+  type ConcreteTypeTag[T]  = scala.reflect.mirror.ConcreteTypeTag[T]
 
   // ClassTag object is defined separately from the mirror
-  lazy val TypeTag        = scala.reflect.mirror.TypeTag
-  lazy val GroundTypeTag  = scala.reflect.mirror.GroundTypeTag
+  lazy val TypeTag         = scala.reflect.mirror.TypeTag
+  lazy val ConcreteTypeTag = scala.reflect.mirror.ConcreteTypeTag
 }