SI-6310 AbsTypeTag => WeakTypeTag

The new name for AbsTypeTag was a matter of a lengthy discussion:
http://groups.google.com/group/scala-internals/browse_thread/thread/fb2007e61b505c4d

I couldn't decide until having fixed SI-6323 today, which is about
trying to reflect against a local class using typeOf.

The problem with local classes is that they aren't pickled, so their metadata
isn't preserved between Scala compilation runs. Sure, we can restore some of
that metadata with Java reflection, but you get the idea.

Before today typeOf of a local class created a free type, a synthetic symbol,
with a bunch of synthetic children that remember the metadata, effectively
creating a mini symbol table. That might be useful at time, but the problem is
that this free type cannot be reflected, because the global symbol table of
Scala reflection doesn't know about its mini symbol table.

And then it struck me. It's not the presence of abs types (type parameters and
abs type members) that differentiates arbitrary type tags from good type tags.
It's the presence of types that don't map well on the runtime world - ones that
can't be used to instantiate values, ones that can't be reflected.

So we just need a name for these types. Phantom types are compile-time only
concept, whereas our types can have partial correspondence with the runtime.
"Weak types" sound more or less okish, so let's try them out.

90 files changed, 277 insertions, 268 deletions

diff --git a/src/compiler/scala/reflect/macros/runtime/Aliases.scala b/src/compiler/scala/reflect/macros/runtime/Aliases.scala
index 5e15b61dbd..30e72997f7 100644
--- a/src/compiler/scala/reflect/macros/runtime/Aliases.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Aliases.scala
@@ -17,12 +17,12 @@ trait Aliases {
   override type Expr[+T] = universe.Expr[T]
   override val Expr = universe.Expr
 
-  override type AbsTypeTag[T] = universe.AbsTypeTag[T]
+  override type WeakTypeTag[T] = universe.WeakTypeTag[T]
   override type TypeTag[T] = universe.TypeTag[T]
-  override val AbsTypeTag = universe.AbsTypeTag
+  override val WeakTypeTag = universe.WeakTypeTag
   override val TypeTag = universe.TypeTag
-  override def absTypeTag[T](implicit attag: AbsTypeTag[T]) = attag
+  override def weakTypeTag[T](implicit attag: WeakTypeTag[T]) = attag
   override def typeTag[T](implicit ttag: TypeTag[T]) = ttag
-  override def absTypeOf[T](implicit attag: AbsTypeTag[T]): Type = attag.tpe
+  override def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type = attag.tpe
   override def typeOf[T](implicit ttag: TypeTag[T]): Type = ttag.tpe
 }
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/runtime/Exprs.scala b/src/compiler/scala/reflect/macros/runtime/Exprs.scala
index 4217a6a404..ebf8fa2b96 100644
--- a/src/compiler/scala/reflect/macros/runtime/Exprs.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Exprs.scala
@@ -4,5 +4,5 @@ package runtime
 trait Exprs {
   self: Context =>
 
-  def Expr[T: AbsTypeTag](tree: Tree): Expr[T] = universe.Expr[T](mirror, universe.FixedMirrorTreeCreator(mirror, tree))
+  def Expr[T: WeakTypeTag](tree: Tree): Expr[T] = universe.Expr[T](mirror, universe.FixedMirrorTreeCreator(mirror, tree))
 }
diff --git a/src/compiler/scala/reflect/macros/runtime/TypeTags.scala b/src/compiler/scala/reflect/macros/runtime/TypeTags.scala
index 2bc2fe6384..19b60159de 100644
--- a/src/compiler/scala/reflect/macros/runtime/TypeTags.scala
+++ b/src/compiler/scala/reflect/macros/runtime/TypeTags.scala
@@ -4,6 +4,6 @@ package runtime
 trait TypeTags {
   self: Context =>
 
-  def AbsTypeTag[T](tpe: Type): AbsTypeTag[T] = universe.AbsTypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
+  def WeakTypeTag[T](tpe: Type): WeakTypeTag[T] = universe.WeakTypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
   def TypeTag[T](tpe: Type): TypeTag[T] = universe.TypeTag[T](mirror, universe.FixedMirrorTypeCreator(mirror, tpe))
 }
diff --git a/src/compiler/scala/reflect/reify/Taggers.scala b/src/compiler/scala/reflect/reify/Taggers.scala
index a8523fe686..bc12d383a4 100644
--- a/src/compiler/scala/reflect/reify/Taggers.scala
+++ b/src/compiler/scala/reflect/reify/Taggers.scala
@@ -37,7 +37,7 @@ abstract class Taggers {
   }
 
   def materializeTypeTag(universe: Tree, mirror: Tree, tpe: Type, concrete: Boolean): Tree = {
-    val tagType = if (concrete) TypeTagClass else AbsTypeTagClass
+    val tagType = if (concrete) TypeTagClass else WeakTypeTagClass
     // what we need here is to compose a type BaseUniverse # TypeTag[$tpe]
     // to look for an implicit that conforms to this type
     // that's why neither appliedType(tagType, List(tpe)) aka TypeRef(TypeTagsClass.thisType, tagType, List(tpe))
@@ -50,7 +50,7 @@ abstract class Taggers {
       case success if !success.isEmpty =>
         Apply(Select(success, nme.in), List(mirror orElse mkDefaultMirrorRef(c.universe)(universe, c.callsiteTyper)))
       case _ =>
-        val tagModule = if (concrete) TypeTagModule else AbsTypeTagModule
+        val tagModule = if (concrete) TypeTagModule else WeakTypeTagModule
         materializeTag(universe, tpe, tagModule, c.reifyType(universe, mirror, tpe, concrete = concrete))
     }
   }
diff --git a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
index 1d2e177688..7aa87dc2f8 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala
@@ -73,7 +73,7 @@ trait GenTypes {
     if (tpe.isSpliceable && !(quantified contains tpe.typeSymbol)) {
       if (reifyDebug) println("splicing " + tpe)
 
-      val tagFlavor = if (concrete) tpnme.TypeTag.toString else tpnme.AbsTypeTag.toString
+      val tagFlavor = if (concrete) tpnme.TypeTag.toString else tpnme.WeakTypeTag.toString
       val key = (tagFlavor, tpe.typeSymbol)
       // if this fails, it might produce the dreaded "erroneous or inaccessible type" error
       // to find out the whereabouts of the error run scalac with -Ydebug
diff --git a/src/compiler/scala/reflect/reify/codegen/GenUtils.scala b/src/compiler/scala/reflect/reify/codegen/GenUtils.scala
index 2b7733fb6c..8aef8d772f 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenUtils.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenUtils.scala
@@ -131,7 +131,7 @@ trait GenUtils {
 
   def isCrossStageTypeBearer(tree: Tree): Boolean = tree match {
     case TypeApply(hk, _) => isCrossStageTypeBearer(hk)
-    case Select(sym @ Select(_, ctor), nme.apply) if ctor == nme.AbsTypeTag || ctor == nme.TypeTag || ctor == nme.Expr => true
+    case Select(sym @ Select(_, ctor), nme.apply) if ctor == nme.WeakTypeTag || ctor == nme.TypeTag || ctor == nme.Expr => true
     case _ => false
   }
 
diff --git a/src/compiler/scala/reflect/reify/phases/Reshape.scala b/src/compiler/scala/reflect/reify/phases/Reshape.scala
index fcf3c0e65c..0b07c47c0f 100644
--- a/src/compiler/scala/reflect/reify/phases/Reshape.scala
+++ b/src/compiler/scala/reflect/reify/phases/Reshape.scala
@@ -103,8 +103,8 @@ trait Reshape {
             // of, say, ClassTag or TypeTag
             case Apply(TypeApply(_, List(tt)), _) if original.symbol == MacroInternal_materializeClassTag =>
               gen.mkNullaryCall(Predef_implicitly, List(appliedType(ClassTagClass, tt.tpe)))
-            case Apply(TypeApply(_, List(tt)), List(pre)) if original.symbol == MacroInternal_materializeAbsTypeTag =>
-              gen.mkNullaryCall(Predef_implicitly, List(typeRef(pre.tpe, AbsTypeTagClass, List(tt.tpe))))
+            case Apply(TypeApply(_, List(tt)), List(pre)) if original.symbol == MacroInternal_materializeWeakTypeTag =>
+              gen.mkNullaryCall(Predef_implicitly, List(typeRef(pre.tpe, WeakTypeTagClass, List(tt.tpe))))
             case Apply(TypeApply(_, List(tt)), List(pre)) if original.symbol == MacroInternal_materializeTypeTag =>
               gen.mkNullaryCall(Predef_implicitly, List(typeRef(pre.tpe, TypeTagClass, List(tt.tpe))))
             case _ =>
diff --git a/src/compiler/scala/reflect/reify/utils/Extractors.scala b/src/compiler/scala/reflect/reify/utils/Extractors.scala
index 3f3f08cf2b..1df9efbb82 100644
--- a/src/compiler/scala/reflect/reify/utils/Extractors.scala
+++ b/src/compiler/scala/reflect/reify/utils/Extractors.scala
@@ -94,7 +94,7 @@ trait Extractors {
 
   object ReifiedTree {
     def apply(universe: Tree, mirror: Tree, symtab: SymbolTable, rtree: Tree, tpe: Type, rtpe: Tree, concrete: Boolean): Tree = {
-      val tagFactory = if (concrete) nme.TypeTag else nme.AbsTypeTag
+      val tagFactory = if (concrete) nme.TypeTag else nme.WeakTypeTag
       val tagCtor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), tagFactory), nme.apply), List(TypeTree(tpe)))
       val exprCtor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), nme.Expr), nme.apply), List(TypeTree(tpe)))
       val tagArgs = List(Ident(nme.MIRROR_SHORT), mkCreator(tpnme.REIFY_TYPECREATOR_PREFIX, symtab, rtpe))
