Initial push.
diff --git a/src/test/examples/shaking2/Interface.java b/src/test/examples/shaking2/Interface.java
new file mode 100644
index 0000000..3862b05
--- /dev/null
+++ b/src/test/examples/shaking2/Interface.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public interface Interface extends SuperInterface1, SuperInterface2 {
+ public void unusedInterfaceMethod();
+ public void interfaceMethod();
+ public void interfaceMethod4();
+ public void interfaceMethod5(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8);
+}
diff --git a/src/test/examples/shaking2/Shaking.java b/src/test/examples/shaking2/Shaking.java
new file mode 100644
index 0000000..f99fd8c
--- /dev/null
+++ b/src/test/examples/shaking2/Shaking.java
@@ -0,0 +1,55 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public class Shaking {
+ public static void callInterfaceMethod(Interface object) {
+ object.interfaceMethod4();
+ object.interfaceMethod5(1, 2, 3, 4, 5, 6, 7, 8);
+ }
+
+ public static void callAsSuperClassAndInterface(SuperClass object) {
+ object.interfaceMethod();
+ object.interfaceMethod2();
+ object.interfaceMethod3();
+ object.virtualMethod();
+ object.virtualMethod2(1, 2, 3, 4, 5, 6, 7, 8);
+ object.accessFields();
+ callInterfaceMethod(object);
+ }
+
+ public static void accessStaticFields() {
+ System.out.println("StaticFields::used: " + StaticFields.used);
+ System.out.println("StaitcFields::read" +
+ " " + StaticFields.readInt +
+ " " + StaticFields.readBoolean+
+ " " + StaticFields.readByte +
+ " " + StaticFields.readChar +
+ " " + StaticFields.readObject +
+ " " + StaticFields.readShort +
+ " " + StaticFields.readDouble);
+ StaticFields.writeInt = 1;
+ StaticFields.writeBoolean = true;
+ StaticFields.writeByte = 2;
+ StaticFields.writeChar = 3;
+ StaticFields.writeObject = new Object();
+ StaticFields.writeShort = 3;
+ StaticFields.writeDouble = 3.3;
+ }
+
+ public static void main(String[] args) {
+ accessStaticFields();
+ SuperClass.staticMethod();
+ SuperClass.staticMethod2(1, 2, 3, 4, 5, 6, 7, 8);
+ SubClass1 instance1 = new SubClass1(1);
+ callAsSuperClassAndInterface(instance1);
+ instance1.virtualMethod3();
+ instance1.virtualMethod4(1, 2, 3, 4, 5, 6, 7, 8);
+ callAsSuperClassAndInterface(new SubClass1(1, 2, 3, 4, 5, 6, 7, 8));
+ SubClass2 instance2 = new SubClass2(2);
+ callAsSuperClassAndInterface(instance2);
+ instance2.virtualMethod3();
+ instance2.virtualMethod4(1, 2, 3, 4, 5, 6, 7, 8);
+ }
+}
diff --git a/src/test/examples/shaking2/StaticFields.java b/src/test/examples/shaking2/StaticFields.java
new file mode 100644
index 0000000..80bf6ba
--- /dev/null
+++ b/src/test/examples/shaking2/StaticFields.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public class StaticFields {
+ public static int used = 42;
+ // Unused but initialized by <clinit>.
+ public static int unused = -42;
+ // Not even used by <clinit>.
+ public static int completelyUnused;
+
+ public static int readInt;
+ public static int writeInt;
+ public static boolean readBoolean;
+ public static boolean writeBoolean;
+ public static byte readByte;
+ public static byte writeByte;
+ public static char readChar;
+ public static char writeChar;
+ public static Object readObject;
+ public static Object writeObject;
+ public static short readShort;
+ public static short writeShort;
+ public static double readDouble;
+ public static double writeDouble;
+}
\ No newline at end of file
diff --git a/src/test/examples/shaking2/SubClass1.java b/src/test/examples/shaking2/SubClass1.java
new file mode 100644
index 0000000..722c6e0
--- /dev/null
+++ b/src/test/examples/shaking2/SubClass1.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public class SubClass1 extends SuperClass {
+ private int used;
+ private int alsoUsed;
+ private boolean usedBoolean;
+ private byte usedByte;
+ private char usedChar;
+ private Object usedObject;
+ private short usedShort;
+ private double usedDouble;
+
+ private int unused;
+
+ public SubClass1(int used) {
+ this.used = used;
+ }
+
+ public SubClass1(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ this.used = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8;
+ }
+
+ @Override
+ public void virtualMethod() {
+ System.out.println("SubClass1::virtualMethod");
+ }
+
+ @Override
+ public void virtualMethod2(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SubClass1::virtualMethod2 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ @Override
+ public void virtualMethod3() {
+ super.virtualMethod3();
+ System.out.println("SubClass1::virtualMethod3");
+ }
+
+ @Override
+ public void virtualMethod4(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ super.virtualMethod4(a1, a2, a3, a4, a5, a6, a7, a8);
+ System.out.println("SubClass1::virtualMethod4 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ @Override
+ public void unusedVirtualMethod() {
+ System.out.println("SubClass1::unusedVirtualMethod");
+ }
+
+ @Override
+ public void interfaceMethod() {
+ System.out.println("SubClass1::interfaceMethod");
+ }
+
+ @Override
+ public void interfaceMethod2() {
+ System.out.println("SubClass1::interfaceMethod2");
+ }
+
+ @Override
+ public void interfaceMethod3() {
+ System.out.println("SubClass1::interfaceMethod3");
+ }
+
+ @Override
+ public void interfaceMethod4() {
+ System.out.println("SubClass1::interfaceMethod4");
+ }
+
+ @Override
+ public void interfaceMethod5(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SubClass1::interfaceMethod5 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ @Override
+ public void accessFields() {
+ super.accessFields();
+ System.out.println("SubClass1::fields: " + used + " " + alsoUsed + " " + usedBoolean +
+ " " + usedByte + " " + usedChar + " " + usedObject + " " + usedShort + " " + usedDouble);
+ used = 1;
+ alsoUsed = 2;
+ usedBoolean = true;
+ usedByte = 3;
+ usedChar = '?';
+ usedObject = new Object();
+ usedShort = 4;
+ usedDouble = 42.42;
+ }
+}
diff --git a/src/test/examples/shaking2/SubClass2.java b/src/test/examples/shaking2/SubClass2.java
new file mode 100644
index 0000000..6a0dcb2
--- /dev/null
+++ b/src/test/examples/shaking2/SubClass2.java
@@ -0,0 +1,61 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public class SubClass2 extends SuperClass {
+ private int used;
+ private int unused;
+ private int unusedToo;
+
+ public SubClass2(int used) {
+ this.used = used;
+ }
+
+ @Override
+ public void virtualMethod() {
+ System.out.println("SubClass2::virtualMethod");
+ }
+
+ @Override
+ public void virtualMethod2(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SubClass2::virtualMethod2 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ @Override
+ public void virtualMethod3() {
+ super.virtualMethod3();
+ System.out.println("SubClass2::virtualMethod3");
+ }
+
+ @Override
+ public void virtualMethod4(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ super.virtualMethod4(a1, a2, a3, a4, a5, a6, a7, a8);
+ System.out.println("SubClass2::virtualMethod4 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ @Override
+ public void interfaceMethod() {
+ System.out.println("SubClass2::interfaceMethod");
+ }
+
+ @Override
+ public void interfaceMethod2() {
+ System.out.println("SubClass2::interfaceMethod2");
+ }
+
+ @Override
+ public void interfaceMethod3() {
+ System.out.println("SubClass2::interfaceMethod3");
+ }
+
+ @Override
+ public void interfaceMethod4() {
+ System.out.println("SubClass2::interfaceMethod4");
+ }
+
+ @Override
+ public void interfaceMethod5(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SubClass1::interfaceMethod5 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+}
diff --git a/src/test/examples/shaking2/SuperClass.java b/src/test/examples/shaking2/SuperClass.java
new file mode 100644
index 0000000..f382671
--- /dev/null
+++ b/src/test/examples/shaking2/SuperClass.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public abstract class SuperClass implements Interface {
+ public int used;
+
+ public static void staticMethod() {
+ System.out.println("SuperClass::staticMethod");
+ }
+
+ public static void staticMethod2(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SuperClass::staticMethod2: " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ public static void unusedStaticMethod() {
+ System.out.println("SuperClass::unusedStaticMethod");
+ }
+
+ public void virtualMethod() {
+ System.out.println("SuperClass::virtualMethod");
+ }
+
+ public void virtualMethod2(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SuperClass::virtualMethod2 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ public void virtualMethod3() {
+ System.out.println("SuperClass::virtualMethod3");
+ }
+
+ public void virtualMethod4(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SuperClass::virtualMethod4 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+
+ public void unusedVirtualMethod() {
+ System.out.println("SuperClass::unusedVirtualMethod");
+ }
+
+ public void unusedInterfaceMethod() { System.out.println("SuperClass::unusedInterfaceMethod"); }
+
+ public void accessFields() {
+ System.out.println("SuperClass::fields: " + used);
+ }
+}
diff --git a/src/test/examples/shaking2/SuperInterface1.java b/src/test/examples/shaking2/SuperInterface1.java
new file mode 100644
index 0000000..7ec5d4e
--- /dev/null
+++ b/src/test/examples/shaking2/SuperInterface1.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public interface SuperInterface1 {
+ public void interfaceMethod2();
+}
diff --git a/src/test/examples/shaking2/SuperInterface2.java b/src/test/examples/shaking2/SuperInterface2.java
new file mode 100644
index 0000000..f9a1ff7
--- /dev/null
+++ b/src/test/examples/shaking2/SuperInterface2.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public interface SuperInterface2 extends SuperInterface1 {
+ public void interfaceMethod3();
+}
diff --git a/src/test/examples/shaking2/UnusedSubclass.java b/src/test/examples/shaking2/UnusedSubclass.java
new file mode 100644
index 0000000..400ec64
--- /dev/null
+++ b/src/test/examples/shaking2/UnusedSubclass.java
@@ -0,0 +1,43 @@
+// Copyright (c) 2016, 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 shaking2;
+
+public class UnusedSubclass extends SuperClass {
+ private int used;
+ private int unused;
+
+ public UnusedSubclass(int used) {
+ this.used = used;
+ }
+
+ @Override
+ public void virtualMethod() {
+ System.out.println("UnusedSubclass::virtualMethod");
+ }
+
+ @Override
+ public void interfaceMethod() {
+ System.out.println("UnusedSubclass::interfaceMethod");
+ }
+
+ @Override
+ public void interfaceMethod2() {
+ System.out.println("UnusedSubclass::interfaceMethod2");
+ }
+
+ @Override
+ public void interfaceMethod3() {
+ System.out.println("UnusedSubclass::interfaceMethod3");
+ }
+
+ @Override
+ public void interfaceMethod4() {
+ System.out.println("UnusedSubclass::interfaceMethod4");
+ }
+
+ @Override
+ public void interfaceMethod5(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
+ System.out.println("SubClass1::interfaceMethod5 " + (a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8));
+ }
+}
diff --git a/src/test/examples/shaking2/keep-rules-dont-shrink.txt b/src/test/examples/shaking2/keep-rules-dont-shrink.txt
new file mode 100644
index 0000000..6edaafc
--- /dev/null
+++ b/src/test/examples/shaking2/keep-rules-dont-shrink.txt
@@ -0,0 +1,7 @@
+# Copyright (c) 2017, 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.
+
+-dontshrink
+
+@keep-rules.txt
\ No newline at end of file
diff --git a/src/test/examples/shaking2/keep-rules.txt b/src/test/examples/shaking2/keep-rules.txt
new file mode 100644
index 0000000..e05f735
--- /dev/null
+++ b/src/test/examples/shaking2/keep-rules.txt
@@ -0,0 +1,12 @@
+# Copyright (c) 2016, 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.
+
+# Keep the application entry point. Get rid of everything that is not
+# reachable from there.
+-keep public class shaking2.Shaking {
+ public static void main(java.lang.String[]);
+}
+
+# allow access modification to enable minifcation
+-allowaccessmodification
