Resolve previously marked issues

Author: odersky

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

@@ -767,7 +767,6 @@ object SymDenotations {
       isPackageObject ||
       isTerm && !is(MethodOrLazy, butNot = Label) && !isLocalDummy
 
-    //    def isOverridable: Boolean = !!! need to enforce that classes cannot be redefined
     def isSkolem: Boolean = name == nme.SKOLEM
 
     def isInlineMethod(implicit ctx: Context): Boolean = is(InlineMethod, butNot = Accessor)
@@ -1673,7 +1672,7 @@ object SymDenotations {
 
       /*>|>*/ trace.onDebug(s"$tp.baseType($this)") /*<|<*/ {
         Stats.record("baseTypeOf")
-        tp.stripTypeVar match { // @!!! dealias?
+        tp.stripTypeVar match {
           case tp: CachedType =>
           val btrCache = baseTypeCache
             try {

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

@@ -63,8 +63,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
             toPrefix(pre, cls, tp.cls)
           case _: BoundType | NoPrefix =>
             tp
-          case tp: RefinedType =>  //@!!! todo: remove
-            derivedRefinedType(tp, apply(tp.parent), apply(tp.refinedInfo))
           case _ =>
             mapOver(tp)
         }
@@ -101,8 +99,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       }
     case  _: ThisType | _: BoundType | NoPrefix =>
       tp
-    case tp: RefinedType => // @!!!
-      tp.derivedRefinedType(simplify(tp.parent, theMap), tp.refinedName, simplify(tp.refinedInfo, theMap))
     case tp: TypeAlias =>
       tp.derivedTypeAlias(simplify(tp.alias, theMap))
     case AndType(l, r) if !ctx.mode.is(Mode.Type) =>

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

@@ -3434,23 +3434,10 @@ object Types {
         val cls = tp.cls
         // Note: Taking a normal typeRef does not work here. A normal ref might contain
         // also other information about the named type (e.g. bounds).
-        if (true) { // ###
-        val loOK =
-          lo.isRef(tp.cls) ||
-          lo.isRef(defn.NothingClass) ||
-          lo.isRef(defn.NullClass) && !tp.cls.isValueClass
-        val hiOK =
-          hi.isRef(tp.cls) ||
-          tp.parents.exists(p => p <:< hi)
-        loOK && hiOK || {
-          println(i"NOT CONTAINS: $this / $tp")
-          false
-        }
-        }
-        else contains(
-          TypeRef(tp.prefix, cls)
-            .withDenot(new UniqueRefDenotation(cls, tp, cls.validFor)))
-      case _ => lo <:< tp && tp <:< hi
+        contains(
+          TypeRef(tp.prefix, cls).withDenot(new UniqueRefDenotation(cls, tp, cls.validFor)))
+      case _ =>
+        lo <:< tp && tp <:< hi
     }
 
     def & (that: TypeBounds)(implicit ctx: Context): TypeBounds =

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

@@ -728,7 +728,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
               }
             }
           case NoPrefix if sym is TypeParam =>
-            pre = sym.owner.thisType // ### needed?
+            pre = sym.owner.thisType
           case _ =>
         }
         val tycon = pre.select(sym)

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

@@ -85,6 +85,4 @@ class ParamForwarding(thisPhase: DenotTransformer) {
 
     cpy.Template(impl)(body = fwd(impl.body)(ctx.withPhase(thisPhase)))
   }
-
-  def adaptRef[T <: RefTree](tree: T)(implicit ctx: Context): T = tree // ###
 }

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

@@ -79,12 +79,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     // TODO fill in
   }
 
-  /** If the type of `tree` is a TermRef with an underdefined
-   *  signature, narrow the type by re-computing the signature (which should
-   *  be fully-defined by now).
-   */
-  private def fixSignature[T <: Tree](tree: T)(implicit ctx: Context): T = tree // ###
-
   class PostTyperTransformer extends Transformer {
 
     private[this] var inJavaAnnot: Boolean = false
@@ -170,15 +164,15 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case tree: Ident if !tree.isType =>
           tree.tpe match {
             case tpe: ThisType => This(tpe.cls).withPos(tree.pos)
-            case _ => paramFwd.adaptRef(fixSignature(tree))
+            case _ => tree
           }
         case tree @ Select(qual, name) =>
           if (name.isTypeName) {
             Checking.checkRealizable(qual.tpe, qual.pos.focus)
             super.transform(tree)
           }
           else
-            transformSelect(paramFwd.adaptRef(fixSignature(tree)), Nil)
+            transformSelect(tree, Nil)
         case tree: Super =>
           if (ctx.owner.enclosingMethod.isInlineMethod)
             ctx.error(SuperCallsNotAllowedInline(ctx.owner), tree.pos)

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

@@ -754,7 +754,7 @@ class Namer { typer: Typer =>
           else levels(c.outer) + 1
         println(s"!!!completing ${denot.symbol.showLocated} in buried typerState, gap = ${levels(ctx)}")
       }
-      assert(ctx.runId == creationContext.runId, "completing $denot in wrong run ${ctx.runId}, was created in ${creationContext.runId}")
+      assert(ctx.runId == creationContext.runId, s"completing $denot in wrong run ${ctx.runId}, was created in ${creationContext.runId}")
       completeInCreationContext(denot)
     }