A test case that scrutinises lambdalifter's output.

No doubt there are plenty of additional variations that could be
added to exercise more code paths.

This is the unflattering "before" photo; the next commit will
make over the name mangling and reveal the simple beauty of
unmangled names.

References SI-6028

1 files changed, 84 insertions, 0 deletions

diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check
new file mode 100644
index 0000000000..6c9930b503
--- /dev/null
+++ b/test/files/run/t6028.check
@@ -0,0 +1,84 @@
+[[syntax trees at end of                lambdalift]] // newSource1
+package <empty> {
+  class T extends Object {
+    <paramaccessor> val T$$classParam: Int = _;
+    def <init>(classParam: Int): T = {
+      T.super.<init>();
+      ()
+    };
+    private[this] val field: Int = 0;
+    <stable> <accessor> def field(): Int = T.this.field;
+    def foo(methodParam$1: Int): Function0 = {
+      val methodLocal$1: Int = 0;
+      {
+        (new anonymous class $anonfun$foo$1(T.this, methodParam$1, methodLocal$1): Function0)
+      }
+    };
+    def bar(barParam$1: Int): Object = {
+      @volatile var MethodLocalObject$module$1: scala.runtime.VolatileObjectRef = new scala.runtime.VolatileObjectRef(<empty>);
+      T.this.MethodLocalObject$1(barParam$1, MethodLocalObject$module$1)
+    };
+    def tryy(tryyParam$1: Int): Function0 = {
+      var tryyLocal$1: scala.runtime.IntRef = new scala.runtime.IntRef(0);
+      {
+        (new anonymous class $anonfun$tryy$1(T.this, tryyParam$1, tryyLocal$1): Function0)
+      }
+    };
+    @SerialVersionUID(0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable {
+      def <init>($outer: T, methodParam$1: Int, methodLocal$1: Int): anonymous class $anonfun$foo$1 = {
+        $anonfun$foo$1.super.<init>();
+        ()
+      };
+      final def apply(): Int = $anonfun$foo$1.this.apply$mcI$sp();
+      <specialized> def apply$mcI$sp(): Int = $anonfun$foo$1.this.$outer.T$$classParam.+($anonfun$foo$1.this.$outer.field()).+($anonfun$foo$1.this.methodParam$1).+($anonfun$foo$1.this.methodLocal$1);
+      <synthetic> <paramaccessor> private[this] val $outer: T = _;
+      <synthetic> <stable> def T$$anonfun$$$outer(): T = $anonfun$foo$1.this.$outer;
+      final <bridge> def apply(): Object = scala.Int.box($anonfun$foo$1.this.apply());
+      <synthetic> <paramaccessor> private[this] val methodParam$1: Int = _;
+      <synthetic> <paramaccessor> private[this] val methodLocal$1: Int = _
+    };
+    abstract trait MethodLocalTrait$1 extends Object {
+      <synthetic> <stable> def T$MethodLocalTrait$$$outer(): T
+    };
+    object MethodLocalObject$2 extends Object with T#MethodLocalTrait$1 {
+      def <init>($outer: T, barParam$1: Int): ... = {
+        MethodLocalObject$2.super.<init>();
+        MethodLocalObject$2.this.$asInstanceOf[T#MethodLocalTrait$1$class]()./*MethodLocalTrait$1$class*/$init$(barParam$1);
+        ()
+      };
+      <synthetic> <paramaccessor> private[this] val $outer: T = _;
+      <synthetic> <stable> def T$MethodLocalObject$$$outer(): T = MethodLocalObject$2.this.$outer;
+      <synthetic> <stable> def T$MethodLocalTrait$$$outer(): T = MethodLocalObject$2.this.$outer
+    };
+    final <stable> private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: scala.runtime.VolatileObjectRef): ... = {
+      MethodLocalObject$module$1.elem = new ...(T.this, barParam$1);
+      MethodLocalObject$module$1.elem.$asInstanceOf[...]()
+    };
+    abstract trait MethodLocalTrait$1$class extends Object with T#MethodLocalTrait$1 {
+      def /*MethodLocalTrait$1$class*/$init$(barParam$1: Int): Unit = {
+        ()
+      };
+      scala.this.Predef.print(scala.Int.box(barParam$1))
+    };
+    @SerialVersionUID(0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable {
+      def <init>($outer: T, tryyParam$1: Int, tryyLocal$1: scala.runtime.IntRef): anonymous class $anonfun$tryy$1 = {
+        $anonfun$tryy$1.super.<init>();
+        ()
+      };
+      final def apply(): Unit = $anonfun$tryy$1.this.apply$mcV$sp();
+      <specialized> def apply$mcV$sp(): Unit = try {
+        $anonfun$tryy$1.this.tryyLocal$1.elem = $anonfun$tryy$1.this.tryyParam$1
+      } finally ();
+      <synthetic> <paramaccessor> private[this] val $outer: T = _;
+      <synthetic> <stable> def T$$anonfun$$$outer(): T = $anonfun$tryy$1.this.$outer;
+      final <bridge> def apply(): Object = {
+        $anonfun$tryy$1.this.apply();
+        scala.runtime.BoxedUnit.UNIT
+      };
+      <synthetic> <paramaccessor> private[this] val tryyParam$1: Int = _;
+      <synthetic> <paramaccessor> private[this] val tryyLocal$1: scala.runtime.IntRef = _
+    }
+  }
+}
+
+warning: there were 1 feature warnings; re-run with -feature for details