More cleanups and removals of now redundant code

Author: odersky

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

@@ -1402,17 +1402,10 @@ object SymDenotations {
     }
 
     private def computeThisType(implicit ctx: Context): Type =
-      ThisType.raw(
-        TypeRef(if (this is Package) NoPrefix else owner.thisType, symbol.asType))
-/*      else {
-        val pre = owner.thisType
-        if (this is Module)
-          if (isMissing(pre)) TermRef(pre, sourceModule.asTerm)
-          else TermRef.withSig(pre, name.sourceModuleName, Signature.NotAMethod)
-        else ThisType.raw(TypeRef(pre, symbol.asType))
-      }
-*/
-    private[this] var myTypeRef: TypeRef = null   
+      ThisType.raw(TypeRef(
+          if (this is Package) NoPrefix else owner.thisType, symbol.asType))
+
+    private[this] var myTypeRef: TypeRef = null
 
     override def typeRef(implicit ctx: Context): TypeRef = {
       if (myTypeRef == null) myTypeRef = super.typeRef

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

@@ -532,8 +532,6 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           else tp.superType)
       case ErasedValueType(_, underlying) =>
         sigName(underlying)
-      case defn.ArrayOf(elem) => // @!!!
-        sigName(this(tp))
       case JavaArrayType(elem) =>
         sigName(elem) ++ "[]"
       case tp: TermRef =>

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

@@ -832,10 +832,6 @@ object Types {
       }
     }
 
-    /** Temporary replacement for baseTypeRef */
-    final def baseTypeTycon(base: Symbol)(implicit ctx: Context): Type = // @!!! drop
-      baseType(base).typeConstructor
-
     def & (that: Type)(implicit ctx: Context): Type = track("&") {
       ctx.typeComparer.glb(this, that)
     }
@@ -3488,24 +3484,10 @@ object Types {
   class CachedClassInfo(prefix: Type, cls: ClassSymbol, classParents: List[Type], decls: Scope, selfInfo: DotClass)
     extends ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
-  /** A class for temporary class infos where `parents` are not yet known. */
+  /** A class for temporary class infos where `parents` are not yet known. // @!!! eliminate? */
   final class TempClassInfo(prefix: Type, cls: ClassSymbol, decls: Scope, selfInfo: DotClass)
   extends CachedClassInfo(prefix, cls, Nil, decls, selfInfo) {
 
-    /** A list of actions that were because they rely on the class info of `cls` to
-     *  be no longer temporary. These actions will be performed once `cls` gets a real
-     *  ClassInfo.
-     */
-    private var suspensions: List[Context => Unit] = Nil
-
-    def addSuspension(suspension: Context => Unit): Unit = suspensions ::= suspension
-
-    /** Install classinfo with known parents in `denot` and resume all suspensions */ // @!!! elim
-    def finalize(denot: SymDenotation, parents: List[Type])(implicit ctx: Context) = {
-      denot.info = derivedClassInfo(classParents = parents)
-      suspensions.foreach(_(ctx))
-    }
-
     override def derivedClassInfo(prefix: Type)(implicit ctx: Context) =
       if (prefix eq this.prefix) this
       else new TempClassInfo(prefix, cls, decls, selfInfo)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -125,7 +125,6 @@ object Scala2Unpickler {
       registerCompanionPair(scalacCompanion, denot.classSymbol)
     }
 
-    tempInfo.finalize(denot, normalizedParents) // install final info, except possibly for typeparams ordering
     denot.ensureTypeParamsInCorrectOrder()
   }
 }

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -128,11 +128,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
   }
 
   /** The longest sequence of refinement types, starting at given type
-   *  and following parents, but stopping at applied types.
+   *  and following parents.
    */
   private def refinementChain(tp: Type): List[Type] =
     tp :: (tp match {
-      case AppliedType(_, _) => Nil // @!!!
       case tp: RefinedType => refinementChain(tp.parent.stripTypeVar)
       case _ => Nil
     })

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -62,10 +62,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   override def nameString(name: Name): String =
     if (ctx.settings.debugNames.value) name.debugString else name.toString
 
