More cleanups

Author: odersky

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

@@ -426,43 +426,6 @@ object SymDenotations {
       case _ => unforcedDecls.openForMutations
     }
 
-    /** If this is a synthetic opaque type alias, mark it as Deferred with bounds
-     *  as given by the right hand side's `WithBounds` annotation, if one is present,
-     *  or with empty bounds of the right kind, otherwise.
-     *  At the same time, integrate the original alias as a refinement of the
-     *  self type of the enclosing class.
-     */
-    final def normalizeOpaque()(implicit ctx: Context) = {
-      def abstractRHS(tp: Type): Type = tp match {
-        case tp: HKTypeLambda => tp.derivedLambdaType(resType = abstractRHS(tp.resType))
-        case _ => defn.AnyType
-      }
-      if (isOpaqueAlias)
-        info match {
-          case TypeAlias(alias) =>
-            val (refiningAlias, bounds) = alias match {
-              case AnnotatedType(alias1, Annotation.WithBounds(bounds)) =>
-              	(alias1, bounds)
-              case _ =>
-              	(alias, TypeBounds(defn.NothingType, abstractRHS(alias)))
-            }
-            def refineSelfType(selfType: Type) =
-              RefinedType(selfType, name, TypeAlias(refiningAlias))
-            val enclClassInfo = owner.asClass.classInfo
-            enclClassInfo.selfInfo match {
-              case self: Type =>
-                owner.info = enclClassInfo.derivedClassInfo(
-                  selfInfo = refineSelfType(self.orElse(defn.AnyType)))
-              case self: Symbol =>
-                self.info = refineSelfType(self.info)
-            }
-            info = bounds
-            setFlag(Deferred)
-            typeRef.recomputeDenot()
-          case _ =>
-        }
-    }
-
     /** If this is an opaque alias, replace the right hand side `info`
      *  by appropriate bounds and store `info` in the refinement of the
      *  self type of the enclosing class.

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -838,8 +838,7 @@ class TreeUnpickler(reader: TastyReader,
                 case _: TypeBounds | _: ClassInfo => checkNonCyclic(sym, rhs.tpe, reportErrors = false)
                 case _ => rhs.tpe.toBounds
             }
-            if sym.isOpaqueAlias then
-              sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
+            if sym.isOpaqueAlias then sym.typeRef.recomputeDenot() // make sure we see the new bounds from now on
             sym.resetFlag(Provisional)
             TypeDef(rhs)
           }

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

@@ -1156,9 +1156,9 @@ class Namer { typer: Typer =>
      *  accessors, that's why the constructor needs to be completed before
      *  the parent types are elaborated.
      */
-    def completeConstructor(denot: SymDenotation): TempClassInfo = {
+    def completeConstructor(denot: SymDenotation): Unit = {
       if (tempInfo != null) // Constructor has been completed already
-        return tempInfo
+        return
 
       addAnnotations(denot.symbol)
 
@@ -1191,7 +1191,6 @@ class Namer { typer: Typer =>
 
       tempInfo = denot.asClass.classInfo.integrateOpaqueMembers.asInstanceOf[TempClassInfo]
       denot.info = savedInfo
-      tempInfo
     }
 
     /** The type signature of a ClassDef with given symbol */

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

@@ -1832,23 +1832,6 @@ class Typer extends Namer
         ctx.featureWarning(nme.dynamics.toString, "extension of type scala.Dynamic", cls, isRequired, cdef.sourcePos)
       }
 
-      // TODO: Drop or use
-      def simplifyOpaques(tp: Type): Type = tp match
-        case tp @ RefinedType(parent, name, alias @ TypeAlias(lzy: LazyRef)) =>
-          tp.derivedRefinedType(simplifyOpaques(parent), name,
-            alias.derivedAlias(lzy.ref))
-        case _ =>
-          tp
-
-      if false && cls.containsOpaques then
-        val cinfo = cls.classInfo
-        cinfo.selfInfo match
-          case self: Type =>
-            cls.info = cinfo.derivedClassInfo(selfInfo = simplifyOpaques(self))
-          case self: Symbol =>
-            self.info = simplifyOpaques(self.info)
-        //println(i"simplified: $cls with ${cls.classInfo.selfInfo}")
-
       checkNonCyclicInherited(cls.thisType, cls.classParents, cls.info.decls, cdef.posd)
 
       // check value class constraints