Partially reverting of 08c6eac

Partial revert of 08c6eac "this type is a term ref to the source module". The problem with
doing this is that it introduces spurious outer references. An inner module that contains
self referenves always needs the directly enclosing class. The revert avoids this dependency
by making ThisTypes always point to TypeRefs.

Several other changes were necessary to make the builds pass: TypeRefs had to get prefixes after
erasure so that they can be reloaded. Symbols of such typerefs had to be retrieved without forcing
a denotation.

One test (blockescapes.scala) fails and is moved to pending, awaiting further resolution.

Also two other new tests in pending which currently fail (and have failed before).

Author: odersky

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

@@ -1026,16 +1026,16 @@ object SymDenotations {
     }
 
     private def computeThisType(implicit ctx: Context): Type =
-      if (this is Package)
-        ThisType.raw(TypeRef(NoPrefix, symbol.asType))
-      else {
+      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
 
     override def typeRef(implicit ctx: Context): TypeRef = {

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

@@ -1253,6 +1253,14 @@ object Types {
       else denot.symbol
     }
 
+    /** Retrieves currently valid symbol without necessarily updating denotation.
+     *  Assumes that symbols do not change between periods in the same run.
+     *  Used to get the class underlying a ThisType.
+     */
+    private[Types] def stableInRunSymbol(implicit ctx: Context): Symbol =
+      if (checkedPeriod.runId == ctx.runId) lastSymbol
+      else symbol
+
     def info(implicit ctx: Context): Type = denot.info
 
     def isType = isInstanceOf[TypeRef]
@@ -1526,7 +1534,7 @@ object Types {
   object TypeRef {
     /** Create type ref with given prefix and name */
     def apply(prefix: Type, name: TypeName)(implicit ctx: Context): TypeRef =
-      ctx.uniqueNamedTypes.enterIfNew(atCurrentPhase(prefix), name).asInstanceOf[TypeRef]
+      ctx.uniqueNamedTypes.enterIfNew(prefix, name).asInstanceOf[TypeRef]
 
     /** Create type ref to given symbol */
     def apply(prefix: Type, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
@@ -1536,7 +1544,7 @@ object Types {
      *  with given prefix, name, and symbol.
      */
     def withNonMemberSym(prefix: Type, name: TypeName, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
-      unique(new NonMemberTypeRef(atCurrentPhase(prefix), name, sym))
+      unique(new NonMemberTypeRef(prefix, name, sym))
 
     /** Create a type ref referring to given symbol with given name.
      *  This is very similar to TypeRef(Type, Symbol),
@@ -1545,12 +1553,12 @@ object Types {
      *  (2) The name in the type ref need not be the same as the name of the Symbol.
      */
     def withSymAndName(prefix: Type, sym: TypeSymbol, name: TypeName)(implicit ctx: Context): TypeRef =
-      if (isMissing(prefix)) withNonMemberSym(prefix, name, sym)
+      if (prefix eq NoPrefix) withNonMemberSym(prefix, name, sym)
       else apply(prefix, name).withSym(sym, Signature.NotAMethod)
 
     /** Create a type ref with given name and initial denotation */
     def apply(prefix: Type, name: TypeName, denot: Denotation)(implicit ctx: Context): TypeRef =
-      (if (isMissing(prefix)) apply(prefix, denot.symbol.asType) else apply(prefix, name)) withDenot denot
+      (if (prefix eq NoPrefix) apply(prefix, denot.symbol.asType) else apply(prefix, name)) withDenot denot
   }
 
   // --- Other SingletonTypes: ThisType/SuperType/ConstantType ---------------------------
@@ -1561,7 +1569,7 @@ object Types {
    *  do not survive runs whereas typerefs do.
    */
   abstract case class ThisType(tref: TypeRef) extends CachedProxyType with SingletonType {
-    def cls(implicit ctx: Context): ClassSymbol = tref.symbol.asClass
+    def cls(implicit ctx: Context): ClassSymbol = tref.stableInRunSymbol.asClass
     override def underlying(implicit ctx: Context): Type =
       if (ctx.erasedTypes) tref else cls.classInfo.selfType
     override def computeHash = doHash(tref)

test/dotc/tests.scala

@@ -26,7 +26,7 @@ class tests extends CompilerTest {
 
   @Test def pos_erasure = compileFile(posDir, "erasure", doErase)
   @Test def pos_Coder() = compileFile(posDir, "Coder", doErase)
-  @Test def pos_blockescapes() = compileFile(posDir, "blockescapes", doErase)
+ // @Test def pos_blockescapes() = compileFile(posDir, "blockescapes", doErase)
   @Test def pos_collections() = compileFile(posDir, "collections", doErase)
   @Test def pos_functions1() = compileFile(posDir, "functions1", doErase)
   @Test def pos_implicits1() = compileFile(posDir, "implicits1", doErase)

tests/pos/blockescapes.scala renamed to tests/pending/pos/blockescapes.scala

@@ -0,0 +1,5 @@
+object test {
+
+  def foo(x: Int) = x + 1 ensuring { y => y >= 0 }
+
+}

tests/pending/pos/ensuring.scala

@@ -0,0 +1,12 @@
+object test {
+
+  class B
+  class C
+
+  def tag[T](x: T): String & T = ???
+
+  val x: Int & String = tag(0)
+
+}
+
+