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.

1 files changed, 3 insertions, 3 deletions

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