TypeAssigner#avoid: more precise types for inner classes

When we need to avoid `A` in the class `A#B`, we can try to replace `A`
by a supertype. Previously, we only tried to replace `A#B` itself by a
supertype.

Fixes scala#711.

Author: smarter

src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -52,14 +52,20 @@ trait TypeAssigner {
         case _ =>
           false
       }
-      def apply(tp: Type) = tp match {
+      def apply(tp: Type): Type = tp match {
         case tp: TermRef if toAvoid(tp) && variance > 0 =>
           apply(tp.info.widenExpr)
         case tp: TypeRef if (forbidden contains tp.symbol) || toAvoid(tp.prefix) =>
           tp.info match {
             case TypeAlias(ref) =>
               apply(ref)
             case info: ClassInfo if variance > 0 =>
+              if (!(forbidden contains tp.symbol)) {
+                val prefix = apply(tp.prefix)
+                val tp1 = tp.derivedSelect(prefix)
+                if (tp1.typeSymbol eq tp.symbol)
+                  return tp1
+              }
               val parentType = info.instantiatedParents.reduceLeft(ctx.typeComparer.andType(_, _))
               def addRefinement(parent: Type, decl: Symbol) = {
                 val inherited =

tests/pos/escapingRefs.scala

@@ -0,0 +1,12 @@
+class Outer {
+  class Inner
+}
+
+object Test {
+  def test = {
+    val a: Outer#Inner = {
+      val o = new Outer
+      new o.Inner
+    }
+  }
+}