Cleanups

Author: odersky

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

@@ -817,7 +817,7 @@ class TreeUnpickler(reader: TastyReader,
             if (companion.exists && isCodefined) sym.registerCompanion(companion)
             TypeDef(readTemplate(localCtx))
           } else {
-            sym.info = TypeBounds.empty // needed to avoid cyclic references when unpicklin rhs, see i3816.scala
+            sym.info = TypeBounds.empty // needed to avoid cyclic references when unpickling rhs, see i3816.scala
             sym.setFlag(Provisional)
             val rhs = readTpt()(localCtx)
             sym.info = new NoCompleter {
@@ -828,8 +828,8 @@ class TreeUnpickler(reader: TastyReader,
               case _: TypeBounds | _: ClassInfo => checkNonCyclic(sym, rhs.tpe, reportErrors = false)
               case _ => rhs.tpe.toBounds
             }
-            sym.resetFlag(Provisional)
             sym.normalizeOpaque()
+            sym.resetFlag(Provisional)
             TypeDef(rhs)
           }
         case PARAM =>

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

@@ -47,6 +47,10 @@ class ElimOpaque extends MiniPhase with DenotTransformer {
           info = cinfo.derivedClassInfo(selfInfo = strippedSelfType),
           initFlags = ref.flags &~ Opaque)
       case _ =>
+        // This is dubbious as it means that we do not see the alias from an external reference
+        // which has tupe UniqueRefDenotion instead of SymDenotation. But to correctly recompote
+        // the alias we'd need a prefix, which we do not have here. To fix this, we'd have to
+        // maintain a prefix in UniqueRefDenotations and JointRefDenotations.
         ref
     }
   }

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

@@ -1467,21 +1467,18 @@ class Namer { typer: Typer =>
       sym.info = NoCompleter
       sym.info = checkNonCyclic(sym, unsafeInfo, reportErrors = true)
     }
+    sym.normalizeOpaque()
     sym.resetFlag(Provisional)
 
     // Here we pay the price for the cavalier setting info to TypeBounds.empty above.
     // We need to compensate by reloading the denotation of references that might
     // still contain the TypeBounds.empty. If we do not do this, stdlib factories
     // fail with a bounds error in PostTyper.
-    def ensureUpToDate(tp: Type, outdated: Type) = tp match {
-      case tref: TypeRef if tref.info == outdated && sym.info != outdated =>
-        tref.recomputeDenot()
-      case _ =>
-    }
-    sym.normalizeOpaque()
+    def ensureUpToDate(tref: TypeRef, outdated: Type) =
+      if (tref.info == outdated && sym.info != outdated) tref.recomputeDenot()
     ensureUpToDate(sym.typeRef, dummyInfo1)
     if (dummyInfo2 `ne` dummyInfo1) ensureUpToDate(sym.typeRef, dummyInfo2)
-    ensureUpToDate(sym.typeRef.appliedTo(tparamSyms.map(_.typeRef)), TypeBounds.empty)
+
     sym.info
   }
 }

tests/neg/no-self-leaks.scala

@@ -0,0 +1,18 @@
+trait C { this: { type T = Int } =>
+
+  type T
+  val x: T
+}
+
+class D extends C {
+  type T = Int
+  val x = 10
+}
+
+object Test {
+
+  val c: C = new D
+  val y: c.T = c.x
+  val x: Int = c.x   // error
+  val z: Int = y     // error
+}

tests/neg/simple-opaque.scala

@@ -0,0 +1,24 @@
+object o {
+
+  opaque type T = Int
+  val x: T = 322
+
+  def toT(x: Int): T = x
+
+  object oo {
+    def apply222(x: Int): T = x
+  }
+}
+
+object Test {
+
+  val y: o.T = o.x
+  val x: Int = o.x   // error
+  val z: Int = y     // error
+
+  val t = o.toT(11)
+  val i: Int = t     // error
+
+  val t2: o.T = o.oo.apply222(22)
+  val i2: Int = t2   // error
+}

tests/neg/toplevel-cyclic/defs_1.scala

@@ -1,2 +1,2 @@
-type A = B  // error: recursion limit exceeded
+type A = B  // error: recursion limit exceeded // error: recursion limit exceeded