From 079943e3cd18faa034aca3b154314e6f7a94a546 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Sun, 3 Apr 2016 13:52:36 +0200 Subject: Make erased value type take a TypeRef instead of a ClassSymbol To address #1198, we need to avoid putting symbols in ErasedValueTypes. --- src/dotty/tools/dotc/core/TypeComparer.scala | 6 +++--- src/dotty/tools/dotc/core/TypeErasure.scala | 14 +++++++------- src/dotty/tools/dotc/printing/RefinedPrinter.scala | 4 ++-- src/dotty/tools/dotc/transform/Erasure.scala | 20 ++++++++++---------- .../tools/dotc/transform/ExtensionMethods.scala | 2 +- 5 files changed, 23 insertions(+), 23 deletions(-) (limited to 'src/dotty/tools/dotc') diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala index c846737b6..c039a8dfa 100644 --- a/src/dotty/tools/dotc/core/TypeComparer.scala +++ b/src/dotty/tools/dotc/core/TypeComparer.scala @@ -237,10 +237,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling { case OrType(tp21, tp22) => if (tp21.stripTypeVar eq tp22.stripTypeVar) isSubType(tp1, tp21) else secondTry(tp1, tp2) - case TypeErasure.ErasedValueType(cls2, underlying2) => + case TypeErasure.ErasedValueType(tycon1, underlying2) => def compareErasedValueType = tp1 match { - case TypeErasure.ErasedValueType(cls1, underlying1) => - (cls1 eq cls2) && isSameType(underlying1, underlying2) + case TypeErasure.ErasedValueType(tycon2, underlying1) => + (tycon1.symbol eq tycon2.symbol) && isSameType(underlying1, underlying2) case _ => secondTry(tp1, tp2) } diff --git a/src/dotty/tools/dotc/core/TypeErasure.scala b/src/dotty/tools/dotc/core/TypeErasure.scala index a7d825131..88c8d610e 100644 --- a/src/dotty/tools/dotc/core/TypeErasure.scala +++ b/src/dotty/tools/dotc/core/TypeErasure.scala @@ -69,17 +69,17 @@ object TypeErasure { * @param cls The value class symbol * @param erasedUnderlying The erased type of the single field of the value class */ - abstract case class ErasedValueType(cls: ClassSymbol, erasedUnderlying: Type) + abstract case class ErasedValueType(tycon: TypeRef, erasedUnderlying: Type) extends CachedGroundType with ValueType { - override def computeHash = doHash(cls, erasedUnderlying) + override def computeHash = doHash(tycon, erasedUnderlying) } - final class CachedErasedValueType(cls: ClassSymbol, erasedUnderlying: Type) - extends ErasedValueType(cls, erasedUnderlying) + final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type) + extends ErasedValueType(tycon, erasedUnderlying) object ErasedValueType { - def apply(cls: ClassSymbol, erasedUnderlying: Type)(implicit ctx: Context) = { - unique(new CachedErasedValueType(cls, erasedUnderlying)) + def apply(tycon: TypeRef, erasedUnderlying: Type)(implicit ctx: Context) = { + unique(new CachedErasedValueType(tycon, erasedUnderlying)) } } @@ -411,7 +411,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean private def eraseDerivedValueClassRef(tref: TypeRef)(implicit ctx: Context): Type = { val cls = tref.symbol.asClass val underlying = underlyingOfValueClass(cls) - if (underlying.exists) ErasedValueType(cls, valueErasure(underlying)) + if (underlying.exists) ErasedValueType(tref, valueErasure(underlying)) else NoType } diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala index e21f12410..55f0b244d 100644 --- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala +++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala @@ -157,8 +157,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { return toText(tp.info) case ExprType(result) => return "=> " ~ toText(result) - case ErasedValueType(clazz, underlying) => - return "ErasedValueType(" ~ toText(clazz.typeRef) ~ ", " ~ toText(underlying) ~ ")" + case ErasedValueType(tycon, underlying) => + return "ErasedValueType(" ~ toText(tycon) ~ ", " ~ toText(underlying) ~ ")" case tp: ClassInfo => return toTextParents(tp.parentsWithArgs) ~ "{...}" case JavaArrayType(elemtp) => diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala index b4beaab88..7acb14af4 100644 --- a/src/dotty/tools/dotc/transform/Erasure.scala +++ b/src/dotty/tools/dotc/transform/Erasure.scala @@ -153,8 +153,8 @@ object Erasure extends TypeTestsCasts{ final def box(tree: Tree, target: => String = "")(implicit ctx: Context): Tree = ctx.traceIndented(i"boxing ${tree.showSummary}: ${tree.tpe} into $target") { tree.tpe.widen match { - case ErasedValueType(clazz, _) => - New(clazz.typeRef, cast(tree, underlyingOfValueClass(clazz)) :: Nil) // todo: use adaptToType? + case ErasedValueType(tycon, _) => + New(tycon, cast(tree, underlyingOfValueClass(tycon.symbol.asClass)) :: Nil) // todo: use adaptToType? case tp => val cls = tp.classSymbol if (cls eq defn.UnitClass) constant(tree, ref(defn.BoxedUnit_UNIT)) @@ -173,10 +173,10 @@ object Erasure extends TypeTestsCasts{ def unbox(tree: Tree, pt: Type)(implicit ctx: Context): Tree = ctx.traceIndented(i"unboxing ${tree.showSummary}: ${tree.tpe} as a $pt") { pt match { - case ErasedValueType(clazz, underlying) => + case ErasedValueType(tycon, underlying) => def unboxedTree(t: Tree) = - adaptToType(t, clazz.typeRef) - .select(valueClassUnbox(clazz)) + adaptToType(t, tycon) + .select(valueClassUnbox(tycon.symbol.asClass)) .appliedToNone // Null unboxing needs to be treated separately since we cannot call a method on null. @@ -185,7 +185,7 @@ object Erasure extends TypeTestsCasts{ val tree1 = if (tree.tpe isRef defn.NullClass) adaptToType(tree, underlying) - else if (!(tree.tpe <:< clazz.typeRef)) { + else if (!(tree.tpe <:< tycon)) { assert(!(tree.tpe.typeSymbol.isPrimitiveValueClass)) val nullTree = Literal(Constant(null)) val unboxedNull = adaptToType(nullTree, underlying) @@ -223,12 +223,12 @@ object Erasure extends TypeTestsCasts{ if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType => // See SI-2386 for one example of when this might be necessary. cast(ref(defn.runtimeMethodRef(nme.toObjectArray)).appliedTo(tree), pt) - case (_, ErasedValueType(cls, _)) => - ref(u2evt(cls)).appliedTo(tree) + case (_, ErasedValueType(tycon, _)) => + ref(u2evt(tycon.symbol.asClass)).appliedTo(tree) case _ => tree.tpe.widen match { - case ErasedValueType(cls, _) => - ref(evt2u(cls)).appliedTo(tree) + case ErasedValueType(tycon, _) => + ref(evt2u(tycon.symbol.asClass)).appliedTo(tree) case _ => if (pt.isPrimitiveValueType) primitiveConversion(tree, pt.classSymbol) diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala index c5ab49c9c..a1d2e5c68 100644 --- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala +++ b/src/dotty/tools/dotc/transform/ExtensionMethods.scala @@ -70,7 +70,7 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful } val underlying = valueErasure(underlyingOfValueClass(valueClass)) - val evt = ErasedValueType(valueClass, underlying) + val evt = ErasedValueType(valueClass.typeRef, underlying) val u2evtSym = ctx.newSymbol(moduleSym, nme.U2EVT, Synthetic | Method, MethodType(List(nme.x_0), List(underlying), evt)) val evt2uSym = ctx.newSymbol(moduleSym, nme.EVT2U, Synthetic | Method, -- cgit v1.2.3