-  override protected def simpleNameString(sym: Symbol): String = {
-    val name = if (ctx.property(XprintMode).isEmpty) sym.originalName else sym.name
-    nameString(if (sym.is(TypeParam)) name.asTypeName.unexpandedName else name) // @!!!
-  }
+  override protected def simpleNameString(sym: Symbol): String =
+    nameString(if (ctx.property(XprintMode).isEmpty) sym.originalName else sym.name)
 
   override def fullNameString(sym: Symbol): String =
     if (isEmptyPrefix(sym.maybeOwner)) nameString(sym)

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

@@ -487,7 +487,7 @@ object Checking {
         ctx.error(ValueClassesMayNotWrapItself(clazz), clazz.pos)
       else {
         val clParamAccessors = clazz.asClass.paramAccessors.filter { param =>
-          param.isTerm && !param.is(Flags.Accessor) // @!!!
+          param.isTerm && !param.is(Flags.Accessor)
         }
         clParamAccessors match {
           case List(param) =>
@@ -565,29 +565,26 @@ trait Checking {
    *  are feasible, i.e. that their lower bound conforms to their upper bound. If a type
    *  argument is infeasible, issue and error and continue with upper bound.
    */
-  def checkFeasibleParent(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type =
+  def checkFeasibleParent(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = {
+    def checkGoodBounds(tp: Type) = tp match {
+      case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
+        ctx.error(ex"no type exists between low bound $lo and high bound $hi$where", pos)
+        TypeBounds(hi, hi)
+      case _ =>
+        tp
+    }
     tp match {
       case tp @ AndType(tp1, tp2) =>
         ctx.error(s"conflicting type arguments$where", pos)
         tp1
       case tp @ AppliedType(tycon, args) =>
-        def checkArg(arg: Type) = arg match {
-          case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
-            ctx.error(ex"no type exists between low bound $lo and high bound $hi$where", pos)
-            hi
-          case _ => arg
-        }
-        tp.derivedAppliedType(tycon, args.mapConserve(checkArg))
-      case tp: RefinedType => // @!!!
-        tp.derivedRefinedType(tp.parent, tp.refinedName, checkFeasibleParent(tp.refinedInfo, pos, where))
-      case tp: RecType => // @!!!
-        tp.rebind(tp.parent)
-      case tp @ TypeBounds(lo, hi) if !(lo <:< hi) => // @!!!
-        ctx.error(ex"no type exists between low bound $lo and high bound $hi$where", pos)
-        TypeAlias(hi)
+        tp.derivedAppliedType(tycon, args.mapConserve(checkGoodBounds))
+      case tp: RefinedType =>
+        tp.derivedRefinedType(tp.parent, tp.refinedName, checkGoodBounds(tp.refinedInfo))
       case _ =>
         tp
     }
+  }
 
   /** Check that `tree` is a pure expression of constant type */
   def checkInlineConformant(tree: Tree, what: => String)(implicit ctx: Context): Unit =

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

@@ -916,8 +916,6 @@ class Namer { typer: Typer =>
       val parentTypes = ensureFirstIsClass(parents.map(checkedParentType(_)), cls.pos)
       typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")
 
-      tempInfo.finalize(denot, parentTypes)
-
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
       cls.info = avoidPrivateLeaks(cls, cls.pos)

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

@@ -85,7 +85,6 @@ object RefChecks {
    */
   private def upwardsThisType(cls: Symbol)(implicit ctx: Context) = cls.info match {
     case ClassInfo(_, _, _, _, tp: Type) if (tp ne cls.typeRef) && !cls.is(ModuleOrFinal) =>
-    // @!!! case ClassInfo(_, _, _, _, selfTp: Type) if selfTp.exists && !cls.is(ModuleOrFinal) =>
       SkolemType(cls.typeRef).withName(nme.this_)
     case _ =>
       cls.thisType