Make ValueClass operations take Symbols, not SymDenotations

Author: odersky

compiler/src/dotty/tools/dotc/transform/TreeExtractors.scala

@@ -36,8 +36,8 @@ object TreeExtractors {
   object ValueClassUnbox {
     def unapply(t: Tree)(implicit ctx: Context): Option[Tree] = t match {
       case Apply(sel @ Select(ref, _), Nil) =>
-        val d = ref.tpe.widenDealias.typeSymbol.denot
-        if (isDerivedValueClass(d) && (sel.symbol eq valueClassUnbox(d.asClass))) {
+        val sym = ref.tpe.widenDealias.typeSymbol
+        if (isDerivedValueClass(sym) && (sel.symbol eq valueClassUnbox(sym.asClass))) {
           Some(ref)
         } else
           None

compiler/src/dotty/tools/dotc/transform/ValueClasses.scala

@@ -4,7 +4,6 @@ package transform
 import core._
 import Types._
 import Symbols._
-import SymDenotations._
 import Contexts._
 import Flags._
 import StdNames._
@@ -13,7 +12,8 @@ import SymUtils._
 /** Methods that apply to user-defined value classes */
 object ValueClasses {
 
-  def isDerivedValueClass(d: SymDenotation)(implicit ctx: Context) = {
+  def isDerivedValueClass(sym: Symbol)(implicit ctx: Context): Boolean = {
+    val d = sym.denot
     !ctx.settings.XnoValueClasses.value &&
     !d.isRefinementClass &&
     d.isValueClass &&
@@ -33,27 +33,27 @@ object ValueClasses {
     }
 
   /** The member of a derived value class that unboxes it. */
-  def valueClassUnbox(d: ClassDenotation)(implicit ctx: Context): Symbol =
+  def valueClassUnbox(cls: ClassSymbol)(implicit ctx: Context): Symbol =
     // (info.decl(nme.unbox)).orElse(...)      uncomment once we accept unbox methods
-    d.classInfo.decls.find(_.is(ParamAccessor))
+    cls.classInfo.decls.find(_.is(ParamAccessor))
 
   /** For a value class `d`, this returns the synthetic cast from the underlying type to
    *  ErasedValueType defined in the companion module. This method is added to the module
    *  and further described in [[ExtensionMethods]].
    */
-  def u2evt(d: ClassDenotation)(implicit ctx: Context): Symbol =
-    d.linkedClass.info.decl(nme.U2EVT).symbol
+  def u2evt(cls: ClassSymbol)(implicit ctx: Context): Symbol =
+    cls.linkedClass.info.decl(nme.U2EVT).symbol
 
   /** For a value class `d`, this returns the synthetic cast from ErasedValueType to the
    *  underlying type defined in the companion module. This method is added to the module
    *  and further described in [[ExtensionMethods]].
    */
-  def evt2u(d: ClassDenotation)(implicit ctx: Context): Symbol =
-    d.linkedClass.info.decl(nme.EVT2U).symbol
+  def evt2u(cls: ClassSymbol)(implicit ctx: Context): Symbol =
+    cls.linkedClass.info.decl(nme.EVT2U).symbol
 
   /** The unboxed type that underlies a derived value class */
-  def underlyingOfValueClass(d: ClassDenotation)(implicit ctx: Context): Type =
-    valueClassUnbox(d).info.resultType
+  def underlyingOfValueClass(sym: ClassSymbol)(implicit ctx: Context): Type =
+    valueClassUnbox(sym).info.resultType
 
   /** Whether a value class wraps itself */
   def isCyclic(cls: ClassSymbol)(implicit ctx: Context): Boolean = {