ClassTags: New phase which synthesises class tags.

[DarkDimius]

No description provided.

[DarkDimius]

@odersky please review.

[odersky]

Can we swap RresolveSuper and ClassTags. ResolveSuper - erasure - Mixin are sort of a unit that should stay together.

[DarkDimius]

ClassTags could go anywhere after ExtensionMethods. It could even be in the same group.
I'm fine with moving it.
Can you explain why you want ResolveSuper - erasure - Mixin to be same unit? We should not rely on this, as there are phases that want to go in between(think class specialization, which changes superclasses)

[odersky]

Otherwise LGTM

[retronym]

Will this do the right thing for:

scala> reflect.classTag[Array[Int]]
res2: scala.reflect.ClassTag[Array[Int]] = Array[int]

[retronym]

Is it possible to get NoSymbol back here? classSymbol seems to return that for some OrTypes.

[DarkDimius]

Thanks for Array example, It's indeed not handled correctly.
classSymbol for OrTypes is bugged, see comment https://github.com/lampepfl/dotty/blob/master/src/dotty/tools/dotc/core/Types.scala#L308. It should not return NoSymbol.
Though this code will not work for some AndTypes.

It seems that classSymbol.orElse(classSymbols.head) should do it correctly.

[odersky]

On Thu, May 14, 2015 at 9:07 AM, Dmitry Petrashko [email protected]
wrote:

In src/dotty/tools/dotc/transform/ClassTags.scala
#563 (comment):

• override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = {
• val predefClass = defn.DottyPredefModule.moduleClass.asClass
• classTagCache = ctx.requiredMethod(predefClass, names.classTag)
• typeTagCache = ctx.requiredMethod(predefClass, names.typeTag)
• scala2ClassTagModule = ctx.requiredModule("scala.reflect.ClassTag")
• this
• }

• override def phaseName: String = "classTags"

• override def transformTypeApply(tree: tpd.TypeApply)(implicit ctx: Context, info: TransformerInfo): tpd.Tree =
• if (tree.fun.symbol eq classTagCache) {

•  val tp = tree.args.head.tpe
  

•  val claz = tp.classSymbol
  

Thanks for Array example, It's indeed not handled correctly.
classSymbol for OrTypes is bugged, see comment
https://github.com/lampepfl/dotty/blob/master/src/dotty/tools/dotc/core/Types.scala#L308.
It should not return NoSymbol.
Though this code will not work for some AndTypes.

It seems that classSymbol.orElse(classSymbols.head) should do it
correctly.

That will return a symbol. but how do you know it's the right one? We are
missing a spec here. I think the most robust would be to take the
classSymbol of the erased type. That has a simple spec and it is likely to
be the one we will want in the end.

—
Reply to this email directly or view it on GitHub
https://github.com/lampepfl/dotty/pull/563/files#r30301852.

Martin Odersky
EPFL

[DarkDimius]

Indeed. Thanks.

[retronym]

In Scala, give a value class Meter, classTag[Meter] and classOf[Meter] return Meter.class, not the underlying type.

So I think using Scala erasure might be a little bit too simple. You could instead use the java erasure, which, after my fix for @smarter's recent bug report, does not unwrap value classes.

Here's a few test cases:

object Test { 
  type T = String
  type U

  def test = {

    val a /* : Class[T]                  */ = classOf[T]                        // [Ljava/lang/String;
    val b /* : ClassTag[T]               */ = reflect.classTag[T]               // ClassTag(classOf[java.lang.String])

//  val c /* :                           */ = classOf[T with U]                 // error: class type required but Test.T with Test.U found
    val d /* : ClassTag[T with U]        */ = reflect.classTag[T with U]        // ClassTag(classOf[java.lang.String])

    val e /* : Class[Array[T with U]]    */ = classOf[Array[T with U]]          // [Ljava/lang/String;
    val f /* : ClassTag[Array[T with U]] */ = reflect.classTag[Array[T with U]] // ClassTag(arrayClass(classOf[java.lang.String]))

    val g /* : Class[Meter]              */ = classOf[Meter]                    // [LMeter;
    val h /* : ClassTag[Meter]           */ = reflect.classTag[Meter]           // ClassTag(classOf[Meter])
  }
}

class Meter(val i: Int) extends AnyVal

[retronym]

Here's the code that backs the materializeClassTag macro in Scala: https://github.com/scala/scala/blob/2.11.x/src/compiler/scala/reflect/reify/package.scala#L49-L72

[DarkDimius]

@odersky please review.

[odersky]

I usually use myClassTag/myTypeTag for private variables, includes variables serving as a cache.

[odersky]

LGTM