TypeTag => AbsTypeTag, ConcreteTypeTag => TypeTag

This protects everyone from the confusion caused by stuff like this:
https://issues.scala-lang.org/browse/SI-5884

7 files changed, 41 insertions, 42 deletions

diff --git a/src/reflect/scala/reflect/api/Exprs.scala b/src/reflect/scala/reflect/api/Exprs.scala
index bda125a1a1..8b2a3b4ea8 100644
--- a/src/reflect/scala/reflect/api/Exprs.scala
+++ b/src/reflect/scala/reflect/api/Exprs.scala
@@ -30,14 +30,14 @@ trait Exprs { self: Universe =>
   }
 
   object Expr {
-    def apply[T: TypeTag](mirror: MirrorOf[self.type], treec: TreeCreator): Expr[T] = new ExprImpl[T](mirror.asInstanceOf[Mirror], treec)
+    def apply[T: AbsTypeTag](mirror: MirrorOf[self.type], treec: TreeCreator): Expr[T] = new ExprImpl[T](mirror.asInstanceOf[Mirror], treec)
     def unapply[T](expr: Expr[T]): Option[Tree] = Some(expr.tree)
   }
 
-  private class ExprImpl[+T: TypeTag](val mirror: Mirror, val treec: TreeCreator) extends Expr[T] {
+  private class ExprImpl[+T: AbsTypeTag](val mirror: Mirror, val treec: TreeCreator) extends Expr[T] {
     def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # Expr[T] = {
       val otherMirror1 = otherMirror.asInstanceOf[MirrorOf[otherMirror.universe.type]]
-      val tag1 = (implicitly[TypeTag[T]] in otherMirror).asInstanceOf[otherMirror.universe.TypeTag[T]]
+      val tag1 = (implicitly[AbsTypeTag[T]] in otherMirror).asInstanceOf[otherMirror.universe.AbsTypeTag[T]]
       otherMirror.universe.Expr[T](otherMirror1, treec)(tag1)
     }
 
@@ -45,7 +45,7 @@ trait Exprs { self: Universe =>
       // [Eugene++] this is important
       // !!! remove when we have improved type inference for singletons
       // search for .type] to find other instances
-    lazy val staticTpe: Type = implicitly[TypeTag[T]].tpe
+    lazy val staticTpe: Type = implicitly[AbsTypeTag[T]].tpe
     def actualTpe: Type = tree.tpe
 
     def splice: T = throw new UnsupportedOperationException("""
diff --git a/src/reflect/scala/reflect/api/TagInterop.scala b/src/reflect/scala/reflect/api/TagInterop.scala
index e10b89d1c6..95c4e78cf4 100644
--- a/src/reflect/scala/reflect/api/TagInterop.scala
+++ b/src/reflect/scala/reflect/api/TagInterop.scala
@@ -11,7 +11,7 @@ trait TagInterop { self: JavaUniverse =>
   // [Eugene++] would be great if we could approximate the interop without any mirrors
   // todo. think how to implement that
 
-  override def concreteTypeTagToManifest[T: ClassTag](mirror0: Any, tag: base.Universe # ConcreteTypeTag[T]): Manifest[T] = {
+  override def typeTagToManifest[T: ClassTag](mirror0: Any, tag: base.Universe # TypeTag[T]): Manifest[T] = {
     // [Eugene++] implement more sophisticated logic
     // Martin said it'd be okay to simply copypaste `Implicits.manifestOfType`
     val mirror = mirror0.asInstanceOf[Mirror]
@@ -19,8 +19,8 @@ trait TagInterop { self: JavaUniverse =>
     Manifest.classType(runtimeClass).asInstanceOf[Manifest[T]]
   }
 
-  override def manifestToConcreteTypeTag[T](mirror0: Any, manifest: Manifest[T]): base.Universe # ConcreteTypeTag[T] =
-    ConcreteTypeTag(mirror0.asInstanceOf[Mirror], new TypeCreator {
+  override def manifestToTypeTag[T](mirror0: Any, manifest: Manifest[T]): base.Universe # TypeTag[T] =
+    TypeTag(mirror0.asInstanceOf[Mirror], new TypeCreator {
       def apply[U <: BaseUniverse with Singleton](mirror: MirrorOf[U]): U # Type = {
         mirror.universe match {
           case ju: JavaUniverse =>
@@ -28,10 +28,10 @@ trait TagInterop { self: JavaUniverse =>
             val sym = jm.reflectClass(manifest.erasure).symbol
             val tpe =
               if (manifest.typeArguments.isEmpty) sym.asType
-              else ju.appliedType(sym.asTypeConstructor, manifest.typeArguments map (targ => ju.manifestToConcreteTypeTag(jm, targ)) map (_.in(jm).tpe))
+              else ju.appliedType(sym.asTypeConstructor, manifest.typeArguments map (targ => ju.manifestToTypeTag(jm, targ)) map (_.in(jm).tpe))
             tpe.asInstanceOf[U # Type]
           case u =>
-            u.manifestToConcreteTypeTag(mirror.asInstanceOf[u.Mirror], manifest).in(mirror).tpe
+            u.manifestToTypeTag(mirror.asInstanceOf[u.Mirror], manifest).in(mirror).tpe
         }
       }
     })
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index e4a2623c31..a9d9b06621 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -470,10 +470,10 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ClassTagModule        = requiredModule[scala.reflect.ClassTag[_]]
     lazy val ClassTagClass         = requiredClass[scala.reflect.ClassTag[_]]
     lazy val TypeTagsClass         = requiredClass[scala.reflect.base.TypeTags]
+    lazy val AbsTypeTagClass       = getMemberClass(TypeTagsClass, tpnme.AbsTypeTag)
+    lazy val AbsTypeTagModule      = getMemberModule(TypeTagsClass, nme.AbsTypeTag)
     lazy val TypeTagClass          = getMemberClass(TypeTagsClass, tpnme.TypeTag)
     lazy val TypeTagModule         = getMemberModule(TypeTagsClass, nme.TypeTag)
-    lazy val ConcreteTypeTagClass  = getMemberClass(TypeTagsClass, tpnme.ConcreteTypeTag)
-    lazy val ConcreteTypeTagModule = getMemberModule(TypeTagsClass, nme.ConcreteTypeTag)
 
     lazy val BaseUniverseClass     = requiredClass[scala.reflect.base.Universe]
     lazy val ApiUniverseClass      = getClassIfDefined("scala.reflect.api.Universe") // defined in scala-reflect.jar, so we need to be careful
@@ -485,17 +485,17 @@ trait Definitions extends api.StandardDefinitions {
     lazy val TypeCreatorClass      = requiredClass[scala.reflect.base.TypeCreator]
     lazy val TreeCreatorClass      = requiredClass[scala.reflect.base.TreeCreator]
 
-    lazy val MacroContextClass                        = getClassIfDefined("scala.reflect.makro.Context") // defined in scala-reflect.jar, so we need to be careful
-         def MacroContextPrefix                       = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.prefix) else NoSymbol
-         def MacroContextPrefixType                   = if (MacroContextClass != NoSymbol) getMemberType(MacroContextClass, tpnme.PrefixType) else NoSymbol
-         def MacroContextUniverse                     = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.universe) else NoSymbol
-         def MacroContextMirror                       = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.mirror) else NoSymbol
-         def MacroContextReify                        = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.reify) else NoSymbol
-    lazy val MacroImplAnnotation                      = requiredClass[scala.reflect.makro.internal.macroImpl]
-    lazy val MacroInternalPackage                     = getPackageObject("scala.reflect.makro.internal")
-         def MacroInternal_materializeClassTag        = getMemberMethod(MacroInternalPackage, nme.materializeClassTag)
-         def MacroInternal_materializeTypeTag         = getMemberMethod(MacroInternalPackage, nme.materializeTypeTag)
-         def MacroInternal_materializeConcreteTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeConcreteTypeTag)
+    lazy val MacroContextClass                   = getClassIfDefined("scala.reflect.makro.Context") // defined in scala-reflect.jar, so we need to be careful
+         def MacroContextPrefix                  = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.prefix) else NoSymbol
+         def MacroContextPrefixType              = if (MacroContextClass != NoSymbol) getMemberType(MacroContextClass, tpnme.PrefixType) else NoSymbol
+         def MacroContextUniverse                = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.universe) else NoSymbol
+         def MacroContextMirror                  = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.mirror) else NoSymbol
+         def MacroContextReify                   = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.reify) else NoSymbol
+    lazy val MacroImplAnnotation                 = requiredClass[scala.reflect.makro.internal.macroImpl]
+    lazy val MacroInternalPackage                = getPackageObject("scala.reflect.makro.internal")
+         def MacroInternal_materializeClassTag   = getMemberMethod(MacroInternalPackage, nme.materializeClassTag)
+         def MacroInternal_materializeAbsTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeAbsTypeTag)
+         def MacroInternal_materializeTypeTag    = getMemberMethod(MacroInternalPackage, nme.materializeTypeTag)
 
     lazy val ScalaSignatureAnnotation = requiredClass[scala.reflect.ScalaSignature]
     lazy val ScalaLongSignatureAnnotation = requiredClass[scala.reflect.ScalaLongSignature]
@@ -506,8 +506,8 @@ trait Definitions extends api.StandardDefinitions {
     lazy val NoneModule: ModuleSymbol = requiredModule[scala.None.type]
     lazy val SomeModule: ModuleSymbol = requiredModule[scala.Some.type]
 
-    def compilerTypeFromTag(tt: BaseUniverse # TypeTag[_]): Type = tt.in(rootMirror).tpe
-    def compilerSymbolFromTag(tt: BaseUniverse # TypeTag[_]): Symbol = tt.in(rootMirror).tpe.typeSymbol
+    def compilerTypeFromTag(tt: BaseUniverse # AbsTypeTag[_]): Type = tt.in(rootMirror).tpe
+    def compilerSymbolFromTag(tt: BaseUniverse # AbsTypeTag[_]): Symbol = tt.in(rootMirror).tpe.typeSymbol
 
     // The given symbol represents either String.+ or StringAdd.+
     def isStringAddition(sym: Symbol) = sym == String_+ || sym == StringAdd_+
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 5ff02bab82..bd02013037 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -122,16 +122,16 @@ trait StdNames {
       scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)
 
     // some types whose companions we utilize
-    final val AnyRef: NameType          = "AnyRef"
-    final val Array: NameType           = "Array"
-    final val List: NameType            = "List"
-    final val Seq: NameType             = "Seq"
-    final val Symbol: NameType          = "Symbol"
-    final val ClassTag: NameType        = "ClassTag"
-    final val TypeTag : NameType        = "TypeTag"
-    final val ConcreteTypeTag: NameType = "ConcreteTypeTag"
-    final val Expr: NameType            = "Expr"
-    final val String: NameType          = "String"
+    final val AnyRef: NameType     = "AnyRef"
+    final val Array: NameType      = "Array"
+    final val List: NameType       = "List"
+    final val Seq: NameType        = "Seq"
+    final val Symbol: NameType     = "Symbol"
+    final val ClassTag: NameType   = "ClassTag"
+    final val AbsTypeTag: NameType = "AbsTypeTag"
+    final val TypeTag : NameType   = "TypeTag"
+    final val Expr: NameType       = "Expr"
+    final val String: NameType     = "String"
 
     // fictions we use as both types and terms
     final val ERROR: NameType    = "<error>"
@@ -642,7 +642,6 @@ trait StdNames {
     val classOf: NameType              = "classOf"
     val classTagToClassManifest: NameType = "classTagToClassManifest"
     val clone_ : NameType              = if (forMSIL) "MemberwiseClone" else "clone" // sn.OClone causes checkinit failure
-    val concreteTypeTagToManifest: NameType = "concreteTypeTagToManifest"
     val conforms: NameType             = "conforms"
     val copy: NameType                 = "copy"
     val currentMirror: NameType        = "currentMirror"
@@ -697,10 +696,10 @@ trait StdNames {
     val macroContext : NameType        = "c"
     val main: NameType                 = "main"
     val manifest: NameType             = "manifest"
-    val manifestToConcreteTypeTag: NameType = "manifestToConcreteTypeTag"
+    val manifestToTypeTag: NameType    = "manifestToTypeTag"
     val map: NameType                  = "map"
     val materializeClassTag: NameType  = "materializeClassTag"
-    val materializeConcreteTypeTag: NameType = "materializeConcreteTypeTag"
+    val materializeAbsTypeTag: NameType = "materializeAbsTypeTag"
     val materializeTypeTag: NameType   = "materializeTypeTag"
     val mirror : NameType              = "mirror"
     val moduleClass : NameType         = "moduleClass"
@@ -764,6 +763,7 @@ trait StdNames {
     val tree : NameType                = "tree"
     val true_ : NameType               = "true"
     val typedProductIterator: NameType = "typedProductIterator"
+    val typeTagToManifest: NameType    = "typeTagToManifest"
     val unapply: NameType              = "unapply"
     val unapplySeq: NameType           = "unapplySeq"
     val unbox: NameType                = "unbox"
diff --git a/src/reflect/scala/reflect/makro/Aliases.scala b/src/reflect/scala/reflect/makro/Aliases.scala
index c78c9a6a04..4bd246572f 100644
--- a/src/reflect/scala/reflect/makro/Aliases.scala
+++ b/src/reflect/scala/reflect/makro/Aliases.scala
@@ -17,11 +17,10 @@ trait Aliases {
   type Expr[+T] = universe.Expr[T]
   val Expr = universe.Expr
 
+  type AbsTypeTag[T] = universe.AbsTypeTag[T]
   type TypeTag[T] = universe.TypeTag[T]
-  type ConcreteTypeTag[T] = universe.ConcreteTypeTag[T]
+  val AbsTypeTag = universe.AbsTypeTag
   val TypeTag = universe.TypeTag
-  val ConcreteTypeTag = universe.ConcreteTypeTag
   def typeTag[T](implicit ttag: TypeTag[T]) = ttag
-  def concreteTypeTag[T](implicit cttag: ConcreteTypeTag[T]) = cttag
   def typeOf[T](implicit ttag: TypeTag[T]): Type = ttag.tpe
 }
diff --git a/src/reflect/scala/reflect/makro/Exprs.scala b/src/reflect/scala/reflect/makro/Exprs.scala
index b4f8e7ac4e..91d3dafbf2 100644
--- a/src/reflect/scala/reflect/makro/Exprs.scala
+++ b/src/reflect/scala/reflect/makro/Exprs.scala
@@ -4,5 +4,5 @@ package makro
 trait Exprs {
   self: Context =>
 
-  def Expr[T: TypeTag](tree: Tree): Expr[T]
+  def Expr[T: AbsTypeTag](tree: Tree): Expr[T]
 }
diff --git a/src/reflect/scala/reflect/makro/TypeTags.scala b/src/reflect/scala/reflect/makro/TypeTags.scala
index 3251c27908..53a9b116e3 100644
--- a/src/reflect/scala/reflect/makro/TypeTags.scala
+++ b/src/reflect/scala/reflect/makro/TypeTags.scala
@@ -4,6 +4,6 @@ package makro
 trait TypeTags {
   self: Context =>
 
+  def AbsTypeTag[T](tpe: Type): AbsTypeTag[T]
   def TypeTag[T](tpe: Type): TypeTag[T]
-  def ConcreteTypeTag[T](tpe: Type): ConcreteTypeTag[T]
 }