Fix #1990: Handle inlining where this proxies change types

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

@@ -60,7 +60,7 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf
   /** Convert a selection of the form `qual.C_<OUTER>` to an outer path from `qual` to `C` */
   override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo) =
     if (tree.name.isOuterSelect)
-      outer.path(tree.tpe.widen.classSymbol, tree.qualifier).ensureConforms(tree.tpe)
+      outer.path(tree.tpe.widen.classSymbol, tree.qualifier, outOfContext = true).ensureConforms(tree.tpe)
     else tree
 
   /** First, add outer accessors if a class does not have them yet and it references an outer this.
@@ -355,14 +355,21 @@ object ExplicitOuter {
     }
 
     /** The path of outer accessors that references `toCls.this` starting from
-     *  the context owner's this node.
+     *  node `start`, which defaults to the context owner's this node.
+     *  @param  outOfContext  When true, we take the `path` in code that has been inlined
+     *                        from somewhere else. In that case, we need to stop not
+     *                        just when `toCls` is reached exactly, but also in any superclass
+     *                        of `treeCls`. This compensates the `asSeenFrom` logic
+     *                        used to compute this-proxies in Inliner.
      */
-    def path(toCls: Symbol, start: Tree = This(ctx.owner.lexicallyEnclosingClass.asClass)): Tree = try {
+    def path(toCls: Symbol,
+             start: Tree = This(ctx.owner.lexicallyEnclosingClass.asClass),
+             outOfContext: Boolean = true): Tree = try {
       def loop(tree: Tree): Tree = {
         val treeCls = tree.tpe.widen.classSymbol
         val outerAccessorCtx = ctx.withPhaseNoLater(ctx.lambdaLiftPhase) // lambdalift mangles local class names, which means we cannot reliably find outer acessors anymore
         ctx.log(i"outer to $toCls of $tree: ${tree.tpe}, looking for ${outerAccName(treeCls.asClass)(outerAccessorCtx)} in $treeCls")
-        if (treeCls == toCls) tree
+        if (treeCls == toCls || outOfContext && toCls.derivesFrom(treeCls)) tree
         else {
           val acc = outerAccessor(treeCls.asClass)(outerAccessorCtx)
           assert(acc.exists,

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

@@ -12,6 +12,7 @@ import core.Types._
 import core.Flags._
 import core.Constants._
 import core.StdNames._
+import core.NameOps._
 import core.Decorators._
 import core.TypeErasure.isErasedType
 import core.Phases.Phase
@@ -336,7 +337,10 @@ class TreeChecker extends Phase with SymTransformer {
       assert(tree.isTerm || !ctx.isAfterTyper, tree.show + " at " + ctx.phase)
       val tpe = tree.typeOpt
       val sym = tree.symbol
-      if (!tpe.isInstanceOf[WithFixedSym] && sym.exists && !sym.is(Private)) {
+      if (!tpe.isInstanceOf[WithFixedSym] &&
+          sym.exists && !sym.is(Private) &&
+          !tree.name.isOuterSelect // outer selects have effectively fixed symbols
+          ) {
         val qualTpe = tree.qualifier.typeOpt
         val member =
           if (sym.is(Private)) qualTpe.member(tree.name)

tests/pos/i1990.scala

@@ -0,0 +1,12 @@
+class A {
+  class Foo {
+    inline def inlineMeth: Unit = {
+      new Bar
+    }
+  }
+  class Bar
+}
+
+class B extends A {
+  (new Foo).inlineMeth
+}

tests/run/builder.check

@@ -0,0 +1 @@
+Table(Row(Cell(A1), Cell(B1)), Row(Cell(A2), Cell(B2)))

tests/run/builder.scala

@@ -0,0 +1,51 @@
+import collection.mutable.ArrayBuffer
+
+class Table {
+  val rows = new ArrayBuffer[Row]
+  def add(r: Row): Unit = rows += r
+  override def toString = rows.mkString("Table(", ", ", ")")
+}
+
+class Row {
+  val cells = new ArrayBuffer[Cell]
+  def add(c: Cell): Unit = cells += c
+  override def toString = cells.mkString("Row(", ", ", ")")
+}
+
+class Cell(elem: String) {
+  override def toString = s"Cell($elem)"
+}
+
+object Test {
+
+  def table(init: implicit Table => Unit) = {
+    implicit val t = new Table
+    init
+    t
+  }
+
+  def row(init: implicit Row => Unit)(implicit t: Table) = {
+    implicit val r = new Row
+    init
+    t.add(r)
+  }
+
+  def cell(str: String)(implicit r: Row) =
+    r.add(new Cell(str))
+
+  val data =
+    table {
+      row {
+        cell("A1")
+        cell("B1")
+      }
+      row {
+        cell("A2")
+        cell("B2")
+      }
+    }
+
+  def main(args: Array[String]) = {
+    println(data)
+  }
+}