Sharpen condition when to elide this during inlining

This fixes the second half of #2895.

Author: odersky

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

@@ -351,6 +351,10 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
       assert(argss.isEmpty)
   }
 
+  private def canElideThis(tpe: ThisType): Boolean =
+    prefix.tpe == tpe && ctx.owner.isContainedIn(tpe.cls) ||
+    tpe.cls.is(Package)
+
   /** Populate `thisProxy` and `paramProxy` as follows:
    *
    *  1a. If given type refers to a static this, thisProxy binds it to corresponding global reference,
@@ -363,9 +367,7 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
    *      and MethodParams, not TypeRefs or TermRefs.
    */
   private def registerType(tpe: Type): Unit = tpe match {
-    case tpe: ThisType
-    if !ctx.owner.isContainedIn(tpe.cls) && !tpe.cls.is(Package) &&
-       !thisProxy.contains(tpe.cls) =>
+    case tpe: ThisType if !canElideThis(tpe) && !thisProxy.contains(tpe.cls) =>
       val proxyName = s"${tpe.cls.name}_this".toTermName
       val proxyType = tpe.asSeenFrom(prefix.tpe, meth.owner)
       thisProxy(tpe.cls) = newSym(proxyName, EmptyFlags, proxyType).termRef

tests/run/i2895a.scala

@@ -0,0 +1,26 @@
+
+trait Foo[A <: Foo[A]] {
+
+  def next: A
+
+  inline final def once: A = next
+
+  def once1: A = once
+
+  def twice: A = once.once
+}
+
+trait Bar extends Foo[Bar]
+
+case object Bar0 extends Bar { def next = Bar1 }
+case object Bar1 extends Bar { def next = Bar2 }
+case object Bar2 extends Bar { def next = this }
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    assert(Bar0.once.once.toString == "Bar2")
+    assert(Bar0.twice.toString == "Bar2")
+  }
+}
+