Rename test package to lower case
Change-Id: I892c99d0c9a40e407e3522ff2ae8eecc202d2937
diff --git a/src/test/examplesJava11/nesthostexample/BasicNestHostClassMerging.java b/src/test/examplesJava11/nesthostexample/BasicNestHostClassMerging.java
new file mode 100644
index 0000000..6e511a0
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/BasicNestHostClassMerging.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class BasicNestHostClassMerging {
+
+ private String field = "Outer";
+
+ public static class MiddleOuter extends BasicNestHostClassMerging {
+
+ private String field = "Middle";
+
+ public static void main(String[] args) {
+ System.out.println(new InnerMost().getFields());
+ }
+ }
+
+ public static class MiddleInner extends MiddleOuter {
+ private String field = "Inner";
+ }
+
+ public static class InnerMost extends MiddleInner {
+
+ @NeverInline
+ public String getFields() {
+ return ((BasicNestHostClassMerging) this).field
+ + ((MiddleOuter) this).field
+ + ((MiddleInner) this).field;
+ }
+ }
+
+ public static void main(String[] args) {
+ System.out.println(new InnerMost().getFields());
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/BasicNestHostTreePruning.java b/src/test/examplesJava11/nesthostexample/BasicNestHostTreePruning.java
new file mode 100644
index 0000000..07ec806
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/BasicNestHostTreePruning.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class BasicNestHostTreePruning {
+
+ private String field = "NotPruned";
+
+ public static class NotPruned extends BasicNestHostTreePruning {
+
+ @NeverInline
+ public String getFields() {
+ return ((BasicNestHostTreePruning) this).field;
+ }
+ }
+
+ public static class Pruned {
+
+ public static void main(String[] args) {
+ System.out.println("NotPruned");
+ }
+ }
+
+ public static void main(String[] args) {
+ System.out.println(new NotPruned().getFields());
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/BasicNestHostWithAnonymousInnerClass.java b/src/test/examplesJava11/nesthostexample/BasicNestHostWithAnonymousInnerClass.java
new file mode 100644
index 0000000..f014507
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/BasicNestHostWithAnonymousInnerClass.java
@@ -0,0 +1,43 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class BasicNestHostWithAnonymousInnerClass {
+
+ private String method() {
+ return "hostMethod";
+ }
+
+ private static String staticMethod() {
+ return "staticHostMethod";
+ }
+
+ private String field = "field";
+ private static String staticField = "staticField";
+
+ public static InterfaceForAnonymousClass createAnonymousNestedInstance() {
+ return new InterfaceForAnonymousClass() {
+ public String accessOuter(BasicNestHostWithAnonymousInnerClass o) {
+ return o.field
+ + o.staticField
+ + BasicNestHostWithAnonymousInnerClass.staticField
+ + o.method()
+ + o.staticMethod()
+ + BasicNestHostWithAnonymousInnerClass.staticMethod();
+ }
+ };
+ }
+
+ public interface InterfaceForAnonymousClass {
+ String accessOuter(BasicNestHostWithAnonymousInnerClass o);
+ }
+
+ public static void main(String[] args) {
+ BasicNestHostWithAnonymousInnerClass outer = new BasicNestHostWithAnonymousInnerClass();
+ InterfaceForAnonymousClass anonymousInner =
+ BasicNestHostWithAnonymousInnerClass.createAnonymousNestedInstance();
+ System.out.println(anonymousInner.accessOuter(outer));
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassConstructors.java b/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassConstructors.java
new file mode 100644
index 0000000..f3ee216
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassConstructors.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class BasicNestHostWithInnerClassConstructors {
+
+ public String field;
+
+ private BasicNestHostWithInnerClassConstructors(String field) {
+ this.field = field;
+ }
+
+ private BasicNestHostWithInnerClassConstructors(int intVal) {
+ this.field = String.valueOf(intVal);
+ }
+
+ public static BasicNestedClass createNestedInstance(String field) {
+ return new BasicNestedClass(field);
+ }
+
+ public static class BasicNestedClass {
+
+ public String field;
+
+ private BasicNestedClass(String field) {
+ this.field = field;
+ }
+
+ private BasicNestedClass(String unused, String field, String alsoUnused) {
+ this.field = field + "UnusedConstructor";
+ }
+
+ public static BasicNestHostWithInnerClassConstructors createOuterInstance(String field) {
+ return new BasicNestHostWithInnerClassConstructors(field);
+ }
+ }
+
+ public static void main(String[] args) {
+ BasicNestHostWithInnerClassConstructors outer = BasicNestedClass.createOuterInstance("field");
+ BasicNestedClass inner =
+ BasicNestHostWithInnerClassConstructors.createNestedInstance("nest1SField");
+ BasicNestHostWithInnerClassConstructors noBridge =
+ new BasicNestHostWithInnerClassConstructors(1);
+ BasicNestedClass unusedParamConstructor =
+ new BasicNestedClass("unused", "innerField", "alsoUnused");
+
+ System.out.println(outer.field);
+ System.out.println(inner.field);
+ System.out.println(noBridge.field);
+ System.out.println(unusedParamConstructor.field);
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassFields.java b/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassFields.java
new file mode 100644
index 0000000..a174723
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassFields.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class BasicNestHostWithInnerClassFields {
+
+ private String fieldWithoutBridge = "noBridge";
+ private String field = "field";
+ private static String staticField = "staticField";
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessNested(BasicNestedClass o) {
+ o.field = "RW" + o.field;
+ o.staticField = "RW" + o.field;
+ return o.field + o.staticField + BasicNestedClass.staticField + fieldWithoutBridge;
+ }
+
+ public static class BasicNestedClass {
+
+ private String field = "nestField";
+ private static String staticField = "staticNestField";
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessOuter(BasicNestHostWithInnerClassFields o) {
+ o.field = "RW" + o.field;
+ o.staticField = "RW" + o.field;
+ return o.field + o.staticField + BasicNestedClass.staticField;
+ }
+ }
+
+ public static void main(String[] args) {
+ BasicNestHostWithInnerClassFields outer = new BasicNestHostWithInnerClassFields();
+ BasicNestedClass inner = new BasicNestedClass();
+
+ System.out.println(outer.accessNested(inner));
+ System.out.println(inner.accessOuter(outer));
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassMethods.java b/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassMethods.java
new file mode 100644
index 0000000..e22088a
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/BasicNestHostWithInnerClassMethods.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class BasicNestHostWithInnerClassMethods {
+
+ private String methodWithoutBridge() {
+ return "noBridge";
+ }
+
+ private String method() {
+ return "hostMethod";
+ }
+
+ private static String staticMethod() {
+ return "staticHostMethod";
+ }
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessNested(BasicNestedClass o) {
+ return o.method() + o.staticMethod() + BasicNestedClass.staticMethod() + methodWithoutBridge();
+ }
+
+ public static class BasicNestedClass {
+ private String method() {
+ return "nestMethod";
+ }
+
+ private static String staticMethod() {
+ return "staticNestMethod";
+ }
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessOuter(BasicNestHostWithInnerClassMethods o) {
+ return o.method() + o.staticMethod() + BasicNestedClass.staticMethod();
+ }
+ }
+
+ public static void main(String[] args) {
+ BasicNestHostWithInnerClassMethods outer = new BasicNestHostWithInnerClassMethods();
+ BasicNestedClass inner = new BasicNestedClass();
+
+ System.out.println(outer.accessNested(inner));
+ System.out.println(inner.accessOuter(outer));
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/NestHostExample.java b/src/test/examplesJava11/nesthostexample/NestHostExample.java
new file mode 100644
index 0000000..3aa3546
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/NestHostExample.java
@@ -0,0 +1,316 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+
+// Warning: This requires Java 9+ to be compiled (private interface methods)
+// This file builds all the possible combinations of private members:
+// - static VS non-static
+// - fields VS methods
+// - multiple nesting levels
+// - nested interfaces
+// Note: Inner interfaces have to be static.
+// Then the accessPrivate methods generate all possibles calls.
+// Each instance is created through a private constructor to test them too.
+@SuppressWarnings("WeakerAccess")
+public class NestHostExample {
+
+ private String method() {
+ return "hostMethod";
+ }
+
+ private static String staticMethod() {
+ return "staticHostMethod";
+ }
+
+ private String field;
+ private static String staticField = "staticField";
+
+ private NestHostExample(String field) {
+ this.field = field;
+ }
+
+ public StaticNestMemberInner createStaticNestMemberInner(String field) {
+ return new StaticNestMemberInner(field);
+ }
+
+ public NestMemberInner createNestMemberInner(String field) {
+ return new NestMemberInner(field);
+ }
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessPrivate(
+ NestHostExample o0,
+ StaticNestMemberInner o1,
+ StaticNestMemberInner.StaticNestMemberInnerInner o2,
+ NestMemberInner o3,
+ NestMemberInner.NestMemberInnerInner o4) {
+ return join(
+ ", ",
+ new String[] {
+ o0.field,
+ o0.staticField,
+ NestHostExample.staticField,
+ o0.method(),
+ o0.staticMethod(),
+ NestHostExample.staticMethod(),
+ o1.field,
+ o1.staticField,
+ StaticNestMemberInner.staticField,
+ o1.method(),
+ o1.staticMethod(),
+ StaticNestMemberInner.staticMethod(),
+ o2.field,
+ o2.staticField,
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticField,
+ o2.method(),
+ o2.staticMethod(),
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticMethod(),
+ o3.field,
+ o3.method(),
+ o4.field,
+ o4.method()
+ });
+ }
+
+ public String accessPrivateInterface(StaticNestInterfaceInner i1) {
+ return i1.interfaceMethod() + StaticNestInterfaceInner.staticInterfaceMethod();
+ }
+
+ // Nested interface (has to be static)
+ public interface StaticNestInterfaceInner {
+
+ private String interfaceMethod() {
+ return "staticInterfaceMethod";
+ }
+
+ private static String staticInterfaceMethod() {
+ return "staticStaticInterfaceMethod";
+ }
+
+ public static NestHostExample createNestHostExample(String field) {
+ return new NestHostExample(field);
+ }
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ default String accessPrivate(
+ NestHostExample o0,
+ StaticNestMemberInner o1,
+ StaticNestMemberInner.StaticNestMemberInnerInner o2,
+ NestMemberInner o3,
+ NestMemberInner.NestMemberInnerInner o4) {
+ return join(
+ ", ",
+ new String[] {
+ o0.field,
+ o0.staticField,
+ NestHostExample.staticField,
+ o0.method(),
+ o0.staticMethod(),
+ NestHostExample.staticMethod(),
+ o1.field,
+ o1.staticField,
+ StaticNestMemberInner.staticField,
+ o1.method(),
+ o1.staticMethod(),
+ StaticNestMemberInner.staticMethod(),
+ o2.field,
+ o2.staticField,
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticField,
+ o2.method(),
+ o2.staticMethod(),
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticMethod(),
+ o3.field,
+ o3.method(),
+ o4.field,
+ o4.method()
+ });
+ }
+
+ default String accessPrivateInterface(StaticNestInterfaceInner i1) {
+ return i1.interfaceMethod() + StaticNestInterfaceInner.staticInterfaceMethod();
+ }
+ }
+
+ // Static Nest mates
+ public static class StaticNestMemberInner {
+
+ private String method() {
+ return "nest1SMethod";
+ }
+
+ private static String staticMethod() {
+ return "staticNest1SMethod";
+ }
+
+ private String field;
+ private static String staticField = "staticNest1SField";
+
+ private StaticNestMemberInner(String field) {
+ this.field = field;
+ }
+
+ public static StaticNestMemberInnerInner createStaticNestMemberInnerInner(String field) {
+ return new StaticNestMemberInnerInner(field);
+ }
+
+ public static class StaticNestMemberInnerInner implements StaticNestInterfaceInner {
+
+ private String method() {
+ return "nest2SMethod";
+ }
+
+ private static String staticMethod() {
+ return "staticNest2SMethod";
+ }
+
+ private String field;
+ private static String staticField = "staticNest2SField";
+
+ private StaticNestMemberInnerInner(String field) {
+ this.field = field;
+ }
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessPrivate(
+ NestHostExample o0,
+ StaticNestMemberInner o1,
+ StaticNestMemberInner.StaticNestMemberInnerInner o2,
+ NestMemberInner o3,
+ NestMemberInner.NestMemberInnerInner o4) {
+ return join(
+ ", ",
+ new String[] {
+ o0.field,
+ o0.staticField,
+ NestHostExample.staticField,
+ o0.method(),
+ o0.staticMethod(),
+ NestHostExample.staticMethod(),
+ o1.field,
+ o1.staticField,
+ StaticNestMemberInner.staticField,
+ o1.method(),
+ o1.staticMethod(),
+ StaticNestMemberInner.staticMethod(),
+ o2.field,
+ o2.staticField,
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticField,
+ o2.method(),
+ o2.staticMethod(),
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticMethod(),
+ o3.field,
+ o3.method(),
+ o4.field,
+ o4.method()
+ });
+ }
+
+ public String accessPrivateInterface(StaticNestInterfaceInner i1) {
+ return i1.interfaceMethod() + StaticNestInterfaceInner.staticInterfaceMethod();
+ }
+ }
+ }
+
+ // Non static Nest mates
+ public class NestMemberInner {
+
+ private String method() {
+ return "nest1Method";
+ }
+
+ private String field;
+
+ private NestMemberInner(String field) {
+ this.field = field;
+ }
+
+ public NestMemberInnerInner createNestMemberInnerInner(String field) {
+ return new NestMemberInnerInner(field);
+ }
+
+ public class NestMemberInnerInner {
+
+ private String method() {
+ return "nest2Method";
+ }
+
+ private String field;
+
+ private NestMemberInnerInner(String field) {
+ this.field = field;
+ }
+
+ @SuppressWarnings("static-access") // we want to test that too.
+ public String accessPrivate(
+ NestHostExample o0,
+ StaticNestMemberInner o1,
+ StaticNestMemberInner.StaticNestMemberInnerInner o2,
+ NestMemberInner o3,
+ NestMemberInner.NestMemberInnerInner o4) {
+ return join(
+ ", ",
+ new String[] {
+ o0.field,
+ o0.staticField,
+ NestHostExample.staticField,
+ o0.method(),
+ o0.staticMethod(),
+ NestHostExample.staticMethod(),
+ o1.field,
+ o1.staticField,
+ StaticNestMemberInner.staticField,
+ o1.method(),
+ o1.staticMethod(),
+ StaticNestMemberInner.staticMethod(),
+ o2.field,
+ o2.staticField,
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticField,
+ o2.method(),
+ o2.staticMethod(),
+ StaticNestMemberInner.StaticNestMemberInnerInner.staticMethod(),
+ o3.field,
+ o3.method(),
+ o4.field,
+ o4.method()
+ });
+ }
+
+ public String accessPrivateInterface(StaticNestInterfaceInner i1) {
+ return i1.interfaceMethod() + StaticNestInterfaceInner.staticInterfaceMethod();
+ }
+ }
+ }
+
+ public static String join(String separator, String[] strings) {
+ StringBuilder sb = new StringBuilder(strings[0]);
+ for (int i = 1; i < strings.length; i++) {
+ sb.append(separator).append(strings[i]);
+ }
+ return sb.toString();
+ }
+
+ @SuppressWarnings("all") // do not know how to remove the redundant i1 variable
+ public static void main(String[] args) {
+ NestHostExample o0 = StaticNestInterfaceInner.createNestHostExample("field");
+ StaticNestMemberInner o1 = o0.createStaticNestMemberInner("nest1SField");
+ StaticNestMemberInner.StaticNestMemberInnerInner o2 =
+ o1.createStaticNestMemberInnerInner("nest2SField");
+ NestMemberInner o3 = o0.createNestMemberInner("nest1Field");
+ NestMemberInner.NestMemberInnerInner o4 = o3.createNestMemberInnerInner("nest2Field");
+
+ StaticNestInterfaceInner i1 = o2;
+
+ System.out.println(o0.accessPrivate(o0, o1, o2, o3, o4));
+ System.out.println(o2.accessPrivate(o0, o1, o2, o3, o4));
+ System.out.println(o4.accessPrivate(o0, o1, o2, o3, o4));
+ System.out.println(i1.accessPrivate(o0, o1, o2, o3, o4));
+
+ System.out.println(o0.accessPrivateInterface(i1));
+ System.out.println(o2.accessPrivateInterface(i1));
+ System.out.println(o4.accessPrivateInterface(i1));
+ System.out.println(i1.accessPrivateInterface(i1));
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/NestHostInlining.java b/src/test/examplesJava11/nesthostexample/NestHostInlining.java
new file mode 100644
index 0000000..4748927
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/NestHostInlining.java
@@ -0,0 +1,35 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class NestHostInlining {
+
+ private String field = "inlining";
+
+ public static class InnerWithPrivAccess {
+ public String access(NestHostInlining host) {
+ return host.field;
+ }
+ }
+
+ public static class InnerNoPrivAccess {
+ public String print() {
+ return "InnerNoPrivAccess";
+ }
+ }
+
+ public abstract static class EmptyNoPrivAccess {}
+
+ public abstract static class EmptyWithPrivAccess {
+ public String access(NestHostInlining host) {
+ return host.field;
+ }
+ }
+
+ public static void main(String[] args) {
+ System.out.println(new InnerWithPrivAccess().access(new NestHostInlining()));
+ System.out.println(new InnerNoPrivAccess().print());
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/NestHostInliningSubclasses.java b/src/test/examplesJava11/nesthostexample/NestHostInliningSubclasses.java
new file mode 100644
index 0000000..a6283a0
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/NestHostInliningSubclasses.java
@@ -0,0 +1,26 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class NestHostInliningSubclasses {
+
+ public static class InnerWithPrivAccess extends NestHostInlining.InnerWithPrivAccess {
+ public String accessSubclass(NestHostInlining host) {
+ return super.access(host) + "Subclass";
+ }
+ }
+
+ public static class InnerNoPrivAccess extends NestHostInlining.InnerNoPrivAccess {
+ @NeverInline
+ public String printSubclass() {
+ return super.print() + "Subclass";
+ }
+ }
+
+ public static void main(String[] args) {
+ System.out.println(new InnerWithPrivAccess().accessSubclass(new NestHostInlining()));
+ System.out.println(new InnerNoPrivAccess().printSubclass());
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/NeverInline.java b/src/test/examplesJava11/nesthostexample/NeverInline.java
new file mode 100644
index 0000000..d800658
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/NeverInline.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+public @interface NeverInline {}
diff --git a/src/test/examplesJava11/nesthostexample/OutsideInliningNoAccess.java b/src/test/examplesJava11/nesthostexample/OutsideInliningNoAccess.java
new file mode 100644
index 0000000..86da4b1
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/OutsideInliningNoAccess.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class OutsideInliningNoAccess extends NestHostInlining.EmptyNoPrivAccess {
+
+ public static void main(String[] args) {
+ System.out.println("OutsideInliningNoAccess");
+ }
+}
diff --git a/src/test/examplesJava11/nesthostexample/OutsideInliningWithAccess.java b/src/test/examplesJava11/nesthostexample/OutsideInliningWithAccess.java
new file mode 100644
index 0000000..c81e437
--- /dev/null
+++ b/src/test/examplesJava11/nesthostexample/OutsideInliningWithAccess.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package nesthostexample;
+
+public class OutsideInliningWithAccess extends NestHostInlining.EmptyWithPrivAccess {
+
+ public static void main(String[] args) {
+ System.out.println("OutsideInliningNoAccess");
+ System.out.println(new OutsideInliningWithAccess().access(new NestHostInlining()));
+ }
+}