@@ -122,7 +122,7 @@ trait Extractors {
 
   object ReifiedType {
     def apply(universe: Tree, mirror: Tree, symtab: SymbolTable, tpe: Type, rtpe: Tree, concrete: Boolean) = {
-      val tagFactory = if (concrete) nme.TypeTag else nme.AbsTypeTag
+      val tagFactory = if (concrete) nme.TypeTag else nme.WeakTypeTag
       val ctor = TypeApply(Select(Select(Ident(nme.UNIVERSE_SHORT), tagFactory), nme.apply), List(TypeTree(tpe)))
       val args = List(Ident(nme.MIRROR_SHORT), mkCreator(tpnme.REIFY_TYPECREATOR_PREFIX, symtab, rtpe))
       val unwrapped = Apply(ctor, args)
diff --git a/src/compiler/scala/tools/nsc/doc/Settings.scala b/src/compiler/scala/tools/nsc/doc/Settings.scala
index dbc34bd7b3..60cd375175 100644
--- a/src/compiler/scala/tools/nsc/doc/Settings.scala
+++ b/src/compiler/scala/tools/nsc/doc/Settings.scala
@@ -257,7 +257,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
       ("scala.reflect.ClassManifest"         -> ((tparam: String) => tparam + " is accompanied by a ClassManifest, which is a runtime representation of its type that survives erasure")) +
       ("scala.reflect.OptManifest"           -> ((tparam: String) => tparam + " is accompanied by an OptManifest, which can be either a runtime representation of its type or the NoManifest, which means the runtime type is not available")) +
       ("scala.reflect.ClassTag"              -> ((tparam: String) => tparam + " is accompanied by a ClassTag, which is a runtime representation of its type that survives erasure")) +
-      ("scala.reflect.AbsTypeTag"            -> ((tparam: String) => tparam + " is accompanied by an AbsTypeTag, which is a runtime representation of its type that survives erasure")) +
+      ("scala.reflect.WeakTypeTag"            -> ((tparam: String) => tparam + " is accompanied by an WeakTypeTag, which is a runtime representation of its type that survives erasure")) +
       ("scala.reflect.base.TypeTags.TypeTag" -> ((tparam: String) => tparam + " is accompanied by a TypeTag, which is a runtime representation of its type that survives erasure"))
 
     /**
diff --git a/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala b/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala
index f1eab841f9..9b0765e394 100644
--- a/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala
+++ b/src/compiler/scala/tools/nsc/doc/html/SyntaxHigh.scala
@@ -40,7 +40,7 @@ private[html] object SyntaxHigh {
 
   /** Standard library classes/objects, sorted alphabetically */
   val standards = Array (
-    "AbsTypeTag", "Any", "AnyRef", "AnyVal", "App", "Application", "Array",
+    "WeakTypeTag", "Any", "AnyRef", "AnyVal", "App", "Application", "Array",
     "Boolean", "Byte", "Char", "Class", "ClassTag", "ClassManifest",
     "Console", "Double", "Enumeration", "Float", "Function", "Int",
     "List", "Long", "Manifest", "Map",
diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala b/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala
index 5b8e4c3d92..cb10de7dca 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ReplVals.scala
@@ -65,7 +65,7 @@ object ReplVals {
      *  I have this forwarder which widens the type and then cast the result back
      *  to the dependent type.
      */
-    def compilerTypeFromTag(t: BaseUniverse # AbsTypeTag[_]): Global#Type =
+    def compilerTypeFromTag(t: BaseUniverse # WeakTypeTag[_]): Global#Type =
       definitions.compilerTypeFromTag(t)
 
     class AppliedTypeFromTags(sym: Symbol) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index 49ace019b9..bbeb549289 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -738,7 +738,7 @@ trait ContextErrors {
         )
         val forgotten = (
           if (sym.isTerm) "splice when splicing this variable into a reifee"
-          else "c.AbsTypeTag annotation for this type parameter"
+          else "c.WeakTypeTag annotation for this type parameter"
         )
         macroExpansionError(expandee, template(sym.name.nameKind).format(sym.name + " " + sym.origin, forgotten))
       }
@@ -1234,7 +1234,7 @@ trait ContextErrors {
       message + suffix
     }
 
-    private def abbreviateCoreAliases(s: String): String = List("AbsTypeTag", "Expr").foldLeft(s)((res, x) => res.replace("c.universe." + x, "c." + x))
+    private def abbreviateCoreAliases(s: String): String = List("WeakTypeTag", "Expr").foldLeft(s)((res, x) => res.replace("c.universe." + x, "c." + x))
 
     private def showMeth(pss: List[List[Symbol]], restpe: Type, abbreviate: Boolean) = {
       var argsPart = (pss map (ps => ps map (_.defString) mkString ("(", ", ", ")"))).mkString
@@ -1313,7 +1313,7 @@ trait ContextErrors {
     // aXXX (e.g. aparams) => characteristics of the macro impl ("a" stands for "actual")
     // rXXX (e.g. rparams) => characteristics of a reference macro impl signature synthesized from the macro def ("r" stands for "reference")
 
-    def MacroImplNonTagImplicitParameters(params: List[Symbol]) = compatibilityError("macro implementations cannot have implicit parameters other than AbsTypeTag evidences")
+    def MacroImplNonTagImplicitParameters(params: List[Symbol]) = compatibilityError("macro implementations cannot have implicit parameters other than WeakTypeTag evidences")
 
     def MacroImplParamssMismatchError() = compatibilityError("number of parameter sections differ")
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 6a91922b4c..08978ef4b5 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1151,7 +1151,7 @@ trait Implicits {
     private def TagSymbols =  TagMaterializers.keySet
     private val TagMaterializers = Map[Symbol, Symbol](
       ClassTagClass   -> MacroInternal_materializeClassTag,
-      AbsTypeTagClass -> MacroInternal_materializeAbsTypeTag,
+      WeakTypeTagClass -> MacroInternal_materializeWeakTypeTag,
       TypeTagClass    -> MacroInternal_materializeTypeTag
     )
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 59935677a8..b9dd31ec77 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -26,7 +26,7 @@ import scala.reflect.macros.runtime.AbortMacroException
  *
  *  Then fooBar needs to point to a static method of the following form:
  *
- *    def fooBar[T: c.AbsTypeTag] // type tag annotation is optional
+ *    def fooBar[T: c.WeakTypeTag] // type tag annotation is optional
  *           (c: scala.reflect.macros.Context)
  *           (xs: c.Expr[List[T]])
  *           : c.Expr[T] = {
@@ -84,7 +84,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     val methName: String,
     // flattens the macro impl's parameter lists having symbols replaced with metadata
     // currently metadata is an index of the type parameter corresponding to that type tag (if applicable)
-    // f.ex. for: def impl[T: AbsTypeTag, U: AbsTypeTag, V](c: Context)(x: c.Expr[T]): (U, V) = ???
+    // f.ex. for: def impl[T: WeakTypeTag, U: WeakTypeTag, V](c: Context)(x: c.Expr[T]): (U, V) = ???
     // `signature` will be equal to List(-1, -1, 0, 1)
     val signature: List[Int],
     // type arguments part of a macro impl ref (the right-hand side of a macro definition)
@@ -216,7 +216,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
   }
 
   /** Transforms parameters lists of a macro impl.
-   *  The `transform` function is invoked only for AbsTypeTag evidence parameters.
+   *  The `transform` function is invoked only for WeakTypeTag evidence parameters.
    *
    *  The transformer takes two arguments: a value parameter from the parameter list
    *  and a type parameter that is witnesses by the value parameter.
@@ -232,7 +232,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     if (paramss.isEmpty || paramss.last.isEmpty) return paramss // no implicit parameters in the signature => nothing to do
     if (paramss.head.isEmpty || !(paramss.head.head.tpe <:< MacroContextClass.tpe)) return paramss // no context parameter in the signature => nothing to do
     def transformTag(param: Symbol): Symbol = param.tpe.dealias match {
-      case TypeRef(SingleType(SingleType(NoPrefix, c), universe), AbsTypeTagClass, targ :: Nil)
+      case TypeRef(SingleType(SingleType(NoPrefix, c), universe), WeakTypeTagClass, targ :: Nil)
       if c == paramss.head.head && universe == MacroContextUniverse =>
         transform(param, targ.typeSymbol)
       case _ =>
@@ -336,7 +336,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
             RepeatedParamClass.typeConstructor,
             List(implType(isType, sigma(origTpe.typeArgs.head))))
         else {
-          val tsym = getMember(MacroContextClass, if (isType) tpnme.AbsTypeTag else tpnme.Expr)
+          val tsym = getMember(MacroContextClass, if (isType) tpnme.WeakTypeTag else tpnme.Expr)
           typeRef(singleType(NoPrefix, ctxParam), tsym, List(sigma(origTpe)))
         }
       val paramCache = collection.mutable.Map[Symbol, Symbol]()
@@ -630,7 +630,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
                 macroDef.owner)
           } else
             targ.tpe
-          context.AbsTypeTag(tpe)
+          context.WeakTypeTag(tpe)
         })
         macroTraceVerbose("tags: ")(tags)
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Tags.scala b/src/compiler/scala/tools/nsc/typechecker/Tags.scala
index f82e009be8..167bf5c857 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Tags.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Tags.scala
@@ -26,7 +26,7 @@ trait Tags {
     /** Finds in scope or materializes a ClassTag.
      *  Should be used instead of ClassManifest every time compiler needs to persist an erasure.
      *
-     *  Once upon a time, we had an `ErasureTag` which was to `ClassTag` the same that `AbsTypeTag` is for `TypeTag`.
+     *  Once upon a time, we had an `ErasureTag` which was to `ClassTag` the same that `WeakTypeTag` is for `TypeTag`.
      *  However we found out that we don't really need this concept, so it got removed.
      *
      *  @param   pos                    Position for error reporting. Please, provide meaningful value.
@@ -43,7 +43,7 @@ trait Tags {
       resolveTag(pos, taggedTp, allowMaterialization)
     }
 
-    /** Finds in scope or materializes an AbsTypeTag (if `concrete` is false) or a TypeTag (if `concrete` is true).
+    /** Finds in scope or materializes an WeakTypeTag (if `concrete` is false) or a TypeTag (if `concrete` is true).
      *
      *  @param   pos                    Position for error reporting. Please, provide meaningful value.
      *  @param   pre                    Prefix that represents a universe this type tag will be bound to.
@@ -60,7 +60,7 @@ trait Tags {
      *           EmptyTree if `allowMaterialization` is false, and there is no array tag in scope.
      */
     def resolveTypeTag(pos: Position, pre: Type, tp: Type, concrete: Boolean, allowMaterialization: Boolean = true): Tree = {
-      val tagSym = if (concrete) TypeTagClass else AbsTypeTagClass
+      val tagSym = if (concrete) TypeTagClass else WeakTypeTagClass
       val tagTp =  if (pre == NoType) TypeRef(BaseUniverseClass.toTypeConstructor, tagSym, List(tp)) else singleType(pre, pre member tagSym.name)
       val taggedTp = appliedType(tagTp, List(tp))
       resolveTag(pos, taggedTp, allowMaterialization)
diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala
index 07c972899e..d6bed0c6d1 100644
--- a/src/compiler/scala/tools/reflect/FastTrack.scala
+++ b/src/compiler/scala/tools/reflect/FastTrack.scala
@@ -23,7 +23,7 @@ trait FastTrack {
     def validate(c: MacroContext): Boolean = expander.isDefinedAt((c, c.expandee))
     def run(c: MacroContext): Any = {
       val result = expander((c, c.expandee))
-      c.Expr[Nothing](result)(c.AbsTypeTag.Nothing)
+      c.Expr[Nothing](result)(c.WeakTypeTag.Nothing)
     }
   }
 
@@ -31,7 +31,7 @@ trait FastTrack {
     var registry = Map[Symbol, FastTrackEntry]()
     implicit class BindTo(sym: Symbol) { def bindTo(expander: FastTrackExpander): Unit = if (sym != NoSymbol) registry += sym -> FastTrackEntry(sym, expander) }
     MacroInternal_materializeClassTag bindTo { case (c, Apply(TypeApply(_, List(tt)), List(u))) => c.materializeClassTag(u, tt.tpe) }
-    MacroInternal_materializeAbsTypeTag bindTo { case (c, Apply(TypeApply(_, List(tt)), List(u))) => c.materializeTypeTag(u, EmptyTree, tt.tpe, concrete = false) }
+    MacroInternal_materializeWeakTypeTag bindTo { case (c, Apply(TypeApply(_, List(tt)), List(u))) => c.materializeTypeTag(u, EmptyTree, tt.tpe, concrete = false) }
     MacroInternal_materializeTypeTag bindTo { case (c, Apply(TypeApply(_, List(tt)), List(u))) => c.materializeTypeTag(u, EmptyTree, tt.tpe, concrete = true) }
     BaseUniverseReify bindTo { case (c, Apply(TypeApply(_, List(tt)), List(expr))) => c.materializeExpr(c.prefix.tree, EmptyTree, expr) }
     ReflectRuntimeCurrentMirror bindTo { case (c, _) => scala.reflect.runtime.Macros.currentMirror(c).tree }
diff --git a/src/library/scala/reflect/base/Exprs.scala b/src/library/scala/reflect/base/Exprs.scala
index 10c222722a..45598c03e2 100644
--- a/src/library/scala/reflect/base/Exprs.scala
+++ b/src/library/scala/reflect/base/Exprs.scala
@@ -28,19 +28,19 @@ trait Exprs { self: Universe =>
   }
 
   object Expr {
-    def apply[T: AbsTypeTag](mirror: MirrorOf[self.type], treec: TreeCreator): Expr[T] = new ExprImpl[T](mirror.asInstanceOf[Mirror], treec)
+    def apply[T: WeakTypeTag](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: AbsTypeTag](val mirror: Mirror, val treec: TreeCreator) extends Expr[T] {
+  private class ExprImpl[+T: WeakTypeTag](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[AbsTypeTag[T]] in otherMirror).asInstanceOf[otherMirror.universe.AbsTypeTag[T]]
+      val tag1 = (implicitly[WeakTypeTag[T]] in otherMirror).asInstanceOf[otherMirror.universe.WeakTypeTag[T]]
       otherMirror.universe.Expr[T](otherMirror1, treec)(tag1)
     }
 
     lazy val tree: Tree = treec(mirror)
-    lazy val staticType: Type = implicitly[AbsTypeTag[T]].tpe
+    lazy val staticType: Type = implicitly[WeakTypeTag[T]].tpe
     def actualType: Type = treeType(tree)
 
     def splice: T = throw new UnsupportedOperationException("""
@@ -54,11 +54,11 @@ trait Exprs { self: Universe =>
       |if you want to get a value of the underlying expression, add scala-compiler.jar to the classpath,
       |import `scala.tools.reflect.Eval` and call `<your expr>.eval` instead.""".trim.stripMargin)
 
-    private def writeReplace(): AnyRef = new SerializedExpr(treec, implicitly[AbsTypeTag[T]].in(scala.reflect.basis.rootMirror))
+    private def writeReplace(): AnyRef = new SerializedExpr(treec, implicitly[WeakTypeTag[T]].in(scala.reflect.basis.rootMirror))
   }
 }
 
-private[scala] class SerializedExpr(var treec: TreeCreator, var tag: scala.reflect.basis.AbsTypeTag[_]) extends Serializable {
+private[scala] class SerializedExpr(var treec: TreeCreator, var tag: scala.reflect.basis.WeakTypeTag[_]) extends Serializable {
   private def writeObject(out: java.io.ObjectOutputStream): Unit = {
     out.writeObject(treec)
     out.writeObject(tag)
@@ -66,7 +66,7 @@ private[scala] class SerializedExpr(var treec: TreeCreator, var tag: scala.refle
 
   private def readObject(in: java.io.ObjectInputStream): Unit = {
     treec = in.readObject().asInstanceOf[TreeCreator]
-    tag = in.readObject().asInstanceOf[scala.reflect.basis.AbsTypeTag[_]]
+    tag = in.readObject().asInstanceOf[scala.reflect.basis.WeakTypeTag[_]]
   }
 
   private def readResolve(): AnyRef = {
diff --git a/src/library/scala/reflect/base/TypeTags.scala b/src/library/scala/reflect/base/TypeTags.scala
index b7e0c37a4b..fd7a204ff4 100644
--- a/src/library/scala/reflect/base/TypeTags.scala
+++ b/src/library/scala/reflect/base/TypeTags.scala
@@ -17,15 +17,15 @@ import language.implicitConversions
  * === Overview ===
  *
  * Type tags are organized in a hierarchy of three classes:
- * [[scala.reflect.ClassTag]], [[scala.reflect.base.Universe#TypeTag]] and [[scala.reflect.base.Universe#AbsTypeTag]].
+ * [[scala.reflect.ClassTag]], [[scala.reflect.base.Universe#TypeTag]] and [[scala.reflect.base.Universe#WeakTypeTag]].
  *
  * A [[scala.reflect.ClassTag]] carries a runtime class that corresponds to the source type T.
  * As of such, it possesses the knowledge about how to build single- and multi-dimensional arrays of elements of that type.
  * It guarantees that the source type T did not to contain any references to type parameters or abstract types.
  * [[scala.reflect.ClassTag]] corresponds to a previous notion of [[scala.reflect.ClassManifest]].
  *
- * A [[scala.reflect.base.Universe#AbsTypeTag]] value wraps a full Scala type in its tpe field.
- * A [[scala.reflect.base.Universe#TypeTag]] value is an [[scala.reflect.base.Universe#AbsTypeTag]]
+ * A [[scala.reflect.base.Universe#WeakTypeTag]] value wraps a full Scala type in its tpe field.
+ * A [[scala.reflect.base.Universe#TypeTag]] value is an [[scala.reflect.base.Universe#WeakTypeTag]]
  * that is guaranteed not to contain any references to type parameters or abstract types.
  *
  * [Eugene++] also mention sensitivity to prefixes, i.e. that rb.TypeTag is different from ru.TypeTag
@@ -40,36 +40,36 @@ import language.implicitConversions
  *   import reflect.mirror._
  *     def f[T: TypeTag, U] = {
  *       type L = T => U
- *       implicitly[AbsTypeTag[L]]
+ *       implicitly[WeakTypeTag[L]]
  *     }
  *
  * Then a call of f[String, Int] will yield a result of the form
  *
- *   AbsTypeTag(<[ String => U ]>).
+ *   WeakTypeTag(<[ String => U ]>).
  *
  * Note that T has been replaced by String, because it comes with a TypeTag in f, whereas U was left as a type parameter.
  *
- * === AbsTypeTag vs TypeTag ===
+ * === WeakTypeTag vs TypeTag ===
  *
- * Be careful with AbsTypeTag, because it will reify types even if these types are abstract.
+ * Be careful with WeakTypeTag, because it will reify types even if these types are abstract.
  * This makes it easy to forget to tag one of the methods in the call chain and discover it much later in the runtime
  * by getting cryptic errors far away from their source. For example, consider the following snippet:
  *
- *   def bind[T: AbsTypeTag](name: String, value: T): IR.Result = bind((name, value))
- *   def bind(p: NamedParam): IR.Result                         = bind(p.name, p.tpe, p.value)
+ *   def bind[T: WeakTypeTag](name: String, value: T): IR.Result = bind((name, value))
+ *   def bind(p: NamedParam): IR.Result                          = bind(p.name, p.tpe, p.value)
  *   object NamedParam {
- *     implicit def namedValue[T: AbsTypeTag](name: String, x: T): NamedParam = apply(name, x)
- *     def apply[T: AbsTypeTag](name: String, x: T): NamedParam = new Typed[T](name, x)
+ *     implicit def namedValue[T: WeakTypeTag](name: String, x: T): NamedParam = apply(name, x)
+ *     def apply[T: WeakTypeTag](name: String, x: T): NamedParam = new Typed[T](name, x)
  *   }
  *
  * This fragment of Scala REPL implementation defines a `bind` function that carries a named value along with its type
- * into the heart of the REPL. Using a [[scala.reflect.base.Universe#AbsTypeTag]] here is reasonable, because it is desirable
+ * into the heart of the REPL. Using a [[scala.reflect.base.Universe#WeakTypeTag]] here is reasonable, because it is desirable
  * to work with all types, even if they are type parameters or abstract type members.
  *
- * However if any of the three `AbsTypeTag` context bounds is omitted, the resulting code will be incorrect,
- * because the missing `AbsTypeTag` will be transparently generated by the compiler, carrying meaningless information.
+ * However if any of the three `WeakTypeTag` context bounds is omitted, the resulting code will be incorrect,
+ * because the missing `WeakTypeTag` will be transparently generated by the compiler, carrying meaningless information.
  * Most likely, this problem will manifest itself elsewhere, making debugging complicated.
- * If `AbsTypeTag` context bounds were replaced with `TypeTag`, then such errors would be reported statically.
+ * If `WeakTypeTag` context bounds were replaced with `TypeTag`, then such errors would be reported statically.
  * But in that case we wouldn't be able to use `bind` in arbitrary contexts.
  *
  * === Backward compatibility ===
@@ -103,72 +103,77 @@ trait TypeTags { self: Universe =>
 
   import definitions._
 
+  // should be removed in the subsequent commit
+  // after the starr is redeployed
+  trait AbsTypeTag[T]
+  object AbsTypeTag
+
   /**
-   * If an implicit value of type u.AbsTypeTag[T] is required, the compiler will make one up on demand.
+   * If an implicit value of type u.WeakTypeTag[T] is required, the compiler will make one up on demand.
    * The implicitly created value contains in its tpe field a value of type u.Type that is a reflective representation of T.
    * In that value, any occurrences of type parameters or abstract types U
    * which come themselves with a TypeTag are represented by the type referenced by that TypeTag.
    *
    * @see [[scala.reflect.base.TypeTags]]
    */
-  @annotation.implicitNotFound(msg = "No AbsTypeTag available for ${T}")
-  trait AbsTypeTag[T] extends Equals with Serializable {
+  @annotation.implicitNotFound(msg = "No WeakTypeTag available for ${T}")
+  trait WeakTypeTag[T] extends Equals with Serializable {
     val mirror: Mirror
-    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # AbsTypeTag[T]
+    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # WeakTypeTag[T]
     def tpe: Type
 
     /** case class accessories */
-    override def canEqual(x: Any) = x.isInstanceOf[AbsTypeTag[_]]
-    override def equals(x: Any) = x.isInstanceOf[AbsTypeTag[_]] && this.mirror == x.asInstanceOf[AbsTypeTag[_]].mirror && this.tpe == x.asInstanceOf[AbsTypeTag[_]].tpe
+    override def canEqual(x: Any) = x.isInstanceOf[WeakTypeTag[_]]
+    override def equals(x: Any) = x.isInstanceOf[WeakTypeTag[_]] && this.mirror == x.asInstanceOf[WeakTypeTag[_]].mirror && this.tpe == x.asInstanceOf[WeakTypeTag[_]].tpe
     override def hashCode = mirror.hashCode * 31 + tpe.hashCode
-    override def toString = "AbsTypeTag[" + tpe + "]"
+    override def toString = "WeakTypeTag[" + tpe + "]"
   }
 
-  object AbsTypeTag {
-    val Byte    : AbsTypeTag[scala.Byte]       = TypeTag.Byte
-    val Short   : AbsTypeTag[scala.Short]      = TypeTag.Short
-    val Char    : AbsTypeTag[scala.Char]       = TypeTag.Char
-    val Int     : AbsTypeTag[scala.Int]        = TypeTag.Int
-    val Long    : AbsTypeTag[scala.Long]       = TypeTag.Long
-    val Float   : AbsTypeTag[scala.Float]      = TypeTag.Float
-    val Double  : AbsTypeTag[scala.Double]     = TypeTag.Double
-    val Boolean : AbsTypeTag[scala.Boolean]    = TypeTag.Boolean
-    val Unit    : AbsTypeTag[scala.Unit]       = TypeTag.Unit
-    val Any     : AbsTypeTag[scala.Any]        = TypeTag.Any
-    val AnyVal  : AbsTypeTag[scala.AnyVal]     = TypeTag.AnyVal
-    val AnyRef  : AbsTypeTag[scala.AnyRef]     = TypeTag.AnyRef
-    val Object  : AbsTypeTag[java.lang.Object] = TypeTag.Object
-    val Nothing : AbsTypeTag[scala.Nothing]    = TypeTag.Nothing
-    val Null    : AbsTypeTag[scala.Null]       = TypeTag.Null
+  object WeakTypeTag {
+    val Byte    : WeakTypeTag[scala.Byte]       = TypeTag.Byte
+    val Short   : WeakTypeTag[scala.Short]      = TypeTag.Short
+    val Char    : WeakTypeTag[scala.Char]       = TypeTag.Char
+    val Int     : WeakTypeTag[scala.Int]        = TypeTag.Int
+    val Long    : WeakTypeTag[scala.Long]       = TypeTag.Long
+    val Float   : WeakTypeTag[scala.Float]      = TypeTag.Float
+    val Double  : WeakTypeTag[scala.Double]     = TypeTag.Double
+    val Boolean : WeakTypeTag[scala.Boolean]    = TypeTag.Boolean
+    val Unit    : WeakTypeTag[scala.Unit]       = TypeTag.Unit
+    val Any     : WeakTypeTag[scala.Any]        = TypeTag.Any
+    val AnyVal  : WeakTypeTag[scala.AnyVal]     = TypeTag.AnyVal
+    val AnyRef  : WeakTypeTag[scala.AnyRef]     = TypeTag.AnyRef
+    val Object  : WeakTypeTag[java.lang.Object] = TypeTag.Object
+    val Nothing : WeakTypeTag[scala.Nothing]    = TypeTag.Nothing
+    val Null    : WeakTypeTag[scala.Null]       = TypeTag.Null
 
-    def apply[T](mirror1: MirrorOf[self.type], tpec1: TypeCreator): AbsTypeTag[T] =
+    def apply[T](mirror1: MirrorOf[self.type], tpec1: TypeCreator): WeakTypeTag[T] =
       tpec1(mirror1) match {
-        case ByteTpe    => AbsTypeTag.Byte.asInstanceOf[AbsTypeTag[T]]
-        case ShortTpe   => AbsTypeTag.Short.asInstanceOf[AbsTypeTag[T]]
-        case CharTpe    => AbsTypeTag.Char.asInstanceOf[AbsTypeTag[T]]
-        case IntTpe     => AbsTypeTag.Int.asInstanceOf[AbsTypeTag[T]]
-        case LongTpe    => AbsTypeTag.Long.asInstanceOf[AbsTypeTag[T]]
-        case FloatTpe   => AbsTypeTag.Float.asInstanceOf[AbsTypeTag[T]]
-        case DoubleTpe  => AbsTypeTag.Double.asInstanceOf[AbsTypeTag[T]]
-        case BooleanTpe => AbsTypeTag.Boolean.asInstanceOf[AbsTypeTag[T]]
-        case UnitTpe    => AbsTypeTag.Unit.asInstanceOf[AbsTypeTag[T]]
-        case AnyTpe     => AbsTypeTag.Any.asInstanceOf[AbsTypeTag[T]]
-        case AnyValTpe  => AbsTypeTag.AnyVal.asInstanceOf[AbsTypeTag[T]]
-        case AnyRefTpe  => AbsTypeTag.AnyRef.asInstanceOf[AbsTypeTag[T]]
-        case ObjectTpe  => AbsTypeTag.Object.asInstanceOf[AbsTypeTag[T]]
-        case NothingTpe => AbsTypeTag.Nothing.asInstanceOf[AbsTypeTag[T]]
-        case NullTpe    => AbsTypeTag.Null.asInstanceOf[AbsTypeTag[T]]
-        case _          => new AbsTypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
+        case ByteTpe    => WeakTypeTag.Byte.asInstanceOf[WeakTypeTag[T]]
+        case ShortTpe   => WeakTypeTag.Short.asInstanceOf[WeakTypeTag[T]]
+        case CharTpe    => WeakTypeTag.Char.asInstanceOf[WeakTypeTag[T]]
+        case IntTpe     => WeakTypeTag.Int.asInstanceOf[WeakTypeTag[T]]
+        case LongTpe    => WeakTypeTag.Long.asInstanceOf[WeakTypeTag[T]]
+        case FloatTpe   => WeakTypeTag.Float.asInstanceOf[WeakTypeTag[T]]
+        case DoubleTpe  => WeakTypeTag.Double.asInstanceOf[WeakTypeTag[T]]
+        case BooleanTpe => WeakTypeTag.Boolean.asInstanceOf[WeakTypeTag[T]]
+        case UnitTpe    => WeakTypeTag.Unit.asInstanceOf[WeakTypeTag[T]]
+        case AnyTpe     => WeakTypeTag.Any.asInstanceOf[WeakTypeTag[T]]
+        case AnyValTpe  => WeakTypeTag.AnyVal.asInstanceOf[WeakTypeTag[T]]
+        case AnyRefTpe  => WeakTypeTag.AnyRef.asInstanceOf[WeakTypeTag[T]]
+        case ObjectTpe  => WeakTypeTag.Object.asInstanceOf[WeakTypeTag[T]]
+        case NothingTpe => WeakTypeTag.Nothing.asInstanceOf[WeakTypeTag[T]]
+        case NullTpe    => WeakTypeTag.Null.asInstanceOf[WeakTypeTag[T]]
+        case _          => new WeakTypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
       }
 
-    def unapply[T](ttag: AbsTypeTag[T]): Option[Type] = Some(ttag.tpe)
+    def unapply[T](ttag: WeakTypeTag[T]): Option[Type] = Some(ttag.tpe)
   }
 
-  private class AbsTypeTagImpl[T](val mirror: Mirror, val tpec: TypeCreator) extends AbsTypeTag[T] {
+  private class WeakTypeTagImpl[T](val mirror: Mirror, val tpec: TypeCreator) extends WeakTypeTag[T] {
     lazy val tpe: Type = tpec(mirror)
-    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # AbsTypeTag[T] = {
+    def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # WeakTypeTag[T] = {
       val otherMirror1 = otherMirror.asInstanceOf[MirrorOf[otherMirror.universe.type]]
-      otherMirror.universe.AbsTypeTag[T](otherMirror1, tpec)
+      otherMirror.universe.WeakTypeTag[T](otherMirror1, tpec)
     }
     private def writeReplace(): AnyRef = new SerializedTypeTag(tpec, concrete = false)
   }
@@ -180,7 +185,7 @@ trait TypeTags { self: Universe =>
    * @see [[scala.reflect.base.TypeTags]]
    */
   @annotation.implicitNotFound(msg = "No TypeTag available for ${T}")
-  trait TypeTag[T] extends AbsTypeTag[T] with Equals with Serializable {
+  trait TypeTag[T] extends WeakTypeTag[T] with Equals with Serializable {
     override def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # TypeTag[T]
 
     /** case class accessories */
@@ -230,7 +235,7 @@ trait TypeTags { self: Universe =>
     def unapply[T](ttag: TypeTag[T]): Option[Type] = Some(ttag.tpe)
   }
 
-  private class TypeTagImpl[T](mirror: Mirror, tpec: TypeCreator) extends AbsTypeTagImpl[T](mirror, tpec) with TypeTag[T] {
+  private class TypeTagImpl[T](mirror: Mirror, tpec: TypeCreator) extends WeakTypeTagImpl[T](mirror, tpec) with TypeTag[T] {
     override def in[U <: Universe with Singleton](otherMirror: MirrorOf[U]): U # TypeTag[T] = {
       val otherMirror1 = otherMirror.asInstanceOf[MirrorOf[otherMirror.universe.type]]
       otherMirror.universe.TypeTag[T](otherMirror1, tpec)
@@ -250,11 +255,11 @@ trait TypeTags { self: Universe =>
   }
 
   // incantations
-  def absTypeTag[T](implicit attag: AbsTypeTag[T]) = attag
+  def weakTypeTag[T](implicit attag: WeakTypeTag[T]) = attag
   def typeTag[T](implicit ttag: TypeTag[T]) = ttag
 
   // big thanks to Viktor Klang for this brilliant idea!
-  def absTypeOf[T](implicit attag: AbsTypeTag[T]): Type = attag.tpe
+  def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type = attag.tpe
   def typeOf[T](implicit ttag: TypeTag[T]): Type = ttag.tpe
 }
 
@@ -272,6 +277,6 @@ private[scala] class SerializedTypeTag(var tpec: TypeCreator, var concrete: Bool
   private def readResolve(): AnyRef = {
     import scala.reflect.basis._
     if (concrete) TypeTag(rootMirror, tpec)
-    else AbsTypeTag(rootMirror, tpec)
+    else WeakTypeTag(rootMirror, tpec)
   }
 }
\ No newline at end of file
diff --git a/src/library/scala/reflect/base/Universe.scala b/src/library/scala/reflect/base/Universe.scala
index f098876c18..18599ad092 100644
--- a/src/library/scala/reflect/base/Universe.scala
+++ b/src/library/scala/reflect/base/Universe.scala
@@ -46,7 +46,7 @@ abstract class Universe extends Symbols
    *    def macroImpl[T](c: Context) = {
    *      ...
    *      // T here is just a type parameter, so the tree produced by reify won't be of much use in a macro expansion
-   *      // however, if T were annotated with c.AbsTypeTag (which would declare an implicit parameter for macroImpl)
+   *      // however, if T were annotated with c.WeakTypeTag (which would declare an implicit parameter for macroImpl)
    *      // then reification would substitute T with the TypeTree that was used in a TypeApply of this particular macro invocation
    *      val factory = c.reify{ new Queryable[T] }
    *      ...
diff --git a/src/library/scala/reflect/macros/internal/package.scala b/src/library/scala/reflect/macros/internal/package.scala
index 0a0e6c5b51..bbb57667ea 100644
--- a/src/library/scala/reflect/macros/internal/package.scala
+++ b/src/library/scala/reflect/macros/internal/package.scala
@@ -7,7 +7,11 @@ import scala.reflect.ClassTag
 // implementation is magically hardwired into `scala.reflect.reify.Taggers`
 // todo. once we have implicit macros for tag generation, we can remove these anchors
 package object internal {
+  // should be removed in the subsequent commit
+  // after the starr is redeployed
+  private[scala] def materializeAbsTypeTag[T](u: BaseUniverse): u.WeakTypeTag[T] = ??? // macro
+
   private[scala] def materializeClassTag[T](u: BaseUniverse): ClassTag[T] = ??? // macro
-  private[scala] def materializeAbsTypeTag[T](u: BaseUniverse): u.AbsTypeTag[T] = ??? // macro
+  private[scala] def materializeWeakTypeTag[T](u: BaseUniverse): u.WeakTypeTag[T] = ??? // macro
   private[scala] def materializeTypeTag[T](u: BaseUniverse): u.TypeTag[T] = ??? // macro
 }
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 15b74058b7..6d9f68a8a5 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -505,8 +505,8 @@ 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 WeakTypeTagClass       = getMemberClass(TypeTagsClass, tpnme.WeakTypeTag)
+    lazy val WeakTypeTagModule      = getMemberModule(TypeTagsClass, nme.WeakTypeTag)
     lazy val TypeTagClass          = getMemberClass(TypeTagsClass, tpnme.TypeTag)
     lazy val TypeTagModule         = getMemberModule(TypeTagsClass, nme.TypeTag)
 
@@ -527,7 +527,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val MacroImplAnnotation                 = requiredClass[scala.reflect.macros.internal.macroImpl]
     lazy val MacroInternalPackage                = getPackageObject("scala.reflect.macros.internal")
          def MacroInternal_materializeClassTag   = getMemberMethod(MacroInternalPackage, nme.materializeClassTag)
-         def MacroInternal_materializeAbsTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeAbsTypeTag)
+         def MacroInternal_materializeWeakTypeTag = getMemberMethod(MacroInternalPackage, nme.materializeWeakTypeTag)
          def MacroInternal_materializeTypeTag    = getMemberMethod(MacroInternalPackage, nme.materializeTypeTag)
 
     lazy val StringContextClass                  = requiredClass[scala.StringContext]
@@ -542,8 +542,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 # AbsTypeTag[_]): Type = tt.in(rootMirror).tpe
-    def compilerSymbolFromTag(tt: BaseUniverse # AbsTypeTag[_]): Symbol = tt.in(rootMirror).tpe.typeSymbol
+    def compilerTypeFromTag(tt: BaseUniverse # WeakTypeTag[_]): Type = tt.in(rootMirror).tpe
+    def compilerSymbolFromTag(tt: BaseUniverse # WeakTypeTag[_]): 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 e9c21d1187..92adc85e25 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -131,7 +131,7 @@ trait StdNames {
     final val Seq: NameType        = "Seq"
     final val Symbol: NameType     = "Symbol"
     final val ClassTag: NameType   = "ClassTag"
-    final val AbsTypeTag: NameType = "AbsTypeTag"
+    final val WeakTypeTag: NameType = "WeakTypeTag"
     final val TypeTag : NameType   = "TypeTag"
     final val Expr: NameType       = "Expr"
     final val String: NameType     = "String"
@@ -704,7 +704,7 @@ trait StdNames {
     val manifestToTypeTag: NameType    = "manifestToTypeTag"
     val map: NameType                  = "map"
     val materializeClassTag: NameType  = "materializeClassTag"
-    val materializeAbsTypeTag: NameType = "materializeAbsTypeTag"
+    val materializeWeakTypeTag: NameType = "materializeWeakTypeTag"
     val materializeTypeTag: NameType   = "materializeTypeTag"
     val mirror : NameType              = "mirror"
     val moduleClass : NameType         = "moduleClass"
diff --git a/src/reflect/scala/reflect/macros/Aliases.scala b/src/reflect/scala/reflect/macros/Aliases.scala
index ad100d7e89..eff7f34b02 100644
--- a/src/reflect/scala/reflect/macros/Aliases.scala
+++ b/src/reflect/scala/reflect/macros/Aliases.scala
@@ -17,12 +17,12 @@ trait Aliases {
   type Expr[+T] = universe.Expr[T]
   val Expr = universe.Expr
 
-  type AbsTypeTag[T] = universe.AbsTypeTag[T]
+  type WeakTypeTag[T] = universe.WeakTypeTag[T]
   type TypeTag[T] = universe.TypeTag[T]
-  val AbsTypeTag = universe.AbsTypeTag
+  val WeakTypeTag = universe.WeakTypeTag
   val TypeTag = universe.TypeTag
-  def absTypeTag[T](implicit attag: AbsTypeTag[T]) = attag
+  def weakTypeTag[T](implicit attag: WeakTypeTag[T]) = attag
   def typeTag[T](implicit ttag: TypeTag[T]) = ttag
-  def absTypeOf[T](implicit attag: AbsTypeTag[T]): Type = attag.tpe
+  def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type = attag.tpe
   def typeOf[T](implicit ttag: TypeTag[T]): Type = ttag.tpe
 }
diff --git a/src/reflect/scala/reflect/macros/Exprs.scala b/src/reflect/scala/reflect/macros/Exprs.scala
index ceaab06d12..280d5508c8 100644
--- a/src/reflect/scala/reflect/macros/Exprs.scala
+++ b/src/reflect/scala/reflect/macros/Exprs.scala
@@ -4,5 +4,5 @@ package macros
 trait Exprs {
   self: Context =>
 
-  def Expr[T: AbsTypeTag](tree: Tree): Expr[T]
+  def Expr[T: WeakTypeTag](tree: Tree): Expr[T]
 }
diff --git a/src/reflect/scala/reflect/macros/TypeTags.scala b/src/reflect/scala/reflect/macros/TypeTags.scala
index 8f590d1de4..2f15e37f6a 100644
--- a/src/reflect/scala/reflect/macros/TypeTags.scala
+++ b/src/reflect/scala/reflect/macros/TypeTags.scala
@@ -4,6 +4,6 @@ package macros
 trait TypeTags {
   self: Context =>
 
-  def AbsTypeTag[T](tpe: Type): AbsTypeTag[T]
+  def WeakTypeTag[T](tpe: Type): WeakTypeTag[T]
   def TypeTag[T](tpe: Type): TypeTag[T]
 }
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index 455cc14789..6abd40abc6 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -133,7 +133,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { self: Sym
     """.trim.stripMargin)
     private def ErrorSetImmutableField(wannabe: Symbol) = throw new ScalaReflectionException(s"cannot set an immutable field ${wannabe.name}")
     private def ErrorNotConstructor(wannabe: Symbol, owner: Symbol) = throw new ScalaReflectionException(s"expected a constructor of $owner, you provided $wannabe")
-    private def ErrorFree(member: Symbol, freeType: Symbol) = throw new ScalaReflectionException(s"cannot reflect ${member.kindString} ${member.name}, because it's a member of a free type ${freeType.name}")
+    private def ErrorFree(member: Symbol, freeType: Symbol) = throw new ScalaReflectionException(s"cannot reflect ${member.kindString} ${member.name}, because it's a member of a weak type ${freeType.name}")
 
     def reflect[T: ClassTag](obj: T): InstanceMirror = new JavaInstanceMirror(obj)
 
diff --git a/src/reflect/scala/reflect/runtime/package.scala b/src/reflect/scala/reflect/runtime/package.scala
index ccdea3e82d..d325cf6a16 100644
--- a/src/reflect/scala/reflect/runtime/package.scala
+++ b/src/reflect/scala/reflect/runtime/package.scala
@@ -17,7 +17,7 @@ package runtime {
       if (runtimeClass.isEmpty) c.abort(c.enclosingPosition, "call site does not have an enclosing class")
       val runtimeUniverse = Select(Select(Select(Ident(newTermName("scala")), newTermName("reflect")), newTermName("runtime")), newTermName("universe"))
       val currentMirror = Apply(Select(runtimeUniverse, newTermName("runtimeMirror")), List(Select(runtimeClass, newTermName("getClassLoader"))))
-      c.Expr[Nothing](currentMirror)(c.AbsTypeTag.Nothing)
+      c.Expr[Nothing](currentMirror)(c.WeakTypeTag.Nothing)
     }
   }
 }
diff --git a/test/files/neg/interop_abstypetags_arenot_classmanifests.scala b/test/files/neg/interop_abstypetags_arenot_classmanifests.scala
index c8567be5d4..5d88c90ffd 100644
--- a/test/files/neg/interop_abstypetags_arenot_classmanifests.scala
+++ b/test/files/neg/interop_abstypetags_arenot_classmanifests.scala
@@ -1,11 +1,11 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  def absTypeTagIsnotClassManifest[T: AbsTypeTag] = {
+  def weakTypeTagIsnotClassManifest[T: WeakTypeTag] = {
     println(classManifest[T])
   }
 
-  absTypeTagIsnotClassManifest[Int]
-  absTypeTagIsnotClassManifest[String]
-  absTypeTagIsnotClassManifest[Array[Int]]
+  weakTypeTagIsnotClassManifest[Int]
+  weakTypeTagIsnotClassManifest[String]
+  weakTypeTagIsnotClassManifest[Array[Int]]
 }
\ No newline at end of file
diff --git a/test/files/neg/interop_abstypetags_arenot_classtags.scala b/test/files/neg/interop_abstypetags_arenot_classtags.scala
index e3911c1588..de1f8657b6 100644
--- a/test/files/neg/interop_abstypetags_arenot_classtags.scala
+++ b/test/files/neg/interop_abstypetags_arenot_classtags.scala
@@ -2,11 +2,11 @@ import scala.reflect.runtime.universe._
 import scala.reflect.{ClassTag, classTag}
 
 object Test extends App {
-  def absTypeTagIsnotClassTag[T: AbsTypeTag] = {
+  def weakTypeTagIsnotClassTag[T: WeakTypeTag] = {
     println(classTag[T])
   }
 
-  absTypeTagIsnotClassTag[Int]
-  absTypeTagIsnotClassTag[String]
-  absTypeTagIsnotClassTag[Array[Int]]
+  weakTypeTagIsnotClassTag[Int]
+  weakTypeTagIsnotClassTag[String]
+  weakTypeTagIsnotClassTag[Array[Int]]
 }
\ No newline at end of file
diff --git a/test/files/neg/interop_abstypetags_arenot_manifests.scala b/test/files/neg/interop_abstypetags_arenot_manifests.scala
index 77a95048fd..1ca3673ce4 100644
--- a/test/files/neg/interop_abstypetags_arenot_manifests.scala
+++ b/test/files/neg/interop_abstypetags_arenot_manifests.scala
@@ -1,11 +1,11 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  def absTypeTagIsnotManifest[T: AbsTypeTag] = {
+  def weakTypeTagIsnotManifest[T: WeakTypeTag] = {
     println(manifest[T])
   }
 
-  absTypeTagIsnotManifest[Int]
-  absTypeTagIsnotManifest[String]
-  absTypeTagIsnotManifest[Array[Int]]
+  weakTypeTagIsnotManifest[Int]
+  weakTypeTagIsnotManifest[String]
+  weakTypeTagIsnotManifest[Array[Int]]
 }
\ No newline at end of file
diff --git a/test/files/neg/macro-invalidsig-context-bounds.check b/test/files/neg/macro-invalidsig-context-bounds.check
index 5d42ebc515..eb5d833bc0 100644
--- a/test/files/neg/macro-invalidsig-context-bounds.check
+++ b/test/files/neg/macro-invalidsig-context-bounds.check
@@ -1,7 +1,7 @@
 Macros_Test_1.scala:2: error: macro implementation has wrong shape:

  required: (c: scala.reflect.macros.Context): c.Expr[Any]

  found   : (c: scala.reflect.macros.Context)(implicit evidence$2: Numeric[U]): c.universe.Literal

-macro implementations cannot have implicit parameters other than AbsTypeTag evidences

+macro implementations cannot have implicit parameters other than WeakTypeTag evidences

   def foo[U] = macro Impls.foo[U]

                            ^

 one error found

diff --git a/test/files/neg/macro-invalidsig-context-bounds/Impls_1.scala b/test/files/neg/macro-invalidsig-context-bounds/Impls_1.scala
index 5aa9a7eaf9..c066c485b1 100644
--- a/test/files/neg/macro-invalidsig-context-bounds/Impls_1.scala
+++ b/test/files/neg/macro-invalidsig-context-bounds/Impls_1.scala
@@ -2,7 +2,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U: c.AbsTypeTag: Numeric](c: Ctx) = {
+  def foo[U: c.WeakTypeTag: Numeric](c: Ctx) = {
     import c.universe._
     Literal(Constant(42))
   }
diff --git a/test/files/neg/macro-invalidsig-implicit-params.check b/test/files/neg/macro-invalidsig-implicit-params.check
index 62156770e4..ca35e62cd7 100644
--- a/test/files/neg/macro-invalidsig-implicit-params.check
+++ b/test/files/neg/macro-invalidsig-implicit-params.check
@@ -1,7 +1,7 @@
 Impls_Macros_1.scala:18: error: macro implementation has wrong shape:

  required: (c: scala.reflect.macros.Context)(x: c.Expr[Int]): c.Expr[Unit]

  found   : (c: scala.reflect.macros.Context)(implicit x: c.Expr[Int]): c.Expr[Unit]

-macro implementations cannot have implicit parameters other than AbsTypeTag evidences

+macro implementations cannot have implicit parameters other than WeakTypeTag evidences

   def foo_targs[U](x: Int) = macro Impls.foo_targs[T, U]

                                          ^

 one error found

diff --git a/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala b/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala
index f724538993..845a168ff2 100644
--- a/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala
+++ b/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala
@@ -2,13 +2,13 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo_targs[T, U: c.AbsTypeTag](c: Ctx)(implicit x: c.Expr[Int]) = {
+  def foo_targs[T, U: c.WeakTypeTag](c: Ctx)(implicit x: c.Expr[Int]) = {
     import c.{prefix => prefix}
     import c.universe._
     val body = Block(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("invoking foo_targs...")))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("type of prefix is: " + prefix.staticType)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("U is: " + implicitly[c.AbsTypeTag[U]].tpe)))),
+      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("U is: " + implicitly[c.WeakTypeTag[U]].tpe)))),
       Literal(Constant(())))
     c.Expr[Unit](body)
   }
diff --git a/test/files/neg/macro-invalidsig-tparams-notparams-a.check b/test/files/neg/macro-invalidsig-tparams-notparams-a.check
index 5aee62b9e5..5404c185f3 100644
--- a/test/files/neg/macro-invalidsig-tparams-notparams-a.check
+++ b/test/files/neg/macro-invalidsig-tparams-notparams-a.check
@@ -1,4 +1,4 @@
-Macros_Test_2.scala:2: error: wrong number of type parameters for method foo: [U](c: scala.reflect.macros.Context)(implicit evidence$1: c.AbsTypeTag[U])Nothing

+Macros_Test_2.scala:2: error: wrong number of type parameters for method foo: [U](c: scala.reflect.macros.Context)(implicit evidence$1: c.WeakTypeTag[U])Nothing

   def foo = macro Impls.foo

                         ^

 one error found

diff --git a/test/files/neg/macro-invalidsig-tparams-notparams-a/Impls_1.scala b/test/files/neg/macro-invalidsig-tparams-notparams-a/Impls_1.scala
index afbe0f0915..f8b3c92869 100644
--- a/test/files/neg/macro-invalidsig-tparams-notparams-a/Impls_1.scala
+++ b/test/files/neg/macro-invalidsig-tparams-notparams-a/Impls_1.scala
@@ -2,5 +2,5 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U: c.AbsTypeTag](c: Ctx) = ???
+  def foo[U: c.WeakTypeTag](c: Ctx) = ???
 }
\ No newline at end of file
diff --git a/test/files/neg/macro-invalidsig-tparams-notparams-b.check b/test/files/neg/macro-invalidsig-tparams-notparams-b.check
index e8de8a4c6b..485d4de96e 100644
--- a/test/files/neg/macro-invalidsig-tparams-notparams-b.check
+++ b/test/files/neg/macro-invalidsig-tparams-notparams-b.check
@@ -1,4 +1,4 @@
-Macros_Test_2.scala:3: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.Context)(implicit evidence$1: c.AbsTypeTag[T], implicit evidence$2: c.AbsTypeTag[U], implicit V: c.AbsTypeTag[V])c.Expr[Unit]

+Macros_Test_2.scala:3: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.Context)(implicit evidence$1: c.WeakTypeTag[T], implicit evidence$2: c.WeakTypeTag[U], implicit V: c.WeakTypeTag[V])c.Expr[Unit]

     def foo[V] = macro Impls.foo

                              ^

 one error found

diff --git a/test/files/neg/macro-invalidsig-tparams-notparams-b/Impls_1.scala b/test/files/neg/macro-invalidsig-tparams-notparams-b/Impls_1.scala
index b48f9d5f98..baf3aab9e3 100644
--- a/test/files/neg/macro-invalidsig-tparams-notparams-b/Impls_1.scala
+++ b/test/files/neg/macro-invalidsig-tparams-notparams-b/Impls_1.scala
@@ -2,9 +2,9 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T: c.AbsTypeTag, U: c.AbsTypeTag, V](c: Ctx)(implicit V: c.AbsTypeTag[V]): c.Expr[Unit] = {
-    println(implicitly[c.AbsTypeTag[T]])
-    println(implicitly[c.AbsTypeTag[U]])
+  def foo[T: c.WeakTypeTag, U: c.WeakTypeTag, V](c: Ctx)(implicit V: c.WeakTypeTag[V]): c.Expr[Unit] = {
+    println(implicitly[c.WeakTypeTag[T]])
+    println(implicitly[c.WeakTypeTag[U]])
     println(V)
     c.literalUnit
   }
diff --git a/test/files/neg/macro-invalidsig-tparams-notparams-c.check b/test/files/neg/macro-invalidsig-tparams-notparams-c.check
index b1078fb233..1530c35097 100644
--- a/test/files/neg/macro-invalidsig-tparams-notparams-c.check
+++ b/test/files/neg/macro-invalidsig-tparams-notparams-c.check
@@ -1,4 +1,4 @@
-Macros_Test_2.scala:3: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.Context)(implicit evidence$1: c.AbsTypeTag[T], implicit evidence$2: c.AbsTypeTag[U], implicit V: c.AbsTypeTag[V])c.Expr[Unit]

+Macros_Test_2.scala:3: error: wrong number of type parameters for method foo: [T, U, V](c: scala.reflect.macros.Context)(implicit evidence$1: c.WeakTypeTag[T], implicit evidence$2: c.WeakTypeTag[U], implicit V: c.WeakTypeTag[V])c.Expr[Unit]

     def foo[V] = macro Impls.foo[V]

                                 ^

 one error found

diff --git a/test/files/neg/macro-invalidsig-tparams-notparams-c/Impls_1.scala b/test/files/neg/macro-invalidsig-tparams-notparams-c/Impls_1.scala
index 3506bdc789..44b4ed6ab3 100644
--- a/test/files/neg/macro-invalidsig-tparams-notparams-c/Impls_1.scala
+++ b/test/files/neg/macro-invalidsig-tparams-notparams-c/Impls_1.scala
@@ -2,10 +2,10 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T: c.AbsTypeTag, U: c.AbsTypeTag, V](c: Ctx)(implicit V: c.AbsTypeTag[V]): c.Expr[Unit] = {
+  def foo[T: c.WeakTypeTag, U: c.WeakTypeTag, V](c: Ctx)(implicit V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
-    println(implicitly[c.AbsTypeTag[T]])
-    println(implicitly[c.AbsTypeTag[U]])
+    println(implicitly[c.WeakTypeTag[T]])
+    println(implicitly[c.WeakTypeTag[U]])
     println(V)
     c.literalUnit
   }
diff --git a/test/files/neg/macro-reify-typetag-useabstypetag/Test.scala b/test/files/neg/macro-reify-typetag-useabstypetag/Test.scala
index b66ad6c523..1e7fcb3f45 100644
--- a/test/files/neg/macro-reify-typetag-useabstypetag/Test.scala
+++ b/test/files/neg/macro-reify-typetag-useabstypetag/Test.scala
@@ -1,7 +1,7 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  def fooTypeTag[T: AbsTypeTag] = {
+  def fooTypeTag[T: WeakTypeTag] = {
     println(implicitly[TypeTag[T]])
     println(implicitly[TypeTag[List[T]]])
   }
diff --git a/test/files/pos/t6047.scala b/test/files/pos/t6047.scala
index 80d5e9668b..bc5f856bd2 100644
--- a/test/files/pos/t6047.scala
+++ b/test/files/pos/t6047.scala
@@ -4,17 +4,17 @@ import java.io.InputStream
 object Macros {
    def unpack[A](input: InputStream): A = macro unpack_impl[A]
 
-   def unpack_impl[A: c.AbsTypeTag](c: Context)(input: c.Expr[InputStream]): c.Expr[A] = {
+   def unpack_impl[A: c.WeakTypeTag](c: Context)(input: c.Expr[InputStream]): c.Expr[A] = {
      import c.universe._
 
      def unpackcode(tpe: c.Type): c.Expr[_] = {
-       if (tpe <:< implicitly[c.AbsTypeTag[Traversable[_]]].tpe) {
+       if (tpe <:< implicitly[c.WeakTypeTag[Traversable[_]]].tpe) {
 
        }
        ???
      }
 
-     unpackcode(implicitly[c.AbsTypeTag[A]].tpe)
+     unpackcode(implicitly[c.WeakTypeTag[A]].tpe)
      ???
    }
  }
\ No newline at end of file
diff --git a/test/files/run/abstypetags_core.scala b/test/files/run/abstypetags_core.scala
index 226de94055..2692fec035 100644
--- a/test/files/run/abstypetags_core.scala
+++ b/test/files/run/abstypetags_core.scala
@@ -1,34 +1,34 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  println(implicitly[AbsTypeTag[Byte]] eq AbsTypeTag.Byte)
-  println(implicitly[AbsTypeTag[Byte]])
-  println(implicitly[AbsTypeTag[Short]] eq AbsTypeTag.Short)
-  println(implicitly[AbsTypeTag[Short]])
-  println(implicitly[AbsTypeTag[Char]] eq AbsTypeTag.Char)
-  println(implicitly[AbsTypeTag[Char]])
-  println(implicitly[AbsTypeTag[Int]] eq AbsTypeTag.Int)
-  println(implicitly[AbsTypeTag[Int]])
-  println(implicitly[AbsTypeTag[Long]] eq AbsTypeTag.Long)
-  println(implicitly[AbsTypeTag[Long]])
-  println(implicitly[AbsTypeTag[Float]] eq AbsTypeTag.Float)
-  println(implicitly[AbsTypeTag[Float]])
-  println(implicitly[AbsTypeTag[Double]] eq AbsTypeTag.Double)
-  println(implicitly[AbsTypeTag[Double]])
-  println(implicitly[AbsTypeTag[Boolean]] eq AbsTypeTag.Boolean)
-  println(implicitly[AbsTypeTag[Boolean]])
-  println(implicitly[AbsTypeTag[Unit]] eq AbsTypeTag.Unit)
-  println(implicitly[AbsTypeTag[Unit]])
-  println(implicitly[AbsTypeTag[Any]] eq AbsTypeTag.Any)
-  println(implicitly[AbsTypeTag[Any]])
-  println(implicitly[AbsTypeTag[AnyVal]] eq AbsTypeTag.AnyVal)
-  println(implicitly[AbsTypeTag[AnyVal]])
-  println(implicitly[AbsTypeTag[AnyRef]] eq AbsTypeTag.AnyRef)
-  println(implicitly[AbsTypeTag[AnyRef]])
-  println(implicitly[AbsTypeTag[Object]] eq AbsTypeTag.Object)
-  println(implicitly[AbsTypeTag[Object]])
-  println(implicitly[AbsTypeTag[Null]] eq AbsTypeTag.Null)
-  println(implicitly[AbsTypeTag[Null]])
-  println(implicitly[AbsTypeTag[Nothing]] eq AbsTypeTag.Nothing)
-  println(implicitly[AbsTypeTag[Nothing]])
+  println(implicitly[WeakTypeTag[Byte]] eq WeakTypeTag.Byte)
+  println(implicitly[WeakTypeTag[Byte]])
+  println(implicitly[WeakTypeTag[Short]] eq WeakTypeTag.Short)
+  println(implicitly[WeakTypeTag[Short]])
+  println(implicitly[WeakTypeTag[Char]] eq WeakTypeTag.Char)
+  println(implicitly[WeakTypeTag[Char]])
+  println(implicitly[WeakTypeTag[Int]] eq WeakTypeTag.Int)
+  println(implicitly[WeakTypeTag[Int]])
+  println(implicitly[WeakTypeTag[Long]] eq WeakTypeTag.Long)
+  println(implicitly[WeakTypeTag[Long]])
+  println(implicitly[WeakTypeTag[Float]] eq WeakTypeTag.Float)
+  println(implicitly[WeakTypeTag[Float]])
+  println(implicitly[WeakTypeTag[Double]] eq WeakTypeTag.Double)
+  println(implicitly[WeakTypeTag[Double]])
+  println(implicitly[WeakTypeTag[Boolean]] eq WeakTypeTag.Boolean)
+  println(implicitly[WeakTypeTag[Boolean]])
+  println(implicitly[WeakTypeTag[Unit]] eq WeakTypeTag.Unit)
+  println(implicitly[WeakTypeTag[Unit]])
+  println(implicitly[WeakTypeTag[Any]] eq WeakTypeTag.Any)
+  println(implicitly[WeakTypeTag[Any]])
+  println(implicitly[WeakTypeTag[AnyVal]] eq WeakTypeTag.AnyVal)
+  println(implicitly[WeakTypeTag[AnyVal]])
+  println(implicitly[WeakTypeTag[AnyRef]] eq WeakTypeTag.AnyRef)
+  println(implicitly[WeakTypeTag[AnyRef]])
+  println(implicitly[WeakTypeTag[Object]] eq WeakTypeTag.Object)
+  println(implicitly[WeakTypeTag[Object]])
+  println(implicitly[WeakTypeTag[Null]] eq WeakTypeTag.Null)
+  println(implicitly[WeakTypeTag[Null]])
+  println(implicitly[WeakTypeTag[Nothing]] eq WeakTypeTag.Nothing)
+  println(implicitly[WeakTypeTag[Nothing]])
 }
\ No newline at end of file
diff --git a/test/files/run/abstypetags_serialize.scala b/test/files/run/abstypetags_serialize.scala
index 5b9142f6d5..38a7aba325 100644
--- a/test/files/run/abstypetags_serialize.scala
+++ b/test/files/run/abstypetags_serialize.scala
@@ -3,7 +3,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
-  def test(tag: AbsTypeTag[_]) =
+  def test(tag: WeakTypeTag[_]) =
     try {
       val fout = new ByteArrayOutputStream()
       val out = new ObjectOutputStream(fout)
@@ -13,7 +13,7 @@ object Test extends App {
 
       val fin = new ByteArrayInputStream(fout.toByteArray)
       val in = new ObjectInputStream(fin)
-      val retag = in.readObject().asInstanceOf[scala.reflect.basis.AbsTypeTag[_]].in(cm)
+      val retag = in.readObject().asInstanceOf[scala.reflect.basis.WeakTypeTag[_]].in(cm)
       in.close()
       fin.close()
 
@@ -24,8 +24,8 @@ object Test extends App {
     }
 
   def qwe[T, U[_]] = {
-    test(implicitly[AbsTypeTag[T]])
-    test(implicitly[AbsTypeTag[U[String]]])
+    test(implicitly[WeakTypeTag[T]])
+    test(implicitly[WeakTypeTag[U[String]]])
   }
 
   qwe
diff --git a/test/files/run/existentials3-new.scala b/test/files/run/existentials3-new.scala
index 31ddc8cc9e..110c8eff7a 100644
--- a/test/files/run/existentials3-new.scala
+++ b/test/files/run/existentials3-new.scala
@@ -38,7 +38,7 @@ object Test {
     println("%s, t=%s, s=%s".format(t, t.asInstanceOf[Product].productPrefix, s))
   }
   def m[T: TypeTag](x: T) = printTpe(typeOf[T])
-  def m2[T: AbsTypeTag](x: T) = printTpe(implicitly[AbsTypeTag[T]].tpe)
+  def m2[T: WeakTypeTag](x: T) = printTpe(implicitly[WeakTypeTag[T]].tpe)
 
   // tags do work for f10/g10
   def main(args: Array[String]): Unit = {
diff --git a/test/files/run/interop_manifests_are_abstypetags.scala b/test/files/run/interop_manifests_are_abstypetags.scala
index 1cba2fdb4b..f2c2723106 100644
--- a/test/files/run/interop_manifests_are_abstypetags.scala
+++ b/test/files/run/interop_manifests_are_abstypetags.scala
@@ -1,11 +1,11 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  def manifestIsAbsTypeTag[T: Manifest] = {
-    println(implicitly[AbsTypeTag[T]].tpe)
+  def manifestIsWeakTypeTag[T: Manifest] = {
+    println(implicitly[WeakTypeTag[T]].tpe)
   }
 
-  manifestIsAbsTypeTag[Int]
-  manifestIsAbsTypeTag[String]
-  manifestIsAbsTypeTag[Array[Int]]
+  manifestIsWeakTypeTag[Int]
+  manifestIsWeakTypeTag[String]
+  manifestIsWeakTypeTag[Array[Int]]
 }
\ No newline at end of file
diff --git a/test/files/run/macro-def-path-dependent-d1/Impls_Macros_1.scala b/test/files/run/macro-def-path-dependent-d1/Impls_Macros_1.scala
index 2daf6fc3fb..69d9708b2a 100644
--- a/test/files/run/macro-def-path-dependent-d1/Impls_Macros_1.scala
+++ b/test/files/run/macro-def-path-dependent-d1/Impls_Macros_1.scala
@@ -5,5 +5,5 @@ import scala.reflect.api.Universe
 object Test {
   def materializeTypeTag[T](u: Universe)(e: T) = macro materializeTypeTag_impl[T]
 
-  def materializeTypeTag_impl[T: c.AbsTypeTag](c: Context)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ???
+  def materializeTypeTag_impl[T: c.WeakTypeTag](c: Context)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ???
 }
\ No newline at end of file
diff --git a/test/files/run/macro-def-path-dependent-d2/Impls_1.scala b/test/files/run/macro-def-path-dependent-d2/Impls_1.scala
index 1cda64e43e..7fa9c3579e 100644
--- a/test/files/run/macro-def-path-dependent-d2/Impls_1.scala
+++ b/test/files/run/macro-def-path-dependent-d2/Impls_1.scala
@@ -3,5 +3,5 @@ import scala.reflect.macros.Context
 import scala.reflect.api.Universe
 
 object Impls {
-  def materializeTypeTag_impl[T: c.AbsTypeTag](c: Context)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ???
+  def materializeTypeTag_impl[T: c.WeakTypeTag](c: Context)(u: c.Expr[Universe])(e: c.Expr[T]): c.Expr[u.value.TypeTag[T]] = ???
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-implicit-argument/Macros_1.scala b/test/files/run/macro-expand-implicit-argument/Macros_1.scala
index 7629c5a9e2..86c4198870 100644
--- a/test/files/run/macro-expand-implicit-argument/Macros_1.scala
+++ b/test/files/run/macro-expand-implicit-argument/Macros_1.scala
@@ -35,7 +35,7 @@ object Macros {
    *     arr
    *   }
    */
-  def arrayMacro[A:c.AbsTypeTag](c:Context)(as:c.Expr[A]*)(ct: c.Expr[ClassTag[A]]): c.Expr[Array[A]] = {
+  def arrayMacro[A:c.WeakTypeTag](c:Context)(as:c.Expr[A]*)(ct: c.Expr[ClassTag[A]]): c.Expr[Array[A]] = {
     import c.mirror._
     import c.universe._
     def const(x:Int) = Literal(Constant(x))
@@ -44,7 +44,7 @@ object Macros {
     val arr = newTermName("arr")
 
     val create = Apply(Select(ct.tree, "newArray"), List(const(n)))
-    val arrtpe = TypeTree(implicitly[c.AbsTypeTag[Array[A]]].tpe)
+    val arrtpe = TypeTree(implicitly[c.WeakTypeTag[Array[A]]].tpe)
     val valdef = ValDef(Modifiers(), arr, arrtpe, create)
 
     val updates = (0 until n).map {
diff --git a/test/files/run/macro-expand-nullary-generic/Impls_1.scala b/test/files/run/macro-expand-nullary-generic/Impls_1.scala
index fbbc23a824..1180c83a40 100644
--- a/test/files/run/macro-expand-nullary-generic/Impls_1.scala
+++ b/test/files/run/macro-expand-nullary-generic/Impls_1.scala
@@ -2,14 +2,14 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def impl[T: c.AbsTypeTag](c: Ctx) = {
+  def impl[T: c.WeakTypeTag](c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works " + implicitly[c.AbsTypeTag[T]]))))
+    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works " + implicitly[c.WeakTypeTag[T]]))))
     c.Expr[Unit](body)
   }
 
-  def fooNullary[T: c.AbsTypeTag](c: Ctx) = impl[T](c)
-  def fooEmpty[T: c.AbsTypeTag](c: Ctx)() = impl[T](c)
-  def barNullary[T: c.AbsTypeTag](c: Ctx)(x: c.Expr[Int]) = impl[T](c)
-  def barEmpty[T: c.AbsTypeTag](c: Ctx)(x: c.Expr[Int])() = impl[T](c)
+  def fooNullary[T: c.WeakTypeTag](c: Ctx) = impl[T](c)
+  def fooEmpty[T: c.WeakTypeTag](c: Ctx)() = impl[T](c)
+  def barNullary[T: c.WeakTypeTag](c: Ctx)(x: c.Expr[Int]) = impl[T](c)
+  def barEmpty[T: c.WeakTypeTag](c: Ctx)(x: c.Expr[Int])() = impl[T](c)
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-explicit/Impls_1.scala b/test/files/run/macro-expand-tparams-explicit/Impls_1.scala
index 0a879687e8..72b420d92f 100644
--- a/test/files/run/macro-expand-tparams-explicit/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-explicit/Impls_1.scala
@@ -2,9 +2,9 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U: c.AbsTypeTag](c: Ctx) = {
+  def foo[U: c.WeakTypeTag](c: Ctx) = {
     import c.universe._
-    val U = implicitly[c.AbsTypeTag[U]]
+    val U = implicitly[c.WeakTypeTag[U]]
     val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(U.toString))))
     c.Expr[Unit](body)
   }
diff --git a/test/files/run/macro-expand-tparams-implicit.check b/test/files/run/macro-expand-tparams-implicit.check
index 1c1a785706..37226ec68d 100644
--- a/test/files/run/macro-expand-tparams-implicit.check
+++ b/test/files/run/macro-expand-tparams-implicit.check
@@ -1,2 +1,2 @@
 TypeTag[Int]

-AbsTypeTag[String]

+WeakTypeTag[String]

diff --git a/test/files/run/macro-expand-tparams-implicit/Impls_1.scala b/test/files/run/macro-expand-tparams-implicit/Impls_1.scala
index f6cb63b9c9..33770516df 100644
--- a/test/files/run/macro-expand-tparams-implicit/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-implicit/Impls_1.scala
@@ -2,9 +2,9 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U: c.AbsTypeTag](c: Ctx)(x: c.Expr[U]) = {
+  def foo[U: c.WeakTypeTag](c: Ctx)(x: c.Expr[U]) = {
     import c.universe._
-    val U = implicitly[c.AbsTypeTag[U]]
+    val U = implicitly[c.WeakTypeTag[U]]
     val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(U.toString))))
     c.Expr[Unit](body)
   }
diff --git a/test/files/run/macro-expand-tparams-prefix-a.check b/test/files/run/macro-expand-tparams-prefix-a.check
index 6a7f9c5f52..7ef9fa7330 100644
--- a/test/files/run/macro-expand-tparams-prefix-a.check
+++ b/test/files/run/macro-expand-tparams-prefix-a.check
@@ -1,4 +1,4 @@
 TypeTag[Int]

 TypeTag[Int]

-AbsTypeTag[String]

+WeakTypeTag[String]

 TypeTag[Boolean]

diff --git a/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala
index f6cb63b9c9..33770516df 100644
--- a/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala
@@ -2,9 +2,9 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U: c.AbsTypeTag](c: Ctx)(x: c.Expr[U]) = {
+  def foo[U: c.WeakTypeTag](c: Ctx)(x: c.Expr[U]) = {
     import c.universe._
-    val U = implicitly[c.AbsTypeTag[U]]
+    val U = implicitly[c.WeakTypeTag[U]]
     val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(U.toString))))
     c.Expr[Unit](body)
   }
diff --git a/test/files/run/macro-expand-tparams-prefix-b.check b/test/files/run/macro-expand-tparams-prefix-b.check
index daae32bd0a..f4a2a8e80d 100644
--- a/test/files/run/macro-expand-tparams-prefix-b.check
+++ b/test/files/run/macro-expand-tparams-prefix-b.check
@@ -1,2 +1,2 @@
 TypeTag[Boolean] TypeTag[Int]

-TypeTag[Boolean] AbsTypeTag[String]

+TypeTag[Boolean] WeakTypeTag[String]

diff --git a/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala
index 7e0fa26569..9378e67712 100644
--- a/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala
@@ -2,10 +2,10 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T: c.AbsTypeTag, U: c.AbsTypeTag](c: Ctx)(x: c.Expr[U]) = {
+  def foo[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Ctx)(x: c.Expr[U]) = {
     import c.universe._
-    val T = implicitly[c.AbsTypeTag[T]]
-    val U = implicitly[c.AbsTypeTag[U]]
+    val T = implicitly[c.WeakTypeTag[T]]
+    val U = implicitly[c.WeakTypeTag[U]]
     val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString + " " + U.toString))))
     c.Expr[Unit](body)
   }
diff --git a/test/files/run/macro-expand-tparams-prefix-c1.check b/test/files/run/macro-expand-tparams-prefix-c1.check
index 5356b3e6d1..473668ac58 100644
--- a/test/files/run/macro-expand-tparams-prefix-c1.check
+++ b/test/files/run/macro-expand-tparams-prefix-c1.check
@@ -1,3 +1,3 @@
 TypeTag[Int]

-AbsTypeTag[String]

+WeakTypeTag[String]

 TypeTag[Boolean]

diff --git a/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala
index ca515be627..afdd7d4f7a 100644
--- a/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala
@@ -2,11 +2,11 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T, U: c.AbsTypeTag, V](c: Ctx)(implicit T: c.AbsTypeTag[T], V: c.AbsTypeTag[V]): c.Expr[Unit] = {
+  def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     c.Expr(Block(List(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.AbsTypeTag[U]].toString)))),
+      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
       Literal(Constant(()))))
   }
diff --git a/test/files/run/macro-expand-tparams-prefix-c2.check b/test/files/run/macro-expand-tparams-prefix-c2.check
index 5356b3e6d1..473668ac58 100644
--- a/test/files/run/macro-expand-tparams-prefix-c2.check
+++ b/test/files/run/macro-expand-tparams-prefix-c2.check
@@ -1,3 +1,3 @@
 TypeTag[Int]

-AbsTypeTag[String]

+WeakTypeTag[String]

 TypeTag[Boolean]

diff --git a/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala b/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala
index 5a554590d8..3c2838208a 100644
--- a/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala
@@ -2,11 +2,11 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T, U: c.AbsTypeTag, V](c: Ctx)(implicit T: c.AbsTypeTag[T], V: c.AbsTypeTag[V]): c.Expr[Unit] = {
+  def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     c.Expr(Block(List(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.AbsTypeTag[U]].toString)))),
+      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
       Literal(Constant(()))))
   }
diff --git a/test/files/run/macro-expand-tparams-prefix-d1.check b/test/files/run/macro-expand-tparams-prefix-d1.check
index 319edfbed0..2331e2549e 100644
--- a/test/files/run/macro-expand-tparams-prefix-d1.check
+++ b/test/files/run/macro-expand-tparams-prefix-d1.check
@@ -1,3 +1,3 @@
-AbsTypeTag[T]

-AbsTypeTag[U]

+WeakTypeTag[T]

+WeakTypeTag[U]

 TypeTag[Boolean]

diff --git a/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala
index ca515be627..afdd7d4f7a 100644
--- a/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala
@@ -2,11 +2,11 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T, U: c.AbsTypeTag, V](c: Ctx)(implicit T: c.AbsTypeTag[T], V: c.AbsTypeTag[V]): c.Expr[Unit] = {
+  def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     c.Expr(Block(List(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.AbsTypeTag[U]].toString)))),
+      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
       Literal(Constant(()))))
   }
diff --git a/test/files/run/macro-impl-default-params/Impls_Macros_1.scala b/test/files/run/macro-impl-default-params/Impls_Macros_1.scala
index 06c58d96ab..db77b1923a 100644
--- a/test/files/run/macro-impl-default-params/Impls_Macros_1.scala
+++ b/test/files/run/macro-impl-default-params/Impls_Macros_1.scala
@@ -2,10 +2,10 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo_targs[T, U: c.AbsTypeTag](c: Ctx = null)(x: c.Expr[Int] = null) = {
+  def foo_targs[T, U: c.WeakTypeTag](c: Ctx = null)(x: c.Expr[Int] = null) = {
     import c.{prefix => prefix}
     import c.universe._
-    val U = implicitly[c.AbsTypeTag[U]]
+    val U = implicitly[c.WeakTypeTag[U]]
     val body = Block(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("invoking foo_targs...")))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("type of prefix is: " + prefix.staticType)))),
diff --git a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala
index a54b7f4b08..4583a726cf 100644
--- a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala
+++ b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala
@@ -1,7 +1,7 @@
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T: c.AbsTypeTag](c: Ctx)(x: c.Expr[T]) = {
+  def foo[T: c.WeakTypeTag](c: Ctx)(x: c.Expr[T]) = {
     import c.universe._
     val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(x.tree.toString))))
     c.Expr[Unit](body)
diff --git a/test/files/run/macro-reify-abstypetag-notypeparams/Test.scala b/test/files/run/macro-reify-abstypetag-notypeparams/Test.scala
index 34f742b9fb..73c2d05921 100644
--- a/test/files/run/macro-reify-abstypetag-notypeparams/Test.scala
+++ b/test/files/run/macro-reify-abstypetag-notypeparams/Test.scala
@@ -1,6 +1,6 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  println(implicitly[AbsTypeTag[Int]])
-  println(implicitly[AbsTypeTag[List[Int]]])
+  println(implicitly[WeakTypeTag[Int]])
+  println(implicitly[WeakTypeTag[List[Int]]])
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reify-abstypetag-typeparams-notags.check b/test/files/run/macro-reify-abstypetag-typeparams-notags.check
index be62b59a69..6aeec96079 100644
--- a/test/files/run/macro-reify-abstypetag-typeparams-notags.check
+++ b/test/files/run/macro-reify-abstypetag-typeparams-notags.check
@@ -1,2 +1,2 @@
-AbsTypeTag[T]

-AbsTypeTag[List[T]]

+WeakTypeTag[T]

+WeakTypeTag[List[T]]

diff --git a/test/files/run/macro-reify-abstypetag-typeparams-notags/Test.scala b/test/files/run/macro-reify-abstypetag-typeparams-notags/Test.scala
index 0b42cc07b5..4ba2231d9a 100644
--- a/test/files/run/macro-reify-abstypetag-typeparams-notags/Test.scala
+++ b/test/files/run/macro-reify-abstypetag-typeparams-notags/Test.scala
@@ -2,8 +2,8 @@ import scala.reflect.runtime.universe._
 
 object Test extends App {
   def fooNoTypeTag[T] = {
-    println(implicitly[AbsTypeTag[T]])
-    println(implicitly[AbsTypeTag[List[T]]])
+    println(implicitly[WeakTypeTag[T]])
+    println(implicitly[WeakTypeTag[List[T]]])
   }
   fooNoTypeTag[Int]
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reify-abstypetag-typeparams-tags.check b/test/files/run/macro-reify-abstypetag-typeparams-tags.check
index d6ca5a85ef..6e2646c5e0 100644
--- a/test/files/run/macro-reify-abstypetag-typeparams-tags.check
+++ b/test/files/run/macro-reify-abstypetag-typeparams-tags.check
@@ -1,2 +1,2 @@
 TypeTag[Int]

-AbsTypeTag[List[Int]]

+WeakTypeTag[List[Int]]

diff --git a/test/files/run/macro-reify-abstypetag-typeparams-tags/Test.scala b/test/files/run/macro-reify-abstypetag-typeparams-tags/Test.scala
index 82a7b7971d..70ca615e1f 100644
--- a/test/files/run/macro-reify-abstypetag-typeparams-tags/Test.scala
+++ b/test/files/run/macro-reify-abstypetag-typeparams-tags/Test.scala
@@ -1,9 +1,9 @@
 import scala.reflect.runtime.universe._
 
 object Test extends App {
-  def fooTypeTag[T: AbsTypeTag] = {
-    println(implicitly[AbsTypeTag[T]])
-    println(implicitly[AbsTypeTag[List[T]]])
+  def fooTypeTag[T: WeakTypeTag] = {
+    println(implicitly[WeakTypeTag[T]])
+    println(implicitly[WeakTypeTag[List[T]]])
   }
   fooTypeTag[Int]
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reify-abstypetag-usetypetag.check b/test/files/run/macro-reify-abstypetag-usetypetag.check
index d6ca5a85ef..6e2646c5e0 100644
--- a/test/files/run/macro-reify-abstypetag-usetypetag.check
+++ b/test/files/run/macro-reify-abstypetag-usetypetag.check
@@ -1,2 +1,2 @@
 TypeTag[Int]

-AbsTypeTag[List[Int]]

+WeakTypeTag[List[Int]]

diff --git a/test/files/run/macro-reify-abstypetag-usetypetag/Test.scala b/test/files/run/macro-reify-abstypetag-usetypetag/Test.scala
index 3c62725c42..ecae4110a8 100644
--- a/test/files/run/macro-reify-abstypetag-usetypetag/Test.scala
+++ b/test/files/run/macro-reify-abstypetag-usetypetag/Test.scala
@@ -2,8 +2,8 @@ import scala.reflect.runtime.universe._
 
 object Test extends App {
   def fooTypeTag[T: TypeTag] = {
-    println(implicitly[AbsTypeTag[T]])
-    println(implicitly[AbsTypeTag[List[T]]])
+    println(implicitly[WeakTypeTag[T]])
+    println(implicitly[WeakTypeTag[List[T]]])
   }
   fooTypeTag[Int]
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reify-freevars/Macros_1.scala b/test/files/run/macro-reify-freevars/Macros_1.scala
index 57fdc32437..20f80c06d1 100644
--- a/test/files/run/macro-reify-freevars/Macros_1.scala
+++ b/test/files/run/macro-reify-freevars/Macros_1.scala
@@ -1,7 +1,7 @@
 package scala.collection.slick
 
 object QueryableMacros{
-  def map[T:c.AbsTypeTag, S:c.AbsTypeTag]
+  def map[T:c.WeakTypeTag, S:c.WeakTypeTag]
          (c: scala.reflect.macros.Context)
          (projection: c.Expr[T => S])
          : c.Expr[scala.collection.slick.Queryable[S]] = {
diff --git a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
index 04714970dd..ae2def2d3e 100644
--- a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
@@ -21,9 +21,9 @@ case class Utils[C <: Context]( c:C ) {
   }
 }
 object QueryableMacros{
-  def _helper[C <: Context,S:c.AbsTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
+  def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
     import c.universe._
-    val element_type = implicitly[c.AbsTypeTag[S]].tpe
+    val element_type = implicitly[c.WeakTypeTag[S]].tpe
     val foo = c.Expr[ru.Expr[Queryable[S]]](
     c.reifyTree( c.runtimeUniverse, EmptyTree, c.typeCheck(
       Utils[c.type](c).removeDoubleReify(
@@ -32,7 +32,7 @@ object QueryableMacros{
       )))
     c.universe.reify{ Queryable.factory[S]( foo.splice )}
   }
-  def map[T:c.AbsTypeTag, S:c.AbsTypeTag]
+  def map[T:c.WeakTypeTag, S:c.WeakTypeTag]
                (c: scala.reflect.macros.Context)
                (projection: c.Expr[T => S]): c.Expr[Queryable[S]] = _helper[c.type,S]( c )( "_map", projection )
 }
diff --git a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
index 04714970dd..ae2def2d3e 100644
--- a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
@@ -21,9 +21,9 @@ case class Utils[C <: Context]( c:C ) {
   }
 }
 object QueryableMacros{
-  def _helper[C <: Context,S:c.AbsTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
+  def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
     import c.universe._
-    val element_type = implicitly[c.AbsTypeTag[S]].tpe
+    val element_type = implicitly[c.WeakTypeTag[S]].tpe
     val foo = c.Expr[ru.Expr[Queryable[S]]](
     c.reifyTree( c.runtimeUniverse, EmptyTree, c.typeCheck(
       Utils[c.type](c).removeDoubleReify(
@@ -32,7 +32,7 @@ object QueryableMacros{
       )))
     c.universe.reify{ Queryable.factory[S]( foo.splice )}
   }
-  def map[T:c.AbsTypeTag, S:c.AbsTypeTag]
+  def map[T:c.WeakTypeTag, S:c.WeakTypeTag]
                (c: scala.reflect.macros.Context)
                (projection: c.Expr[T => S]): c.Expr[Queryable[S]] = _helper[c.type,S]( c )( "_map", projection )
 }
diff --git a/test/files/run/macro-reify-tagful-a/Macros_1.scala b/test/files/run/macro-reify-tagful-a/Macros_1.scala
index 0eac74236f..f2512dcfaf 100644
--- a/test/files/run/macro-reify-tagful-a/Macros_1.scala
+++ b/test/files/run/macro-reify-tagful-a/Macros_1.scala
@@ -5,7 +5,7 @@ object Macros {
   def foo[T](s: T) = macro Impls.foo[T]
 
   object Impls {
-    def foo[T: c.AbsTypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
+    def foo[T: c.WeakTypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       List(s.splice)
     }
   }
diff --git a/test/files/run/macro-reify-tagless-a.check b/test/files/run/macro-reify-tagless-a.check
index d69f641280..c2385ba008 100644
--- a/test/files/run/macro-reify-tagless-a.check
+++ b/test/files/run/macro-reify-tagless-a.check
@@ -1,3 +1,3 @@
 reflective compilation has failed: 

 

-Macro expansion contains free type variable T defined by foo in Impls_Macros_1.scala:7:13. Have you forgotten to use c.AbsTypeTag annotation for this type parameter? If you have troubles tracking free type variables, consider using -Xlog-free-types

+Macro expansion contains free type variable T defined by foo in Impls_Macros_1.scala:7:13. Have you forgotten to use c.WeakTypeTag annotation for this type parameter? If you have troubles tracking free type variables, consider using -Xlog-free-types

diff --git a/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala b/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala
index 3d350a50fa..bcbd12817b 100644
--- a/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala
+++ b/test/files/run/macro-undetparams-consfromsls/Impls_Macros_1.scala
@@ -2,13 +2,13 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.Context
 
 object Macros {
-  def cons_impl[A: c.AbsTypeTag](c: Context)(x: c.Expr[A], xs: c.Expr[List[A]]): c.Expr[List[A]] = c.universe.reify {
-    println("A = " + c.literal(implicitly[c.AbsTypeTag[A]].toString).splice)
+  def cons_impl[A: c.WeakTypeTag](c: Context)(x: c.Expr[A], xs: c.Expr[List[A]]): c.Expr[List[A]] = c.universe.reify {
+    println("A = " + c.literal(implicitly[c.WeakTypeTag[A]].toString).splice)
     x.splice :: xs.splice
   }
 
-  def nil_impl[B: c.AbsTypeTag](c: Context): c.Expr[List[B]] = c.universe.reify {
-    println("B = " + c.literal(implicitly[c.AbsTypeTag[B]].toString).splice)
+  def nil_impl[B: c.WeakTypeTag](c: Context): c.Expr[List[B]] = c.universe.reify {
+    println("B = " + c.literal(implicitly[c.WeakTypeTag[B]].toString).splice)
     Nil
   }
 
diff --git a/test/files/run/macro-undetparams-macroitself.check b/test/files/run/macro-undetparams-macroitself.check
index 1c1a785706..37226ec68d 100644
--- a/test/files/run/macro-undetparams-macroitself.check
+++ b/test/files/run/macro-undetparams-macroitself.check
@@ -1,2 +1,2 @@
 TypeTag[Int]

-AbsTypeTag[String]

+WeakTypeTag[String]

diff --git a/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala b/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala
index 081894cf52..0244273b6f 100644
--- a/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala
+++ b/test/files/run/macro-undetparams-macroitself/Impls_Macros_1.scala
@@ -2,7 +2,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.Context
 
 object Macros {
-  def impl[T: c.AbsTypeTag](c: Context)(foo: c.Expr[T]): c.Expr[Unit] = c.universe.reify { println(c.literal(implicitly[c.AbsTypeTag[T]].toString).splice) }
+  def impl[T: c.WeakTypeTag](c: Context)(foo: c.Expr[T]): c.Expr[Unit] = c.universe.reify { println(c.literal(implicitly[c.WeakTypeTag[T]].toString).splice) }
 
   def foo[T](foo: T) = macro impl[T]
 }
\ No newline at end of file
diff --git a/test/files/run/reify_newimpl_26.check b/test/files/run/reify_newimpl_26.check
index c006cb7ffb..5996f3b322 100644
--- a/test/files/run/reify_newimpl_26.check
+++ b/test/files/run/reify_newimpl_26.check
@@ -5,16 +5,16 @@ scala>
 

 scala> def foo[T]{

   import scala.reflect.runtime.universe._

-  val tt = implicitly[AbsTypeTag[List[T]]]

+  val tt = implicitly[WeakTypeTag[List[T]]]

   println(tt)

 }

 <console>:9: free type: Ident(newTypeName("T")) defined by foo in <console>:7:16

-         val tt = implicitly[AbsTypeTag[List[T]]]

+         val tt = implicitly[WeakTypeTag[List[T]]]

                             ^

 foo: [T]=> Unit

 

 scala> foo[Int]

-AbsTypeTag[scala.List[T]]

+WeakTypeTag[scala.List[T]]

 

 scala> 

 

diff --git a/test/files/run/reify_newimpl_26.scala b/test/files/run/reify_newimpl_26.scala
index a12d8a2970..af74d60e8b 100644
--- a/test/files/run/reify_newimpl_26.scala
+++ b/test/files/run/reify_newimpl_26.scala
@@ -5,7 +5,7 @@ object Test extends ReplTest {
   def code = """
 def foo[T]{
   import scala.reflect.runtime.universe._
-  val tt = implicitly[AbsTypeTag[List[T]]]
+  val tt = implicitly[WeakTypeTag[List[T]]]
   println(tt)
 }
 foo[Int]
diff --git a/test/files/run/t1195-new.scala b/test/files/run/t1195-new.scala
index 690c6213cf..0f62b140c9 100644
--- a/test/files/run/t1195-new.scala
+++ b/test/files/run/t1195-new.scala
@@ -9,7 +9,7 @@ object Test {
   val g1 = g()
   val h1 = h()
 
-  def m[T: AbsTypeTag](x: T) = println(absTypeOf[T] + ", underlying = " + absTypeOf[T].typeSymbol.typeSignature)
+  def m[T: WeakTypeTag](x: T) = println(weakTypeOf[T] + ", underlying = " + weakTypeOf[T].typeSymbol.typeSignature)
 
   def main(args: Array[String]): Unit = {
     m(f)
diff --git a/test/files/run/t6323b.check b/test/files/run/t6323b.check
index 2219278a16..80b6176178 100644
--- a/test/files/run/t6323b.check
+++ b/test/files/run/t6323b.check
@@ -1 +1 @@
-cannot reflect value a, because it's a member of a free type Test

+cannot reflect value a, because it's a member of a weak type Test

diff --git a/test/files/run/t6323b.scala b/test/files/run/t6323b.scala
index 25a2329d94..f530ac3ecc 100644
--- a/test/files/run/t6323b.scala
+++ b/test/files/run/t6323b.scala
@@ -8,7 +8,7 @@ object Test extends App {
       case class Test(a:String,b:List[Int])
 
       val lookAtMe = m.reflect(Test("a",List(5)))
-      val value = u.absTypeOf[Test]
+      val value = u.weakTypeOf[Test]
       val members = value.members
       val member = value.members.filter(_.name.encoded == "a")
       val aAccessor = lookAtMe.reflectMethod(member.head.asMethod)
diff --git a/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala b/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala
index 26d4a45fee..15bcb581c8 100644
--- a/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala
+++ b/test/pending/run/macro-expand-implicit-macro-defeats-type-inference/Impls_1.scala
@@ -1,7 +1,7 @@
 import scala.reflect.macros.Context
 
 object Impls {
-  def foo[T: c.AbsTypeTag](c: Context): c.Expr[List[T]] = c.universe.reify {
+  def foo[T: c.WeakTypeTag](c: Context): c.Expr[List[T]] = c.universe.reify {
     println("openImplicits are: " + c.literal(c.openImplicits.toString).splice)
     println("enclosingImplicits are: " + c.literal(c.enclosingImplicits.toString).splice)
     println("typetag is: " + c.literal(c.tag[T].toString).splice)
diff --git a/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala b/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala
index d6ebb907e5..26de70cc12 100644
--- a/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala
+++ b/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala
@@ -1,11 +1,11 @@
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T, U: c.AbsTypeTag, V](c: Ctx)(implicit T: c.AbsTypeTag[T], V: c.AbsTypeTag[V]): c.Expr[Unit] = {
+  def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     Block(List(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.AbsTypeTag[U]].toString)))),
+      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
       Literal(Constant(())))
   }
diff --git a/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala b/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala
index d6ebb907e5..26de70cc12 100644
--- a/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala
+++ b/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala
@@ -1,11 +1,11 @@
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[T, U: c.AbsTypeTag, V](c: Ctx)(implicit T: c.AbsTypeTag[T], V: c.AbsTypeTag[V]): c.Expr[Unit] = {
+  def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     Block(List(
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.AbsTypeTag[U]].toString)))),
+      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
       Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
       Literal(Constant(())))
   }
diff --git a/test/pending/run/macro-reify-array/Macros_1.scala b/test/pending/run/macro-reify-array/Macros_1.scala
index 99006c548a..f970be5caa 100644
--- a/test/pending/run/macro-reify-array/Macros_1.scala
+++ b/test/pending/run/macro-reify-array/Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo[T](s: String) = macro Impls.foo[T]
 
   object Impls {
-    def foo[T: c.AbsTypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
+    def foo[T: c.WeakTypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       Array(s.splice)
     }
   }
diff --git a/test/pending/run/macro-reify-tagful-b/Macros_1.scala b/test/pending/run/macro-reify-tagful-b/Macros_1.scala
index a14187e8a7..59dbe7157b 100644
--- a/test/pending/run/macro-reify-tagful-b/Macros_1.scala
+++ b/test/pending/run/macro-reify-tagful-b/Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def foo[T](s: T) = macro Impls.foo[List[T]]
 
   object Impls {
-    def foo[T: c.AbsTypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
+    def foo[T: c.WeakTypeTag](c: Ctx)(s: c.Expr[T]) = c.universe.reify {
       List(s.splice)
     }
   }