Make classSymbol also work for SingletonTypes

Analogius to the change for typeSymbol

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -416,7 +416,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   private def followOuterLinks(t: Tree)(using Context) = t match {
     case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
       // after erasure outer paths should be respected
-      ExplicitOuter.OuterOps(ctx).path(toCls = t.tpe.widen.classSymbol)
+      ExplicitOuter.OuterOps(ctx).path(toCls = t.tpe.classSymbol)
     case t =>
       t
   }

compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala

@@ -77,8 +77,8 @@ trait PatternTypeConstrainer { self: TypeComparer =>
 
     def classesMayBeCompatible: Boolean = {
       import Flags._
-      val patClassSym = pat.widenSingleton.classSymbol
-      val scrutClassSym = scrut.widenSingleton.classSymbol
+      val patClassSym = pat.classSymbol
+      val scrutClassSym = scrut.classSymbol
       !patClassSym.exists || !scrutClassSym.exists || {
         if (patClassSym.is(Final)) patClassSym.derivesFrom(scrutClassSym)
         else if (scrutClassSym.is(Final)) scrutClassSym.derivesFrom(patClassSym)

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -752,7 +752,7 @@ object TypeOps:
     // variance. As this logic is only needed in exhaustivity check,
     // we manually patch subtyping check instead of changing TypeComparer.
     // See tests/patmat/i3645b.scala
-    def parentQualify(tp1: Type, tp2: Type) = tp1.widen.classSymbol.info.parents.exists { parent =>
+    def parentQualify(tp1: Type, tp2: Type) = tp1.classSymbol.info.parents.exists { parent =>
       parent.argInfos.nonEmpty && approximateTypeParams(parent) <:< tp2
     }
 

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -437,8 +437,6 @@ object Types {
         if (sym.isClass) sym else tp.superType.classSymbol
       case tp: ClassInfo =>
         tp.cls
-      case tp: SingletonType =>
-        NoSymbol
       case tp: TypeProxy =>
         tp.underlying.classSymbol
       case AndType(l, r) =>

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

@@ -34,7 +34,7 @@ class ArrayConstructors extends MiniPhase {
     }
     else if ((tree.fun.symbol.maybeOwner eq defn.ArrayModule.moduleClass) && (tree.fun.symbol.name eq nme.ofDim) && !tree.tpe.isInstanceOf[MethodicType]) {
       val Apply(Apply(TypeApply(_, List(tp)), _), _) = tree
-      val cs = tp.tpe.widen.classSymbol
+      val cs = tp.tpe.classSymbol
       tree.fun match {
         case Apply(TypeApply(t: Ident, targ), dims)
           if !TypeErasure.isGeneric(targ.head.tpe) && !ValueClasses.isDerivedValueClass(cs) =>

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

@@ -287,7 +287,7 @@ object Erasure {
 
           cast(tree1, pt)
         case _ =>
-          val cls = pt.widen.classSymbol
+          val cls = pt.classSymbol
           if (cls eq defn.UnitClass) constant(tree, Literal(Constant(())))
           else {
             assert(cls ne defn.ArrayClass)
@@ -430,7 +430,7 @@ object Erasure {
           val implResultType = implType.resultType
           val samResultType = sam.resultType
 
-          if (!defn.isSpecializableFunction(implClosure.tpe.widen.classSymbol.asClass, implParamTypes, implResultType)) {
+          if (!defn.isSpecializableFunction(implClosure.tpe.classSymbol.asClass, implParamTypes, implResultType)) {
             def autoAdaptedParam(tp: Type) = !tp.isErasedValueType && !tp.isPrimitiveValueType
             val explicitSAMType = implClosure.tpt.tpe.exists
             def autoAdaptedResult(tp: Type) = !tp.isErasedValueType &&

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

@@ -398,7 +398,7 @@ object ExplicitOuter {
              count: Int = -1): Tree =
       try
         @tailrec def loop(tree: Tree, count: Int): Tree =
-          val treeCls = tree.tpe.widen.classSymbol
+          val treeCls = tree.tpe.classSymbol
           report.log(i"outer to $toCls of $tree: ${tree.tpe}, looking for ${atPhaseNoLater(lambdaLiftPhase)(outerAccName(treeCls.asClass))} in $treeCls")
           if (count == 0 || count < 0 && treeCls == toCls) tree
           else

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

@@ -28,7 +28,7 @@ class FunctionalInterfaces extends MiniPhase {
   private val functionPackage = "dotty.runtime.function.".toTermName
 
   override def transformClosure(tree: Closure)(using Context): Tree = {
-    val cls = tree.tpe.widen.classSymbol.asClass
+    val cls = tree.tpe.classSymbol.asClass
 
     val implType = tree.meth.tpe.widen
     val List(implParamTypes) = implType.paramInfoss

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

@@ -41,8 +41,8 @@ object TypeUtils {
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         val arity = tl.tupleArity
         if (arity < 0) arity else arity + 1
-      case self: TermRef if self.symbol == defn.EmptyTupleModule =>
-        0
+      case self: SingletonType =>
+        if self.termSymbol == defn.EmptyTupleModule then 0 else -1
       case self if defn.isTupleClass(self.classSymbol) =>
         self.dealias.argInfos.length
       case _ =>
@@ -53,7 +53,8 @@ object TypeUtils {
     def tupleElementTypes(using Context): List[Type] = self match {
       case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
         hd :: tl.tupleElementTypes
-      case self: TermRef if self.symbol == defn.EmptyTupleModule =>
+      case self: SingletonType =>
+        assert(self.termSymbol == defn.EmptyTupleModule, "not a tuple")
         Nil
       case self if defn.isTupleClass(self.classSymbol) =>
         self.dealias.argInfos

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -645,26 +645,22 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
 
   /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */
-  def canDecompose(tp: Type): Boolean = {
-    val dealiasedTp = tp.dealias
-    val res =
-      (tp.classSymbol.is(Sealed) &&
-        tp.classSymbol.isOneOf(AbstractOrTrait) &&
-        !tp.classSymbol.hasAnonymousChild &&
-        tp.classSymbol.children.nonEmpty ) ||
-      dealiasedTp.isInstanceOf[OrType] ||
-      (dealiasedTp.isInstanceOf[AndType] && {
-        val and = dealiasedTp.asInstanceOf[AndType]
-        canDecompose(and.tp1) || canDecompose(and.tp2)
-      }) ||
-      tp.isRef(defn.BooleanClass) ||
-      tp.isRef(defn.UnitClass) ||
-      tp.classSymbol.isAllOf(JavaEnumTrait)
-
+  def canDecompose(tp: Type): Boolean =
+    val res = tp.dealias match
+      case _: SingletonType => false
+      case _: OrType => true
+      case and: AndType => canDecompose(and.tp1) || canDecompose(and.tp2)
+      case _ =>
+        val cls = tp.classSymbol
+        cls.is(Sealed)
+        && cls.isOneOf(AbstractOrTrait)
+        && !cls.hasAnonymousChild
+        && cls.children.nonEmpty
+        || cls.isAllOf(JavaEnumTrait)
+        || tp.isRef(defn.BooleanClass)
+        || tp.isRef(defn.UnitClass)
     debug.println(s"decomposable: ${tp.show} = $res")
-
     res
-  }
 
   /** Show friendly type name with current scope in mind
    *
@@ -765,7 +761,8 @@ class SpaceEngine(using Context) extends SpaceLogic {
         if (flattenList && tp <:< scalaNilType) ""
         else tp.symbol.showName
       case Typ(tp, decomposed) =>
-        val sym = tp.widen.classSymbol
+
+        val sym = tp.classSymbol
 
         if (ctx.definitions.isTupleType(tp))
           params(tp).map(_ => "_").mkString("(", ", ", ")")

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -2039,7 +2039,7 @@ trait Applications extends Compatibility {
           case ConstantType(c: Constant) if c.tag == IntTag =>
             targetClass(ts1, cls, true)
           case t =>
-            val sym = t.widen.classSymbol
+            val sym = t.classSymbol
             if (!sym.isNumericValueClass || cls.exists && cls != sym) NoSymbol
             else targetClass(ts1, sym, intLitSeen)
         }

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -920,7 +920,7 @@ trait Checking {
       if (caller.is(Module)) {
         val traverser = new TreeTraverser {
           def traverse(tree: Tree)(using Context) = tree match {
-            case tree: RefTree if tree.isTerm && (tree.tpe.widen.classSymbol eq caller) =>
+            case tree: RefTree if tree.isTerm && (tree.tpe.classSymbol eq caller) =>
               report.error("super constructor cannot be passed a self reference", tree.srcPos)
             case _ =>
               traverseChildren(tree)

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -466,7 +466,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     val sortedProxies = thisProxy.toList.map {
       case (cls, proxy) =>
         // The class that the this-proxy `selfSym` represents
-        def classOf(selfSym: Symbol) = selfSym.info.widen.classSymbol
+        def classOf(selfSym: Symbol) = selfSym.info.classSymbol
         // The total nesting depth of the class represented by `selfSym`.
         def outerLevel(selfSym: Symbol): Int = classOf(selfSym).ownersIterator.length
         (outerLevel(cls), proxy.symbol)
@@ -1082,7 +1082,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
             scrut.widenTermRefExpr =:= pat.tpe
           case pat: RefTree =>
             scrut =:= pat.tpe ||
-            scrut.widen.classSymbol.is(Module) && scrut.widen =:= pat.tpe.widen && {
+            scrut.classSymbol.is(Module) && scrut.widen =:= pat.tpe.widen && {
               scrut.prefix match {
                 case _: SingletonType | NoPrefix => true
                 case _ => false

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -99,7 +99,7 @@ object RefChecks {
       def checkSelfConforms(other: ClassSymbol, category: String, relation: String) = {
         val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
         if otherSelf.exists && !(cinfo.selfType <:< otherSelf) then
-          report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other.classSymbol),
+          report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
             cls.srcPos)
       }
       val parents = cinfo.classParents

tests/neg/i6226.scala

@@ -7,6 +7,6 @@ object O2 {
 }
 
 object O3 { // error
-  opaque type R[X] = T[X]
+  opaque type R[X] = T[X] // error
   opaque type T[X] = R[X] // error
 }

tests/neg/i8337.scala

@@ -2,5 +2,5 @@ trait Foo[F <: Foo[F]]
 class Bar extends Foo[Bar]
 
 object Q {    // error: recursion limit exceeded
-  opaque type X <: Foo[X] = Bar // error: out of bounds
+  opaque type X <: Foo[X] = Bar // error: out of bounds // error
 }