WIP widen2

Author: odersky

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -558,7 +558,7 @@ class ClassfileParser(
 
   class ClassfileAnnotation(annotType: Type, args: List[untpd.Tree]) extends LazyAnnotation {
     protected var mySym: Symbol | (Context ?=> Symbol) =
-      (using ctx: Context) => annotType.classSymbol
+      (using ctx: Context) => annotType.widen.classSymbol
 
     protected var myTree: Tree | (Context ?=> Tree) =
       (using ctx: Context) => untpd.resolveConstructor(annotType, args)

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

@@ -723,7 +723,7 @@ object PatternMatcher {
 
           def outerTest: Tree = thisPhase.transformFollowingDeep {
             val expectedOuter = singleton(expectedTp.normalizedPrefix)
-            val expectedClass = expectedTp.dealias.classSymbol.asClass
+            val expectedClass = expectedTp.dealias.widen.classSymbol.asClass
             ExplicitOuter.ensureOuterAccessors(expectedClass)
             scrutinee.ensureConforms(expectedTp)
               .outerSelect(1, expectedClass.owner.typeRef)

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

@@ -465,7 +465,7 @@ object Splicer {
         }
         def javaArraySig(tpe: Type): String = {
           val (elemType, depth) = arrayDepth(tpe, 0)
-          val sym = elemType.classSymbol
+          val sym = elemType.widen.classSymbol
           val suffix =
             if (sym == defn.BooleanClass) "Z"
             else if (sym == defn.ByteClass) "B"
@@ -482,12 +482,12 @@ object Splicer {
           case tpe: JavaArrayType => javaArraySig(tpe)
           case _ =>
             // Take the flatten name of the class and the full package name
-            val pack = tpe.classSymbol.topLevelClass.owner
+            val pack = tpe.widen.classSymbol.topLevelClass.owner
             val packageName = if (pack == defn.EmptyPackageClass) "" else s"${pack.fullName}."
-            packageName + tpe.classSymbol.fullNameSeparated(FlatName).toString
+            packageName + tpe.widen.classSymbol.fullNameSeparated(FlatName).toString
         }
 
-        val sym = param.classSymbol
+        val sym = param.widen.classSymbol
         if (sym == defn.BooleanClass) classOf[Boolean]
         else if (sym == defn.ByteClass) classOf[Byte]
         else if (sym == defn.CharClass) classOf[Char]

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

@@ -95,7 +95,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       if (isDerivedValueClass(clazz)) clazz.paramAccessors.take(1) // Tail parameters can only be `erased`
       else clazz.caseAccessors
     val isEnumCase = clazz.derivesFrom(defn.EnumClass) && clazz != defn.EnumClass
-    val isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.classSymbol.is(Enum)
+    val isEnumValue = isEnumCase && clazz.isAnonymousClass && clazz.classParents.head.widen.classSymbol.is(Enum)
     val isNonJavaEnumValue = isEnumValue && !clazz.derivesFrom(defn.JavaEnumClass)
 
     val symbolsToSynthesize: List[Symbol] =
@@ -302,7 +302,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     def chooseHashcode(using Context) =
       if (clazz.is(ModuleClass))
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString.hashCode))
-      else if (accessors.exists(_.info.finalResultType.classSymbol.isPrimitiveValueClass))
+      else if (accessors.exists(_.info.finalResultType.widen.classSymbol.isPrimitiveValueClass))
         caseHashCodeBody
       else
         ref(defn.ScalaRuntime__hashCode).appliedTo(This(clazz))
@@ -576,9 +576,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
       makeSingletonMirror()
     else if (impl.removeAttachment(ExtendsProductMirror).isDefined)
-      makeProductMirror(monoType.typeRef.dealias.classSymbol)
+      makeProductMirror(monoType.typeRef.dealias.widen.classSymbol)
     else if (impl.removeAttachment(ExtendsSumMirror).isDefined)
-      makeSumMirror(monoType.typeRef.dealias.classSymbol)
+      makeSumMirror(monoType.typeRef.dealias.widen.classSymbol)
 
     cpy.Template(impl)(parents = newParents, body = newBody)
   }

compiler/src/dotty/tools/dotc/transform/init/Checking.scala

@@ -142,7 +142,7 @@ object Checking {
         checkConstructor(ctor.symbol, parent.tpe, parent)
 
       case ref =>
-        val cls = ref.tpe.classSymbol.asClass
+        val cls = ref.tpe.widen.classSymbol.asClass
         if (!state.parentsInited.contains(cls) && cls.primaryConstructor.exists)
           checkConstructor(cls.primaryConstructor, ref.tpe, ref)
     }

compiler/src/dotty/tools/dotc/transform/init/Summarization.scala

@@ -83,7 +83,7 @@ object Summarization {
         }
 
         val tref = typeRefOf(tpt.tpe)
-        val cls = tref.classSymbol.asClass
+        val cls = tref.widen.classSymbol.asClass
         // local class may capture, thus we need to track it
         if (tref.prefix == NoPrefix) {
           val cur = theCtx.owner.lexicallyEnclosingClass.asClass
@@ -305,7 +305,7 @@ object Summarization {
 
           case ref =>
             val tref: TypeRef = ref.tpe.typeConstructor.asInstanceOf
-            val cls = tref.classSymbol.asClass
+            val cls = tref.widen.classSymbol.asClass
             if (cls == defn.AnyClass || cls == defn.AnyValClass) Effects.empty
             else {
               val ctor = cls.primaryConstructor
@@ -326,7 +326,7 @@ object Summarization {
   def classSummary(cls: ClassSymbol)(implicit env: Env): ClassSummary = trace("summarizing " + cls.show, init) {
     def extractParentOuters(parent: Type, source: Tree): (ClassSymbol, Potentials) = {
       val tref = parent.typeConstructor.stripAnnots.asInstanceOf[TypeRef]
-      val parentCls = tref.classSymbol.asClass
+      val parentCls = tref.widen.classSymbol.asClass
       val env2: Env = env.withOwner(cls.owner.lexicallyEnclosingClass)
       if (tref.prefix != NoPrefix)
         parentCls -> analyze(tref.prefix, source)(env2)._1

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

@@ -910,7 +910,7 @@ trait Checking {
 
   def checkParentCall(call: Tree, caller: ClassSymbol)(using Context): Unit =
     if (!ctx.isAfterTyper) {
-      val called = call.tpe.classSymbol
+      val called = call.tpe.widen.classSymbol
       if (caller.is(Trait))
         report.error(i"$caller may not call constructor of $called", call.srcPos)
       else if (called.is(Trait) && !caller.mixins.contains(called))

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

@@ -83,7 +83,7 @@ trait Deriving {
     private def processDerivedInstance(derived: untpd.Tree): Unit = {
       val originalTypeClassType = typedAheadType(derived, AnyTypeConstructorProto).tpe
       val typeClassType = checkClassType(underlyingClassRef(originalTypeClassType), derived.srcPos, traitReq = false, stablePrefixReq = true)
-      val typeClass = typeClassType.classSymbol
+      val typeClass = typeClassType.widen.classSymbol
       val typeClassParams = typeClass.typeParams
       val typeClassArity = typeClassParams.length
 

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

@@ -1101,7 +1101,7 @@ trait Implicits:
       else ViewProto(wildApprox(argument.tpe.widen), wildApprox(pt))
         // Not clear whether we need to drop the `.widen` here. All tests pass with it in place, though.
 
-    val isNot: Boolean = wildProto.classSymbol == defn.NotClass
+    val isNot: Boolean = wildProto.widen.classSymbol == defn.NotClass
 
     /** Try to type-check implicit reference, after checking that this is not
       * a diverging search

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

@@ -336,7 +336,7 @@ object Inferencing {
   def companionRef(tp: Type)(using Context): Type =
     tp.underlyingClassRef(refinementOK = true) match {
       case tp: TypeRef =>
-        val companion = tp.classSymbol.companionModule
+        val companion = tp.widen.classSymbol.companionModule
         if (companion.exists)
           companion.termRef.asSeenFrom(tp.prefix, companion.owner)
         else NoType
@@ -356,7 +356,7 @@ object Inferencing {
       else if (v == -1) tvar.instantiate(fromBelow = true)
       else {
         val bounds = TypeComparer.fullBounds(tvar.origin)
-        if (bounds.hi <:< bounds.lo || bounds.hi.classSymbol.is(Final) || fromScala2x)
+        if (bounds.hi <:< bounds.lo || bounds.hi.widen.classSymbol.is(Final) || fromScala2x)
           tvar.instantiate(fromBelow = false)
         else {
           // We do not add the created symbols to GADT constraint immediately, since they may have inter-dependencies.