Harden outer proxy computation of inlined code

It turns out that we simply cannot do reliable outer path
computation that fills in the right hand sides of this-proxies
from the types of these proxies. As-seen-from logic can mangle
the types of proxies enough to scramble the necessary information.

What we now do instead is simply count: We record the number
of outer accesses to an outer this in inlineable code, and do the same number
of outer accesses when computing the proxy.

2 files changed, 21 insertions, 0 deletions

diff --git a/tests/run/i1990b.check b/tests/run/i1990b.check
new file mode 100644
index 000000000..dd84bc9fb
--- /dev/null
+++ b/tests/run/i1990b.check
@@ -0,0 +1 @@
+C()
diff --git a/tests/run/i1990b.scala b/tests/run/i1990b.scala
new file mode 100644
index 000000000..2460208db
--- /dev/null
+++ b/tests/run/i1990b.scala
@@ -0,0 +1,20 @@
+trait A { self =>
+  class Foo {
+    inline def inlineMeth: Unit = {
+      println(self)
+    }
+  }
+}
+
+case class A2() extends A {
+  case class C() extends Foo with A
+
+  val c = new C
+  (new c.Foo).inlineMeth
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new A2
+  }
+}