GroundTypeTag => ConcreteTypeTag

10 files changed, 39 insertions, 39 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index b1c822ed97..12b083b4f6 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -477,16 +477,16 @@ trait Definitions extends reflect.api.StandardDefinitions {
          def ExprValue     = getMember(ExprClass, nme.value)
     lazy val ExprModule    = getMember(getRequiredClass("scala.reflect.api.Exprs"), nme.Expr)
 
-    lazy val ClassTagClass       = getRequiredClass("scala.reflect.ClassTag")
-         def ClassTagErasure     = getMember(ClassTagClass, nme.erasure)
-         def ClassTagTpe         = getMember(ClassTagClass, nme.tpe)
-    lazy val ClassTagModule      = getRequiredModule("scala.reflect.ClassTag")
-    lazy val TypeTagsClass       = getRequiredClass("scala.reflect.api.TypeTags")
-    lazy val TypeTagClass        = getMember(TypeTagsClass, tpnme.TypeTag)
-         def TypeTagTpe          = getMember(TypeTagClass, nme.tpe)
-    lazy val TypeTagModule       = getMember(TypeTagsClass, nme.TypeTag)
-    lazy val GroundTypeTagClass  = getMember(TypeTagsClass, tpnme.GroundTypeTag)
-    lazy val GroundTypeTagModule = getMember(TypeTagsClass, nme.GroundTypeTag)
+    lazy val ClassTagClass         = getRequiredClass("scala.reflect.ClassTag")
+         def ClassTagErasure       = getMember(ClassTagClass, nme.erasure)
+         def ClassTagTpe           = getMember(ClassTagClass, nme.tpe)
+    lazy val ClassTagModule        = getRequiredModule("scala.reflect.ClassTag")
+    lazy val TypeTagsClass         = getRequiredClass("scala.reflect.api.TypeTags")
+    lazy val TypeTagClass          = getMember(TypeTagsClass, tpnme.TypeTag)
+         def TypeTagTpe            = getMember(TypeTagClass, nme.tpe)
+    lazy val TypeTagModule         = getMember(TypeTagsClass, nme.TypeTag)
+    lazy val ConcreteTypeTagClass  = getMember(TypeTagsClass, tpnme.ConcreteTypeTag)
+    lazy val ConcreteTypeTagModule = getMember(TypeTagsClass, nme.ConcreteTypeTag)
 
     lazy val MacroContextClass                        = getRequiredClass("scala.reflect.makro.Context")
          def MacroContextPrefix                       = getMember(MacroContextClass, nme.prefix)
@@ -497,7 +497,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val MacroInternalPackage                     = getPackageObject("scala.reflect.makro.internal")
          def MacroInternal_materializeClassTag        = getMember(MacroInternalPackage, nme.materializeClassTag)
          def MacroInternal_materializeTypeTag         = getMember(MacroInternalPackage, nme.materializeTypeTag)
-         def MacroInternal_materializeGroundTypeTag   = getMember(MacroInternalPackage, nme.materializeGroundTypeTag)
+         def MacroInternal_materializeConcreteTypeTag = getMember(MacroInternalPackage, nme.materializeConcreteTypeTag)
 
     lazy val ScalaSignatureAnnotation = getRequiredClass("scala.reflect.ScalaSignature")
     lazy val ScalaLongSignatureAnnotation = getRequiredClass("scala.reflect.ScalaLongSignature")
diff --git a/src/compiler/scala/reflect/internal/StdNames.scala b/src/compiler/scala/reflect/internal/StdNames.scala
index b72610f1e0..1666887133 100644
--- a/src/compiler/scala/reflect/internal/StdNames.scala
+++ b/src/compiler/scala/reflect/internal/StdNames.scala
@@ -126,7 +126,7 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     final val Symbol: NameType = "Symbol"
     final val ClassTag: NameType = "ClassTag"
     final val TypeTag : NameType = "TypeTag"
-    final val GroundTypeTag: NameType = "GroundTypeTag"
+    final val ConcreteTypeTag: NameType = "ConcreteTypeTag"
 
     // fictions we use as both types and terms
     final val ERROR: NameType    = "<error>"
@@ -396,7 +396,7 @@ trait StdNames extends NameManglers { self: SymbolTable =>
     val map: NameType                  = "map"
     val materializeClassTag: NameType  = "materializeClassTag"
     val materializeTypeTag: NameType   = "materializeTypeTag"
-    val materializeGroundTypeTag: NameType = "materializeGroundTypeTag"
+    val materializeConcreteTypeTag: NameType = "materializeConcreteTypeTag"
     val mirror : NameType              = "mirror"
     val moduleClass : NameType         = "moduleClass"
     val name: NameType                 = "name"
diff --git a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
index 826fa7153f..2488b06d6c 100644
--- a/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
+++ b/src/compiler/scala/reflect/makro/runtime/Reifiers.scala
@@ -21,16 +21,16 @@ trait Reifiers {
   def reifyTree(prefix: Tree, tree: Tree): Tree =
     reifyTopLevel(prefix, tree)
 
-  def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, noTypeVariablesInResult: Boolean = false): Tree =
-    reifyTopLevel(prefix, tpe, dontSpliceAtTopLevel, noTypeVariablesInResult)
+  def reifyType(prefix: Tree, tpe: Type, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree =
+    reifyTopLevel(prefix, tpe, dontSpliceAtTopLevel, requireConcreteTypeTag)
 
   def unreifyTree(tree: Tree): Tree =
     Select(tree, definitions.ExprEval)
 
-  def reifyTopLevel(prefix: Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireGroundTypeTag: Boolean = false): Tree = {
+  def reifyTopLevel(prefix: Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Tree = {
     // [Eugene] the plumbing is not very pretty, but anyways factoring out the reifier seems like a necessary step to me
     import scala.reflect.reify._
-    val reifier = mkReifier(mirror)(callsiteTyper, prefix, reifee, dontSpliceAtTopLevel, requireGroundTypeTag)
+    val reifier = mkReifier(mirror)(callsiteTyper, prefix, reifee, dontSpliceAtTopLevel, requireConcreteTypeTag)
 
     try {
       val result = reifier.reified
diff --git a/src/compiler/scala/reflect/reify/Errors.scala b/src/compiler/scala/reflect/reify/Errors.scala
index 8bfe64621b..30c6c06c7b 100644
--- a/src/compiler/scala/reflect/reify/Errors.scala
+++ b/src/compiler/scala/reflect/reify/Errors.scala
@@ -33,8 +33,8 @@ trait Errors {
     throw new ReificationError(defaultErrorPosition, msg)
   }
 
-  def CannotReifyGroundTypeTagHavingUnresolvedTypeParameters(tpe: Type) = {
-    val msg = "cannot reify GroundTypeTag having unresolved type parameter %s".format(tpe)
+  def CannotReifyConcreteTypeTagHavingUnresolvedTypeParameters(tpe: Type) = {
+    val msg = "cannot reify ConcreteTypeTag having unresolved type parameter %s".format(tpe)
     throw new ReificationError(defaultErrorPosition, msg)
   }
 
diff --git a/src/compiler/scala/reflect/reify/Reifiers.scala b/src/compiler/scala/reflect/reify/Reifiers.scala
index 6854710949..16c26734b2 100644
--- a/src/compiler/scala/reflect/reify/Reifiers.scala
+++ b/src/compiler/scala/reflect/reify/Reifiers.scala
@@ -21,7 +21,7 @@ abstract class Reifier extends Phases
   val prefix: Tree
   val reifee: Any
   val dontSpliceAtTopLevel: Boolean
-  val requireGroundTypeTag: Boolean
+  val requireConcreteTypeTag: Boolean
 
   /**
    *  For ``reifee'' and other reification parameters, generate a tree of the form
@@ -74,7 +74,7 @@ abstract class Reifier extends Phases
 
           val manifestedType = typer.packedType(tree, NoSymbol)
           val manifestedRtype = reifyType(manifestedType)
-          val tagModule = if (definitelyGround) GroundTypeTagModule else TypeTagModule
+          val tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule
           var typeTagCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType)))
           var exprCtor = TypeApply(Select(Ident(nme.MIRROR_SHORT), ExprModule.name), List(TypeTree(manifestedType)))
           Apply(Apply(exprCtor, List(rtree)), List(Apply(typeTagCtor, List(manifestedRtype))))
@@ -85,7 +85,7 @@ abstract class Reifier extends Phases
           val rtree = reify(tpe)
 
           val manifestedType = tpe
-          var tagModule = if (definitelyGround) GroundTypeTagModule else TypeTagModule
+          var tagModule = if (definitelyConcrete) ConcreteTypeTagModule else TypeTagModule
           var ctor = TypeApply(Select(Ident(nme.MIRROR_SHORT), tagModule.name), List(TypeTree(manifestedType)))
           Apply(ctor, List(rtree))
 
diff --git a/src/compiler/scala/reflect/reify/codegen/Types.scala b/src/compiler/scala/reflect/reify/codegen/Types.scala
index 6f3a60a076..9bc113e8a4 100644
--- a/src/compiler/scala/reflect/reify/codegen/Types.scala
+++ b/src/compiler/scala/reflect/reify/codegen/Types.scala
@@ -67,8 +67,8 @@ trait Types {
   private var spliceTypesEnabled = !dontSpliceAtTopLevel
 
   /** Keeps track of whether this reification contains abstract type parameters */
-  var maybeGround = true
-  var definitelyGround = true
+  var maybeConcrete = true
+  var definitelyConcrete = true
 
   def eligibleForSplicing(tpe: Type): Boolean = {
     // [Eugene] is this comprehensive?
@@ -88,7 +88,7 @@ trait Types {
       if (reifyDebug) println("splicing " + tpe)
 
       if (spliceTypesEnabled) {
-        var tagClass = if (requireGroundTypeTag) GroundTypeTagClass else TypeTagClass
+        var tagClass = if (requireConcreteTypeTag) ConcreteTypeTagClass else TypeTagClass
         val tagTpe = singleType(prefix.tpe, prefix.tpe member tagClass.name)
 
         // [Eugene] this should be enough for an abstract type, right?
@@ -99,16 +99,16 @@ trait Types {
           // to find out the whereabouts of the error run scalac with -Ydebug
           if (reifyDebug) println("launching implicit search for %s.%s[%s]".format(prefix, tagClass.name, tpe))
           val positionBearer = mirror.analyzer.openMacros.find(c => c.macroApplication.pos != NoPosition).map(_.macroApplication).getOrElse(EmptyTree).asInstanceOf[Tree]
-          typer.resolveTypeTag(positionBearer, prefix.tpe, tpe, requireGroundTypeTag) match {
+          typer.resolveTypeTag(positionBearer, prefix.tpe, tpe, requireConcreteTypeTag) match {
             case failure if failure.isEmpty =>
               if (reifyDebug) println("implicit search was fruitless")
-              definitelyGround &= false
-              maybeGround &= false
+              definitelyConcrete &= false
+              maybeConcrete &= false
               EmptyTree
             case success =>
               if (reifyDebug) println("implicit search has produced a result: " + success)
-              definitelyGround |= requireGroundTypeTag
-              maybeGround |= true
+              definitelyConcrete |= requireConcreteTypeTag
+              maybeConcrete |= true
               var splice = Select(success, nme.tpe)
               splice match {
                 case InlinedTypeSplice(_, inlinedSymbolTable, tpe) =>
@@ -126,8 +126,8 @@ trait Types {
         if (reifyDebug) println("splicing has been cancelled: spliceTypesEnabled = false")
       }
 
-      if (requireGroundTypeTag)
-        CannotReifyGroundTypeTagHavingUnresolvedTypeParameters(tpe)
+      if (requireConcreteTypeTag)
+        CannotReifyConcreteTypeTagHavingUnresolvedTypeParameters(tpe)
     }
 
     spliceTypesEnabled = true
diff --git a/src/compiler/scala/reflect/reify/package.scala b/src/compiler/scala/reflect/reify/package.scala
index 7041fbf6ed..85cf92fe2f 100644
--- a/src/compiler/scala/reflect/reify/package.scala
+++ b/src/compiler/scala/reflect/reify/package.scala
@@ -3,12 +3,12 @@ package scala.reflect
 import scala.tools.nsc.Global
 
 package object reify {
-  def mkReifier(global: Global)(typer: global.analyzer.Typer, prefix: global.Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireGroundTypeTag: Boolean = false): Reifier { val mirror: global.type } = {
+  def mkReifier(global: Global)(typer: global.analyzer.Typer, prefix: global.Tree, reifee: Any, dontSpliceAtTopLevel: Boolean = false, requireConcreteTypeTag: Boolean = false): Reifier { val mirror: global.type } = {
     val typer1: typer.type = typer
     val prefix1: prefix.type = prefix
     val reifee1 = reifee
     val dontSpliceAtTopLevel1 = dontSpliceAtTopLevel
-    val requireGroundTypeTag1 = requireGroundTypeTag
+    val requireConcreteTypeTag1 = requireConcreteTypeTag
 
     new {
       val mirror: global.type = global
@@ -16,7 +16,7 @@ package object reify {
       val prefix = prefix1
       val reifee = reifee1
       val dontSpliceAtTopLevel = dontSpliceAtTopLevel1
-      val requireGroundTypeTag = requireGroundTypeTag1
+      val requireConcreteTypeTag = requireConcreteTypeTag1
     } with Reifier
   }
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 8aa257983a..3a789b83b6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1099,11 +1099,11 @@ trait Implicits {
     }
 
     // these should be lazy, otherwise we wouldn't be able to compile scala-library with starr
-    private val TagSymbols = Set(ClassTagClass, TypeTagClass, GroundTypeTagClass)
+    private val TagSymbols = Set(ClassTagClass, TypeTagClass, ConcreteTypeTagClass)
     private val TagMaterializers = Map(
       ClassTagClass -> MacroInternal_materializeClassTag,
       TypeTagClass -> MacroInternal_materializeTypeTag,
-      GroundTypeTagClass -> MacroInternal_materializeGroundTypeTag
+      ConcreteTypeTagClass -> MacroInternal_materializeConcreteTypeTag
     )
 
     def tagOfType(pre: Type, tp: Type, tagClass: Symbol): SearchResult = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 3b270a92ad..9608108a0d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -877,7 +877,7 @@ trait Macros { self: Analyzer =>
       tpe
     }) map (tpe => {
       val ttag = TypeTag(tpe)
-      if (ttag.isGround) ttag.toGround else ttag
+      if (ttag.isConcrete) ttag.toConcrete else ttag
     })
     argss = argss.dropRight(1) :+ (evidences ++ argss.last)
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 1b508a96fe..5d9b8ae94a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -5020,7 +5020,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
     def resolveTypeTag(tree: Tree, pre: Type, tp: Type, full: Boolean): Tree = beforeTyper {
       inferImplicit(
         EmptyTree,
-        appliedType(singleType(pre, pre member (if (full) GroundTypeTagClass else TypeTagClass).name), List(tp)),
+        appliedType(singleType(pre, pre member (if (full) ConcreteTypeTagClass else TypeTagClass).name), List(tp)),
         /*reportAmbiguous =*/ true,
         /*isView =*/ false,
         /*context =*/ context,