Merge commit '1ca046cd32f799037e856a633fbc632b4392d449' into dev-release
diff --git a/src/library_desugar/desugar_jdk_libs.json b/src/library_desugar/desugar_jdk_libs.json
index 0ba3777..a859aa1 100644
--- a/src/library_desugar/desugar_jdk_libs.json
+++ b/src/library_desugar/desugar_jdk_libs.json
@@ -251,6 +251,7 @@
"-keepclassmembers class j$.util.DoubleSummaryStatistics { long count; double sum; double min; double max; }",
"-keepattributes Signature",
"-keepattributes EnclosingMethod",
- "-keepattributes InnerClasses"
+ "-keepattributes InnerClasses",
+ "-dontwarn sun.misc.Unsafe"
]
}
diff --git a/src/main/dontwarn.txt b/src/main/dontwarn.txt
new file mode 100644
index 0000000..42afa1d
--- /dev/null
+++ b/src/main/dontwarn.txt
@@ -0,0 +1,4 @@
+# TODO(b/176783536): Avoid need to use -dontwarn.
+-dontwarn com.google.errorprone.annotations.**
+-dontwarn com.google.j2objc.annotations.*
+-dontwarn javax.annotation.Nullable
diff --git a/src/main/java/com/android/tools/r8/cf/CfPrinter.java b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
index 92930b0..09f14ce 100644
--- a/src/main/java/com/android/tools/r8/cf/CfPrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
@@ -395,10 +395,12 @@
builder.append(opcodeName(Opcodes.INVOKEDYNAMIC)).append(' ');
builder.append(callSite.methodName);
builder.append(callSite.methodProto.toDescriptorString());
- DexMethodHandle handle = callSite.bootstrapArgs.get(1).asDexValueMethodHandle().getValue();
- builder.append(", handle:");
- builder.append(handle.toSourceString());
- builder.append(", itf: ").append(handle.isInterface);
+ if (callSite.bootstrapArgs.size() > 1) {
+ DexMethodHandle handle = callSite.bootstrapArgs.get(1).asDexValueMethodHandle().getValue();
+ builder.append(", handle:");
+ builder.append(handle.toSourceString());
+ builder.append(", itf: ").append(handle.isInterface);
+ }
builder.append(", bsm:");
appendMethod(bootstrapMethod.asMethod());
}
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java b/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
index 42844fd..c69ba09 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
@@ -153,6 +153,10 @@
return false;
}
+ public boolean isInvokeStatic() {
+ return false;
+ }
+
public CfLabel asLabel() {
return null;
}
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
index 5cc4435..db81a5f 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInvoke.java
@@ -180,6 +180,7 @@
return opcode == Opcodes.INVOKESPECIAL;
}
+ @Override
public boolean isInvokeStatic() {
return opcode == Opcodes.INVOKESTATIC;
}
diff --git a/src/main/java/com/android/tools/r8/contexts/CompilationContext.java b/src/main/java/com/android/tools/r8/contexts/CompilationContext.java
index aa3247c..b2cc211 100644
--- a/src/main/java/com/android/tools/r8/contexts/CompilationContext.java
+++ b/src/main/java/com/android/tools/r8/contexts/CompilationContext.java
@@ -137,6 +137,10 @@
return method.getHolder();
}
+ public ProgramMethod getMethodContext() {
+ return method;
+ }
+
private StringBuilder buildSuffix(StringBuilder builder) {
// TODO(b/172194101): Sanitize the method descriptor instead of hashing.
Hasher hasher = Hashing.sha256().newHasher();
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingClassInfo.java b/src/main/java/com/android/tools/r8/diagnostic/MissingClassInfo.java
new file mode 100644
index 0000000..41f255a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingClassInfo.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.ClassReference;
+
+@Keep
+public interface MissingClassInfo extends MissingDefinitionInfo {
+
+ /** Returns the reference of the missing class. */
+ ClassReference getClassReference();
+
+ @Override
+ default boolean isMissingClass() {
+ return true;
+ }
+
+ @Override
+ default MissingClassInfo asMissingClass() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionClassContext.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionClassContext.java
new file mode 100644
index 0000000..1b73b9f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionClassContext.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.ClassReference;
+
+@Keep
+public interface MissingDefinitionClassContext extends MissingDefinitionContext {
+
+ /** Returns the reference of the class context. */
+ ClassReference getClassReference();
+
+ @Override
+ default boolean isClassContext() {
+ return true;
+ }
+
+ @Override
+ default MissingDefinitionClassContext asClassContext() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java
index 268c7cc..cb5d3b4 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionContext.java
@@ -6,15 +6,56 @@
import com.android.tools.r8.Keep;
import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.references.ClassReference;
/** A context that references a missing definition in the program, classpath, or library. */
@Keep
public interface MissingDefinitionContext {
- /** The class context from which a missing definition is referenced. */
- ClassReference getClassReference();
-
/** The origin of the context. */
Origin getOrigin();
+
+ /** Predicate that is true iff this is an instance of {@link MissingDefinitionClassContext}. */
+ default boolean isClassContext() {
+ return false;
+ }
+
+ /** Predicate that is true iff this is an instance of {@link MissingDefinitionFieldContext}. */
+ default boolean isFieldContext() {
+ return false;
+ }
+
+ /** Predicate that is true iff this is an instance of {@link MissingDefinitionMethodContext}. */
+ default boolean isMethodContext() {
+ return false;
+ }
+
+ /**
+ * Return a non-null {@link MissingDefinitionClassContext} if this type is {@link
+ * MissingDefinitionClassContext}.
+ *
+ * @return this with static type of {@link MissingDefinitionClassContext}.
+ */
+ default MissingDefinitionClassContext asClassContext() {
+ return null;
+ }
+
+ /**
+ * Return a non-null {@link MissingDefinitionFieldContext} if this type is {@link
+ * MissingDefinitionFieldContext}.
+ *
+ * @return this with static type of {@link MissingDefinitionFieldContext}.
+ */
+ default MissingDefinitionFieldContext asFieldContext() {
+ return null;
+ }
+
+ /**
+ * Return a non-null {@link MissingDefinitionMethodContext} if this type is {@link
+ * MissingDefinitionMethodContext}.
+ *
+ * @return this with static type of {@link MissingDefinitionMethodContext}.
+ */
+ default MissingDefinitionMethodContext asMethodContext() {
+ return null;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionFieldContext.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionFieldContext.java
new file mode 100644
index 0000000..7564f5a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionFieldContext.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.FieldReference;
+
+@Keep
+public interface MissingDefinitionFieldContext extends MissingDefinitionContext {
+
+ /** Returns the reference of the field context. */
+ FieldReference getFieldReference();
+
+ @Override
+ default boolean isFieldContext() {
+ return true;
+ }
+
+ @Override
+ default MissingDefinitionFieldContext asFieldContext() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java
index ea8def0..c2905ce 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionInfo.java
@@ -13,6 +13,57 @@
@Keep
public interface MissingDefinitionInfo {
+ /**
+ * Predicate that is true iff the MissingDefinitionInfo is an instance of {@link
+ * MissingClassInfo}.
+ */
+ default boolean isMissingClass() {
+ return false;
+ }
+
+ /**
+ * Predicate that is true iff the MissingDefinitionInfo is an instance of {@link
+ * MissingFieldInfo}.
+ */
+ default boolean isMissingField() {
+ return false;
+ }
+
+ /**
+ * Predicate that is true iff the MissingDefinitionInfo is an instance of {@link
+ * MissingMethodInfo}.
+ */
+ default boolean isMissingMethod() {
+ return false;
+ }
+
+ /**
+ * Return a non-null {@link MissingClassInfo} if this type is {@link MissingClassInfo}.
+ *
+ * @return this with static type of {@link MissingClassInfo}.
+ */
+ default MissingClassInfo asMissingClass() {
+ return null;
+ }
+
+ /**
+ * Return a non-null {@link MissingFieldInfo} if this type is {@link MissingFieldInfo}.
+ *
+ * @return this with static type of {@link MissingFieldInfo}.
+ */
+ default MissingFieldInfo asMissingField() {
+ return null;
+ }
+
+ /**
+ * Return a non-null {@link MissingMethodInfo} if this type is {@link MissingMethodInfo}.
+ *
+ * @return this with static type of {@link MissingMethodInfo}.
+ */
+ default MissingMethodInfo asMissingMethod() {
+ return null;
+ }
+
/** The contexts from which this missing definition was referenced. */
Collection<MissingDefinitionContext> getReferencedFromContexts();
}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionMethodContext.java b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionMethodContext.java
new file mode 100644
index 0000000..315a29c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingDefinitionMethodContext.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.MethodReference;
+
+@Keep
+public interface MissingDefinitionMethodContext extends MissingDefinitionContext {
+
+ /** Returns the reference of the method context. */
+ MethodReference getMethodReference();
+
+ @Override
+ default boolean isMethodContext() {
+ return true;
+ }
+
+ @Override
+ default MissingDefinitionMethodContext asMethodContext() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingFieldInfo.java b/src/main/java/com/android/tools/r8/diagnostic/MissingFieldInfo.java
new file mode 100644
index 0000000..1ae6df1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingFieldInfo.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.FieldReference;
+
+@Keep
+public interface MissingFieldInfo extends MissingDefinitionInfo {
+
+ /** Returns the reference of the missing field. */
+ FieldReference getFieldReference();
+
+ @Override
+ default boolean isMissingField() {
+ return true;
+ }
+
+ @Override
+ default MissingFieldInfo asMissingField() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/MissingMethodInfo.java b/src/main/java/com/android/tools/r8/diagnostic/MissingMethodInfo.java
new file mode 100644
index 0000000..3cf8cc0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/MissingMethodInfo.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic;
+
+import com.android.tools.r8.Keep;
+import com.android.tools.r8.references.MethodReference;
+
+@Keep
+public interface MissingMethodInfo extends MissingDefinitionInfo {
+
+ /** Returns the reference of the missing method. */
+ MethodReference getMethodReference();
+
+ @Override
+ default boolean isMissingMethod() {
+ return true;
+ }
+
+ @Override
+ default MissingMethodInfo asMissingMethod() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassAccessContexts.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassAccessContexts.java
index 3406c0d..23abebb 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassAccessContexts.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassAccessContexts.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ProgramDerivedContext;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.MethodReference;
@@ -68,8 +69,10 @@
private final Set<DexReference> contexts = Sets.newIdentityHashSet();
- Builder addAll(Set<DexReference> contexts) {
- this.contexts.addAll(contexts);
+ Builder addAll(Set<ProgramDerivedContext> contexts) {
+ for (ProgramDerivedContext context : contexts) {
+ this.contexts.add(context.getContext().getReference());
+ }
return this;
}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java
new file mode 100644
index 0000000..b240279
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingClassInfoImpl.java
@@ -0,0 +1,47 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingClassInfo;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
+import com.android.tools.r8.references.ClassReference;
+import java.util.Collection;
+
+public class MissingClassInfoImpl extends MissingDefinitionInfoBase implements MissingClassInfo {
+
+ private final ClassReference classReference;
+
+ private MissingClassInfoImpl(
+ ClassReference classReference, Collection<MissingDefinitionContext> referencedFromContexts) {
+ super(referencedFromContexts);
+ this.classReference = classReference;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ @Override
+ public ClassReference getClassReference() {
+ return classReference;
+ }
+
+ public static class Builder extends MissingDefinitionInfoBase.Builder {
+
+ private ClassReference classReference;
+
+ private Builder() {}
+
+ public Builder setClass(ClassReference classReference) {
+ this.classReference = classReference;
+ return this;
+ }
+
+ public MissingDefinitionInfo build() {
+ return new MissingClassInfoImpl(classReference, referencedFromContextsBuilder.build());
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionClassContextImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionClassContextImpl.java
new file mode 100644
index 0000000..7944a1e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionClassContextImpl.java
@@ -0,0 +1,59 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionClassContext;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.ClassReference;
+
+public class MissingDefinitionClassContextImpl extends MissingDefinitionContextBase
+ implements MissingDefinitionClassContext {
+
+ private final ClassReference classReference;
+
+ private MissingDefinitionClassContextImpl(ClassReference classReference, Origin origin) {
+ super(origin);
+ this.classReference = classReference;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ @Override
+ public ClassReference getClassReference() {
+ return classReference;
+ }
+
+ public static class Builder extends MissingDefinitionContextBase.Builder<Builder> {
+
+ private ClassReference classReference;
+
+ private Builder() {}
+
+ public Builder setClassContext(ClassReference classReference) {
+ this.classReference = classReference;
+ return this;
+ }
+
+ @Override
+ Builder self() {
+ return this;
+ }
+
+ @Override
+ public MissingDefinitionClassContextImpl build() {
+ assert validate();
+ return new MissingDefinitionClassContextImpl(classReference, origin);
+ }
+
+ @Override
+ public boolean validate() {
+ super.validate();
+ assert classReference != null;
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextBase.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextBase.java
new file mode 100644
index 0000000..cf6a0d1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextBase.java
@@ -0,0 +1,41 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.origin.Origin;
+
+public abstract class MissingDefinitionContextBase implements MissingDefinitionContext {
+
+ private final Origin origin;
+
+ MissingDefinitionContextBase(Origin origin) {
+ this.origin = origin;
+ }
+
+ @Override
+ public Origin getOrigin() {
+ return origin;
+ }
+
+ abstract static class Builder<B extends Builder<B>> {
+
+ Origin origin;
+
+ public B setOrigin(Origin origin) {
+ this.origin = origin;
+ return self();
+ }
+
+ abstract B self();
+
+ public abstract MissingDefinitionContext build();
+
+ public boolean validate() {
+ assert origin != null;
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextUtils.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextUtils.java
new file mode 100644
index 0000000..74b48c5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionContextUtils.java
@@ -0,0 +1,79 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionClassContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionFieldContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionMethodContext;
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.Definition;
+import com.android.tools.r8.graph.ProgramDerivedContext;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class MissingDefinitionContextUtils {
+
+ public static void accept(
+ MissingDefinitionContext missingDefinitionContext,
+ Consumer<MissingDefinitionClassContext> missingDefinitionClassContextConsumer,
+ Consumer<MissingDefinitionFieldContext> missingDefinitionFieldContextConsumer,
+ Consumer<MissingDefinitionMethodContext> missingDefinitionMethodContextConsumer) {
+ if (missingDefinitionContext.isClassContext()) {
+ missingDefinitionClassContextConsumer.accept(missingDefinitionContext.asClassContext());
+ } else if (missingDefinitionContext.isFieldContext()) {
+ missingDefinitionFieldContextConsumer.accept(missingDefinitionContext.asFieldContext());
+ } else {
+ assert missingDefinitionContext.isMethodContext();
+ missingDefinitionMethodContextConsumer.accept(missingDefinitionContext.asMethodContext());
+ }
+ }
+
+ public static <T> T apply(
+ MissingDefinitionContext missingDefinitionContext,
+ Function<MissingDefinitionClassContext, T> missingDefinitionClassContextFn,
+ Function<MissingDefinitionFieldContext, T> missingDefinitionFieldContextFn,
+ Function<MissingDefinitionMethodContext, T> missingDefinitionMethodContextFn) {
+ if (missingDefinitionContext.isClassContext()) {
+ return missingDefinitionClassContextFn.apply(missingDefinitionContext.asClassContext());
+ } else if (missingDefinitionContext.isFieldContext()) {
+ return missingDefinitionFieldContextFn.apply(missingDefinitionContext.asFieldContext());
+ } else {
+ assert missingDefinitionContext.isMethodContext();
+ return missingDefinitionMethodContextFn.apply(missingDefinitionContext.asMethodContext());
+ }
+ }
+
+ public static MissingDefinitionContext create(ProgramDerivedContext programDerivedContext) {
+ Definition context = programDerivedContext.getContext();
+ MissingDefinitionContextBase.Builder<?> builder;
+ if (context.isClass()) {
+ builder =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(context.asClass().getClassReference());
+ } else if (context.isField()) {
+ builder =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(context.asField().getFieldReference());
+ } else if (context.isMethod()) {
+ builder =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(context.asMethod().getMethodReference());
+ } else {
+ throw new Unreachable();
+ }
+ return builder.setOrigin(context.getOrigin()).build();
+ }
+
+ public static String toSourceString(MissingDefinitionContext missingDefinitionContext) {
+ return MissingDefinitionContextUtils.apply(
+ missingDefinitionContext,
+ classContext -> classContext.getClassReference().getTypeName(),
+ fieldContext -> FieldReferenceUtils.toSourceString(fieldContext.getFieldReference()),
+ methodContext -> MethodReferenceUtils.toSourceString(methodContext.getMethodReference()));
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionFieldContextImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionFieldContextImpl.java
new file mode 100644
index 0000000..b9ecf41
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionFieldContextImpl.java
@@ -0,0 +1,59 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionFieldContext;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.FieldReference;
+
+public class MissingDefinitionFieldContextImpl extends MissingDefinitionContextBase
+ implements MissingDefinitionFieldContext {
+
+ private final FieldReference fieldReference;
+
+ private MissingDefinitionFieldContextImpl(FieldReference fieldReference, Origin origin) {
+ super(origin);
+ this.fieldReference = fieldReference;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ @Override
+ public FieldReference getFieldReference() {
+ return fieldReference;
+ }
+
+ public static class Builder extends MissingDefinitionContextBase.Builder<Builder> {
+
+ private FieldReference fieldReference;
+
+ private Builder() {}
+
+ public Builder setFieldContext(FieldReference fieldReference) {
+ this.fieldReference = fieldReference;
+ return this;
+ }
+
+ @Override
+ Builder self() {
+ return this;
+ }
+
+ @Override
+ public MissingDefinitionFieldContextImpl build() {
+ assert validate();
+ return new MissingDefinitionFieldContextImpl(fieldReference, origin);
+ }
+
+ @Override
+ public boolean validate() {
+ super.validate();
+ assert fieldReference != null;
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java
new file mode 100644
index 0000000..0f9e655
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoBase.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+
+public abstract class MissingDefinitionInfoBase implements MissingDefinitionInfo {
+
+ final Collection<MissingDefinitionContext> referencedFromContexts;
+
+ MissingDefinitionInfoBase(Collection<MissingDefinitionContext> referencedFromContexts) {
+ this.referencedFromContexts = referencedFromContexts;
+ }
+
+ @Override
+ public final Collection<MissingDefinitionContext> getReferencedFromContexts() {
+ return referencedFromContexts;
+ }
+
+ public abstract static class Builder {
+
+ final ImmutableList.Builder<MissingDefinitionContext> referencedFromContextsBuilder =
+ ImmutableList.builder();
+
+ Builder() {}
+
+ public Builder addReferencedFromContext(MissingDefinitionContext missingDefinitionContext) {
+ referencedFromContextsBuilder.add(missingDefinitionContext);
+ return this;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java
new file mode 100644
index 0000000..29d008f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionInfoUtils.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingClassInfo;
+import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
+import com.android.tools.r8.diagnostic.MissingFieldInfo;
+import com.android.tools.r8.diagnostic.MissingMethodInfo;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.utils.ClassReferenceUtils;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import java.util.Comparator;
+import java.util.function.Consumer;
+
+public class MissingDefinitionInfoUtils {
+
+ private static final Comparator<MissingDefinitionInfo> COMPARATOR =
+ (info, other) -> {
+ if (info.isMissingClass()) {
+ ClassReference classReference = info.asMissingClass().getClassReference();
+ if (other.isMissingClass()) {
+ return ClassReferenceUtils.compare(
+ classReference, other.asMissingClass().getClassReference());
+ }
+ if (other.isMissingField()) {
+ return ClassReferenceUtils.compare(
+ classReference, other.asMissingField().getFieldReference().getHolderClass());
+ }
+ return ClassReferenceUtils.compare(
+ classReference, other.asMissingMethod().getMethodReference().getHolderClass());
+ }
+ if (info.isMissingField()) {
+ FieldReference fieldReference = info.asMissingField().getFieldReference();
+ if (other.isMissingClass()) {
+ return ClassReferenceUtils.compare(
+ fieldReference.getHolderClass(), other.asMissingClass().getClassReference());
+ }
+ if (other.isMissingField()) {
+ return FieldReferenceUtils.compare(
+ fieldReference, other.asMissingField().getFieldReference());
+ }
+ return ClassReferenceUtils.compare(
+ fieldReference.getHolderClass(),
+ other.asMissingMethod().getMethodReference().getHolderClass());
+ }
+ MethodReference methodReference = info.asMissingMethod().getMethodReference();
+ if (other.isMissingClass()) {
+ return ClassReferenceUtils.compare(
+ methodReference.getHolderClass(), other.asMissingClass().getClassReference());
+ }
+ if (other.isMissingField()) {
+ ClassReferenceUtils.compare(
+ methodReference.getHolderClass(),
+ other.asMissingField().getFieldReference().getHolderClass());
+ }
+ return MethodReferenceUtils.compare(
+ methodReference, other.asMissingMethod().getMethodReference());
+ };
+
+ public static void accept(
+ MissingDefinitionInfo missingDefinitionInfo,
+ Consumer<MissingClassInfo> missingClassInfoConsumer,
+ Consumer<MissingFieldInfo> missingFieldInfoConsumer,
+ Consumer<MissingMethodInfo> missingMethodInfoConsumer) {
+ if (missingDefinitionInfo.isMissingClass()) {
+ missingClassInfoConsumer.accept(missingDefinitionInfo.asMissingClass());
+ } else if (missingDefinitionInfo.isMissingField()) {
+ missingFieldInfoConsumer.accept(missingDefinitionInfo.asMissingField());
+ } else {
+ assert missingDefinitionInfo.isMissingMethod();
+ missingMethodInfoConsumer.accept(missingDefinitionInfo.asMissingMethod());
+ }
+ }
+
+ public static Comparator<MissingDefinitionInfo> getComparator() {
+ return COMPARATOR;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionMethodContextImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionMethodContextImpl.java
new file mode 100644
index 0000000..eba8719
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionMethodContextImpl.java
@@ -0,0 +1,59 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnostic.internal;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionMethodContext;
+import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.MethodReference;
+
+public class MissingDefinitionMethodContextImpl extends MissingDefinitionContextBase
+ implements MissingDefinitionMethodContext {
+
+ private final MethodReference methodReference;
+
+ private MissingDefinitionMethodContextImpl(MethodReference methodReference, Origin origin) {
+ super(origin);
+ this.methodReference = methodReference;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ @Override
+ public MethodReference getMethodReference() {
+ return methodReference;
+ }
+
+ public static class Builder extends MissingDefinitionContextBase.Builder<Builder> {
+
+ private MethodReference methodReference;
+
+ private Builder() {}
+
+ public Builder setMethodContext(MethodReference methodReference) {
+ this.methodReference = methodReference;
+ return this;
+ }
+
+ @Override
+ Builder self() {
+ return this;
+ }
+
+ @Override
+ public MissingDefinitionMethodContextImpl build() {
+ assert validate();
+ return new MissingDefinitionMethodContextImpl(methodReference, origin);
+ }
+
+ @Override
+ public boolean validate() {
+ super.validate();
+ assert methodReference != null;
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionsDiagnosticImpl.java b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionsDiagnosticImpl.java
index 044b1d5..5da21fd 100644
--- a/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionsDiagnosticImpl.java
+++ b/src/main/java/com/android/tools/r8/diagnostic/internal/MissingDefinitionsDiagnosticImpl.java
@@ -4,48 +4,50 @@
package com.android.tools.r8.diagnostic.internal;
+import static com.android.tools.r8.utils.ClassReferenceUtils.getClassReferenceComparator;
+import static com.android.tools.r8.utils.FieldReferenceUtils.getFieldReferenceComparator;
+import static com.android.tools.r8.utils.MethodReferenceUtils.getMethodReferenceComparator;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
-import com.android.tools.r8.errors.Unimplemented;
-import com.android.tools.r8.graph.DexReference;
-import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.position.Position;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.Reference;
-import com.google.common.collect.ImmutableSortedMap;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
import java.util.Collection;
-import java.util.Comparator;
import java.util.Iterator;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.SortedMap;
+import java.util.List;
public class MissingDefinitionsDiagnosticImpl implements MissingDefinitionsDiagnostic {
- private final boolean fatal;
- private final SortedMap<ClassReference, MissingClassAccessContexts> missingClasses;
+ private final Collection<MissingDefinitionInfo> missingDefinitions;
- private MissingDefinitionsDiagnosticImpl(
- boolean fatal, SortedMap<ClassReference, MissingClassAccessContexts> missingClasses) {
- assert !missingClasses.isEmpty();
- this.fatal = fatal;
- this.missingClasses = missingClasses;
+ private MissingDefinitionsDiagnosticImpl(Collection<MissingDefinitionInfo> missingDefinitions) {
+ assert !missingDefinitions.isEmpty();
+ this.missingDefinitions = missingDefinitions;
}
public static Builder builder() {
return new Builder();
}
- @Deprecated
- public Set<ClassReference> getMissingClasses() {
- return missingClasses.keySet();
- }
-
@Override
public Collection<MissingDefinitionInfo> getMissingDefinitions() {
- throw new Unimplemented();
+ return missingDefinitions;
+ }
+
+ private Collection<MissingDefinitionInfo> getMissingDefinitionsWithDeterministicOrder() {
+ List<MissingDefinitionInfo> missingDefinitionsWithDeterministicOrder =
+ new ArrayList<>(getMissingDefinitions());
+ missingDefinitionsWithDeterministicOrder.sort(MissingDefinitionInfoUtils.getComparator());
+ return missingDefinitionsWithDeterministicOrder;
}
/** A missing class(es) failure can generally not be attributed to a single origin. */
@@ -62,84 +64,102 @@
@Override
public String getDiagnosticMessage() {
- return fatal ? getFatalDiagnosticMessage() : getNonFatalDiagnosticMessage();
- }
-
- private String getFatalDiagnosticMessage() {
- if (missingClasses.size() == 1) {
- StringBuilder builder =
- new StringBuilder(
- "Compilation can't be completed because the following class is missing: ");
- writeMissingClass(builder, missingClasses.entrySet().iterator().next());
- return builder.append(".").toString();
- }
-
- StringBuilder builder =
- new StringBuilder("Compilation can't be completed because the following ")
- .append(missingClasses.size())
- .append(" classes are missing:");
- missingClasses.forEach(
- (missingClass, contexts) ->
- writeMissingClass(
- builder.append(System.lineSeparator()).append("- "), missingClass, contexts));
- return builder.toString();
- }
-
- private String getNonFatalDiagnosticMessage() {
StringBuilder builder = new StringBuilder();
- Iterator<Entry<ClassReference, MissingClassAccessContexts>> missingClassesIterator =
- missingClasses.entrySet().iterator();
+ Iterator<MissingDefinitionInfo> missingDefinitionsIterator =
+ getMissingDefinitionsWithDeterministicOrder().iterator();
// The diagnostic is always non-empty.
- assert missingClassesIterator.hasNext();
+ assert missingDefinitionsIterator.hasNext();
// Write first line.
- writeMissingClass(builder.append("Missing class "), missingClassesIterator.next());
+ writeMissingDefinition(builder.append("Missing class "), missingDefinitionsIterator.next());
// Write remaining lines with line separator before.
- missingClassesIterator.forEachRemaining(
- missingClassInfo ->
- writeMissingClass(
- builder.append(System.lineSeparator()).append("Missing class "), missingClassInfo));
+ missingDefinitionsIterator.forEachRemaining(
+ missingDefinition ->
+ writeMissingDefinition(
+ builder.append(System.lineSeparator()).append("Missing class "),
+ missingDefinition));
return builder.toString();
}
- private static void writeMissingClass(
- StringBuilder builder, Entry<ClassReference, MissingClassAccessContexts> missingClassInfo) {
- writeMissingClass(builder, missingClassInfo.getKey(), missingClassInfo.getValue());
+ private static void writeMissingDefinition(
+ StringBuilder builder, MissingDefinitionInfo missingDefinitionInfo) {
+ MissingDefinitionInfoUtils.accept(
+ missingDefinitionInfo,
+ missingClassInfo -> builder.append(missingClassInfo.getClassReference().getTypeName()),
+ missingFieldInfo ->
+ builder.append(
+ FieldReferenceUtils.toSourceString(missingFieldInfo.getFieldReference())),
+ missingMethodInfo ->
+ builder.append(
+ MethodReferenceUtils.toSourceString(missingMethodInfo.getMethodReference())));
+ writeReferencedFromSuffix(builder, missingDefinitionInfo);
}
- private static void writeMissingClass(
- StringBuilder builder, ClassReference missingClass, MissingClassAccessContexts contexts) {
- builder
- .append(missingClass.getTypeName())
- .append(contexts.getReferencedFromMessageSuffix(missingClass));
+ private static void writeReferencedFromSuffix(
+ StringBuilder builder, MissingDefinitionInfo missingDefinitionInfo) {
+ Box<ClassReference> classContext = new Box<>();
+ Box<FieldReference> fieldContext = new Box<>();
+ Box<MethodReference> methodContext = new Box<>();
+ for (MissingDefinitionContext missingDefinitionContext :
+ missingDefinitionInfo.getReferencedFromContexts()) {
+ MissingDefinitionContextUtils.accept(
+ missingDefinitionContext,
+ missingDefinitionClassContext ->
+ classContext.setMin(
+ missingDefinitionClassContext.getClassReference(), getClassReferenceComparator()),
+ missingDefinitionFieldContext ->
+ fieldContext.setMin(
+ missingDefinitionFieldContext.getFieldReference(), getFieldReferenceComparator()),
+ missingDefinitionMethodContext ->
+ methodContext.setMin(
+ missingDefinitionMethodContext.getMethodReference(),
+ getMethodReferenceComparator()));
+ }
+ if (fieldContext.isSet()) {
+ writeReferencedFromSuffix(
+ builder, missingDefinitionInfo, FieldReferenceUtils.toSourceString(fieldContext.get()));
+ } else if (methodContext.isSet()) {
+ writeReferencedFromSuffix(
+ builder, missingDefinitionInfo, MethodReferenceUtils.toSourceString(methodContext.get()));
+ } else if (classContext.isSet()) {
+ writeReferencedFromSuffix(builder, missingDefinitionInfo, classContext.get().getTypeName());
+ } else {
+ // TODO(b/175543745): Once legacy reporting is removed this should never happen.
+ builder.append(" (referenced from: <not known>)");
+ }
+ }
+
+ private static void writeReferencedFromSuffix(
+ StringBuilder builder, MissingDefinitionInfo missingDefinitionInfo, String referencedFrom) {
+ int numberOfOtherContexts = missingDefinitionInfo.getReferencedFromContexts().size() - 1;
+ assert numberOfOtherContexts >= 0;
+ builder.append(" (referenced from: ").append(referencedFrom);
+ if (numberOfOtherContexts >= 1) {
+ builder.append(", and ").append(numberOfOtherContexts).append(" other context");
+ if (numberOfOtherContexts >= 2) {
+ builder.append("s");
+ }
+ }
+ builder.append(")");
}
public static class Builder {
- private boolean fatal;
- private ImmutableSortedMap.Builder<ClassReference, MissingClassAccessContexts>
- missingClassesBuilder =
- ImmutableSortedMap.orderedBy(Comparator.comparing(ClassReference::getDescriptor));
+ private ImmutableList.Builder<MissingDefinitionInfo> missingDefinitionsBuilder =
+ ImmutableList.builder();
- public Builder addMissingClasses(Map<DexType, Set<DexReference>> missingClasses) {
- missingClasses.forEach(
- (missingClass, contexts) ->
- missingClassesBuilder.put(
- Reference.classFromDescriptor(missingClass.toDescriptorString()),
- MissingClassAccessContexts.builder().addAll(contexts).build()));
- return this;
- }
+ private Builder() {}
- public Builder setFatal(boolean fatal) {
- this.fatal = fatal;
+ public Builder addMissingDefinitionInfo(MissingDefinitionInfo missingDefinition) {
+ missingDefinitionsBuilder.add(missingDefinition);
return this;
}
public MissingDefinitionsDiagnostic build() {
- return new MissingDefinitionsDiagnosticImpl(fatal, missingClassesBuilder.build());
+ return new MissingDefinitionsDiagnosticImpl(missingDefinitionsBuilder.build());
}
}
}
diff --git a/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java b/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java
index ff4a73d..d14300b 100644
--- a/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java
+++ b/src/main/java/com/android/tools/r8/errors/dontwarn/DontWarnConfiguration.java
@@ -4,11 +4,10 @@
package com.android.tools.r8.errors.dontwarn;
-import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.Definition;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.shaking.ProguardConfiguration;
import com.android.tools.r8.utils.InternalOptions;
-import java.util.Set;
public abstract class DontWarnConfiguration {
@@ -24,10 +23,8 @@
return new EmptyDontWarnConfiguration();
}
- public abstract Set<DexType> getNonMatches(Set<DexType> types);
-
- public final boolean matches(DexClass clazz) {
- return matches(clazz.getType());
+ public final boolean matches(Definition clazz) {
+ return matches(clazz.getContextType());
}
public abstract boolean matches(DexType type);
diff --git a/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java b/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java
index e115168..4cc7f04 100644
--- a/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java
+++ b/src/main/java/com/android/tools/r8/errors/dontwarn/EmptyDontWarnConfiguration.java
@@ -6,16 +6,10 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.utils.InternalOptions;
-import java.util.Set;
public class EmptyDontWarnConfiguration extends DontWarnConfiguration {
@Override
- public Set<DexType> getNonMatches(Set<DexType> types) {
- return types;
- }
-
- @Override
public boolean matches(DexType type) {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java b/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java
index 89bcb10..ae31723 100644
--- a/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java
+++ b/src/main/java/com/android/tools/r8/errors/dontwarn/NonEmptyDontWarnConfiguration.java
@@ -29,17 +29,6 @@
}
@Override
- public Set<DexType> getNonMatches(Set<DexType> types) {
- Set<DexType> nonMatches = Sets.newIdentityHashSet();
- for (DexType type : types) {
- if (!matches(type)) {
- nonMatches.add(type);
- }
- }
- return nonMatches;
- }
-
- @Override
public boolean matches(DexType type) {
for (ProguardClassNameList dontWarnPattern : dontWarnPatterns) {
if (dontWarnPattern.matches(type)) {
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index 8b09674..7622121 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -39,6 +39,7 @@
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.InternalOptions.TestingOptions;
import com.android.tools.r8.utils.OptionalBool;
+import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.ThrowingConsumer;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableSet;
@@ -454,6 +455,10 @@
return appInfo.options();
}
+ public Reporter reporter() {
+ return options().reporter;
+ }
+
public TestingOptions testing() {
return options().testing;
}
diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index 4247d74..337ec1d 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -135,8 +135,8 @@
// TODO(b/135969130): Make IR building lens aware and avoid caching the holder type.
private final DexType originalHolder;
- private final int maxStack;
private int maxLocals;
+ private int maxStack;
private List<CfInstruction> instructions;
private final List<CfTryCatch> tryCatchRanges;
private final List<LocalVariableInfo> localVariables;
@@ -188,6 +188,10 @@
maxLocals = newMaxLocals;
}
+ public void setMaxStack(int newMaxStack) {
+ maxStack = newMaxStack;
+ }
+
public List<CfTryCatch> getTryCatchRanges() {
return tryCatchRanges;
}
diff --git a/src/main/java/com/android/tools/r8/graph/ClassDefinition.java b/src/main/java/com/android/tools/r8/graph/ClassDefinition.java
new file mode 100644
index 0000000..f4f1c31
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClassDefinition.java
@@ -0,0 +1,45 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.graph;
+
+import com.android.tools.r8.references.ClassReference;
+import java.util.function.Consumer;
+
+public interface ClassDefinition extends Definition {
+
+ Iterable<DexType> allImmediateSupertypes();
+
+ void forEachClassField(Consumer<? super DexClassAndField> consumer);
+
+ void forEachClassMethod(Consumer<? super DexClassAndMethod> consumer);
+
+ MethodCollection getMethodCollection();
+
+ ClassReference getClassReference();
+
+ DexType getType();
+
+ @Override
+ default boolean isClass() {
+ return true;
+ }
+
+ @Override
+ default ClassDefinition asClass() {
+ return this;
+ }
+
+ boolean isClasspathClass();
+
+ DexClasspathClass asClasspathClass();
+
+ boolean isLibraryClass();
+
+ DexLibraryClass asLibraryClass();
+
+ boolean isProgramClass();
+
+ DexProgramClass asProgramClass();
+}
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathClass.java b/src/main/java/com/android/tools/r8/graph/ClasspathClass.java
new file mode 100644
index 0000000..9ae72e4
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathClass.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.graph;
+
+public interface ClasspathClass extends ClasspathDefinition, ClasspathOrLibraryClass {}
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java b/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java
index 89013fd..11cd7ad 100644
--- a/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathDefinition.java
@@ -6,7 +6,7 @@
import java.util.function.Function;
-public interface ClasspathDefinition extends Definition {
+public interface ClasspathDefinition extends ClasspathOrLibraryDefinition {
@Override
default <T> T apply(
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryClass.java b/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryClass.java
new file mode 100644
index 0000000..cf385e0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryClass.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.graph;
+
+public interface ClasspathOrLibraryClass extends ClassDefinition, ClasspathOrLibraryDefinition {}
diff --git a/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryDefinition.java b/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryDefinition.java
new file mode 100644
index 0000000..261e6bd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ClasspathOrLibraryDefinition.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.graph;
+
+public interface ClasspathOrLibraryDefinition extends Definition {
+
+ @Override
+ default ClasspathOrLibraryDefinition asClasspathOrLibraryDefinition() {
+ return this;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/Definition.java b/src/main/java/com/android/tools/r8/graph/Definition.java
index a7e4ed9..7e42398 100644
--- a/src/main/java/com/android/tools/r8/graph/Definition.java
+++ b/src/main/java/com/android/tools/r8/graph/Definition.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.graph;
+import com.android.tools.r8.origin.Origin;
import java.util.function.Function;
public interface Definition {
@@ -13,9 +14,51 @@
Function<ClasspathDefinition, T> classpathFunction,
Function<LibraryDefinition, T> libraryFunction);
+ default ClasspathOrLibraryClass asClasspathOrLibraryClass() {
+ return null;
+ }
+
+ default ClasspathOrLibraryDefinition asClasspathOrLibraryDefinition() {
+ return null;
+ }
+
ProgramDerivedContext asProgramDerivedContext(ProgramDerivedContext witness);
DexType getContextType();
+ Origin getOrigin();
+
DexReference getReference();
+
+ default boolean isClass() {
+ return false;
+ }
+
+ default ClassDefinition asClass() {
+ return null;
+ }
+
+ default boolean isField() {
+ return false;
+ }
+
+ default DexClassAndField asField() {
+ return null;
+ }
+
+ default boolean isMethod() {
+ return false;
+ }
+
+ default DexClassAndMethod asMethod() {
+ return null;
+ }
+
+ default boolean isProgramDefinition() {
+ return false;
+ }
+
+ default ProgramDefinition asProgramDefinition() {
+ return null;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 2b45551..f0745c8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -12,6 +12,8 @@
import com.android.tools.r8.graph.GenericSignature.ClassSignature;
import com.android.tools.r8.kotlin.KotlinClassLevelInfo;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.IterableUtils;
import com.android.tools.r8.utils.OptionalBool;
@@ -33,7 +35,7 @@
import java.util.function.Function;
import java.util.function.Predicate;
-public abstract class DexClass extends DexDefinition implements Definition {
+public abstract class DexClass extends DexDefinition implements ClassDefinition {
public interface FieldSetter {
void setField(int index, DexEncodedField field);
@@ -132,6 +134,17 @@
Consumer<DexClasspathClass> classpathClassConsumer,
Consumer<DexLibraryClass> libraryClassConsumer);
+ @Override
+ public void forEachClassField(Consumer<? super DexClassAndField> consumer) {
+ forEachClassFieldMatching(alwaysTrue(), consumer);
+ }
+
+ public void forEachClassFieldMatching(
+ Predicate<DexEncodedField> predicate, Consumer<? super DexClassAndField> consumer) {
+ forEachFieldMatching(predicate, field -> consumer.accept(DexClassAndField.create(this, field)));
+ }
+
+ @Override
public void forEachClassMethod(Consumer<? super DexClassAndMethod> consumer) {
forEachClassMethodMatching(alwaysTrue(), consumer);
}
@@ -177,6 +190,7 @@
return Iterables.concat(fields(predicate), methods(predicate));
}
+ @Override
public MethodCollection getMethodCollection() {
return methodCollection;
}
@@ -277,12 +291,12 @@
}
public void forEachField(Consumer<DexEncodedField> consumer) {
- for (DexEncodedField field : staticFields()) {
- consumer.accept(field);
- }
- for (DexEncodedField field : instanceFields()) {
- consumer.accept(field);
- }
+ forEachFieldMatching(alwaysTrue(), consumer);
+ }
+
+ public void forEachFieldMatching(
+ Predicate<DexEncodedField> predicate, Consumer<DexEncodedField> consumer) {
+ fields(predicate).forEach(consumer);
}
public TraversalContinuation traverseFields(Function<DexEncodedField, TraversalContinuation> fn) {
@@ -613,20 +627,24 @@
return this;
}
+ @Override
public boolean isClasspathClass() {
return false;
}
+ @Override
public DexClasspathClass asClasspathClass() {
return null;
}
public abstract boolean isNotProgramClass();
+ @Override
public boolean isLibraryClass() {
return false;
}
+ @Override
public DexLibraryClass asLibraryClass() {
return null;
}
@@ -655,10 +673,17 @@
return classInitializer;
}
+ @Override
+ public ClassReference getClassReference() {
+ return Reference.classFromDescriptor(getType().toDescriptorString());
+ }
+
+ @Override
public Origin getOrigin() {
return this.origin;
}
+ @Override
public DexType getType() {
return type;
}
@@ -761,6 +786,7 @@
}
}
+ @Override
public Iterable<DexType> allImmediateSupertypes() {
Iterator<DexType> iterator =
superType != null
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndField.java b/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
index 505a7ec..e2deec9 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndField.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.graph;
+import com.android.tools.r8.references.FieldReference;
+
public abstract class DexClassAndField extends DexClassAndMember<DexEncodedField, DexField> {
DexClassAndField(DexClass holder, DexEncodedField field) {
@@ -29,10 +31,24 @@
return getDefinition().getAccessFlags();
}
+ public FieldReference getFieldReference() {
+ return getReference().asFieldReference();
+ }
+
public DexType getType() {
return getReference().getType();
}
+ @Override
+ public boolean isField() {
+ return true;
+ }
+
+ @Override
+ public DexClassAndField asField() {
+ return this;
+ }
+
public boolean isClasspathField() {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
index 8459067..2ac7ced 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMember.java
@@ -49,6 +49,7 @@
return definition.getReference();
}
+ @Override
public Origin getOrigin() {
return holder.origin;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
index d944c02..6ab995d 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClassAndMethod.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.graph;
+import com.android.tools.r8.references.MethodReference;
+
public abstract class DexClassAndMethod extends DexClassAndMember<DexEncodedMethod, DexMethod>
implements LookupTarget {
@@ -42,10 +44,22 @@
return getDefinition().getAccessFlags();
}
+ public MethodReference getMethodReference() {
+ return getReference().asMethodReference();
+ }
+
+ public DexTypeList getParameters() {
+ return getReference().getParameters();
+ }
+
public DexProto getProto() {
return getReference().getProto();
}
+ public DexType getReturnType() {
+ return getReference().getReturnType();
+ }
+
@Override
public boolean isMethodTarget() {
return true;
@@ -56,6 +70,16 @@
return this;
}
+ @Override
+ public boolean isMethod() {
+ return true;
+ }
+
+ @Override
+ public DexClassAndMethod asMethod() {
+ return this;
+ }
+
public boolean isClasspathMethod() {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java b/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
index 125155e..6385ecc 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClasspathClass.java
@@ -22,7 +22,7 @@
import java.util.function.Supplier;
public class DexClasspathClass extends DexClass
- implements ClasspathDefinition, Supplier<DexClasspathClass>, StructuralItem<DexClasspathClass> {
+ implements ClasspathClass, Supplier<DexClasspathClass>, StructuralItem<DexClasspathClass> {
public DexClasspathClass(
DexType type,
@@ -103,6 +103,11 @@
return this;
}
+ @Override
+ public DexClasspathClass asClasspathOrLibraryClass() {
+ return this;
+ }
+
public static DexClasspathClass asClasspathClassOrNull(DexClass clazz) {
return clazz != null ? clazz.asClasspathClass() : null;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexField.java b/src/main/java/com/android/tools/r8/graph/DexField.java
index 5ebf3ae..ef99d01 100644
--- a/src/main/java/com/android/tools/r8/graph/DexField.java
+++ b/src/main/java/com/android/tools/r8/graph/DexField.java
@@ -36,6 +36,19 @@
}
@Override
+ public int compareTo(DexReference other) {
+ if (other.isDexField()) {
+ return compareTo(other.asDexField());
+ }
+ if (other.isDexMethod()) {
+ int comparisonResult = getHolderType().compareTo(other.getContextType());
+ return comparisonResult != 0 ? comparisonResult : -1;
+ }
+ int comparisonResult = getHolderType().compareTo(other.asDexType());
+ return comparisonResult != 0 ? comparisonResult : 1;
+ }
+
+ @Override
public DexField self() {
return this;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index ed0339d..0752d20 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -438,7 +438,18 @@
public final DexType timeConversionsType =
createStaticallyKnownType("Ljava/time/TimeConversions;");
- public Iterable<DexType> getConversionTypes() {
+ public final DexType doubleSummaryStatisticsConversionsJ$Type =
+ createStaticallyKnownType("Lj$/util/DoubleSummaryStatisticsConversions;");
+ public final DexType intSummaryStatisticsConversionsJ$Type =
+ createStaticallyKnownType("Lj$/util/IntSummaryStatisticsConversions;");
+ public final DexType longSummaryStatisticsConversionsJ$Type =
+ createStaticallyKnownType("Lj$/util/LongSummaryStatisticsConversions;");
+ public final DexType optionalConversionsJ$Type =
+ createStaticallyKnownType("Lj$/util/OptionalConversions;");
+ public final DexType timeConversionsJ$Type =
+ createStaticallyKnownType("Lj$/time/TimeConversions;");
+
+ public Iterable<DexType> getJavaConversionTypes() {
return ImmutableList.of(
doubleSummaryStatisticsConversionsType,
intSummaryStatisticsConversionsType,
@@ -447,6 +458,15 @@
timeConversionsType);
}
+ public Iterable<DexType> getJ$ConversionTypes() {
+ return ImmutableList.of(
+ doubleSummaryStatisticsConversionsJ$Type,
+ intSummaryStatisticsConversionsJ$Type,
+ longSummaryStatisticsConversionsJ$Type,
+ optionalConversionsJ$Type,
+ timeConversionsJ$Type);
+ }
+
public final DexType javaIoFileType = createStaticallyKnownType("Ljava/io/File;");
public final DexType javaMathBigIntegerType = createStaticallyKnownType("Ljava/math/BigInteger;");
public final DexType javaNioByteOrderType = createStaticallyKnownType("Ljava/nio/ByteOrder;");
@@ -616,8 +636,12 @@
public final DexType externalizableType = createStaticallyKnownType("Ljava/io/Externalizable;");
public final DexType cloneableType = createStaticallyKnownType("Ljava/lang/Cloneable;");
public final DexType comparableType = createStaticallyKnownType("Ljava/lang/Comparable;");
+ public final DexType stringConcatFactoryType =
+ createStaticallyKnownType("Ljava/lang/invoke/StringConcatFactory;");
public final ServiceLoaderMethods serviceLoaderMethods = new ServiceLoaderMethods();
+ public final StringConcatFactoryMembers stringConcatFactoryMembers =
+ new StringConcatFactoryMembers();
public final BiMap<DexType, DexType> primitiveToBoxed = HashBiMap.create(
ImmutableMap.<DexType, DexType>builder()
@@ -678,33 +702,6 @@
public final DexMethod deserializeLambdaMethod =
createMethod(objectType, deserializeLambdaMethodProto, deserializeLambdaMethodName);
- public final DexType stringConcatFactoryType =
- createStaticallyKnownType("Ljava/lang/invoke/StringConcatFactory;");
-
- public final DexMethod stringConcatWithConstantsMethod =
- createMethod(
- stringConcatFactoryType,
- createProto(
- callSiteType,
- lookupType,
- stringType,
- methodTypeType,
- stringType,
- objectArrayType),
- createString("makeConcatWithConstants")
- );
-
- public final DexMethod stringConcatMethod =
- createMethod(
- stringConcatFactoryType,
- createProto(
- callSiteType,
- lookupType,
- stringType,
- methodTypeType),
- createString("makeConcat")
- );
-
public Map<DexMethod, int[]> libraryMethodsNonNullParamOrThrow =
buildLibraryMethodsNonNullParamOrThrow();
@@ -1155,6 +1152,21 @@
}
}
+ public class StringConcatFactoryMembers {
+
+ public final DexMethod makeConcat =
+ createMethod(
+ stringConcatFactoryType,
+ createProto(callSiteType, lookupType, stringType, methodTypeType),
+ createString("makeConcat"));
+ public final DexMethod makeConcatWithConstants =
+ createMethod(
+ stringConcatFactoryType,
+ createProto(
+ callSiteType, lookupType, stringType, methodTypeType, stringType, objectArrayType),
+ createString("makeConcatWithConstants"));
+ }
+
public class ThrowableMethods {
public final DexMethod addSuppressed;
diff --git a/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java b/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
index f34162c..92659f8 100644
--- a/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexLibraryClass.java
@@ -17,8 +17,7 @@
import java.util.function.Predicate;
import java.util.function.Supplier;
-public class DexLibraryClass extends DexClass
- implements LibraryDefinition, Supplier<DexLibraryClass> {
+public class DexLibraryClass extends DexClass implements LibraryClass, Supplier<DexLibraryClass> {
public DexLibraryClass(
DexType type,
@@ -126,6 +125,11 @@
}
@Override
+ public DexLibraryClass asClasspathOrLibraryClass() {
+ return this;
+ }
+
+ @Override
public KotlinClassLevelInfo getKotlinInfo() {
throw new Unreachable("We should never consider metadata for library classes");
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethod.java b/src/main/java/com/android/tools/r8/graph/DexMethod.java
index 29e9792..8484a94 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethod.java
@@ -36,6 +36,15 @@
}
@Override
+ public int compareTo(DexReference other) {
+ if (other.isDexMethod()) {
+ return compareTo(other.asDexMethod());
+ }
+ int comparisonResult = getHolderType().compareTo(other.getContextType());
+ return comparisonResult != 0 ? comparisonResult : 1;
+ }
+
+ @Override
public StructuralMapping<DexMethod> getStructuralMapping() {
return DexMethod::specify;
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexProto.java b/src/main/java/com/android/tools/r8/graph/DexProto.java
index 36ad355..dc30560 100644
--- a/src/main/java/com/android/tools/r8/graph/DexProto.java
+++ b/src/main/java/com/android/tools/r8/graph/DexProto.java
@@ -83,6 +83,10 @@
return parameters.values[index];
}
+ public DexTypeList getParameters() {
+ return parameters;
+ }
+
public int getArity() {
return parameters.size();
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexReference.java b/src/main/java/com/android/tools/r8/graph/DexReference.java
index 77976f1..27264bb 100644
--- a/src/main/java/com/android/tools/r8/graph/DexReference.java
+++ b/src/main/java/com/android/tools/r8/graph/DexReference.java
@@ -29,6 +29,8 @@
public abstract void collectIndexedItems(IndexedItemCollection indexedItems);
+ public abstract int compareTo(DexReference other);
+
public abstract DexType getContextType();
public boolean isDexType() {
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index aaeb156..75b592b 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -53,6 +53,15 @@
}
@Override
+ public int compareTo(DexReference other) {
+ if (other.isDexType()) {
+ return compareTo(other.asDexType());
+ }
+ int comparisonResult = compareTo(other.getContextType());
+ return comparisonResult != 0 ? comparisonResult : -1;
+ }
+
+ @Override
public DexType self() {
return this;
}
diff --git a/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java b/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java
index 8b1ca9d..dbc2119 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldResolutionResult.java
@@ -25,6 +25,7 @@
return null;
}
+ @Override
public DexClassAndField getResolutionPair() {
return null;
}
diff --git a/src/main/java/com/android/tools/r8/graph/GenericSignatureCorrectnessHelper.java b/src/main/java/com/android/tools/r8/graph/GenericSignatureCorrectnessHelper.java
index a7979f6..3401560 100644
--- a/src/main/java/com/android/tools/r8/graph/GenericSignatureCorrectnessHelper.java
+++ b/src/main/java/com/android/tools/r8/graph/GenericSignatureCorrectnessHelper.java
@@ -110,6 +110,7 @@
return result;
}
+ @SuppressWarnings("unchecked")
private <T extends DexDefinitionSignature<?>> SignatureEvaluationResult evaluate(
Supplier<T> getter, Function<T, SignatureEvaluationResult> evaluate, Consumer<T> setter) {
T signature = getter.get();
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryClass.java b/src/main/java/com/android/tools/r8/graph/LibraryClass.java
new file mode 100644
index 0000000..f4a7081
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/LibraryClass.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.graph;
+
+public interface LibraryClass extends LibraryDefinition, ClasspathOrLibraryClass {}
diff --git a/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java b/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java
index a2fb6a8..6767199 100644
--- a/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java
+++ b/src/main/java/com/android/tools/r8/graph/LibraryDefinition.java
@@ -6,7 +6,7 @@
import java.util.function.Function;
-public interface LibraryDefinition extends Definition {
+public interface LibraryDefinition extends ClasspathOrLibraryDefinition {
@Override
default <T> T apply(
diff --git a/src/main/java/com/android/tools/r8/graph/MemberResolutionResult.java b/src/main/java/com/android/tools/r8/graph/MemberResolutionResult.java
index 01294be..285859d 100644
--- a/src/main/java/com/android/tools/r8/graph/MemberResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/MemberResolutionResult.java
@@ -9,6 +9,10 @@
public abstract class MemberResolutionResult<
D extends DexEncodedMember<D, R>, R extends DexMember<D, R>> {
+ public DexClassAndMember<D, R> getResolutionPair() {
+ return null;
+ }
+
public abstract boolean isSuccessfulMemberResolutionResult();
public abstract SuccessfulMemberResolutionResult<D, R> asSuccessfulMemberResolutionResult();
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java b/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java
index 862efbc..17e779e 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramDefinition.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.graph;
-import com.android.tools.r8.origin.Origin;
import java.util.function.Function;
public interface ProgramDefinition extends Definition, ProgramDerivedContext {
@@ -28,8 +27,6 @@
DexDefinition getDefinition();
- Origin getOrigin();
-
default boolean isProgramClass() {
return false;
}
@@ -38,6 +35,16 @@
return null;
}
+ @Override
+ default boolean isProgramDefinition() {
+ return true;
+ }
+
+ @Override
+ default ProgramDefinition asProgramDefinition() {
+ return this;
+ }
+
default boolean isProgramField() {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java b/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java
index f9ec920..d46cf33 100644
--- a/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java
+++ b/src/main/java/com/android/tools/r8/graph/ProgramDerivedContext.java
@@ -7,4 +7,8 @@
public interface ProgramDerivedContext {
Definition getContext();
+
+ default boolean isProgramContext() {
+ return getContext().isProgramDefinition();
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
index 3356777..041033e 100644
--- a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
@@ -74,6 +74,11 @@
return null;
}
+ @Override
+ public DexClassAndMethod getResolutionPair() {
+ return null;
+ }
+
public abstract OptionalBool isAccessibleForVirtualDispatchFrom(
ProgramDefinition context, AppInfoWithClassHierarchy appInfo);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
index fb9c5d3..6d79c9c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverter.java
@@ -67,36 +67,36 @@
// Process the wave and wait for all IR processing to complete.
D8CfInstructionDesugaringEventConsumer desugaringEventConsumer =
- CfInstructionDesugaringEventConsumer.createForD8(
- resultBuilder::addSynthesizedLambdaClass, methodProcessor);
+ CfInstructionDesugaringEventConsumer.createForD8(methodProcessor);
methodProcessor.newWave();
ThreadUtils.processItems(
wave, clazz -> convertClass(clazz, desugaringEventConsumer), executorService);
methodProcessor.awaitMethodProcessing();
- // Finalize the desugaring of the processed classes. This may require reprocessing of some
- // methods, because nest-based access desugaring changes the body of virtual methods.
- List<ProgramMethod> needsReprocessing = desugaringEventConsumer.finalizeDesugaring(appView);
- if (!needsReprocessing.isEmpty()) {
+ // Finalize the desugaring of the processed classes. This may require processing (and
+ // reprocessing) of some methods.
+ List<ProgramMethod> needsProcessing =
+ desugaringEventConsumer.finalizeDesugaring(appView, resultBuilder);
+ if (!needsProcessing.isEmpty()) {
// Create a new processor context to ensure unique method processing contexts.
methodProcessor.newWave();
// Process the methods that require reprocessing. These are all simple bridge methods and
// should therefore not lead to additional desugaring.
ThreadUtils.processItems(
- needsReprocessing,
+ needsProcessing,
method -> {
DexEncodedMethod definition = method.getDefinition();
- assert definition.isProcessed();
- definition.markNotProcessed();
+ if (definition.isProcessed()) {
+ definition.markNotProcessed();
+ }
methodProcessor.processMethod(method, desugaringEventConsumer);
},
executorService);
- // Verify that there is no more desugaring to do, and that all IR processing has been
- // completed.
+ // Verify there is nothing to finalize once method processing finishes.
+ methodProcessor.awaitMethodProcessing();
assert desugaringEventConsumer.verifyNothingToFinalize();
- assert methodProcessor.verifyNoPendingMethodProcessing();
}
classes = deferred;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverterResult.java b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverterResult.java
index 4a07e14..e65179a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/ClassConverterResult.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ClassConverterResult.java
@@ -4,48 +4,38 @@
package com.android.tools.r8.ir.conversion;
-import com.android.tools.r8.ir.desugar.LambdaClass;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.function.Consumer;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.ir.desugar.lambda.ForcefullyMovedLambdaMethodConsumer;
+import java.util.IdentityHashMap;
+import java.util.Map;
public class ClassConverterResult {
- private final List<LambdaClass> synthesizedLambdaClassesWithDeterministicOrder;
+ private final Map<DexMethod, DexMethod> forcefullyMovedLambdaMethods;
- private ClassConverterResult(List<LambdaClass> synthesizedLambdaClassesWithDeterministicOrder) {
- this.synthesizedLambdaClassesWithDeterministicOrder =
- synthesizedLambdaClassesWithDeterministicOrder;
+ private ClassConverterResult(Map<DexMethod, DexMethod> forcefullyMovedLambdaMethods) {
+ this.forcefullyMovedLambdaMethods = forcefullyMovedLambdaMethods;
}
public static Builder builder() {
return new Builder();
}
- public void forEachSynthesizedLambdaClassWithDeterministicOrdering(
- Consumer<LambdaClass> consumer) {
- synthesizedLambdaClassesWithDeterministicOrder.forEach(consumer);
+ public Map<DexMethod, DexMethod> getForcefullyMovedLambdaMethods() {
+ return forcefullyMovedLambdaMethods;
}
- public List<LambdaClass> getSynthesizedLambdaClasses() {
- return synthesizedLambdaClassesWithDeterministicOrder;
- }
+ public static class Builder implements ForcefullyMovedLambdaMethodConsumer {
- public static class Builder {
+ private final Map<DexMethod, DexMethod> forcefullyMovedLambdaMethods = new IdentityHashMap<>();
- private final List<LambdaClass> synthesizedLambdaClasses = new ArrayList<>();
-
- public Builder addSynthesizedLambdaClass(LambdaClass lambdaClass) {
- synchronized (synthesizedLambdaClasses) {
- synthesizedLambdaClasses.add(lambdaClass);
- }
- return this;
+ @Override
+ public void acceptForcefullyMovedLambdaMethod(DexMethod from, DexMethod to) {
+ forcefullyMovedLambdaMethods.put(from, to);
}
public ClassConverterResult build() {
- synthesizedLambdaClasses.sort(Comparator.comparing(LambdaClass::getType));
- return new ClassConverterResult(synthesizedLambdaClasses);
+ return new ClassConverterResult(forcefullyMovedLambdaMethods);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
index bee8182..bb8e12a 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/D8MethodProcessor.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer.D8CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackIgnore;
import com.android.tools.r8.utils.ThreadUtils;
import com.google.common.collect.Sets;
@@ -24,9 +25,18 @@
private final IRConverter converter;
private final ExecutorService executorService;
- private final List<Future<?>> futures = Collections.synchronizedList(new ArrayList<>());
private final Set<DexType> scheduled = Sets.newIdentityHashSet();
+ // Asynchronous method processing actions. These are "terminal" method processing actions in the
+ // sense that the method processing is known not to fork any other futures.
+ private final List<Future<?>> terminalFutures = Collections.synchronizedList(new ArrayList<>());
+
+ // Asynchronous method processing actions. This list includes both "terminal" and "non-terminal"
+ // method processing actions. Thus, before the asynchronous method processing finishes, it may
+ // fork the processing of another method.
+ private final List<Future<?>> nonTerminalFutures =
+ Collections.synchronizedList(new ArrayList<>());
+
private ProcessorContext processorContext;
public D8MethodProcessor(IRConverter converter, ExecutorService executorService) {
@@ -55,6 +65,27 @@
return true;
}
+ public void scheduleMethodForProcessing(
+ ProgramMethod method, D8CfInstructionDesugaringEventConsumer eventConsumer) {
+ // TODO(b/179755192): By building up waves of methods in the class converter, we can avoid the
+ // following check and always process the method asynchronously.
+ if (!scheduled.contains(method.getHolderType())
+ && !converter.appView.getSyntheticItems().isNonLegacySynthetic(method.getHolder())) {
+ // The non-synthetic holder is not scheduled. It will be processed once holder is scheduled.
+ return;
+ }
+ nonTerminalFutures.add(
+ ThreadUtils.processAsynchronously(
+ () ->
+ converter.rewriteCode(
+ method,
+ eventConsumer,
+ OptimizationFeedbackIgnore.getInstance(),
+ this,
+ processorContext.createMethodProcessingContext(method)),
+ executorService));
+ }
+
@Override
public void scheduleDesugaredMethodForProcessing(ProgramMethod method) {
// TODO(b/179755192): By building up waves of methods in the class converter, we can avoid the
@@ -64,7 +95,7 @@
// The non-synthetic holder is not scheduled. It will be processed once holder is scheduled.
return;
}
- futures.add(
+ terminalFutures.add(
ThreadUtils.processAsynchronously(
() ->
converter.rewriteDesugaredCode(
@@ -86,8 +117,21 @@
}
public void awaitMethodProcessing() throws ExecutionException {
- ThreadUtils.awaitFutures(futures);
- futures.clear();
+ // Await the non-terminal futures until there are only terminal futures left.
+ while (!nonTerminalFutures.isEmpty()) {
+ List<Future<?>> futuresToAwait;
+ synchronized (nonTerminalFutures) {
+ futuresToAwait = new ArrayList<>(nonTerminalFutures);
+ nonTerminalFutures.clear();
+ }
+ ThreadUtils.awaitFutures(futuresToAwait);
+ }
+
+ // Await the terminal futures. There futures will by design not to fork new method processing.
+ int numberOfTerminalFutures = terminalFutures.size();
+ ThreadUtils.awaitFutures(terminalFutures);
+ assert terminalFutures.size() == numberOfTerminalFutures;
+ terminalFutures.clear();
}
public void processMethod(
@@ -99,12 +143,9 @@
processorContext.createMethodProcessingContext(method));
}
- public void processDesugaredMethod(ProgramMethod method) {
- processMethod(method, CfInstructionDesugaringEventConsumer.createForDesugaredCode());
- }
-
public boolean verifyNoPendingMethodProcessing() {
- assert futures.isEmpty();
+ assert terminalFutures.isEmpty();
+ assert nonTerminalFutures.isEmpty();
return true;
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index db7c135..72f9ac7 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -5,13 +5,12 @@
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.Flavor.ExcludeDexResources;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.Flavor.IncludeAllResources;
-import static com.android.tools.r8.ir.desugar.lambda.D8LambdaDesugaring.synthesizeAccessibilityBridgesForLambdaClasses;
+import static com.android.tools.r8.ir.desugar.lambda.D8LambdaDesugaring.rewriteEnclosingLambdaMethodAttributes;
import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.Code;
@@ -43,7 +42,6 @@
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.code.NumericType;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringCollection;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer.D8CfInstructionDesugaringEventConsumer;
@@ -53,8 +51,6 @@
import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.Flavor;
-import com.android.tools.r8.ir.desugar.StringConcatRewriter;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
import com.android.tools.r8.ir.desugar.lambda.LambdaDeserializationMethodRemover;
import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.optimize.AssertionsRewriter;
@@ -101,10 +97,8 @@
import com.android.tools.r8.utils.ExceptionUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.InternalOptions.DesugarState;
-import com.android.tools.r8.utils.IterableUtils;
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.StringDiagnostic;
-import com.android.tools.r8.utils.SupplierUtils;
import com.android.tools.r8.utils.ThreadUtils;
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.collections.ProgramMethodSet;
@@ -134,13 +128,10 @@
private final CfInstructionDesugaringCollection desugaring;
private final FieldAccessAnalysis fieldAccessAnalysis;
private final LibraryMethodOverrideAnalysis libraryMethodOverrideAnalysis;
- private final StringConcatRewriter stringConcatRewriter;
private final StringOptimizer stringOptimizer;
private final StringBuilderOptimizer stringBuilderOptimizer;
private final IdempotentFunctionCallCanonicalizer idempotentFunctionCallCanonicalizer;
private final InterfaceMethodRewriter interfaceMethodRewriter;
- private final TwrCloseResourceRewriter twrCloseResourceRewriter;
- private final BackportedMethodRewriter backportedMethodRewriter;
private final DesugaredLibraryRetargeter desugaredLibraryRetargeter;
private final ClassInliner classInliner;
private final ClassStaticizer classStaticizer;
@@ -199,7 +190,6 @@
this.constantCanonicalizer = new ConstantCanonicalizer(codeRewriter);
this.classInitializerDefaultsOptimization =
new ClassInitializerDefaultsOptimization(appView, this);
- this.stringConcatRewriter = new StringConcatRewriter(appView);
this.stringOptimizer = new StringOptimizer(appView);
this.stringBuilderOptimizer = new StringBuilderOptimizer(appView);
this.deadCodeRemover = new DeadCodeRemover(appView, codeRewriter);
@@ -223,7 +213,7 @@
// The following desugaring are present so all desugaring is performed cf to cf in L8, and
// the second L8 phase can just run with Desugar turned off:
// - InterfaceMethodRewriter for non L8 specific interface method desugaring,
- // - TwrCloseResourceRewriter,
+ // - twr close resource desugaring,
// - nest based access desugaring,
// - invoke-special desugaring.
assert options.desugarState.isOn();
@@ -238,11 +228,6 @@
: new InterfaceMethodRewriter(appView, this);
this.desugaredLibraryAPIConverter =
new DesugaredLibraryAPIConverter(appView, Mode.GENERATE_CALLBACKS_AND_WRAPPERS);
- this.backportedMethodRewriter = new BackportedMethodRewriter(appView);
- this.twrCloseResourceRewriter =
- TwrCloseResourceRewriter.enableTwrCloseResourceDesugaring(appView.options())
- ? new TwrCloseResourceRewriter(appView)
- : null;
this.covariantReturnTypeAnnotationTransformer = null;
this.dynamicTypeOptimization = null;
this.classInliner = null;
@@ -272,15 +257,6 @@
options.isInterfaceMethodDesugaringEnabled()
? new InterfaceMethodRewriter(appView, this)
: null;
- this.twrCloseResourceRewriter =
- (TwrCloseResourceRewriter.enableTwrCloseResourceDesugaring(options)
- && !appView.enableWholeProgramOptimizations())
- ? new TwrCloseResourceRewriter(appView)
- : null;
- this.backportedMethodRewriter =
- (options.desugarState == DesugarState.ON && !appView.enableWholeProgramOptimizations())
- ? new BackportedMethodRewriter(appView)
- : null;
this.desugaredLibraryRetargeter =
options.desugaredLibraryConfiguration.getRetargetCoreLibMember().isEmpty()
? null
@@ -410,19 +386,6 @@
}
}
- private void processTwrCloseResourceUtilityMethods() {
- if (twrCloseResourceRewriter != null) {
- twrCloseResourceRewriter.processSynthesizedMethods(this);
- }
- }
-
- private void processSynthesizedJava8UtilityClasses(ExecutorService executorService)
- throws ExecutionException {
- if (backportedMethodRewriter != null) {
- backportedMethodRewriter.processSynthesizedClasses(this, executorService);
- }
- }
-
private void synthesizeRetargetClass(Builder<?> builder, ExecutorService executorService)
throws ExecutionException {
if (desugaredLibraryRetargeter != null) {
@@ -454,7 +417,6 @@
convertClasses(executor);
reportNestDesugarDependencies();
- processTwrCloseResourceUtilityMethods();
if (appView.getSyntheticItems().hasPendingSyntheticClasses()) {
appView.setAppInfo(
@@ -468,7 +430,6 @@
Builder<?> builder = application.builder().setHighestSortingString(highestSortingString);
desugarInterfaceMethods(builder, ExcludeDexResources, executor);
- processSynthesizedJava8UtilityClasses(executor);
synthesizeRetargetClass(builder, executor);
processCovariantReturnTypeAnnotations(builder);
generateDesugaredLibraryAPIWrappers(builder, executor);
@@ -487,19 +448,15 @@
ClassConverterResult classConverterResult =
ClassConverter.create(appView, this, methodProcessor).convertClasses(executorService);
- // The synthesis of accessibility bridges in lambda desugaring and nest based access desugaring
- // will schedule and await the processing of synthesized methods.
+ // The synthesis of accessibility bridges in nest based access desugaring will schedule and
+ // await the processing of synthesized methods.
synthesizeBridgesForNestBasedAccessesOnClasspath(methodProcessor, executorService);
- synthesizeAccessibilityBridgesForLambdaClasses(appView, classConverterResult, methodProcessor);
- methodProcessor
- .scheduleDesugaredMethodsForProcessing(
- IterableUtils.flatMap(
- classConverterResult.getSynthesizedLambdaClasses(),
- lambdaClass -> lambdaClass.getLambdaProgramClass().programMethods()))
- .awaitMethodProcessing();
// There should be no outstanding method processing.
methodProcessor.verifyNoPendingMethodProcessing();
+
+ rewriteEnclosingLambdaMethodAttributes(
+ appView, classConverterResult.getForcefullyMovedLambdaMethods());
}
void convertMethods(
@@ -584,14 +541,12 @@
if (options.isDesugaredLibraryCompilation()) {
return true;
}
-
if (!options.cfToCfDesugar) {
return true;
}
- if (method.getHolder().isInANest()) {
+ if (desugaring.needsDesugaring(method)) {
return true;
}
-
if (desugaredLibraryAPIConverter != null
&& desugaredLibraryAPIConverter.shouldRegisterCallback(method)) {
return true;
@@ -600,7 +555,6 @@
NeedsIRDesugarUseRegistry useRegistry =
new NeedsIRDesugarUseRegistry(
appView,
- backportedMethodRewriter,
desugaredLibraryRetargeter,
interfaceMethodRewriter,
desugaredLibraryAPIConverter);
@@ -793,7 +747,6 @@
feedback.updateVisibleOptimizationInfo();
printPhase("Utility classes synthesis");
- processSynthesizedJava8UtilityClasses(executorService);
synthesizeRetargetClass(builder, executorService);
synthesizeEnumUnboxingUtilityMethods(executorService);
@@ -1129,8 +1082,7 @@
method.toSourceString(),
logCode(options, method.getDefinition()));
}
- boolean didDesugar =
- desugar(method, desugaringEventConsumer, methodProcessor, methodProcessingContext);
+ boolean didDesugar = desugar(method, desugaringEventConsumer, methodProcessingContext);
if (Log.ENABLED && didDesugar) {
Log.debug(
getClass(),
@@ -1156,24 +1108,14 @@
private boolean desugar(
ProgramMethod method,
CfInstructionDesugaringEventConsumer desugaringEventConsumer,
- MethodProcessor methodProcessor,
MethodProcessingContext methodProcessingContext) {
- if (options.desugarState.isOff() || !method.getDefinition().getCode().isCfCode()) {
+ if (options.desugarState.isOff()
+ || !method.getDefinition().getCode().isCfCode()
+ || !desugaring.needsDesugaring(method)) {
return false;
}
-
- boolean didDesugar = false;
- Supplier<AppInfoWithClassHierarchy> lazyAppInfo =
- SupplierUtils.nonThreadSafeMemoize(appView::appInfoForDesugaring);
- if (desugaring.needsDesugaring(method)) {
- desugaring.desugar(method, methodProcessingContext, desugaringEventConsumer);
- didDesugar = true;
- }
- if (backportedMethodRewriter != null) {
- didDesugar |=
- backportedMethodRewriter.desugar(method, lazyAppInfo.get(), methodProcessingContext);
- }
- return didDesugar;
+ desugaring.desugar(method, methodProcessingContext, desugaringEventConsumer);
+ return true;
}
// TODO(b/140766440): Convert all sub steps an implementer of CodeOptimization
@@ -1457,10 +1399,6 @@
timing.end();
}
- timing.begin("Desugar string concat");
- stringConcatRewriter.desugarStringConcats(method.method, code);
- timing.end();
-
previous = printMethod(code, "IR after lambda desugaring (SSA)", previous);
assert code.verifyTypes(appView);
@@ -1520,12 +1458,6 @@
previous = printMethod(code, "IR after desugared library API Conversion (SSA)", previous);
- if (twrCloseResourceRewriter != null) {
- timing.begin("Rewrite TWR close");
- twrCloseResourceRewriter.rewriteIR(code, methodProcessingContext);
- timing.end();
- }
-
assert code.verifyTypes(appView);
previous = printMethod(code, "IR after twr close resource rewriter (SSA)", previous);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
index c12c6f0..9877f8d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/NeedsIRDesugarUseRegistry.java
@@ -17,30 +17,23 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.UseRegistry;
import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
import com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
class NeedsIRDesugarUseRegistry extends UseRegistry {
private boolean needsDesugaring = false;
- private final AppView appView;
- private final BackportedMethodRewriter backportedMethodRewriter;
private final DesugaredLibraryRetargeter desugaredLibraryRetargeter;
private final InterfaceMethodRewriter interfaceMethodRewriter;
private final DesugaredLibraryAPIConverter desugaredLibraryAPIConverter;
public NeedsIRDesugarUseRegistry(
- AppView appView,
- BackportedMethodRewriter backportedMethodRewriter,
+ AppView<?> appView,
DesugaredLibraryRetargeter desugaredLibraryRetargeter,
InterfaceMethodRewriter interfaceMethodRewriter,
DesugaredLibraryAPIConverter desugaredLibraryAPIConverter) {
super(appView.dexItemFactory());
- this.appView = appView;
- this.backportedMethodRewriter = backportedMethodRewriter;
this.desugaredLibraryRetargeter = desugaredLibraryRetargeter;
this.interfaceMethodRewriter = interfaceMethodRewriter;
this.desugaredLibraryAPIConverter = desugaredLibraryAPIConverter;
@@ -61,7 +54,6 @@
@Override
public void registerInvokeVirtual(DexMethod method) {
- registerBackportedMethodRewriting(method);
registerLibraryRetargeting(method, false);
registerInterfaceMethodRewriting(method, VIRTUAL);
registerDesugaredLibraryAPIConverter(method);
@@ -74,19 +66,6 @@
registerDesugaredLibraryAPIConverter(method);
}
- private void registerTwrCloseResourceRewriting(DexMethod method) {
- if (!needsDesugaring) {
- needsDesugaring =
- TwrCloseResourceRewriter.isTwrCloseResourceMethod(method, appView.dexItemFactory());
- }
- }
-
- private void registerBackportedMethodRewriting(DexMethod method) {
- if (!needsDesugaring) {
- needsDesugaring = backportedMethodRewriter.needsDesugaring(method);
- }
- }
-
private void registerInterfaceMethodRewriting(DexMethod method, Type invokeType) {
if (!needsDesugaring) {
needsDesugaring =
@@ -113,8 +92,6 @@
@Override
public void registerInvokeStatic(DexMethod method) {
- registerTwrCloseResourceRewriting(method);
- registerBackportedMethodRewriting(method);
registerLibraryRetargeting(method, false);
registerInterfaceMethodRewriting(method, STATIC);
registerDesugaredLibraryAPIConverter(method);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 704ed92..998b47c 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.dex.ApplicationReader;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppInfo;
-import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.Code;
@@ -22,7 +21,7 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.conversion.IRConverter;
+import com.android.tools.r8.ir.desugar.backports.BackportedMethodDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.backports.BackportedMethods;
import com.android.tools.r8.ir.desugar.backports.BooleanMethodRewrites;
import com.android.tools.r8.ir.desugar.backports.CollectionMethodGenerators;
@@ -36,42 +35,59 @@
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.InternalOptions.DesugarState;
-import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableList;
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.List;
-import java.util.ListIterator;
import java.util.Map;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.function.Consumer;
import org.objectweb.asm.Opcodes;
-public final class BackportedMethodRewriter {
+public final class BackportedMethodRewriter implements CfInstructionDesugaring {
private final AppView<?> appView;
private final RewritableMethods rewritableMethods;
- private final boolean enabled;
-
- private final Queue<ProgramMethod> synthesizedMethods = new ConcurrentLinkedQueue<>();
public BackportedMethodRewriter(AppView<?> appView) {
+ assert appView.options().desugarState.isOn();
this.appView = appView;
this.rewritableMethods = new RewritableMethods(appView.options(), appView);
- // Disable rewriting if there are no methods to rewrite or if the API level is higher than
- // the highest known API level when the compiler is built. This ensures that when this is used
- // by the Android Platform build (which normally use an API level of 10000) there will be
- // no rewriting of backported methods. See b/147480264.
- this.enabled =
- appView.options().desugarState == DesugarState.ON
- && !this.rewritableMethods.isEmpty()
- && appView.options().minApiLevel <= AndroidApiLevel.LATEST.getLevel();
+ }
+
+ public boolean hasBackports() {
+ return !rewritableMethods.isEmpty();
+ }
+
+ @Override
+ public Collection<CfInstruction> desugarInstruction(
+ CfInstruction instruction,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
+ CfInstructionDesugaringEventConsumer eventConsumer,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext) {
+ if (!instruction.isInvoke()) {
+ return null;
+ }
+
+ CfInvoke invoke = instruction.asInvoke();
+ DexMethod invokedMethod = invoke.getMethod();
+ if (!needsDesugaring(invokedMethod)) {
+ return null;
+ }
+
+ return getMethodProviderOrNull(invokedMethod)
+ .rewriteInvoke(invoke, appView, eventConsumer, methodProcessingContext);
+ }
+
+ @Override
+ public boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
+ return instruction.isInvoke() && needsDesugaring(instruction.asInvoke().getMethod());
}
public boolean needsDesugaring(DexMethod method) {
@@ -106,65 +122,6 @@
BackportedMethods.registerSynthesizedCodeReferences(options.itemFactory);
}
- public boolean desugar(
- ProgramMethod method,
- AppInfoWithClassHierarchy appInfo,
- MethodProcessingContext methodProcessingContext) {
- return desugar(method, appInfo, methodProcessingContext, synthesizedMethods::add);
- }
-
- public boolean desugar(
- ProgramMethod method,
- AppInfoWithClassHierarchy appInfo,
- MethodProcessingContext methodProcessingContext,
- Consumer<ProgramMethod> consumer) {
- if (!enabled) {
- return false;
- }
- if (method.getDefinition().getCode().isDexCode()) {
- appView
- .options()
- .reporter
- .error(
- new StringDiagnostic(
- "Unsupported attempt to desugar DEX code",
- method.getOrigin(),
- method.getPosition()));
- return false;
- }
- CfCode code = method.getDefinition().getCode().asCfCode();
- ListIterator<CfInstruction> iterator = code.getInstructions().listIterator();
- boolean replaced = false;
- while (iterator.hasNext()) {
- CfInvoke invoke = iterator.next().asInvoke();
- if (invoke == null) {
- continue;
- }
- DexMethod invokedMethod = invoke.getMethod();
- MethodProvider provider = getMethodProviderOrNull(invokedMethod);
- if (provider != null) {
- if (!replaced) {
- // Create mutable instructions on first write.
- ArrayList<CfInstruction> mutableInstructions = new ArrayList<>(code.getInstructions());
- code.setInstructions(mutableInstructions);
- iterator = mutableInstructions.listIterator(iterator.previousIndex());
- iterator.next();
- }
- provider.rewriteInvoke(invoke, iterator, appInfo, consumer, methodProcessingContext);
- replaced = true;
- }
- }
- return replaced;
- }
-
- public void processSynthesizedClasses(IRConverter converter, ExecutorService executor)
- throws ExecutionException {
- while (!synthesizedMethods.isEmpty()) {
- ArrayList<ProgramMethod> methods = new ArrayList<>(synthesizedMethods);
- synthesizedMethods.clear();
- converter.optimizeSynthesizedMethods(methods, executor);
- }
- }
private MethodProvider getMethodProviderOrNull(DexMethod method) {
DexMethod original = appView.graphLens().getOriginalMethodSignature(method);
@@ -212,7 +169,7 @@
DexItemFactory factory = options.itemFactory;
if (options.minApiLevel < AndroidApiLevel.K.getLevel()) {
- initializeAndroidKMethodProviders(factory, appView);
+ initializeAndroidKMethodProviders(factory);
}
if (options.minApiLevel < AndroidApiLevel.N.getLevel()) {
initializeAndroidNMethodProviders(factory);
@@ -253,7 +210,7 @@
rewritable.keySet().forEach(consumer);
}
- private void initializeAndroidKMethodProviders(DexItemFactory factory, AppView<?> appView) {
+ private void initializeAndroidKMethodProviders(DexItemFactory factory) {
// Byte
DexType type = factory.boxedByteType;
// int Byte.compare(byte a, byte b)
@@ -579,20 +536,19 @@
// Math & StrictMath, which have some symmetric, binary-compatible APIs
DexType[] mathTypes = {factory.mathType, factory.strictMathType};
- for (int i = 0; i < mathTypes.length; i++) {
- type = mathTypes[i];
+ for (DexType mathType : mathTypes) {
// int {Math,StrictMath}.addExact(int, int)
name = factory.createString("addExact");
proto = factory.createProto(factory.intType, factory.intType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(method, BackportedMethods::MathMethods_addExactInt, "addExactInt"));
// long {Math,StrictMath}.addExact(long, long)
name = factory.createString("addExact");
proto = factory.createProto(factory.longType, factory.longType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_addExactLong, "addExactLong"));
@@ -600,14 +556,14 @@
// int {Math,StrictMath}.floorDiv(int, int)
name = factory.createString("floorDiv");
proto = factory.createProto(factory.intType, factory.intType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(method, BackportedMethods::MathMethods_floorDivInt, "floorDivInt"));
// long {Math,StrictMath}.floorDiv(long, long)
name = factory.createString("floorDiv");
proto = factory.createProto(factory.longType, factory.longType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_floorDivLong, "floorDivLong"));
@@ -615,14 +571,14 @@
// int {Math,StrictMath}.floorMod(int, int)
name = factory.createString("floorMod");
proto = factory.createProto(factory.intType, factory.intType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(method, BackportedMethods::MathMethods_floorModInt, "floorModInt"));
// long {Math,StrictMath}.floorMod(long, long)
name = factory.createString("floorMod");
proto = factory.createProto(factory.longType, factory.longType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_floorModLong, "floorModLong"));
@@ -630,7 +586,7 @@
// int {Math,StrictMath}.multiplyExact(int, int)
name = factory.createString("multiplyExact");
proto = factory.createProto(factory.intType, factory.intType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_multiplyExactInt, "multiplyExactInt"));
@@ -638,7 +594,7 @@
// long {Math,StrictMath}.multiplyExact(long, long)
name = factory.createString("multiplyExact");
proto = factory.createProto(factory.longType, factory.longType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_multiplyExactLong, "multiplyExactLong"));
@@ -646,7 +602,7 @@
// double {Math,StrictMath}.nextDown(double)
name = factory.createString("nextDown");
proto = factory.createProto(factory.doubleType, factory.doubleType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_nextDownDouble, "nextDownDouble"));
@@ -654,7 +610,7 @@
// float {Math,StrictMath}.nextDown(float)
name = factory.createString("nextDown");
proto = factory.createProto(factory.floatType, factory.floatType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_nextDownFloat, "nextDownFloat"));
@@ -662,7 +618,7 @@
// int {Math,StrictMath}.subtractExact(int, int)
name = factory.createString("subtractExact");
proto = factory.createProto(factory.intType, factory.intType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_subtractExactInt, "subtractExactInt"));
@@ -670,7 +626,7 @@
// long {Math,StrictMath}.subtractExact(long, long)
name = factory.createString("subtractExact");
proto = factory.createProto(factory.longType, factory.longType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_subtractExactLong, "subtractExactLong"));
@@ -678,7 +634,7 @@
// int {Math,StrictMath}.toIntExact(long)
name = factory.createString("toIntExact");
proto = factory.createProto(factory.intType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(new MethodGenerator(method, BackportedMethods::MathMethods_toIntExact));
}
@@ -1015,13 +971,12 @@
private void initializeJava9MethodProviders(DexItemFactory factory) {
// Math & StrictMath, which have some symmetric, binary-compatible APIs
DexType[] mathTypes = {factory.mathType, factory.strictMathType};
- for (int i = 0; i < mathTypes.length; i++) {
- DexType type = mathTypes[i];
+ for (DexType mathType : mathTypes) {
// long {Math,StrictMath}.multiplyExact(long, int)
DexString name = factory.createString("multiplyExact");
DexProto proto = factory.createProto(factory.longType, factory.longType, factory.intType);
- DexMethod method = factory.createMethod(type, proto, name);
+ DexMethod method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method,
@@ -1031,19 +986,19 @@
// long {Math,StrictMath}.multiplyFull(int, int)
name = factory.createString("multiplyFull");
proto = factory.createProto(factory.longType, factory.intType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(new MethodGenerator(method, BackportedMethods::MathMethods_multiplyFull));
// long {Math,StrictMath}.multiplyHigh(long, long)
name = factory.createString("multiplyHigh");
proto = factory.createProto(factory.longType, factory.longType, factory.longType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(new MethodGenerator(method, BackportedMethods::MathMethods_multiplyHigh));
// long {Math,StrictMath}.floorDiv(long, int)
name = factory.createString("floorDiv");
proto = factory.createProto(factory.longType, factory.longType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_floorDivLongInt, "floorDivLongInt"));
@@ -1051,7 +1006,7 @@
// int {Math,StrictMath}.floorMod(long, int)
name = factory.createString("floorMod");
proto = factory.createProto(factory.intType, factory.longType, factory.intType);
- method = factory.createMethod(type, proto, name);
+ method = factory.createMethod(mathType, proto, name);
addProvider(
new MethodGenerator(
method, BackportedMethods::MathMethods_floorModLongInt, "floorModLongInt"));
@@ -1349,11 +1304,10 @@
this.method = method;
}
- public abstract void rewriteInvoke(
+ public abstract Collection<CfInstruction> rewriteInvoke(
CfInvoke invoke,
- ListIterator<CfInstruction> iterator,
- AppInfoWithClassHierarchy appInfo,
- Consumer<ProgramMethod> registerSynthesizedMethod,
+ AppView<?> appView,
+ BackportedMethodDesugaringEventConsumer eventConsumer,
MethodProcessingContext methodProcessingContext);
}
@@ -1367,13 +1321,12 @@
}
@Override
- public void rewriteInvoke(
+ public Collection<CfInstruction> rewriteInvoke(
CfInvoke invoke,
- ListIterator<CfInstruction> iterator,
- AppInfoWithClassHierarchy appInfo,
- Consumer<ProgramMethod> registerSynthesizedMethod,
+ AppView<?> appView,
+ BackportedMethodDesugaringEventConsumer eventConsumer,
MethodProcessingContext methodProcessingContext) {
- rewriter.rewrite(invoke, iterator, appInfo.dexItemFactory());
+ return rewriter.rewrite(invoke, appView.dexItemFactory());
}
}
@@ -1393,32 +1346,29 @@
}
@Override
- public void rewriteInvoke(
+ public Collection<CfInstruction> rewriteInvoke(
CfInvoke invoke,
- ListIterator<CfInstruction> iterator,
- AppInfoWithClassHierarchy appInfo,
- Consumer<ProgramMethod> registerSynthesizedMethod,
+ AppView<?> appView,
+ BackportedMethodDesugaringEventConsumer eventConsumer,
MethodProcessingContext methodProcessingContext) {
- ProgramMethod method = getSyntheticMethod(appInfo, methodProcessingContext);
- registerSynthesizedMethod.accept(method);
- iterator.remove();
- iterator.add(new CfInvoke(Opcodes.INVOKESTATIC, method.getReference(), false));
+ ProgramMethod method = getSyntheticMethod(appView, methodProcessingContext);
+ eventConsumer.acceptBackportedMethod(method, methodProcessingContext.getMethodContext());
+ return ImmutableList.of(new CfInvoke(Opcodes.INVOKESTATIC, method.getReference(), false));
}
private ProgramMethod getSyntheticMethod(
- AppInfoWithClassHierarchy appInfo, MethodProcessingContext methodProcessingContext) {
- return appInfo
+ AppView<?> appView, MethodProcessingContext methodProcessingContext) {
+ return appView
.getSyntheticItems()
.createMethod(
SyntheticNaming.SyntheticKind.BACKPORT,
methodProcessingContext.createUniqueContext(),
- appInfo.dexItemFactory(),
+ appView.dexItemFactory(),
builder ->
builder
- .setProto(getProto(appInfo.dexItemFactory()))
+ .setProto(getProto(appView.dexItemFactory()))
.setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
- .setCode(
- methodSig -> generateTemplateMethod(appInfo.app().options, methodSig)));
+ .setCode(methodSig -> generateTemplateMethod(appView.options(), methodSig)));
}
public DexProto getProto(DexItemFactory itemFactory) {
@@ -1459,10 +1409,8 @@
CfInstruction rewriteSingle(CfInvoke invoke, DexItemFactory factory);
// Convenience wrapper since most rewrites are to a single instruction.
- default void rewrite(
- CfInvoke invoke, ListIterator<CfInstruction> iterator, DexItemFactory factory) {
- iterator.remove();
- iterator.add(rewriteSingle(invoke, factory));
+ default Collection<CfInstruction> rewrite(CfInvoke invoke, DexItemFactory factory) {
+ return ImmutableList.of(rewriteSingle(invoke, factory));
}
}
@@ -1474,7 +1422,6 @@
}
@Override
- public abstract void rewrite(
- CfInvoke invoke, ListIterator<CfInstruction> iterator, DexItemFactory factory);
+ public abstract Collection<CfInstruction> rewrite(CfInvoke invoke, DexItemFactory factory);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaring.java
index 22b1d92..b4cab05 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaring.java
@@ -19,6 +19,7 @@
Collection<CfInstruction> desugarInstruction(
CfInstruction instruction,
FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
CfInstructionDesugaringEventConsumer eventConsumer,
ProgramMethod context,
MethodProcessingContext methodProcessingContext);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
index 4041efd..d765537 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/CfInstructionDesugaringEventConsumer.java
@@ -10,12 +10,15 @@
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.ProgramField;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.conversion.ClassConverterResult;
import com.android.tools.r8.ir.conversion.D8MethodProcessor;
+import com.android.tools.r8.ir.desugar.backports.BackportedMethodDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.invokespecial.InvokeSpecialBridgeInfo;
import com.android.tools.r8.ir.desugar.invokespecial.InvokeSpecialToSelfDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.lambda.LambdaDeserializationMethodRemover;
import com.android.tools.r8.ir.desugar.lambda.LambdaDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.twr.TwrCloseResourceDesugaringEventConsumer;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
@@ -24,6 +27,7 @@
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.function.BiConsumer;
import java.util.function.Consumer;
/**
@@ -31,24 +35,34 @@
* inserting of a new method).
*/
public abstract class CfInstructionDesugaringEventConsumer
- implements InvokeSpecialToSelfDesugaringEventConsumer,
+ implements BackportedMethodDesugaringEventConsumer,
+ InvokeSpecialToSelfDesugaringEventConsumer,
LambdaDesugaringEventConsumer,
- NestBasedAccessDesugaringEventConsumer {
+ NestBasedAccessDesugaringEventConsumer,
+ TwrCloseResourceDesugaringEventConsumer {
public static D8CfInstructionDesugaringEventConsumer createForD8(
- Consumer<LambdaClass> lambdaClassConsumer, D8MethodProcessor methodProcessor) {
- return new D8CfInstructionDesugaringEventConsumer(lambdaClassConsumer, methodProcessor);
+ D8MethodProcessor methodProcessor) {
+ return new D8CfInstructionDesugaringEventConsumer(methodProcessor);
}
public static R8CfInstructionDesugaringEventConsumer createForR8(
- AppView<? extends AppInfoWithClassHierarchy> appView) {
- return new R8CfInstructionDesugaringEventConsumer(appView);
+ AppView<? extends AppInfoWithClassHierarchy> appView,
+ BiConsumer<LambdaClass, ProgramMethod> lambdaClassConsumer,
+ BiConsumer<ProgramMethod, ProgramMethod> twrCloseResourceMethodConsumer) {
+ return new R8CfInstructionDesugaringEventConsumer(
+ appView, lambdaClassConsumer, twrCloseResourceMethodConsumer);
}
public static CfInstructionDesugaringEventConsumer createForDesugaredCode() {
return new CfInstructionDesugaringEventConsumer() {
@Override
+ public void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context) {
+ assert false;
+ }
+
+ @Override
public void acceptInvokeSpecialBridgeInfo(InvokeSpecialBridgeInfo info) {
assert false;
}
@@ -72,25 +86,33 @@
public void acceptNestMethodBridge(ProgramMethod target, ProgramMethod bridge) {
assert false;
}
+
+ @Override
+ public void acceptTwrCloseResourceMethod(ProgramMethod closeMethod, ProgramMethod context) {
+ assert false;
+ }
};
}
public static class D8CfInstructionDesugaringEventConsumer
extends CfInstructionDesugaringEventConsumer {
- private final Consumer<LambdaClass> lambdaClassConsumer;
private final D8MethodProcessor methodProcessor;
private final Map<DexReference, InvokeSpecialBridgeInfo> pendingInvokeSpecialBridges =
new LinkedHashMap<>();
+ private final List<LambdaClass> synthesizedLambdaClasses = new ArrayList<>();
- private D8CfInstructionDesugaringEventConsumer(
- Consumer<LambdaClass> lambdaClassConsumer, D8MethodProcessor methodProcessor) {
- this.lambdaClassConsumer = lambdaClassConsumer;
+ private D8CfInstructionDesugaringEventConsumer(D8MethodProcessor methodProcessor) {
this.methodProcessor = methodProcessor;
}
@Override
+ public void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context) {
+ methodProcessor.scheduleMethodForProcessing(backportedMethod, this);
+ }
+
+ @Override
public void acceptInvokeSpecialBridgeInfo(InvokeSpecialBridgeInfo info) {
synchronized (pendingInvokeSpecialBridges) {
assert !pendingInvokeSpecialBridges.containsKey(info.getNewDirectMethod().getReference());
@@ -100,7 +122,9 @@
@Override
public void acceptLambdaClass(LambdaClass lambdaClass, ProgramMethod context) {
- lambdaClassConsumer.accept(lambdaClass);
+ synchronized (synthesizedLambdaClasses) {
+ synthesizedLambdaClasses.add(lambdaClass);
+ }
}
@Override
@@ -118,14 +142,21 @@
methodProcessor.scheduleDesugaredMethodForProcessing(bridge);
}
- public List<ProgramMethod> finalizeDesugaring(AppView<?> appView) {
- List<ProgramMethod> needsReprocessing = new ArrayList<>();
- finalizeInvokeSpecialDesugaring(appView, needsReprocessing::add);
- return needsReprocessing;
+ @Override
+ public void acceptTwrCloseResourceMethod(ProgramMethod closeMethod, ProgramMethod context) {
+ methodProcessor.scheduleDesugaredMethodForProcessing(closeMethod);
+ }
+
+ public List<ProgramMethod> finalizeDesugaring(
+ AppView<?> appView, ClassConverterResult.Builder classConverterResultBuilder) {
+ List<ProgramMethod> needsProcessing = new ArrayList<>();
+ finalizeInvokeSpecialDesugaring(appView, needsProcessing::add);
+ finalizeLambdaDesugaring(classConverterResultBuilder, needsProcessing::add);
+ return needsProcessing;
}
private void finalizeInvokeSpecialDesugaring(
- AppView<?> appView, Consumer<ProgramMethod> needsReprocessing) {
+ AppView<?> appView, Consumer<ProgramMethod> needsProcessing) {
// Fixup the code of the new private methods have that been synthesized.
pendingInvokeSpecialBridges
.values()
@@ -146,14 +177,26 @@
info.getVirtualMethod()
.getDefinition()
.setCode(info.getVirtualMethodCode(), appView);
- needsReprocessing.accept(info.getVirtualMethod());
+ needsProcessing.accept(info.getVirtualMethod());
});
pendingInvokeSpecialBridges.clear();
}
+ private void finalizeLambdaDesugaring(
+ ClassConverterResult.Builder classConverterResultBuilder,
+ Consumer<ProgramMethod> needsProcessing) {
+ for (LambdaClass lambdaClass : synthesizedLambdaClasses) {
+ lambdaClass.target.ensureAccessibilityIfNeeded(
+ classConverterResultBuilder, needsProcessing);
+ lambdaClass.getLambdaProgramClass().forEachProgramMethod(needsProcessing);
+ }
+ synthesizedLambdaClasses.clear();
+ }
+
public boolean verifyNothingToFinalize() {
assert pendingInvokeSpecialBridges.isEmpty();
+ assert synthesizedLambdaClasses.isEmpty();
return true;
}
}
@@ -163,13 +206,28 @@
private final AppView<? extends AppInfoWithClassHierarchy> appView;
+ // TODO(b/180091213): Remove these two consumers when synthesizing contexts are accessible from
+ // synthetic items.
+ private final BiConsumer<LambdaClass, ProgramMethod> lambdaClassConsumer;
+ private final BiConsumer<ProgramMethod, ProgramMethod> twrCloseResourceMethodConsumer;
+
private final Map<LambdaClass, ProgramMethod> synthesizedLambdaClasses =
new IdentityHashMap<>();
private final List<InvokeSpecialBridgeInfo> pendingInvokeSpecialBridges = new ArrayList<>();
public R8CfInstructionDesugaringEventConsumer(
- AppView<? extends AppInfoWithClassHierarchy> appView) {
+ AppView<? extends AppInfoWithClassHierarchy> appView,
+ BiConsumer<LambdaClass, ProgramMethod> lambdaClassConsumer,
+ BiConsumer<ProgramMethod, ProgramMethod> twrCloseResourceMethodConsumer) {
this.appView = appView;
+ this.lambdaClassConsumer = lambdaClassConsumer;
+ this.twrCloseResourceMethodConsumer = twrCloseResourceMethodConsumer;
+ }
+
+ @Override
+ public void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context) {
+ // Intentionally empty. The backported method will be hit by the tracing in R8 as if it was
+ // present in the input code, and thus nothing needs to be done.
}
@Override
@@ -184,6 +242,9 @@
synchronized (synthesizedLambdaClasses) {
synthesizedLambdaClasses.put(lambdaClass, context);
}
+ // TODO(b/180091213): Remove the recording of the synthesizing context when this is accessible
+ // from synthetic items.
+ lambdaClassConsumer.accept(lambdaClass, context);
}
@Override
@@ -204,6 +265,15 @@
// in the input code, and thus nothing needs to be done.
}
+ @Override
+ public void acceptTwrCloseResourceMethod(ProgramMethod closeMethod, ProgramMethod context) {
+ // Intentionally empty. The close method will be hit by the tracing in R8 as if they were
+ // present in the input code, and thus nothing needs to be done.
+ // TODO(b/180091213): Remove the recording of the synthesizing context when this is accessible
+ // from synthetic items.
+ twrCloseResourceMethodConsumer.accept(closeMethod, context);
+ }
+
public void finalizeDesugaring() {
finalizeInvokeSpecialDesugaring();
finalizeLambdaDesugaring();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
index 30ea01c..d1cd87a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
@@ -236,11 +236,10 @@
instructions.add(new CfLoad(valueType, maxLocals));
maxLocals += valueType.requiredRegisters();
DexType expectedParamType = implReceiverAndArgs.get(i + capturedValues);
- maxStack =
- Math.max(
- maxStack,
- prepareParameterValue(
- erasedParams[i], enforcedParams[i], expectedParamType, instructions, factory));
+ maxStack +=
+ valueType.requiredRegisters()
+ + prepareParameterValue(
+ erasedParams[i], enforcedParams[i], expectedParamType, instructions, factory);
}
instructions.add(
@@ -260,15 +259,13 @@
} else {
// Either the new instance or the called-method result is on top of stack.
assert constructorTarget || !methodToCallReturnType.isVoidType();
- maxStack =
- Math.max(
- maxStack,
- prepareReturnValue(
- erasedReturnType,
- enforcedReturnType,
- constructorTarget ? methodToCall.holder : methodToCallReturnType,
- instructions,
- factory));
+ maxStack +=
+ prepareReturnValue(
+ erasedReturnType,
+ enforcedReturnType,
+ constructorTarget ? methodToCall.holder : methodToCallReturnType,
+ instructions,
+ factory);
instructions.add(new CfReturn(ValueType.fromDexType(enforcedReturnType)));
}
@@ -363,9 +360,12 @@
Builder<CfInstruction> instructions,
DexItemFactory factory) {
internalAdjustType(fromType, toType, returnType, instructions, factory);
- return Math.max(
- ValueType.fromDexType(fromType).requiredRegisters(),
- ValueType.fromDexType(toType).requiredRegisters());
+ int inSize = ValueType.fromDexType(fromType).requiredRegisters();
+ int outSize = ValueType.fromDexType(toType).requiredRegisters();
+ if (outSize > inSize) {
+ return outSize - inSize;
+ }
+ return 0;
}
private static void internalAdjustType(
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LocalStackAllocator.java b/src/main/java/com/android/tools/r8/ir/desugar/LocalStackAllocator.java
new file mode 100644
index 0000000..8c83d4a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LocalStackAllocator.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.ir.desugar;
+
+public interface LocalStackAllocator {
+
+ void allocateLocalStack(int localStackHeight);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java b/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
index c34e32c..5815053 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NonEmptyCfInstructionDesugaringCollection.java
@@ -16,6 +16,8 @@
import com.android.tools.r8.ir.desugar.lambda.LambdaInstructionDesugaring;
import com.android.tools.r8.ir.desugar.nest.D8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring;
+import com.android.tools.r8.ir.desugar.stringconcat.StringConcatInstructionDesugaring;
+import com.android.tools.r8.ir.desugar.twr.TwrCloseResourceInstructionDesugaring;
import com.android.tools.r8.utils.IntBox;
import com.android.tools.r8.utils.IteratorUtils;
import com.android.tools.r8.utils.ListUtils;
@@ -39,6 +41,16 @@
this.nestBasedAccessDesugaring = NestBasedAccessDesugaring.create(appView);
desugarings.add(new LambdaInstructionDesugaring(appView));
desugarings.add(new InvokeSpecialToSelfDesugaring(appView));
+ desugarings.add(new StringConcatInstructionDesugaring(appView));
+ if (appView.options().enableBackportedMethodRewriting()) {
+ BackportedMethodRewriter backportedMethodRewriter = new BackportedMethodRewriter(appView);
+ if (backportedMethodRewriter.hasBackports()) {
+ desugarings.add(backportedMethodRewriter);
+ }
+ }
+ if (appView.options().enableTryWithResourcesDesugaring()) {
+ desugarings.add(new TwrCloseResourceInstructionDesugaring(appView));
+ }
if (nestBasedAccessDesugaring != null) {
desugarings.add(nestBasedAccessDesugaring);
}
@@ -86,6 +98,9 @@
IntBox maxLocalsForCode = new IntBox(cfCode.getMaxLocals());
IntBox maxLocalsForInstruction = new IntBox(cfCode.getMaxLocals());
+ IntBox maxStackForCode = new IntBox(cfCode.getMaxStack());
+ IntBox maxStackForInstruction = new IntBox(cfCode.getMaxStack());
+
List<CfInstruction> desugaredInstructions =
ListUtils.flatMap(
cfCode.getInstructions(),
@@ -94,6 +109,7 @@
desugarInstruction(
instruction,
maxLocalsForInstruction::getAndIncrement,
+ maxStackForInstruction::getAndIncrement,
eventConsumer,
method,
methodProcessingContext);
@@ -110,8 +126,10 @@
null);
if (desugaredInstructions != null) {
assert maxLocalsForCode.get() >= cfCode.getMaxLocals();
+ assert maxStackForCode.get() >= cfCode.getMaxStack();
cfCode.setInstructions(desugaredInstructions);
cfCode.setMaxLocals(maxLocalsForCode.get());
+ cfCode.setMaxStack(maxStackForCode.get());
} else {
assert false : "Expected code to be desugared";
}
@@ -120,6 +138,7 @@
private Collection<CfInstruction> desugarInstruction(
CfInstruction instruction,
FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
CfInstructionDesugaringEventConsumer eventConsumer,
ProgramMethod context,
MethodProcessingContext methodProcessingContext) {
@@ -129,7 +148,12 @@
CfInstructionDesugaring desugaring = iterator.next();
Collection<CfInstruction> replacement =
desugaring.desugarInstruction(
- instruction, freshLocalProvider, eventConsumer, context, methodProcessingContext);
+ instruction,
+ freshLocalProvider,
+ localStackAllocator,
+ eventConsumer,
+ context,
+ methodProcessingContext);
if (replacement != null) {
assert verifyNoOtherDesugaringNeeded(
instruction, context, methodProcessingContext, iterator);
@@ -177,6 +201,9 @@
assert false;
return 0;
},
+ localStackHeight -> {
+ assert false;
+ },
CfInstructionDesugaringEventConsumer.createForDesugaredCode(),
context,
methodProcessingContext)
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/StringConcatRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/StringConcatRewriter.java
deleted file mode 100644
index 514ee97..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/StringConcatRewriter.java
+++ /dev/null
@@ -1,454 +0,0 @@
-// 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.
-
-package com.android.tools.r8.ir.desugar;
-
-import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
-
-import com.android.tools.r8.dex.Constants;
-import com.android.tools.r8.errors.CompilationError;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexCallSite;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.graph.DexValue;
-import com.android.tools.r8.graph.DexValue.DexValueString;
-import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.BasicBlock;
-import com.android.tools.r8.ir.code.ConstString;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.Instruction;
-import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.InvokeCustom;
-import com.android.tools.r8.ir.code.InvokeDirect;
-import com.android.tools.r8.ir.code.InvokeVirtual;
-import com.android.tools.r8.ir.code.NewInstance;
-import com.android.tools.r8.ir.code.Value;
-import com.google.common.collect.Lists;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Map;
-
-/** String concatenation desugaring rewriter. */
-public class StringConcatRewriter {
- private static final String CONCAT_FACTORY_TYPE_DESCR = "Ljava/lang/invoke/StringConcatFactory;";
- private static final String CALLSITE_TYPE_DESCR = "Ljava/lang/invoke/CallSite;";
- private static final String LOOKUP_TYPE_DESCR = "Ljava/lang/invoke/MethodHandles$Lookup;";
- private static final String METHOD_TYPE_TYPE_DESCR = "Ljava/lang/invoke/MethodType;";
-
- private static final String MAKE_CONCAT = "makeConcat";
- private static final String MAKE_CONCAT_WITH_CONSTANTS = "makeConcatWithConstants";
- private static final String TO_STRING = "toString";
- private static final String APPEND = "append";
-
- private final AppView<?> appView;
- private final DexItemFactory factory;
-
- private final DexMethod makeConcat;
- private final DexMethod makeConcatWithConstants;
-
- private final DexMethod stringBuilderInit;
- private final DexMethod stringBuilderToString;
-
- private final Map<DexType, DexMethod> paramTypeToAppendMethod = new IdentityHashMap<>();
- private final DexMethod defaultAppendMethod;
-
- public StringConcatRewriter(AppView<?> appView) {
- this.appView = appView;
- this.factory = appView.dexItemFactory();
-
- DexType factoryType = factory.createType(CONCAT_FACTORY_TYPE_DESCR);
- DexType callSiteType = factory.createType(CALLSITE_TYPE_DESCR);
- DexType lookupType = factory.createType(LOOKUP_TYPE_DESCR);
- DexType methodTypeType = factory.createType(METHOD_TYPE_TYPE_DESCR);
-
- makeConcat = factory.createMethod(factoryType,
- factory.createProto(callSiteType, lookupType, factory.stringType, methodTypeType),
- factory.createString(MAKE_CONCAT));
-
- makeConcatWithConstants = factory.createMethod(factoryType,
- factory.createProto(callSiteType, lookupType, factory.stringType, methodTypeType,
- factory.stringType, factory.objectArrayType),
- factory.createString(MAKE_CONCAT_WITH_CONSTANTS));
-
- stringBuilderInit = factory.createMethod(
- factory.stringBuilderType, factory.createProto(factory.voidType),
- factory.createString(Constants.INSTANCE_INITIALIZER_NAME));
-
- stringBuilderToString = factory.createMethod(
- factory.stringBuilderType, factory.createProto(factory.stringType),
- factory.createString(TO_STRING));
-
- // Mapping of type parameters to methods of StringBuilder.
- DexType stringBuilderType = factory.stringBuilderType;
- paramTypeToAppendMethod.put(factory.booleanType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.booleanType), APPEND));
- paramTypeToAppendMethod.put(factory.charType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.charType), APPEND));
- paramTypeToAppendMethod.put(factory.byteType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.intType), APPEND));
- paramTypeToAppendMethod.put(factory.shortType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.intType), APPEND));
- paramTypeToAppendMethod.put(factory.intType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.intType), APPEND));
- paramTypeToAppendMethod.put(factory.longType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.longType), APPEND));
- paramTypeToAppendMethod.put(factory.floatType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.floatType), APPEND));
- paramTypeToAppendMethod.put(factory.doubleType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.doubleType), APPEND));
- paramTypeToAppendMethod.put(factory.stringType, factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.stringType), APPEND));
- defaultAppendMethod = factory.createMethod(
- stringBuilderType, factory.createProto(stringBuilderType, factory.objectType), APPEND);
- }
-
- /**
- * Find and desugar all string concatenations implemented via `invokedynamic` call
- * to either of StringConcatFactory bootstrap methods.
- */
- public void desugarStringConcats(DexMethod method, IRCode code) {
- ListIterator<BasicBlock> blocks = code.listIterator();
- while (blocks.hasNext()) {
- BasicBlock block = blocks.next();
- InstructionListIterator instructions = block.listIterator(code);
- while (instructions.hasNext()) {
- Instruction instruction = instructions.next();
- if (!instruction.isInvokeCustom()) {
- continue;
- }
-
- InvokeCustom invokeCustom = instruction.asInvokeCustom();
- DexCallSite callSite = invokeCustom.getCallSite();
-
- // We are interested in bootstrap methods StringConcatFactory::makeConcat
- // and StringConcatFactory::makeConcatWithConstants, both are static.
- if (!callSite.bootstrapMethod.type.isInvokeStatic()) {
- continue;
- }
-
- DexMethod bootstrapMethod = callSite.bootstrapMethod.asMethod();
- // We rely on both rewrite methods called below performing their work in
- // a way which keeps both `instructions` and `blocks` iterators in
- // valid state so that we can continue iteration.
- if (bootstrapMethod == this.makeConcat) {
- rewriteMakeConcat(method, code, blocks, instructions, invokeCustom);
- } else if (bootstrapMethod == this.makeConcatWithConstants) {
- rewriteMakeConcatWithConstants(method, code, blocks, instructions, invokeCustom);
- }
- }
- }
- }
-
- /**
- * Rewrite concatenation with StringConcatFactory::makeConcat​(...). There is no
- * format string (`recipe`), all arguments are just concatenated in order.
- */
- private void rewriteMakeConcat(DexMethod method, IRCode code, ListIterator<BasicBlock> blocks,
- InstructionListIterator instructions, InvokeCustom invokeCustom) {
- DexProto proto = invokeCustom.getCallSite().methodProto;
- DexType[] parameters = proto.parameters.values;
- int paramCount = parameters.length;
- List<Value> arguments = invokeCustom.inValues();
-
- // Signature of the callsite proto defines the effective types of the arguments.
- if (paramCount != arguments.size()) {
- throw error(method, "inconsistent arguments: expected " +
- paramCount + ", actual " + arguments.size());
- }
-
- // Collect chunks.
- ConcatBuilder builder = new ConcatBuilder(appView, code, blocks, instructions);
- for (int i = 0; i < paramCount; i++) {
- builder.addChunk(arguments.get(i),
- paramTypeToAppendMethod.getOrDefault(parameters[i], defaultAppendMethod));
- }
-
- // Desugar the instruction.
- builder.desugar();
- }
-
- /**
- * Rewrite concatenation with StringConcatFactory::makeConcat​WithConstants(...).
- * There is a format string (`recipe`) specifying where exactly the arguments are
- * to be inserted into a template string `recipe`.
- *
- * NOTE: `makeConcat​WithConstants` also supports passing compilation time `constants`
- * as bootstrap method arguments, but current version seems to only support String
- * constants. This method does not support desugaring of `makeConcatWithConstants`
- * with non-string constants provided as bootstrap method arguments.
- */
- private void rewriteMakeConcatWithConstants(
- DexMethod method, IRCode code, ListIterator<BasicBlock> blocks,
- InstructionListIterator instructions, InvokeCustom invokeCustom) {
- DexCallSite callSite = invokeCustom.getCallSite();
- DexProto proto = callSite.methodProto;
- DexType[] parameters = proto.parameters.values;
- int paramCount = parameters.length;
- List<Value> callArgs = invokeCustom.inValues();
- List<DexValue> bootstrapArgs = callSite.bootstrapArgs;
-
- // Signature of the callsite proto defines the effective types of the arguments.
- if (paramCount != callArgs.size()) {
- throw error(method, "inconsistent arguments: expected " +
- paramCount + ", actual " + callArgs.size());
- }
-
- // Get `recipe` string.
- if (bootstrapArgs.size() == 0) {
- throw error(method, "bootstrap method misses `recipe` argument");
- }
-
- // Constant arguments to `recipe`.
- List<DexValue> constArgs = new ArrayList<>();
- for (int i = 1; i < bootstrapArgs.size(); i++) {
- constArgs.add(bootstrapArgs.get(i));
- }
-
- // Extract recipe.
- DexValueString recipeValue = bootstrapArgs.get(0).asDexValueString();
- if (recipeValue == null) {
- throw error(method, "bootstrap method argument `recipe` must be a string");
- }
- String recipe = recipeValue.getValue().toString();
-
- // Collect chunks and patch the instruction.
- ConcatBuilder builder = new ConcatBuilder(appView, code, blocks, instructions);
- StringBuilder acc = new StringBuilder();
- int argIndex = 0;
- int constArgIndex = 0;
- int length = recipe.length();
- for (int i = 0; i < length; i++) {
- char c = recipe.charAt(i);
- if (c == '\u0001') {
- // Reference to an argument.
- if (acc.length() > 0) {
- builder.addChunk(acc.toString(), paramTypeToAppendMethod.get(factory.stringType));
- acc.setLength(0);
- }
- if (argIndex >= paramCount) {
- throw error(method, "too many argument references in `recipe`");
- }
- builder.addChunk(callArgs.get(argIndex),
- paramTypeToAppendMethod.getOrDefault(parameters[argIndex], defaultAppendMethod));
- argIndex++;
-
- } else if (c == '\u0002') {
- if (constArgIndex >= constArgs.size()) {
- throw error(method, "too many constant references in `recipe`");
- }
-
- // Reference to a constant. Since it's a constant we just convert it to
- // string and append to `acc`, this way we will avoid calling toString()
- // on every call.
- acc.append(convertToString(method, constArgs.get(constArgIndex++)));
-
- } else {
- acc.append(c);
- }
- }
-
- if (argIndex != paramCount) {
- throw error(method, "too few argument references in `recipe`, "
- + "expected " + paramCount + ", referenced: " + argIndex);
- }
- if (constArgIndex != constArgs.size()) {
- throw error(method, "too few constant references in `recipe`, "
- + "expected " + constArgs.size() + ", referenced: " + constArgIndex);
- }
-
- // Final part.
- if (acc.length() > 0) {
- builder.addChunk(acc.toString(), paramTypeToAppendMethod.get(factory.stringType));
- }
-
- // Desugar the instruction.
- builder.desugar();
- }
-
- private static String convertToString(DexMethod method, DexValue value) {
- if (value.isDexValueString()) {
- return value.asDexValueString().getValue().toString();
- }
- throw error(method,
- "const arg referenced from `recipe` is not supported: " + value.getClass().getName());
- }
-
- private final class ConcatBuilder {
- private final AppView<?> appView;
- private final IRCode code;
- private final ListIterator<BasicBlock> blocks;
- private final InstructionListIterator instructions;
- private final Instruction invokeCustom;
- private final BasicBlock currentBlock;
- private final List<Chunk> chunks = new ArrayList<>();
-
- private ConcatBuilder(
- AppView<?> appView,
- IRCode code,
- ListIterator<BasicBlock> blocks,
- InstructionListIterator instructions) {
- this.appView = appView;
- this.code = code;
- this.blocks = blocks;
- this.instructions = instructions;
-
- invokeCustom = instructions.peekPrevious();
- assert invokeCustom.isInvokeCustom();
- currentBlock = invokeCustom.getBlock();
- }
-
- private void appendInstruction(Instruction instruction) {
- instruction.setPosition(invokeCustom.getPosition());
- instructions.add(instruction);
- }
-
- final void addChunk(Value value, DexMethod method) {
- chunks.add(new ArgumentChunk(value, method));
- }
-
- final void addChunk(String str, DexMethod method) {
- chunks.add(new ConstantChunk(str, method));
- }
-
- /**
- * Patch current `invoke-custom` instruction with:
- * <pre>
- * prologue:
- * | new-instance v0, StringBuilder
- * | invoke-direct {v0}, void StringBuilder.<init>()
- *
- * populate each chunk:
- * | (optional) load the constant, e.g.: const-string v1, ""
- * | invoke-virtual {v0, v1}, StringBuilder StringBuilder.append([type])
- *
- * epilogue:
- * | invoke-virtual {v0}, String StringBuilder.toString()
- *
- * </pre>
- */
- final void desugar() {
- // Move the iterator before the invoke-custom we are about to patch.
- instructions.previous();
-
- // new-instance v0, StringBuilder
- TypeElement stringBuilderTypeLattice =
- TypeElement.fromDexType(factory.stringBuilderType, definitelyNotNull(), appView);
- Value sbInstance = code.createValue(stringBuilderTypeLattice);
- appendInstruction(new NewInstance(factory.stringBuilderType, sbInstance));
-
- // invoke-direct {v0}, void StringBuilder.<init>()
- appendInstruction(new InvokeDirect(stringBuilderInit,
- null /* no return value */, Collections.singletonList(sbInstance)));
-
- // Add calls to append(...) methods
- for (Chunk chunk : chunks) {
- chunk.addAppendCall(sbInstance);
- }
-
- // invoke-virtual {v0}, String StringBuilder.toString()
- Instruction nextInstruction = instructions.next();
- assert invokeCustom == nextInstruction;
-
- // The value representing the string: we reuse the value from the
- // original invoke-custom instruction, and thus all its usages.
- Value concatValue = invokeCustom.outValue();
- if (concatValue == null) {
- // The out value might be empty in case it was optimized out.
- concatValue = code.createValue(TypeElement.stringClassType(appView, definitelyNotNull()));
- }
-
- // Replace the instruction.
- instructions.replaceCurrentInstruction(new InvokeVirtual(
- stringBuilderToString, concatValue, Collections.singletonList(sbInstance)));
-
- if (!currentBlock.hasCatchHandlers()) {
- return;
- }
-
- // Since the block has handlers we should split the block at exception throwing
- // instructions. Splitting blocks while adding instructions seems more complicated.
- //
- // NOTE: we collect new blocks first and copy catch handlers from the original
- // one after all blocks are split. Copying handlers just after splitting involves
- // extra complexity since split() method expects that the block being split is
- // located right before the iterator point and new blocks created while copying
- // handles break this expectation.
- List<BasicBlock> newBlocks = new ArrayList<>();
- InstructionListIterator it = currentBlock.listIterator(code);
- while (it.hasNext()) {
- Instruction instruction = it.next();
- if (instruction.instructionTypeCanThrow() && it.hasNext()) {
- // We split block in case we see throwing instruction which
- // is not the last instruction of the block.
- BasicBlock newBlock = it.split(code, blocks);
- newBlocks.add(newBlock);
- // Follow with the next block.
- it = newBlock.listIterator(code);
- }
- }
- // Copy catch handlers after all blocks are split.
- for (BasicBlock newBlock : newBlocks) {
- newBlock.copyCatchHandlers(code, blocks, currentBlock, appView.options());
- }
- }
-
- private abstract class Chunk {
- final DexMethod method;
-
- Chunk(DexMethod method) {
- this.method = method;
- }
-
- abstract Value getOrCreateValue();
-
- final void addAppendCall(Value sbInstance) {
- appendInstruction(new InvokeVirtual(
- method, null /* don't care about return value */,
- Lists.newArrayList(sbInstance, getOrCreateValue())));
- }
- }
-
- private final class ArgumentChunk extends Chunk {
- final Value value;
-
- ArgumentChunk(Value value, DexMethod method) {
- super(method);
- this.value = value;
- }
-
- @Override
- Value getOrCreateValue() {
- return value;
- }
- }
-
- private final class ConstantChunk extends Chunk {
- final String str;
-
- ConstantChunk(String str, DexMethod method) {
- super(method);
- this.str = str;
- }
-
- @Override
- Value getOrCreateValue() {
- Value value = code.createValue(TypeElement.stringClassType(appView, definitelyNotNull()));
- appendInstruction(new ConstString(value, factory.createString(str)));
- return value;
- }
- }
- }
-
- private static CompilationError error(DexMethod method, String message) {
- return new CompilationError(
- "String concatenation desugaring error (method: " +
- method.qualifiedName() + "): " + message);
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
deleted file mode 100644
index 69b4dc2..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/TwrCloseResourceRewriter.java
+++ /dev/null
@@ -1,146 +0,0 @@
-// 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 com.android.tools.r8.ir.desugar;
-
-import com.android.tools.r8.cf.code.CfInstruction;
-import com.android.tools.r8.cf.code.CfInvoke;
-import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.CfCode;
-import com.android.tools.r8.graph.DexItemFactory;
-import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexProto;
-import com.android.tools.r8.graph.MethodAccessFlags;
-import com.android.tools.r8.graph.ProgramMethod;
-import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.InstructionListIterator;
-import com.android.tools.r8.ir.code.InvokeStatic;
-import com.android.tools.r8.ir.conversion.IRConverter;
-import com.android.tools.r8.ir.desugar.backports.BackportedMethods;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
-import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.InternalOptions.DesugarState;
-import com.google.common.base.Suppliers;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-import org.objectweb.asm.Opcodes;
-
-// Try with resources close-resource desugaring.
-//
-// Rewrites $closeResource methods synthesized by java compilers to work on older DEX runtimes.
-// All invocations to $closeResource methods are rewritten to target a compiler generated version
-// that is correct on older DEX runtimes where not all types implement AutoClosable as expected.
-//
-// Note that we don't remove $closeResource(...) synthesized by java compiler, relying on
-// tree shaking to remove them since now they should not be referenced.
-// TODO(b/177401708): D8 does not tree shake so we should remove the now unused method.
-public final class TwrCloseResourceRewriter {
-
- private final AppView<?> appView;
- private final DexProto twrCloseResourceProto;
- private final List<ProgramMethod> synthesizedMethods = new ArrayList<>();
-
- public static boolean enableTwrCloseResourceDesugaring(InternalOptions options) {
- return options.desugarState == DesugarState.ON
- && options.enableTryWithResourcesDesugaring()
- && !options.canUseTwrCloseResourceMethod();
- }
-
- public TwrCloseResourceRewriter(AppView<?> appView) {
- this.appView = appView;
- DexItemFactory dexItemFactory = appView.dexItemFactory();
- twrCloseResourceProto =
- dexItemFactory.createProto(
- dexItemFactory.voidType, dexItemFactory.throwableType, dexItemFactory.objectType);
- }
-
- public int rewriteCf(
- ProgramMethod method,
- Consumer<ProgramMethod> newMethodCallback,
- MethodProcessingContext methodProcessingContext) {
- CfCode code = method.getDefinition().getCode().asCfCode();
- List<CfInstruction> instructions = code.getInstructions();
- Supplier<List<CfInstruction>> lazyNewInstructions =
- Suppliers.memoize(() -> new ArrayList<>(instructions));
- int replaced = 0;
- int newInstructionDelta = 0;
- for (int i = 0; i < instructions.size(); i++) {
- CfInvoke invoke = instructions.get(i).asInvoke();
- if (invoke == null
- || invoke.getOpcode() != Opcodes.INVOKESTATIC
- || !isTwrCloseResourceMethod(invoke.getMethod(), appView.dexItemFactory())) {
- continue;
- }
- // Synthesize a new method.
- ProgramMethod closeMethod = createSyntheticCloseResourceMethod(methodProcessingContext);
- newMethodCallback.accept(closeMethod);
- // Rewrite the invoke to the new synthetic.
- int newInstructionIndex = i + newInstructionDelta;
- lazyNewInstructions
- .get()
- .set(
- newInstructionIndex,
- new CfInvoke(Opcodes.INVOKESTATIC, closeMethod.getReference(), false));
- ++replaced;
- }
- if (replaced > 0) {
- code.setInstructions(lazyNewInstructions.get());
- }
- return replaced;
- }
-
- // Rewrites calls to $closeResource() method. Can be invoked concurrently.
- public void rewriteIR(IRCode code, MethodProcessingContext methodProcessingContext) {
- InstructionListIterator iterator = code.instructionListIterator();
- while (iterator.hasNext()) {
- InvokeStatic invoke = iterator.next().asInvokeStatic();
- if (invoke == null
- || !isTwrCloseResourceMethod(invoke.getInvokedMethod(), appView.dexItemFactory())) {
- continue;
- }
-
- // Replace with a call to a synthetic utility.
- assert invoke.outValue() == null;
- assert invoke.inValues().size() == 2;
- ProgramMethod closeResourceMethod =
- createSyntheticCloseResourceMethod(methodProcessingContext);
- InvokeStatic newInvoke =
- new InvokeStatic(closeResourceMethod.getReference(), null, invoke.inValues());
- iterator.replaceCurrentInstruction(newInvoke);
- synchronized (synthesizedMethods) {
- synthesizedMethods.add(closeResourceMethod);
- }
- }
- }
-
- public static boolean isTwrCloseResourceMethod(DexMethod method, DexItemFactory factory) {
- return method.name == factory.twrCloseResourceMethodName
- && method.proto == factory.twrCloseResourceMethodProto;
- }
-
- private ProgramMethod createSyntheticCloseResourceMethod(
- MethodProcessingContext methodProcessingContext) {
- return appView
- .getSyntheticItems()
- .createMethod(
- SyntheticKind.TWR_CLOSE_RESOURCE,
- methodProcessingContext.createUniqueContext(),
- appView.dexItemFactory(),
- methodBuilder ->
- methodBuilder
- .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
- .setProto(twrCloseResourceProto)
- .setCode(
- m ->
- BackportedMethods.CloseResourceMethod_closeResourceImpl(
- appView.options(), m)));
- }
-
- public void processSynthesizedMethods(IRConverter converter) {
- synthesizedMethods.forEach(converter::optimizeSynthesizedMethod);
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethodDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethodDesugaringEventConsumer.java
new file mode 100644
index 0000000..c62501f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethodDesugaringEventConsumer.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.ir.desugar.backports;
+
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface BackportedMethodDesugaringEventConsumer {
+
+ void acceptBackportedMethod(ProgramMethod backportedMethod, ProgramMethod context);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/backports/NumericMethodRewrites.java b/src/main/java/com/android/tools/r8/ir/desugar/backports/NumericMethodRewrites.java
index 050aefa..51949c9 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/backports/NumericMethodRewrites.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/backports/NumericMethodRewrites.java
@@ -8,7 +8,8 @@
import com.android.tools.r8.ir.code.NumericType;
import com.android.tools.r8.ir.desugar.BackportedMethodRewriter.FullMethodInvokeRewriter;
import com.android.tools.r8.ir.desugar.BackportedMethodRewriter.MethodInvokeRewriter;
-import java.util.ListIterator;
+import java.util.Collection;
+import java.util.Collections;
import org.objectweb.asm.Opcodes;
public final class NumericMethodRewrites {
@@ -33,10 +34,9 @@
public static MethodInvokeRewriter rewriteAsIdentity() {
return new FullMethodInvokeRewriter() {
@Override
- public void rewrite(
- CfInvoke invoke, ListIterator<CfInstruction> iterator, DexItemFactory factory) {
+ public Collection<CfInstruction> rewrite(CfInvoke invoke, DexItemFactory factory) {
// The invoke consumes the stack value and pushes another assumed to be the same.
- iterator.remove();
+ return Collections.emptyList();
}
};
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java b/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java
index 69253be..f8ab4a7 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/backports/ObjectsMethodRewrites.java
@@ -12,7 +12,8 @@
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.desugar.BackportedMethodRewriter.FullMethodInvokeRewriter;
import com.android.tools.r8.ir.desugar.BackportedMethodRewriter.MethodInvokeRewriter;
-import java.util.ListIterator;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import org.objectweb.asm.Opcodes;
public final class ObjectsMethodRewrites {
@@ -31,13 +32,12 @@
return new FullMethodInvokeRewriter() {
@Override
- public void rewrite(
- CfInvoke invoke, ListIterator<CfInstruction> iterator, DexItemFactory factory) {
- iterator.remove();
+ public Collection<CfInstruction> rewrite(CfInvoke invoke, DexItemFactory factory) {
// requireNonNull returns the operand, so dup top-of-stack, do getClass and pop the class.
- iterator.add(new CfStackInstruction(Opcode.Dup));
- iterator.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, factory.objectMembers.getClass, false));
- iterator.add(new CfStackInstruction(Opcode.Pop));
+ return ImmutableList.of(
+ new CfStackInstruction(Opcode.Dup),
+ new CfInvoke(Opcodes.INVOKEVIRTUAL, factory.objectMembers.getClass, false),
+ new CfStackInstruction(Opcode.Pop));
}
};
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/invokespecial/InvokeSpecialToSelfDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/invokespecial/InvokeSpecialToSelfDesugaring.java
index a4f4b9b..0b9c80e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/invokespecial/InvokeSpecialToSelfDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/invokespecial/InvokeSpecialToSelfDesugaring.java
@@ -17,6 +17,7 @@
import com.android.tools.r8.ir.desugar.CfInstructionDesugaring;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.FreshLocalProvider;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
import com.android.tools.r8.ir.synthetic.ForwardMethodBuilder;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
@@ -68,6 +69,7 @@
public Collection<CfInstruction> desugarInstruction(
CfInstruction instruction,
FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
CfInstructionDesugaringEventConsumer eventConsumer,
ProgramMethod context,
MethodProcessingContext methodProcessingContext) {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/lambda/D8LambdaDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/lambda/D8LambdaDesugaring.java
index 2d89fce..24c179e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/lambda/D8LambdaDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/lambda/D8LambdaDesugaring.java
@@ -8,37 +8,11 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.EnclosingMethodAttribute;
-import com.android.tools.r8.ir.conversion.ClassConverterResult;
-import com.android.tools.r8.ir.conversion.D8MethodProcessor;
-import com.android.tools.r8.utils.collections.ProgramMethodSet;
-import java.util.IdentityHashMap;
import java.util.Map;
-import java.util.concurrent.ExecutionException;
public class D8LambdaDesugaring {
- public static void synthesizeAccessibilityBridgesForLambdaClasses(
- AppView<?> appView,
- ClassConverterResult classConverterResult,
- D8MethodProcessor methodProcessor)
- throws ExecutionException {
- Map<DexMethod, DexMethod> forcefullyMovedLambdaMethods = new IdentityHashMap<>();
- ProgramMethodSet seenAccessibilityBridges = ProgramMethodSet.createConcurrent();
- classConverterResult.forEachSynthesizedLambdaClassWithDeterministicOrdering(
- lambdaClass -> {
- // Collect the accessibility bridges that require processing. Note that we cannot schedule
- // the methods for processing directly here, since that would lead to concurrent IR
- // processing meanwhile we update the program (insert bridges on existing classes).
- lambdaClass.target.ensureAccessibilityIfNeeded(
- forcefullyMovedLambdaMethods::put, seenAccessibilityBridges::add);
- });
- methodProcessor
- .scheduleDesugaredMethodsForProcessing(seenAccessibilityBridges)
- .awaitMethodProcessing();
- rewriteEnclosingMethodAttributes(appView, forcefullyMovedLambdaMethods);
- }
-
- private static void rewriteEnclosingMethodAttributes(
+ public static void rewriteEnclosingLambdaMethodAttributes(
AppView<?> appView, Map<DexMethod, DexMethod> forcefullyMovedLambdaMethods) {
if (forcefullyMovedLambdaMethods.isEmpty()) {
return;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/lambda/LambdaInstructionDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/lambda/LambdaInstructionDesugaring.java
index 54477eb..34dda4e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/lambda/LambdaInstructionDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/lambda/LambdaInstructionDesugaring.java
@@ -24,6 +24,7 @@
import com.android.tools.r8.ir.desugar.FreshLocalProvider;
import com.android.tools.r8.ir.desugar.LambdaClass;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
import com.android.tools.r8.synthesis.SyntheticNaming;
import com.android.tools.r8.utils.Box;
import com.google.common.collect.ImmutableList;
@@ -44,6 +45,7 @@
public Collection<CfInstruction> desugarInstruction(
CfInstruction instruction,
FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
CfInstructionDesugaringEventConsumer eventConsumer,
ProgramMethod context,
MethodProcessingContext methodProcessingContext) {
@@ -51,6 +53,7 @@
return desugarInvokeDynamicInstruction(
instruction.asInvokeDynamic(),
freshLocalProvider,
+ localStackAllocator,
eventConsumer,
context,
methodProcessingContext);
@@ -61,6 +64,7 @@
private Collection<CfInstruction> desugarInvokeDynamicInstruction(
CfInvokeDynamic invoke,
FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
LambdaDesugaringEventConsumer eventConsumer,
ProgramMethod context,
MethodProcessingContext methodProcessingContext) {
@@ -89,6 +93,13 @@
replacement.addLast(new CfLoad(valueType, freshLocal));
});
replacement.add(new CfInvoke(Opcodes.INVOKESPECIAL, lambdaClass.constructor, false));
+
+ // Coming into the original invoke-dynamic instruction, we have N arguments on the stack. We pop
+ // the N arguments from the stack, and then add a new-instance and dup it. With those two new
+ // elements on the stack, we load all the N arguments back onto the stack. At this point, we
+ // have the original N arguments on the stack plus the 2 new stack elements.
+ localStackAllocator.allocateLocalStack(2);
+
return replacement;
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
index af0a140..cec4cb1 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/nest/NestBasedAccessDesugaring.java
@@ -32,6 +32,7 @@
import com.android.tools.r8.ir.desugar.CfInstructionDesugaring;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.FreshLocalProvider;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
@@ -146,6 +147,7 @@
public Collection<CfInstruction> desugarInstruction(
CfInstruction instruction,
FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
CfInstructionDesugaringEventConsumer eventConsumer,
ProgramMethod context,
MethodProcessingContext methodProcessingContext) {
@@ -153,7 +155,8 @@
return desugarFieldInstruction(instruction.asFieldInstruction(), context, eventConsumer);
}
if (instruction.isInvoke()) {
- return desugarInvokeInstruction(instruction.asInvoke(), context, eventConsumer);
+ return desugarInvokeInstruction(
+ instruction.asInvoke(), localStackAllocator, context, eventConsumer);
}
return null;
}
@@ -178,6 +181,7 @@
private List<CfInstruction> desugarInvokeInstruction(
CfInvoke invoke,
+ LocalStackAllocator localStackAllocator,
ProgramMethod context,
NestBasedAccessDesugaringEventConsumer eventConsumer) {
DexMethod invokedMethod = invoke.getMethod();
@@ -197,6 +201,8 @@
DexMethod bridge = ensureMethodBridge(target, eventConsumer);
if (target.getDefinition().isInstanceInitializer()) {
assert !invoke.isInterface();
+ // Ensure room on the stack for the extra null argument.
+ localStackAllocator.allocateLocalStack(1);
return ImmutableList.of(
new CfConstNull(), new CfInvoke(Opcodes.INVOKESPECIAL, bridge, false));
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/stringconcat/StringConcatInstructionDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/stringconcat/StringConcatInstructionDesugaring.java
new file mode 100644
index 0000000..cae3e54
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/stringconcat/StringConcatInstructionDesugaring.java
@@ -0,0 +1,419 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.ir.desugar.stringconcat;
+
+import com.android.tools.r8.cf.code.CfConstString;
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.cf.code.CfInvokeDynamic;
+import com.android.tools.r8.cf.code.CfLoad;
+import com.android.tools.r8.cf.code.CfNew;
+import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
+import com.android.tools.r8.cf.code.CfStore;
+import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexCallSite;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexItemFactory.StringBuildingMethods;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaring;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.FreshLocalProvider;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.IteratorUtils;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.objectweb.asm.Opcodes;
+
+/** String concatenation desugaring rewriter. */
+public class StringConcatInstructionDesugaring implements CfInstructionDesugaring {
+
+ private final DexItemFactory factory;
+ private final StringBuildingMethods stringBuilderMethods;
+
+ private final Map<DexType, DexMethod> paramTypeToAppendMethod = new IdentityHashMap<>();
+
+ public StringConcatInstructionDesugaring(AppView<?> appView) {
+ this.factory = appView.dexItemFactory();
+ this.stringBuilderMethods = factory.stringBuilderMethods;
+
+ // Mapping of type parameters to methods of StringBuilder.
+ paramTypeToAppendMethod.put(factory.booleanType, stringBuilderMethods.appendBoolean);
+ paramTypeToAppendMethod.put(factory.charType, stringBuilderMethods.appendChar);
+ paramTypeToAppendMethod.put(factory.byteType, stringBuilderMethods.appendInt);
+ paramTypeToAppendMethod.put(factory.shortType, stringBuilderMethods.appendInt);
+ paramTypeToAppendMethod.put(factory.intType, stringBuilderMethods.appendInt);
+ paramTypeToAppendMethod.put(factory.longType, stringBuilderMethods.appendLong);
+ paramTypeToAppendMethod.put(factory.floatType, stringBuilderMethods.appendFloat);
+ paramTypeToAppendMethod.put(factory.doubleType, stringBuilderMethods.appendDouble);
+ paramTypeToAppendMethod.put(factory.stringType, stringBuilderMethods.appendString);
+ }
+
+ @Override
+ public Collection<CfInstruction> desugarInstruction(
+ CfInstruction instruction,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
+ CfInstructionDesugaringEventConsumer eventConsumer,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext) {
+ if (instruction.isInvokeDynamic()) {
+ // We are interested in bootstrap methods StringConcatFactory::makeConcat
+ // and StringConcatFactory::makeConcatWthConstants, both are static.
+ CfInvokeDynamic invoke = instruction.asInvokeDynamic();
+ DexCallSite callSite = invoke.getCallSite();
+ if (callSite.bootstrapMethod.type.isInvokeStatic()) {
+ DexMethod bootstrapMethod = callSite.bootstrapMethod.asMethod();
+ if (bootstrapMethod == factory.stringConcatFactoryMembers.makeConcat) {
+ return desugarMakeConcat(invoke, freshLocalProvider, localStackAllocator);
+ }
+ if (bootstrapMethod == factory.stringConcatFactoryMembers.makeConcatWithConstants) {
+ return desugarMakeConcatWithConstants(
+ invoke, freshLocalProvider, localStackAllocator, context);
+ }
+ }
+ }
+ return null;
+ }
+
+ private Collection<CfInstruction> desugarMakeConcat(
+ CfInvokeDynamic invoke,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator) {
+ DexProto proto = invoke.getCallSite().methodProto;
+ DexType[] parameters = proto.parameters.values;
+
+ // Collect chunks.
+ ConcatBuilder builder = new ConcatBuilder();
+ for (DexType parameter : parameters) {
+ ValueType valueType = ValueType.fromDexType(parameter);
+ builder.addChunk(
+ new ArgumentChunk(
+ paramTypeToAppendMethod.getOrDefault(parameter, stringBuilderMethods.appendObject),
+ freshLocalProvider.getFreshLocal(valueType.requiredRegisters())));
+ }
+
+ // Desugar the instruction.
+ return builder.desugar(localStackAllocator);
+ }
+
+ private Collection<CfInstruction> desugarMakeConcatWithConstants(
+ CfInvokeDynamic invoke,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
+ ProgramMethod context) {
+ DexCallSite callSite = invoke.getCallSite();
+ DexProto proto = callSite.methodProto;
+ DexTypeList parameters = proto.getParameters();
+ List<DexValue> bootstrapArgs = callSite.bootstrapArgs;
+
+ // Get `recipe` string.
+ if (bootstrapArgs.isEmpty()) {
+ throw error(context, "bootstrap method misses `recipe` argument");
+ }
+
+ // Extract recipe.
+ DexValueString recipeValue = bootstrapArgs.get(0).asDexValueString();
+ if (recipeValue == null) {
+ throw error(context, "bootstrap method argument `recipe` must be a string");
+ }
+ String recipe = recipeValue.getValue().toString();
+
+ // Constant arguments to `recipe`.
+ List<DexValue> constantArguments = new ArrayList<>();
+ for (int i = 1; i < bootstrapArgs.size(); i++) {
+ constantArguments.add(bootstrapArgs.get(i));
+ }
+
+ // Collect chunks and patch the instruction.
+ ConcatBuilder builder = new ConcatBuilder();
+ StringBuilder acc = new StringBuilder();
+ int length = recipe.length();
+ Iterator<DexValue> constantArgumentsIterator = constantArguments.iterator();
+ Iterator<DexType> parameterIterator = parameters.iterator();
+ for (int i = 0; i < length; i++) {
+ char c = recipe.charAt(i);
+ if (c == '\u0001') {
+ // Reference to an argument, so we need to flush the accumulated string.
+ if (acc.length() > 0) {
+ DexString stringConstant = factory.createString(acc.toString());
+ builder.addChunk(
+ new ConstantChunk(paramTypeToAppendMethod.get(factory.stringType), stringConstant));
+ acc.setLength(0);
+ }
+ if (!parameterIterator.hasNext()) {
+ throw error(context, "too many argument references in `recipe`");
+ }
+ DexType parameter = parameterIterator.next();
+ ValueType valueType = ValueType.fromDexType(parameter);
+ builder.addChunk(
+ new ArgumentChunk(
+ paramTypeToAppendMethod.getOrDefault(parameter, stringBuilderMethods.appendObject),
+ freshLocalProvider.getFreshLocal(valueType.requiredRegisters())));
+ } else if (c == '\u0002') {
+ // Reference to a constant. Since it's a constant we just convert it to string and append to
+ // `acc`, this way we will avoid calling toString() on every call.
+ if (!constantArgumentsIterator.hasNext()) {
+ throw error(context, "too many constant references in `recipe`");
+ }
+ acc.append(convertToString(constantArgumentsIterator.next(), context));
+ } else {
+ acc.append(c);
+ }
+ }
+
+ if (parameterIterator.hasNext()) {
+ throw error(
+ context,
+ "too few argument references in `recipe`, "
+ + "expected "
+ + parameters.size()
+ + ", referenced: "
+ + (parameters.size() - IteratorUtils.countRemaining(parameterIterator)));
+ }
+
+ if (constantArgumentsIterator.hasNext()) {
+ throw error(
+ context,
+ "too few constant references in `recipe`, "
+ + "expected "
+ + constantArguments.size()
+ + ", referenced: "
+ + (constantArguments.size()
+ - IteratorUtils.countRemaining(constantArgumentsIterator)));
+ }
+
+ // Final part.
+ if (acc.length() > 0) {
+ DexString stringConstant = factory.createString(acc.toString());
+ builder.addChunk(
+ new ConstantChunk(paramTypeToAppendMethod.get(factory.stringType), stringConstant));
+ }
+
+ // Desugar the instruction.
+ return builder.desugar(localStackAllocator);
+ }
+
+ @Override
+ public boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
+ return instruction.isInvokeDynamic()
+ && needsDesugaring(instruction.asInvokeDynamic().getCallSite());
+ }
+
+ private boolean needsDesugaring(DexCallSite callSite) {
+ // We are interested in bootstrap methods StringConcatFactory::makeConcat
+ // and StringConcatFactory::makeConcatWithConstants, both are static.
+ if (callSite.bootstrapMethod.type.isInvokeStatic()) {
+ DexMethod bootstrapMethod = callSite.bootstrapMethod.asMethod();
+ return bootstrapMethod == factory.stringConcatFactoryMembers.makeConcat
+ || bootstrapMethod == factory.stringConcatFactoryMembers.makeConcatWithConstants;
+ }
+ return false;
+ }
+
+ private static String convertToString(DexValue value, ProgramMethod context) {
+ if (value.isDexValueString()) {
+ return value.asDexValueString().getValue().toString();
+ }
+ throw error(
+ context,
+ "const arg referenced from `recipe` is not supported: " + value.getClass().getName());
+ }
+
+ private final class ConcatBuilder {
+
+ private final List<Chunk> chunks = new ArrayList<>();
+
+ private ArgumentChunk biggestArgumentChunk = null;
+ private ConstantChunk firstConstantChunk = null;
+ private int argumentChunksStackSize = 0;
+
+ ConcatBuilder() {}
+
+ void addChunk(ArgumentChunk chunk) {
+ chunks.add(chunk);
+ argumentChunksStackSize += chunk.getValueType().requiredRegisters();
+ if (biggestArgumentChunk == null
+ || chunk.getValueType().requiredRegisters()
+ > biggestArgumentChunk.getValueType().requiredRegisters()) {
+ biggestArgumentChunk = chunk;
+ }
+ }
+
+ void addChunk(ConstantChunk chunk) {
+ chunks.add(chunk);
+ if (firstConstantChunk == null) {
+ firstConstantChunk = chunk;
+ }
+ }
+
+ /**
+ * Patch current `invoke-custom` instruction with:
+ *
+ * <pre>
+ * prologue:
+ * | new-instance v0, StringBuilder
+ * | invoke-direct {v0}, void StringBuilder.<init>()
+ *
+ * populate each chunk:
+ * | (optional) load the constant, e.g.: const-string v1, ""
+ * | invoke-virtual {v0, v1}, StringBuilder StringBuilder.append([type])
+ *
+ * epilogue:
+ * | invoke-virtual {v0}, String StringBuilder.toString()
+ *
+ * </pre>
+ */
+ final Collection<CfInstruction> desugar(LocalStackAllocator localStackAllocator) {
+ Deque<CfInstruction> replacement = new ArrayDeque<>();
+ for (Chunk chunk : chunks) {
+ if (chunk.isArgumentChunk()) {
+ ArgumentChunk argumentChunk = chunk.asArgumentChunk();
+ replacement.addFirst(
+ new CfStore(argumentChunk.getValueType(), argumentChunk.getVariableIndex()));
+ }
+ }
+ replacement.add(new CfNew(factory.stringBuilderType));
+ replacement.add(new CfStackInstruction(Opcode.Dup));
+ replacement.add(
+ new CfInvoke(Opcodes.INVOKESPECIAL, stringBuilderMethods.defaultConstructor, false));
+ for (Chunk chunk : chunks) {
+ if (chunk.isArgumentChunk()) {
+ ArgumentChunk argumentChunk = chunk.asArgumentChunk();
+ replacement.add(
+ new CfLoad(argumentChunk.getValueType(), argumentChunk.getVariableIndex()));
+ } else {
+ assert chunk.isConstantChunk();
+ replacement.add(new CfConstString(chunk.asConstantChunk().getStringConstant()));
+ }
+ replacement.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, chunk.method, false));
+ }
+ replacement.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, stringBuilderMethods.toString, false));
+
+ // Coming into the original invoke-dynamic instruction, we have N arguments on the stack. We
+ // then pop the N arguments from the stack, allocate a new-instance on the stack, and dup it,
+ // to initialize the instance. We then one-by-one load the arguments and call append(). We
+ // therefore need a local stack of size 3 if there is a wide argument, and otherwise a local
+ // stack of size 2.
+ int maxLocalStackSizeAfterStores =
+ 2
+ + BooleanUtils.intValue(
+ biggestArgumentChunk != null
+ && biggestArgumentChunk.getValueType().requiredRegisters() == 2);
+ if (maxLocalStackSizeAfterStores > argumentChunksStackSize) {
+ localStackAllocator.allocateLocalStack(
+ maxLocalStackSizeAfterStores - argumentChunksStackSize);
+ }
+ return replacement;
+ }
+ }
+
+ private abstract static class Chunk {
+
+ private final DexMethod method;
+
+ Chunk(DexMethod method) {
+ this.method = method;
+ }
+
+ public DexMethod getMethod() {
+ return method;
+ }
+
+ public ValueType getValueType() {
+ assert method.getProto().getArity() == 1;
+ return ValueType.fromDexType(method.getParameter(0));
+ }
+
+ public boolean isArgumentChunk() {
+ return false;
+ }
+
+ public ArgumentChunk asArgumentChunk() {
+ return null;
+ }
+
+ public boolean isConstantChunk() {
+ return false;
+ }
+
+ public ConstantChunk asConstantChunk() {
+ return null;
+ }
+ }
+
+ private static final class ArgumentChunk extends Chunk {
+
+ private final int variableIndex;
+
+ ArgumentChunk(DexMethod method, int variableIndex) {
+ super(method);
+ this.variableIndex = variableIndex;
+ }
+
+ public int getVariableIndex() {
+ return variableIndex;
+ }
+
+ @Override
+ public boolean isArgumentChunk() {
+ return true;
+ }
+
+ @Override
+ public ArgumentChunk asArgumentChunk() {
+ return this;
+ }
+ }
+
+ private static final class ConstantChunk extends Chunk {
+
+ private final DexString stringConstant;
+
+ ConstantChunk(DexMethod method, DexString stringConstant) {
+ super(method);
+ this.stringConstant = stringConstant;
+ }
+
+ public DexString getStringConstant() {
+ return stringConstant;
+ }
+
+ @Override
+ public boolean isConstantChunk() {
+ return true;
+ }
+
+ @Override
+ public ConstantChunk asConstantChunk() {
+ return this;
+ }
+ }
+
+ private static CompilationError error(ProgramMethod context, String message) {
+ return new CompilationError(
+ "String concatenation desugaring error (method: "
+ + context.toSourceString()
+ + "): "
+ + message);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/twr/TwrCloseResourceDesugaringEventConsumer.java b/src/main/java/com/android/tools/r8/ir/desugar/twr/TwrCloseResourceDesugaringEventConsumer.java
new file mode 100644
index 0000000..1311da0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/twr/TwrCloseResourceDesugaringEventConsumer.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.ir.desugar.twr;
+
+import com.android.tools.r8.graph.ProgramMethod;
+
+public interface TwrCloseResourceDesugaringEventConsumer {
+
+ void acceptTwrCloseResourceMethod(ProgramMethod closeMethod, ProgramMethod context);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/twr/TwrCloseResourceInstructionDesugaring.java b/src/main/java/com/android/tools/r8/ir/desugar/twr/TwrCloseResourceInstructionDesugaring.java
new file mode 100644
index 0000000..076c9b3
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/twr/TwrCloseResourceInstructionDesugaring.java
@@ -0,0 +1,94 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.ir.desugar.twr;
+
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfInvoke;
+import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.MethodAccessFlags;
+import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaring;
+import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
+import com.android.tools.r8.ir.desugar.FreshLocalProvider;
+import com.android.tools.r8.ir.desugar.LocalStackAllocator;
+import com.android.tools.r8.ir.desugar.backports.BackportedMethods;
+import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import org.objectweb.asm.Opcodes;
+
+public class TwrCloseResourceInstructionDesugaring implements CfInstructionDesugaring {
+
+ private final AppView<?> appView;
+ private final DexItemFactory dexItemFactory;
+ private final DexProto twrCloseResourceProto;
+
+ public TwrCloseResourceInstructionDesugaring(AppView<?> appView) {
+ this.appView = appView;
+ this.dexItemFactory = appView.dexItemFactory();
+ this.twrCloseResourceProto =
+ dexItemFactory.createProto(
+ dexItemFactory.voidType, dexItemFactory.throwableType, dexItemFactory.objectType);
+ }
+
+ @Override
+ public Collection<CfInstruction> desugarInstruction(
+ CfInstruction instruction,
+ FreshLocalProvider freshLocalProvider,
+ LocalStackAllocator localStackAllocator,
+ CfInstructionDesugaringEventConsumer eventConsumer,
+ ProgramMethod context,
+ MethodProcessingContext methodProcessingContext) {
+ if (!instruction.isInvokeStatic()) {
+ return null;
+ }
+
+ CfInvoke invoke = instruction.asInvoke();
+ DexMethod invokedMethod = invoke.getMethod();
+ if (!isTwrCloseResourceMethod(invokedMethod)) {
+ return null;
+ }
+
+ // Synthesize a new method.
+ ProgramMethod closeMethod = createSyntheticCloseResourceMethod(methodProcessingContext);
+ eventConsumer.acceptTwrCloseResourceMethod(closeMethod, context);
+
+ // Rewrite the invoke to the new synthetic.
+ return ImmutableList.of(new CfInvoke(Opcodes.INVOKESTATIC, closeMethod.getReference(), false));
+ }
+
+ private ProgramMethod createSyntheticCloseResourceMethod(
+ MethodProcessingContext methodProcessingContext) {
+ return appView
+ .getSyntheticItems()
+ .createMethod(
+ SyntheticKind.TWR_CLOSE_RESOURCE,
+ methodProcessingContext.createUniqueContext(),
+ appView.dexItemFactory(),
+ methodBuilder ->
+ methodBuilder
+ .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
+ .setProto(twrCloseResourceProto)
+ .setCode(
+ m ->
+ BackportedMethods.CloseResourceMethod_closeResourceImpl(
+ appView.options(), m)));
+ }
+
+ @Override
+ public boolean needsDesugaring(CfInstruction instruction, ProgramMethod context) {
+ return instruction.isInvokeStatic()
+ && isTwrCloseResourceMethod(instruction.asInvoke().getMethod());
+ }
+
+ private boolean isTwrCloseResourceMethod(DexMethod method) {
+ return method.name == dexItemFactory.twrCloseResourceMethodName
+ && method.proto == dexItemFactory.twrCloseResourceMethodProto;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index 3aaba06..7432e43 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -1248,10 +1248,29 @@
// Collect basic blocks that check nullability of the parameter.
Set<BasicBlock> nullCheckedBlocks = Sets.newIdentityHashSet();
for (Instruction user : value.aliasedUsers()) {
- if (user.isAssumeWithNonNullAssumption()
- || user.throwsNpeIfValueIsNull(value, appView, code.context())) {
+ if (user.isAssumeWithNonNullAssumption()) {
+ // We don't allow assume instructions after throwing instructions, thus this block is either
+ // non-throwing or the assume instruction is before the throwing instruction.
+ assert !user.getBlock().hasCatchHandlers()
+ || user.getBlock().getInstructions().stream()
+ .filter(
+ instruction -> instruction == user || instruction.instructionTypeCanThrow())
+ .findFirst()
+ .get()
+ == user;
nullCheckedBlocks.add(user.getBlock());
+ continue;
}
+
+ if (user.throwsNpeIfValueIsNull(value, appView, code.context())) {
+ if (user.getBlock().hasCatchHandlers()) {
+ nullCheckedBlocks.addAll(user.getBlock().getNormalSuccessors());
+ } else {
+ nullCheckedBlocks.add(user.getBlock());
+ }
+ continue;
+ }
+
if (user.isIf()
&& user.asIf().isZeroTest()
&& (user.asIf().getType() == If.Type.EQ || user.asIf().getType() == If.Type.NE)) {
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 2f7edb2..0d7fe26 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -22,6 +22,9 @@
import com.android.tools.r8.experimental.graphinfo.GraphConsumer;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.ClassDefinition;
+import com.android.tools.r8.graph.ClasspathOrLibraryClass;
+import com.android.tools.r8.graph.ClasspathOrLibraryDefinition;
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexApplication;
@@ -85,13 +88,12 @@
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.InvokeVirtual;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringCollection;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer.R8CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
+import com.android.tools.r8.ir.desugar.LambdaClass;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
-import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
import com.android.tools.r8.kotlin.KotlinMetadataEnqueuerExtension;
import com.android.tools.r8.logging.Log;
import com.android.tools.r8.naming.identifiernamestring.IdentifierNameStringLookupResult;
@@ -108,9 +110,9 @@
import com.android.tools.r8.shaking.RootSetUtils.RootSet;
import com.android.tools.r8.shaking.RootSetUtils.RootSetBuilder;
import com.android.tools.r8.shaking.ScopedDexMethodSet.AddMethodIfMoreVisibleResult;
+import com.android.tools.r8.synthesis.SyntheticItems.SynthesizingContextOracle;
import com.android.tools.r8.utils.Action;
import com.android.tools.r8.utils.InternalOptions;
-import com.android.tools.r8.utils.InternalOptions.DesugarState;
import com.android.tools.r8.utils.IteratorUtils;
import com.android.tools.r8.utils.MethodSignatureEquivalence;
import com.android.tools.r8.utils.OptionalBool;
@@ -249,6 +251,13 @@
private final Map<DexProgramClass, ProgramFieldSet> reachableInstanceFields =
Maps.newIdentityHashMap();
+ // TODO(b/180091213): Remove when supported by synthetic items.
+ /**
+ * The synthesizing contexts for classes synthesized by lambda desugaring and twr close resource
+ * desugaring.
+ */
+ private final Map<DexProgramClass, ProgramMethod> synthesizingContexts = new IdentityHashMap<>();
+
/**
* Set of types that are mentioned in the program. We at least need an empty abstract class item
* for these.
@@ -278,7 +287,7 @@
*
* <p>Used to build a new app of just referenced types and avoid duplicate tracing.
*/
- private final Set<DexClass> liveNonProgramTypes = Sets.newIdentityHashSet();
+ private final Set<ClasspathOrLibraryClass> liveNonProgramTypes = Sets.newIdentityHashSet();
/** Set of reachable proto types that will be dead code eliminated. */
private final Set<DexProgramClass> deadProtoTypeCandidates = Sets.newIdentityHashSet();
@@ -382,13 +391,7 @@
private final GraphReporter graphReporter;
private final CfInstructionDesugaringCollection desugaring;
-
- private final BackportedMethodRewriter backportRewriter;
- private final TwrCloseResourceRewriter twrCloseResourceRewriter;
-
private final DesugaredLibraryConversionWrapperAnalysis desugaredLibraryWrapperAnalysis;
- private final Map<DexMethod, ProgramMethod> methodsWithBackports = new IdentityHashMap<>();
- private final Map<DexMethod, ProgramMethod> methodsWithTwrCloseResource = new IdentityHashMap<>();
private final ProgramMethodSet pendingDesugaring = ProgramMethodSet.create();
Enqueuer(
@@ -435,12 +438,6 @@
mode.isInitialTreeShaking()
? CfInstructionDesugaringCollection.create(appView)
: CfInstructionDesugaringCollection.empty();
- backportRewriter =
- options.desugarState == DesugarState.ON ? new BackportedMethodRewriter(appView) : null;
- twrCloseResourceRewriter =
- TwrCloseResourceRewriter.enableTwrCloseResourceDesugaring(options)
- ? new TwrCloseResourceRewriter(appView)
- : null;
objectAllocationInfoCollection =
ObjectAllocationInfoCollectionImpl.builder(mode.isInitialTreeShaking(), graphReporter);
@@ -539,7 +536,8 @@
if (clazz == null) {
ignoreMissingClass(type);
} else if (clazz.isNotProgramClass()) {
- addLiveNonProgramType(clazz);
+ addLiveNonProgramType(
+ clazz.asClasspathOrLibraryClass(), this::ignoreMissingClasspathOrLibraryClass);
}
}
@@ -568,13 +566,13 @@
definitionFor(type, context, missingClassConsumer);
}
- private void recordMethodReference(DexMethod method, ProgramDefinition context) {
+ private void recordMethodReference(DexMethod method, ProgramDerivedContext context) {
recordMethodReference(method, context, this::reportMissingClass);
}
private void recordMethodReference(
DexMethod method,
- ProgramDefinition context,
+ ProgramDerivedContext context,
BiConsumer<DexType, ProgramDerivedContext> missingClassConsumer) {
recordTypeReference(method.holder, context, missingClassConsumer);
recordTypeReference(method.proto.returnType, context, missingClassConsumer);
@@ -617,7 +615,10 @@
return null;
}
if (clazz.isNotProgramClass()) {
- addLiveNonProgramType(clazz);
+ addLiveNonProgramType(
+ clazz.asClasspathOrLibraryClass(),
+ (missingType, derivedContext) ->
+ reportMissingClass(missingType, derivedContext.asProgramDerivedContext(context)));
}
return clazz;
}
@@ -626,58 +627,66 @@
return keepInfo.isPinned(type, appInfo);
}
- private void addLiveNonProgramType(DexClass clazz) {
- assert clazz.isNotProgramClass();
- // Fast path to avoid the worklist when the class is already seen.
- if (!liveNonProgramTypes.add(clazz)) {
- return;
- }
- Deque<DexClass> worklist = new ArrayDeque<>();
- worklist.addLast(clazz);
- while (!worklist.isEmpty()) {
- DexClass definition = worklist.removeFirst();
- processNewLiveNonProgramType(definition, worklist);
+ private void addLiveNonProgramType(
+ ClasspathOrLibraryClass clazz,
+ BiConsumer<DexType, ClasspathOrLibraryDefinition> missingClassConsumer) {
+ WorkList<ClasspathOrLibraryClass> worklist =
+ WorkList.newIdentityWorkList(clazz, liveNonProgramTypes);
+ while (worklist.hasNext()) {
+ ClasspathOrLibraryClass definition = worklist.next();
+ processNewLiveNonProgramType(definition, worklist, missingClassConsumer);
}
}
- private void processNewLiveNonProgramType(DexClass clazz, Deque<DexClass> worklist) {
- assert clazz.isNotProgramClass();
+ private void processNewLiveNonProgramType(
+ ClasspathOrLibraryClass clazz,
+ WorkList<ClasspathOrLibraryClass> worklist,
+ BiConsumer<DexType, ClasspathOrLibraryDefinition> missingClassConsumer) {
if (clazz.isLibraryClass()) {
// TODO(b/149201735): This likely needs to apply to classpath too.
ensureMethodsContinueToWidenAccess(clazz);
// Only libraries must not derive program. Classpath classes can, assuming correct keep rules.
warnIfLibraryTypeInheritsFromProgramType(clazz.asLibraryClass());
}
- for (DexEncodedField field : clazz.fields()) {
- addNonProgramClassToWorklist(field.field.type, worklist);
- }
- for (DexEncodedMethod method : clazz.methods()) {
- addNonProgramClassToWorklist(method.method.proto.returnType, worklist);
- for (DexType param : method.method.proto.parameters.values) {
- addNonProgramClassToWorklist(param, worklist);
- }
- }
+ clazz.forEachClassField(
+ field ->
+ addNonProgramClassToWorklist(
+ field.getType(),
+ field.asClasspathOrLibraryDefinition(),
+ worklist,
+ missingClassConsumer));
+ clazz.forEachClassMethod(
+ method -> {
+ ClasspathOrLibraryDefinition derivedContext = method.asClasspathOrLibraryDefinition();
+ addNonProgramClassToWorklist(
+ method.getReturnType(), derivedContext, worklist, missingClassConsumer);
+ for (DexType parameter : method.getParameters()) {
+ addNonProgramClassToWorklist(parameter, derivedContext, worklist, missingClassConsumer);
+ }
+ });
for (DexType supertype : clazz.allImmediateSupertypes()) {
- addNonProgramClassToWorklist(supertype, worklist);
+ addNonProgramClassToWorklist(
+ supertype, clazz.asClasspathOrLibraryDefinition(), worklist, missingClassConsumer);
}
}
- private void addNonProgramClassToWorklist(DexType type, Deque<DexClass> worklist) {
+ private void addNonProgramClassToWorklist(
+ DexType type,
+ ClasspathOrLibraryDefinition context,
+ WorkList<ClasspathOrLibraryClass> worklist,
+ BiConsumer<DexType, ClasspathOrLibraryDefinition> missingClassConsumer) {
if (type.isArrayType()) {
type = type.toBaseType(appView.dexItemFactory());
}
if (!type.isClassType()) {
return;
}
- DexClass definition = appView.definitionFor(type);
- if (definition == null) {
- reportMissingClassWithoutContext(type);
- return;
+ DexClass clazz = appView.definitionFor(type);
+ if (clazz == null) {
+ missingClassConsumer.accept(type, context);
+ } else if (!clazz.isProgramClass()) {
+ worklist.addIfNotSeen(clazz.asClasspathOrLibraryClass());
}
- if (definition.isProgramClass() || !liveNonProgramTypes.add(definition)) {
- return;
- }
- worklist.addLast(definition);
}
private DexProgramClass getProgramClassOrNull(DexType type, ProgramDefinition context) {
@@ -1207,9 +1216,6 @@
private void traceInvokeDirect(
DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
- if (registerBackportInvoke(invokedMethod, context)) {
- return;
- }
if (!registerMethodWithTargetAndContext(
methodAccessInfoCollection::registerInvokeDirectInContext, invokedMethod, context)) {
return;
@@ -1231,10 +1237,6 @@
private void traceInvokeInterface(
DexMethod method, ProgramMethod context, KeepReason keepReason) {
- if (registerBackportInvoke(method, context)) {
- return;
- }
-
if (!registerMethodWithTargetAndContext(
methodAccessInfoCollection::registerInvokeInterfaceInContext, method, context)) {
return;
@@ -1254,32 +1256,8 @@
traceInvokeStatic(invokedMethod, context, KeepReason.invokedFromLambdaCreatedIn(context));
}
- private boolean registerBackportInvoke(DexMethod invokedMethod, ProgramMethod context) {
- if (backportRewriter != null && backportRewriter.needsDesugaring(invokedMethod)) {
- methodsWithBackports.putIfAbsent(context.getReference(), context);
- return true;
- }
- return false;
- }
-
- private boolean registerCloseResource(DexMethod invokedMethod, ProgramMethod context) {
- if (twrCloseResourceRewriter != null
- && TwrCloseResourceRewriter.isTwrCloseResourceMethod(
- invokedMethod, appView.dexItemFactory())) {
- methodsWithTwrCloseResource.putIfAbsent(context.getReference(), context);
- return true;
- }
- return false;
- }
-
private void traceInvokeStatic(
DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
- if (registerBackportInvoke(invokedMethod, context)) {
- return;
- }
- if (registerCloseResource(invokedMethod, context)) {
- return;
- }
DexItemFactory dexItemFactory = appView.dexItemFactory();
if (dexItemFactory.classMethods.isReflectiveClassLookup(invokedMethod)
|| dexItemFactory.atomicFieldUpdaterMethods.isFieldUpdater(invokedMethod)) {
@@ -1311,9 +1289,6 @@
}
void traceInvokeSuper(DexMethod invokedMethod, ProgramMethod context) {
- if (registerBackportInvoke(invokedMethod, context)) {
- return;
- }
// We have to revisit super invokes based on the context they are found in. The same
// method descriptor will hit different targets, depending on the context it is used in.
DexMethod actualTarget = getInvokeSuperTarget(invokedMethod, context);
@@ -1338,10 +1313,6 @@
private void traceInvokeVirtual(
DexMethod invokedMethod, ProgramMethod context, KeepReason reason) {
- if (registerBackportInvoke(invokedMethod, context)) {
- return;
- }
-
if (invokedMethod == appView.dexItemFactory().classMethods.newInstance
|| invokedMethod == appView.dexItemFactory().constructorMethods.newInstance) {
pendingReflectiveUses.add(context);
@@ -1836,11 +1807,12 @@
analyses.forEach(analysis -> analysis.processNewlyLiveClass(clazz, workList));
}
- private void ensureMethodsContinueToWidenAccess(DexClass clazz) {
+ private void ensureMethodsContinueToWidenAccess(ClassDefinition clazz) {
assert !clazz.isProgramClass();
ScopedDexMethodSet seen =
- scopedMethodsForLiveTypes.computeIfAbsent(clazz.type, ignore -> new ScopedDexMethodSet());
- clazz.virtualMethods().forEach(seen::addMethodIfMoreVisible);
+ scopedMethodsForLiveTypes.computeIfAbsent(
+ clazz.getType(), ignore -> new ScopedDexMethodSet());
+ clazz.getMethodCollection().forEachVirtualMethod(seen::addMethodIfMoreVisible);
}
private void ensureMethodsContinueToWidenAccess(
@@ -1983,11 +1955,15 @@
private SingleResolutionResult resolveMethod(
DexMethod method, ProgramDefinition context, KeepReason reason, boolean interfaceInvoke) {
// Record the references in case they are not program types.
- recordMethodReference(method, context);
ResolutionResult resolutionResult = appInfo.resolveMethod(method, interfaceInvoke);
- if (resolutionResult.isFailedResolution()) {
+ if (resolutionResult.isSingleResolution()) {
+ recordMethodReference(
+ method, resolutionResult.getResolutionPair().asProgramDerivedContext(context));
+ } else {
+ assert resolutionResult.isFailedResolution();
markFailedMethodResolutionTargets(
method, resolutionResult.asFailedResolution(), context, reason);
+ recordMethodReference(method, context);
}
return resolutionResult.asSingleResolution();
}
@@ -2230,6 +2206,15 @@
ignoreMissingClass(clazz);
}
+ private void ignoreMissingClasspathOrLibraryClass(DexType clazz) {
+ ignoreMissingClass(clazz);
+ }
+
+ private void ignoreMissingClasspathOrLibraryClass(
+ DexType clazz, ClasspathOrLibraryDefinition context) {
+ ignoreMissingClasspathOrLibraryClass(clazz);
+ }
+
private void reportMissingClass(DexType clazz, ProgramDerivedContext context) {
assert !mode.isFinalTreeShaking()
|| missingClassesBuilder.wasAlreadyMissing(clazz)
@@ -2238,19 +2223,23 @@
// TODO(b/157107464): See if we can clean this up.
|| (initialPrunedTypes != null && initialPrunedTypes.contains(clazz))
: "Unexpected missing class `" + clazz.toSourceString() + "`";
- missingClassesBuilder.addNewMissingClass(clazz, context);
- }
-
- @Deprecated
- private void reportMissingClassWithoutContext(DexType clazz) {
- assert !mode.isFinalTreeShaking()
- || missingClassesBuilder.wasAlreadyMissing(clazz)
- || appView.dexItemFactory().isPossiblyCompilerSynthesizedType(clazz)
- || initialDeadProtoTypes.contains(clazz)
- // TODO(b/157107464): See if we can clean this up.
- || (initialPrunedTypes != null && initialPrunedTypes.contains(clazz))
- : "Unexpected missing class `" + clazz.toSourceString() + "`";
- missingClassesBuilder.legacyAddNewMissingClass(clazz);
+ // Do not report missing classes from D8/R8 synthesized methods on non-synthetic classes (for
+ // example, lambda accessibility bridges).
+ // TODO(b/180376674): Clean this up. Ideally the D8/R8 synthesized methods would be synthesized
+ // using synthetic items, such that the synthetic items infrastructure would track the
+ // synthesizing contexts for these methods as well. That way, this would just work without any
+ // special handling because the mapping to the synthesizing contexts would also work for these
+ // synthetic methods.
+ if (context.isProgramContext()
+ && context.getContext().isMethod()
+ && context.getContext().asMethod().getDefinition().isD8R8Synthesized()
+ && !appView
+ .getSyntheticItems()
+ .isSyntheticClass(context.getContext().asProgramDefinition().getContextClass())) {
+ missingClassesBuilder.ignoreNewMissingClass(clazz);
+ } else {
+ missingClassesBuilder.addNewMissingClass(clazz, context);
+ }
}
/**
@@ -3175,8 +3164,6 @@
desugar(additions);
synthesizeInterfaceMethodBridges(additions);
synthesizeLibraryConversionWrappers(additions);
- synthesizeBackports(additions);
- synthesizeTwrCloseResource(additions);
if (additions.isEmpty()) {
return;
}
@@ -3202,7 +3189,10 @@
return;
}
R8CfInstructionDesugaringEventConsumer desugaringEventConsumer =
- CfInstructionDesugaringEventConsumer.createForR8(appView);
+ CfInstructionDesugaringEventConsumer.createForR8(
+ appView,
+ this::recordLambdaSynthesizingContext,
+ this::recordTwrCloseResourceMethodSynthesizingContext);
ThreadUtils.processItems(
pendingDesugaring,
method ->
@@ -3213,6 +3203,19 @@
pendingDesugaring.clear();
}
+ private void recordLambdaSynthesizingContext(LambdaClass lambdaClass, ProgramMethod context) {
+ synchronized (synthesizingContexts) {
+ synthesizingContexts.put(lambdaClass.getLambdaProgramClass(), context);
+ }
+ }
+
+ private void recordTwrCloseResourceMethodSynthesizingContext(
+ ProgramMethod closeMethod, ProgramMethod context) {
+ synchronized (synthesizingContexts) {
+ synthesizingContexts.put(closeMethod.getHolder(), context);
+ }
+ }
+
private void synthesizeInterfaceMethodBridges(SyntheticAdditions additions) {
for (ProgramMethod bridge : syntheticInterfaceMethodBridges.values()) {
DexProgramClass holder = bridge.getHolder();
@@ -3223,20 +3226,6 @@
syntheticInterfaceMethodBridges.clear();
}
- private void synthesizeBackports(SyntheticAdditions additions) {
- for (ProgramMethod method : methodsWithBackports.values()) {
- backportRewriter.desugar(
- method, appInfo, additions.getMethodContext(method), additions::addLiveMethod);
- }
- }
-
- private void synthesizeTwrCloseResource(SyntheticAdditions additions) {
- for (ProgramMethod method : methodsWithTwrCloseResource.values()) {
- twrCloseResourceRewriter.rewriteCf(
- method, additions::addLiveMethod, additions.getMethodContext(method));
- }
- }
-
private void finalizeLibraryMethodOverrideInformation() {
for (DexProgramClass liveType : liveTypes.getItems()) {
for (DexEncodedMethod method : liveType.virtualMethods()) {
@@ -3285,7 +3274,7 @@
// Rebuild a new app only containing referenced types.
Set<DexLibraryClass> libraryClasses = Sets.newIdentityHashSet();
Set<DexClasspathClass> classpathClasses = Sets.newIdentityHashSet();
- for (DexClass clazz : liveNonProgramTypes) {
+ for (ClasspathOrLibraryClass clazz : liveNonProgramTypes) {
if (clazz.isLibraryClass()) {
libraryClasses.add(clazz.asLibraryClass());
} else if (clazz.isClasspathClass()) {
@@ -3305,6 +3294,13 @@
// Verify the references on the pruned application after type synthesis.
assert verifyReferences(app);
+ SynthesizingContextOracle lambdaSynthesizingContextOracle =
+ syntheticClass -> {
+ ProgramMethod lambdaSynthesisContext = synthesizingContexts.get(syntheticClass);
+ return lambdaSynthesisContext != null
+ ? ImmutableSet.of(lambdaSynthesisContext.getReference())
+ : ImmutableSet.of(syntheticClass.getType());
+ };
AppInfoWithLiveness appInfoWithLiveness =
new AppInfoWithLiveness(
appInfo.getSyntheticItems().commit(app),
@@ -3312,7 +3308,10 @@
appInfo.getMainDexInfo(),
deadProtoTypes,
appView.testing().enableExperimentalMissingClassesReporting
- ? missingClassesBuilder.reportMissingClasses(appView)
+ ? (mode.isInitialTreeShaking()
+ ? missingClassesBuilder.reportMissingClasses(
+ appView, lambdaSynthesizingContextOracle)
+ : missingClassesBuilder.assertNoMissingClasses(appView))
: missingClassesBuilder.ignoreMissingClasses(),
SetUtils.mapIdentityHashSet(liveTypes.getItems(), DexProgramClass::getType),
Enqueuer.toDescriptorSet(targetedMethods.getItems()),
@@ -3818,7 +3817,7 @@
}
private void markMethodAsTargeted(ProgramMethod method, KeepReason reason) {
- if (!targetedMethods.add(method, reason)) {
+ if (!addTargetedMethod(method, reason)) {
// Already targeted.
return;
}
@@ -4218,7 +4217,7 @@
continue;
}
- DexProgramClass clazz = getProgramClassOrNull(type, method);
+ DexProgramClass clazz = getProgramClassOrNullFromReflectiveAccess(type, method);
if (clazz != null && clazz.isInterface()) {
// Add this interface to the set of pinned items to ensure that we do not merge the
// interface into its unique subtype, if any.
diff --git a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
index aa49727..3670701 100644
--- a/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
+++ b/src/main/java/com/android/tools/r8/shaking/MissingClasses.java
@@ -7,24 +7,32 @@
import static com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter.DESCRIPTOR_VIVIFIED_PREFIX;
import static com.android.tools.r8.ir.desugar.DesugaredLibraryRetargeter.getRetargetPackageAndClassPrefixDescriptor;
import static com.android.tools.r8.ir.desugar.InterfaceMethodRewriter.EMULATE_LIBRARY_CLASS_NAME_SUFFIX;
+import static com.android.tools.r8.utils.collections.IdentityHashSetFromMap.newProgramDerivedContextSet;
import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
+import com.android.tools.r8.diagnostic.internal.MissingClassInfoImpl;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionContextUtils;
import com.android.tools.r8.diagnostic.internal.MissingDefinitionsDiagnosticImpl;
import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ProgramDerivedContext;
+import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.synthesis.CommittedItems;
+import com.android.tools.r8.synthesis.SyntheticItems.SynthesizingContextOracle;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.SetUtils;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.IdentityHashMap;
+import java.util.Iterator;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Predicate;
@@ -62,7 +70,8 @@
public static class Builder {
private final Set<DexType> alreadyMissingClasses;
- private final Map<DexType, Set<DexReference>> newMissingClasses = new IdentityHashMap<>();
+ private final Map<DexType, Set<ProgramDerivedContext>> newMissingClasses =
+ new IdentityHashMap<>();
// Set of missing types that are not to be reported as missing. This does not hide reports
// if the same type is in newMissingClasses in which case it is reported regardless.
@@ -81,16 +90,15 @@
assert context.getContext().getContextType() != type;
if (!alreadyMissingClasses.contains(type)) {
newMissingClasses
- .computeIfAbsent(type, ignore -> Sets.newIdentityHashSet())
- .add(context.getContext().getReference());
+ .computeIfAbsent(type, ignore -> newProgramDerivedContextSet())
+ .add(context);
}
}
public void legacyAddNewMissingClass(DexType type) {
if (!alreadyMissingClasses.contains(type)) {
- // The legacy reporting is context insensitive, so therefore we use the missing classes
- // themselves as contexts.
- newMissingClasses.computeIfAbsent(type, ignore -> Sets.newIdentityHashSet()).add(type);
+ // The legacy reporting is context insensitive, so we just use an empty set of contexts.
+ newMissingClasses.computeIfAbsent(type, ignore -> newProgramDerivedContextSet());
}
}
@@ -105,7 +113,9 @@
}
public boolean contains(DexType type) {
- return alreadyMissingClasses.contains(type) || newMissingClasses.containsKey(type);
+ return alreadyMissingClasses.contains(type)
+ || newMissingClasses.containsKey(type)
+ || newIgnoredMissingClasses.contains(type);
}
Builder removeAlreadyMissingClasses(Iterable<DexType> types) {
@@ -115,34 +125,120 @@
return this;
}
+ public MissingClasses assertNoMissingClasses(AppView<?> appView) {
+ assert getMissingClassesToBeReported(appView, clazz -> ImmutableSet.of(clazz.getType()))
+ .isEmpty();
+ return build();
+ }
+
@Deprecated
public MissingClasses ignoreMissingClasses() {
return build();
}
public MissingClasses reportMissingClasses(AppView<?> appView) {
- InternalOptions options = appView.options();
- Map<DexType, Set<DexReference>> missingClassesToBeReported =
- getMissingClassesToBeReported(appView);
+ return reportMissingClasses(appView, clazz -> ImmutableSet.of(clazz.getType()));
+ }
+
+ public MissingClasses reportMissingClasses(
+ AppView<?> appView, SynthesizingContextOracle synthesizingContextOracle) {
+ Map<DexType, Set<ProgramDerivedContext>> missingClassesToBeReported =
+ getMissingClassesToBeReported(appView, synthesizingContextOracle);
if (!missingClassesToBeReported.isEmpty()) {
- MissingDefinitionsDiagnostic diagnostic =
- MissingDefinitionsDiagnosticImpl.builder()
- .addMissingClasses(missingClassesToBeReported)
- .setFatal(!options.ignoreMissingClasses)
- .build();
- if (options.ignoreMissingClasses) {
- options.reporter.warning(diagnostic);
+ MissingDefinitionsDiagnostic diagnostic = createDiagnostic(missingClassesToBeReported);
+ if (appView.options().ignoreMissingClasses) {
+ appView.reporter().warning(diagnostic);
} else {
- throw options.reporter.fatalError(diagnostic);
+ throw appView.reporter().fatalError(diagnostic);
}
}
return build();
}
- private Map<DexType, Set<DexReference>> getMissingClassesToBeReported(AppView<?> appView) {
+ private MissingDefinitionsDiagnostic createDiagnostic(
+ Map<DexType, Set<ProgramDerivedContext>> missingClassesToBeReported) {
+ MissingDefinitionsDiagnosticImpl.Builder diagnosticBuilder =
+ MissingDefinitionsDiagnosticImpl.builder();
+ missingClassesToBeReported.forEach(
+ (missingClass, programDerivedContexts) -> {
+ MissingClassInfoImpl.Builder missingClassInfoBuilder =
+ MissingClassInfoImpl.builder().setClass(missingClass.asClassReference());
+ for (ProgramDerivedContext programDerivedContext : programDerivedContexts) {
+ missingClassInfoBuilder.addReferencedFromContext(
+ MissingDefinitionContextUtils.create(programDerivedContext));
+ }
+ diagnosticBuilder.addMissingDefinitionInfo(missingClassInfoBuilder.build());
+ });
+ return diagnosticBuilder.build();
+ }
+
+ private void rewriteMissingClassContexts(
+ AppView<?> appView, SynthesizingContextOracle synthesizingContextOracle) {
+ Iterator<Entry<DexType, Set<ProgramDerivedContext>>> newMissingClassesIterator =
+ newMissingClasses.entrySet().iterator();
+ while (newMissingClassesIterator.hasNext()) {
+ Entry<DexType, Set<ProgramDerivedContext>> entry = newMissingClassesIterator.next();
+ entry.setValue(
+ rewriteMissingClassContextsForSingleMissingClass(
+ appView, entry.getValue(), synthesizingContextOracle));
+ }
+ }
+
+ private static Set<ProgramDerivedContext> rewriteMissingClassContextsForSingleMissingClass(
+ AppView<?> appView,
+ Set<ProgramDerivedContext> contexts,
+ SynthesizingContextOracle synthesizingContextOracle) {
+ if (contexts.isEmpty()) {
+ // Legacy reporting does not have any contexts.
+ return contexts;
+ }
+
+ Set<ProgramDerivedContext> rewrittenContexts = newProgramDerivedContextSet();
+ for (ProgramDerivedContext context : contexts) {
+ if (!context.isProgramContext()) {
+ rewrittenContexts.add(context);
+ continue;
+ }
+
+ DexProgramClass clazz = context.getContext().asProgramDefinition().getContextClass();
+ if (!appView.getSyntheticItems().isSyntheticClass(clazz)) {
+ rewrittenContexts.add(context);
+ continue;
+ }
+
+ // Rewrite the synthetic context to its synthesizing contexts.
+ Set<DexReference> synthesizingContextReferences =
+ appView.getSyntheticItems().getSynthesizingContexts(clazz, synthesizingContextOracle);
+ assert synthesizingContextReferences != null;
+ assert !synthesizingContextReferences.isEmpty();
+ for (DexReference synthesizingContextReference : synthesizingContextReferences) {
+ if (synthesizingContextReference.isDexMethod()) {
+ DexProgramClass holder =
+ appView
+ .definitionFor(synthesizingContextReference.getContextType())
+ .asProgramClass();
+ ProgramMethod synthesizingContext =
+ holder.lookupProgramMethod(synthesizingContextReference.asDexMethod());
+ assert synthesizingContext != null;
+ rewrittenContexts.add(synthesizingContext);
+ } else {
+ assert false
+ : "Unexpected synthesizing context: "
+ + synthesizingContextReference.toSourceString();
+ }
+ }
+ }
+ return rewrittenContexts;
+ }
+
+ private Map<DexType, Set<ProgramDerivedContext>> getMissingClassesToBeReported(
+ AppView<?> appView, SynthesizingContextOracle synthesizingContextOracle) {
+ // Rewrite synthetic program contexts into their synthesizing contexts, to avoid reporting
+ // any synthetic contexts.
+ rewriteMissingClassContexts(appView, synthesizingContextOracle);
Predicate<DexType> allowedMissingClassesPredicate =
getIsAllowedMissingClassesPredicate(appView);
- Map<DexType, Set<DexReference>> missingClassesToBeReported =
+ Map<DexType, Set<ProgramDerivedContext>> missingClassesToBeReported =
new IdentityHashMap<>(newMissingClasses.size());
newMissingClasses.forEach(
(missingClass, contexts) -> {
@@ -151,10 +247,20 @@
return;
}
+ // TODO(b/175543745): This is a legacy reported missing class; remove once no longer
+ // supported.
+ if (contexts.isEmpty()) {
+ missingClassesToBeReported.put(missingClass, contexts);
+ return;
+ }
+
// Remove all contexts that are matched by a -dontwarn rule (a missing class should not
// be reported if it os only referenced from contexts that are matched by a -dontwarn).
contexts.removeIf(
- context -> appView.getDontWarnConfiguration().matches(context.getContextType()));
+ context ->
+ appView
+ .getDontWarnConfiguration()
+ .matches(context.getContext().getContextType()));
// If there are any contexts not matched by a -dontwarn rule, then report.
if (!contexts.isEmpty()) {
@@ -184,12 +290,9 @@
dexItemFactory.annotationSynthesizedClass,
dexItemFactory.annotationSynthesizedClassMap,
dexItemFactory.annotationThrows,
- dexItemFactory.serializedLambdaType,
- // TODO(b/176133674) StringConcatFactory is backported, but the class is reported as
- // missing because the enqueuer runs prior to backporting and thus sees the
- // non-desugared code.
- dexItemFactory.stringConcatFactoryType)
- .addAll(dexItemFactory.getConversionTypes())
+ dexItemFactory.serializedLambdaType)
+ .addAll(dexItemFactory.getJavaConversionTypes())
+ .addAll(dexItemFactory.getJ$ConversionTypes())
.build();
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
index 1067e93..82f3204 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SynthesizingContext.java
@@ -8,15 +8,12 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
-import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
import com.android.tools.r8.graph.ProgramDefinition;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.MainDexInfo;
-import com.android.tools.r8.synthesis.SyntheticNaming.Phase;
-import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
import java.util.Comparator;
import java.util.Set;
@@ -63,33 +60,6 @@
return new SynthesizingContext(synthesizingContextType, clazz.type, clazz.origin);
}
- static SynthesizingContext fromSyntheticContextChange(
- SyntheticKind kind,
- DexType syntheticType,
- SynthesizingContext oldContext,
- DexItemFactory factory) {
- String descriptor = syntheticType.toDescriptorString();
- DexType newContext;
- if (kind.isFixedSuffixSynthetic) {
- int i = descriptor.lastIndexOf(kind.descriptor);
- if (i < 0 || descriptor.length() != i + kind.descriptor.length() + 1) {
- assert false : "Unexpected fixed synthetic with invalid suffix: " + syntheticType;
- return null;
- }
- newContext = factory.createType(descriptor.substring(0, i) + ";");
- } else {
- int i = descriptor.indexOf(SyntheticNaming.getPhaseSeparator(Phase.INTERNAL));
- if (i <= 0) {
- assert false : "Unexpected synthetic without internal separator: " + syntheticType;
- return null;
- }
- newContext = factory.createType(descriptor.substring(0, i) + ";");
- }
- return newContext == oldContext.getSynthesizingContextType()
- ? oldContext
- : new SynthesizingContext(newContext, newContext, oldContext.inputContextOrigin);
- }
-
private SynthesizingContext(
DexType synthesizingContextType, DexType inputContextType, Origin inputContextOrigin) {
this.synthesizingContextType = synthesizingContextType;
@@ -127,10 +97,10 @@
}
void registerPrefixRewriting(DexType hygienicType, AppView<?> appView) {
- assert hygienicType.toSourceString().startsWith(synthesizingContextType.toSourceString());
if (!appView.options().isDesugaredLibraryCompilation()) {
return;
}
+ assert hygienicType.toSourceString().startsWith(synthesizingContextType.toSourceString());
DexType rewrittenContext =
appView
.options()
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
index 25142ee..69f87fe 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClassReference.java
@@ -30,4 +30,9 @@
DexType getHolder() {
return type;
}
+
+ @Override
+ DexType getReference() {
+ return type;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java
index 5b9ba3c..72beb13 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticClasspathClassReference.java
@@ -34,9 +34,12 @@
}
@Override
- SyntheticClasspathClassReference rewrite(NonIdentityGraphLens lens) {
+ SyntheticClasspathClassReference internalRewrite(
+ SynthesizingContext rewrittenContext, NonIdentityGraphLens lens) {
assert type == lens.lookupType(type)
: "Unexpected classpath rewrite of type " + type.toSourceString();
+ assert getContext() == rewrittenContext
+ : "Unexpected classpath rewrite of context type " + getContext();
return this;
}
}
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
index 239e7d0..9520d57 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticDefinition.java
@@ -59,12 +59,21 @@
return context;
}
+ final String getPrefixForExternalSyntheticType() {
+ return SyntheticNaming.getPrefixForExternalSyntheticType(getKind(), getHolder().getType());
+ }
+
public abstract C getHolder();
final HashCode computeHash(
RepresentativeMap map, boolean intermediate, ClassToFeatureSplitMap classToFeatureSplitMap) {
Hasher hasher = Hashing.murmur3_128().newHasher();
- if (intermediate || getKind().isFixedSuffixSynthetic) {
+ if (getKind().isFixedSuffixSynthetic) {
+ // Fixed synthetics are non-shareable. Its unique type is used as the hash key.
+ getHolder().getType().hash(hasher);
+ return hasher.hash();
+ }
+ if (intermediate) {
// If in intermediate mode, include the context type as sharing is restricted to within a
// single context.
getContext().getSynthesizingContextType().hashWithTypeEquivalence(hasher, map);
@@ -95,7 +104,13 @@
boolean includeContext,
GraphLens graphLens,
ClassToFeatureSplitMap classToFeatureSplitMap) {
- if (includeContext || getKind().isFixedSuffixSynthetic) {
+ DexType thisType = getHolder().getType();
+ DexType otherType = other.getHolder().getType();
+ if (getKind().isFixedSuffixSynthetic) {
+ // Fixed synthetics are non-shareable. Ordered by their unique type.
+ return thisType.compareTo(otherType);
+ }
+ if (includeContext) {
int order = getContext().compareTo(other.getContext());
if (order != 0) {
return order;
@@ -113,8 +128,6 @@
return order;
}
}
- DexType thisType = getHolder().getType();
- DexType otherType = other.getHolder().getType();
RepresentativeMap map = null;
// If the synthetics have been moved include the original types in the equivalence.
if (graphLens.isNonIdentityLens()) {
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
index 741831e..60dca8f 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticFinalization.java
@@ -265,7 +265,7 @@
ImmutableMap.builder();
List<DexProgramClass> finalSyntheticProgramDefinitions = new ArrayList<>();
{
- Map<DexType, NumberGenerator> generators = new IdentityHashMap<>();
+ Map<String, NumberGenerator> generators = new HashMap<>();
application =
buildLensAndProgram(
appView,
@@ -317,7 +317,7 @@
Map<DexType, EquivalenceGroup<D>> computeEquivalences(
AppView<?> appView,
ImmutableCollection<R> references,
- Map<DexType, NumberGenerator> generators) {
+ Map<String, NumberGenerator> generators) {
boolean intermediate = appView.options().intermediate;
Map<DexType, D> definitions = lookupDefinitions(appView, references);
ClassToFeatureSplitMap classToFeatureSplitMap =
@@ -662,11 +662,11 @@
private <T extends SyntheticDefinition<?, T, ?>>
Map<DexType, EquivalenceGroup<T>> computeActualEquivalences(
Collection<List<T>> potentialEquivalences,
- Map<DexType, NumberGenerator> generators,
+ Map<String, NumberGenerator> generators,
AppView<?> appView,
boolean intermediate,
ClassToFeatureSplitMap classToFeatureSplitMap) {
- Map<DexType, List<EquivalenceGroup<T>>> groupsPerContext = new IdentityHashMap<>();
+ Map<String, List<EquivalenceGroup<T>>> groupsPerPrefix = new HashMap<>();
potentialEquivalences.forEach(
members -> {
List<List<T>> groups =
@@ -677,17 +677,16 @@
// The representative is required to be the first element of the group.
group.remove(representative);
group.add(0, representative);
- groupsPerContext
+ groupsPerPrefix
.computeIfAbsent(
- representative.getContext().getSynthesizingContextType(),
- k -> new ArrayList<>())
+ representative.getPrefixForExternalSyntheticType(), k -> new ArrayList<>())
.add(new EquivalenceGroup<>(representative, group));
}
});
Map<DexType, EquivalenceGroup<T>> equivalences = new IdentityHashMap<>();
- groupsPerContext.forEach(
- (context, groups) -> {
+ groupsPerPrefix.forEach(
+ (externalSyntheticTypePrefix, groups) -> {
// Sort the equivalence groups that go into 'context' including the context type of the
// representative which is equal to 'context' here (see assert below).
groups.sort(
@@ -695,14 +694,18 @@
a.compareToIncludingContext(b, appView.graphLens(), classToFeatureSplitMap));
for (int i = 0; i < groups.size(); i++) {
EquivalenceGroup<T> group = groups.get(i);
- assert group.getRepresentative().getContext().getSynthesizingContextType() == context;
+ assert group
+ .getRepresentative()
+ .getPrefixForExternalSyntheticType()
+ .equals(externalSyntheticTypePrefix);
// Two equivalence groups in same context type must be distinct otherwise the assignment
// of the synthetic name will be non-deterministic between the two.
assert i == 0
|| checkGroupsAreDistinct(
groups.get(i - 1), group, appView.graphLens(), classToFeatureSplitMap);
SyntheticKind kind = group.members.get(0).getKind();
- DexType representativeType = createExternalType(kind, context, generators, appView);
+ DexType representativeType =
+ createExternalType(kind, externalSyntheticTypePrefix, generators, appView);
equivalences.put(representativeType, group);
}
});
@@ -752,7 +755,7 @@
T smallest = members.get(0);
for (int i = 1; i < members.size(); i++) {
T next = members.get(i);
- if (next.compareTo(smallest, true, graphLens, classToFeatureSplitMap) < 0) {
+ if (next.toReference().getReference().compareTo(smallest.toReference().getReference()) < 0) {
smallest = next;
}
}
@@ -761,20 +764,20 @@
private DexType createExternalType(
SyntheticKind kind,
- DexType representativeContext,
- Map<DexType, NumberGenerator> generators,
+ String externalSyntheticTypePrefix,
+ Map<String, NumberGenerator> generators,
AppView<?> appView) {
DexItemFactory factory = appView.dexItemFactory();
if (kind.isFixedSuffixSynthetic) {
- return SyntheticNaming.createExternalType(kind, representativeContext, "", factory);
+ return SyntheticNaming.createExternalType(kind, externalSyntheticTypePrefix, "", factory);
}
NumberGenerator generator =
- generators.computeIfAbsent(representativeContext, k -> new NumberGenerator());
+ generators.computeIfAbsent(externalSyntheticTypePrefix, k -> new NumberGenerator());
DexType externalType;
do {
externalType =
SyntheticNaming.createExternalType(
- kind, representativeContext, Integer.toString(generator.next()), factory);
+ kind, externalSyntheticTypePrefix, Integer.toString(generator.next()), factory);
DexClass clazz = appView.appInfo().definitionForWithoutExistenceAssert(externalType);
if (clazz != null && isNotSyntheticType(clazz.type)) {
assert options.testing.allowConflictingSyntheticTypes
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
index 73b61b3..8263f40 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticItems.java
@@ -217,9 +217,14 @@
// TODO(b/180091213): Implement this and remove client provided the oracle.
public Set<DexReference> getSynthesizingContexts(
- DexProgramClass clazz, Function<DexProgramClass, Set<DexReference>> oracle) {
+ DexProgramClass clazz, SynthesizingContextOracle oracle) {
assert isSyntheticClass(clazz);
- return oracle.apply(clazz);
+ return oracle.getSynthesizingContexts(clazz);
+ }
+
+ public interface SynthesizingContextOracle {
+
+ Set<DexReference> getSynthesizingContexts(DexProgramClass clazz);
}
// The compiler should not inspect the kind of a synthetic, so this provided only as a assertion
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
index 930443a..fd63ea2 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticMethodReference.java
@@ -34,6 +34,11 @@
}
@Override
+ DexMethod getReference() {
+ return method;
+ }
+
+ @Override
SyntheticMethodDefinition lookupDefinition(Function<DexType, DexClass> definitions) {
DexClass clazz = definitions.apply(method.holder);
if (clazz == null) {
@@ -47,7 +52,8 @@
}
@Override
- SyntheticMethodReference rewrite(NonIdentityGraphLens lens) {
+ SyntheticMethodReference internalRewrite(
+ SynthesizingContext rewrittenContext, NonIdentityGraphLens lens) {
DexMethod rewritten = lens.lookupMethod(method);
// If the reference has been non-trivially rewritten the compiler has changed it and it can no
// longer be considered a synthetic. The context may or may not have changed.
@@ -58,20 +64,10 @@
assert SyntheticNaming.verifyNotInternalSynthetic(rewritten.holder);
return null;
}
- SynthesizingContext context = getContext().rewrite(lens);
- if (context == getContext() && rewritten == method) {
+ if (rewrittenContext == getContext() && rewritten == method) {
return this;
}
- // Ensure that if a synthetic moves its context moves consistently.
- if (method != rewritten) {
- context =
- SynthesizingContext.fromSyntheticContextChange(
- getKind(), rewritten.holder, context, lens.dexItemFactory());
- if (context == null) {
- return null;
- }
- }
- return new SyntheticMethodReference(getKind(), context, rewritten);
+ return new SyntheticMethodReference(getKind(), rewrittenContext, rewritten);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
index 63772a2..25e59ae 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticNaming.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.synthesis;
+import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.references.ClassReference;
@@ -62,24 +63,32 @@
}
}
+ private static final String SYNTHETIC_CLASS_SEPARATOR = "-$$";
/**
* The internal synthetic class separator is only used for representing synthetic items during
* compilation. In particular, this separator must never be used to write synthetic classes to the
* final compilation result.
*/
- private static final String INTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$InternalSynthetic";
+ private static final String INTERNAL_SYNTHETIC_CLASS_SEPARATOR =
+ SYNTHETIC_CLASS_SEPARATOR + "InternalSynthetic";
/**
* The external synthetic class separator is used when writing classes. It may appear in types
* during compilation as the output of a compilation may be the input to another.
*/
- private static final String EXTERNAL_SYNTHETIC_CLASS_SEPARATOR = "-$$ExternalSynthetic";
+ private static final String EXTERNAL_SYNTHETIC_CLASS_SEPARATOR =
+ SYNTHETIC_CLASS_SEPARATOR + "ExternalSynthetic";
/** Method prefix when generating synthetic methods in a class. */
static final String INTERNAL_SYNTHETIC_METHOD_PREFIX = "m";
- // TODO(b/158159959): Remove usage of name-based identification.
- public static boolean isSyntheticName(String typeName) {
- return typeName.contains(INTERNAL_SYNTHETIC_CLASS_SEPARATOR)
- || typeName.contains(EXTERNAL_SYNTHETIC_CLASS_SEPARATOR);
+ static String getPrefixForExternalSyntheticType(SyntheticKind kind, DexType type) {
+ String binaryName = type.toBinaryName();
+ int index =
+ binaryName.lastIndexOf(
+ kind.isFixedSuffixSynthetic ? kind.descriptor : SYNTHETIC_CLASS_SEPARATOR);
+ if (index < 0) {
+ throw new Unreachable("Unexpected failure to compute an synthetic prefix");
+ }
+ return binaryName.substring(0, index);
}
public static DexType createFixedType(
@@ -100,12 +109,12 @@
}
static DexType createExternalType(
- SyntheticKind kind, DexType context, String id, DexItemFactory factory) {
+ SyntheticKind kind, String externalSyntheticTypePrefix, String id, DexItemFactory factory) {
assert kind.isFixedSuffixSynthetic == id.isEmpty();
return createType(
kind.isFixedSuffixSynthetic ? "" : EXTERNAL_SYNTHETIC_CLASS_SEPARATOR,
kind,
- context,
+ externalSyntheticTypePrefix,
id,
factory);
}
@@ -115,10 +124,19 @@
return factory.createType(createDescriptor(separator, kind, context.getInternalName(), id));
}
+ private static DexType createType(
+ String separator,
+ SyntheticKind kind,
+ String externalSyntheticTypePrefix,
+ String id,
+ DexItemFactory factory) {
+ return factory.createType(createDescriptor(separator, kind, externalSyntheticTypePrefix, id));
+ }
+
private static String createDescriptor(
- String separator, SyntheticKind kind, String context, String id) {
+ String separator, SyntheticKind kind, String externalSyntheticTypePrefix, String id) {
return DescriptorUtils.getDescriptorFromClassBinaryName(
- context + separator + kind.descriptor + id);
+ externalSyntheticTypePrefix + separator + kind.descriptor + id);
}
public static boolean verifyNotInternalSynthetic(DexType type) {
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
index 7e798e0..5a17b04 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticProgramClassReference.java
@@ -36,7 +36,8 @@
}
@Override
- SyntheticProgramClassReference rewrite(NonIdentityGraphLens lens) {
+ SyntheticProgramClassReference internalRewrite(
+ SynthesizingContext rewrittenContext, NonIdentityGraphLens lens) {
DexType rewritten = lens.lookupType(type);
// If the reference has been non-trivially rewritten the compiler has changed it and it can no
// longer be considered a synthetic. The context may or may not have changed.
@@ -46,20 +47,10 @@
assert SyntheticNaming.verifyNotInternalSynthetic(rewritten);
return null;
}
- SynthesizingContext context = getContext().rewrite(lens);
- if (context == getContext() && rewritten == type) {
+ if (rewrittenContext == getContext() && rewritten == type) {
return this;
}
- // Ensure that if a synthetic moves its context moves consistently.
- if (type != rewritten) {
- context =
- SynthesizingContext.fromSyntheticContextChange(
- getKind(), rewritten, context, lens.dexItemFactory());
- if (context == null) {
- return null;
- }
- }
- return new SyntheticProgramClassReference(getKind(), context, rewritten);
+ return new SyntheticProgramClassReference(getKind(), rewrittenContext, rewritten);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
index 1a2d2fb..ddb28f7 100644
--- a/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
+++ b/src/main/java/com/android/tools/r8/synthesis/SyntheticReference.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.synthesis;
import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.GraphLens.NonIdentityGraphLens;
import com.android.tools.r8.synthesis.SyntheticNaming.SyntheticKind;
@@ -20,13 +21,13 @@
C extends DexClass> {
private final SyntheticKind kind;
- private final SynthesizingContext context;
+ private final SynthesizingContext rewrittenContext;
SyntheticReference(SyntheticKind kind, SynthesizingContext context) {
assert kind != null;
assert context != null;
this.kind = kind;
- this.context = context;
+ this.rewrittenContext = context;
}
abstract D lookupDefinition(Function<DexType, DexClass> definitions);
@@ -36,10 +37,17 @@
}
final SynthesizingContext getContext() {
- return context;
+ return rewrittenContext;
}
abstract DexType getHolder();
- abstract R rewrite(NonIdentityGraphLens lens);
+ abstract DexReference getReference();
+
+ final R rewrite(NonIdentityGraphLens lens) {
+ SynthesizingContext rewrittenContext = getContext().rewrite(lens);
+ return internalRewrite(rewrittenContext, lens);
+ }
+
+ abstract R internalRewrite(SynthesizingContext rewrittenContext, NonIdentityGraphLens lens);
}
diff --git a/src/main/java/com/android/tools/r8/utils/Box.java b/src/main/java/com/android/tools/r8/utils/Box.java
index 77be1c9..de67cf6 100644
--- a/src/main/java/com/android/tools/r8/utils/Box.java
+++ b/src/main/java/com/android/tools/r8/utils/Box.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.utils;
+import java.util.Comparator;
+import java.util.Objects;
import java.util.function.Supplier;
public class Box<T> {
@@ -31,6 +33,12 @@
this.value = value;
}
+ public void setMin(T element, Comparator<T> comparator) {
+ if (!isSet() || comparator.compare(element, get()) < 0) {
+ set(element);
+ }
+ }
+
public boolean isSet() {
return value != null;
}
@@ -40,4 +48,18 @@
value = newValue;
return oldValue;
}
+
+ @Override
+ public boolean equals(Object object) {
+ if (object == null || getClass() != object.getClass()) {
+ return false;
+ }
+ Box<?> box = (Box<?>) object;
+ return Objects.equals(value, box.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(value);
+ }
}
diff --git a/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java
new file mode 100644
index 0000000..171344e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/ClassReferenceUtils.java
@@ -0,0 +1,22 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.utils;
+
+import com.android.tools.r8.references.ClassReference;
+import java.util.Comparator;
+
+public class ClassReferenceUtils {
+
+ private static final Comparator<ClassReference> COMPARATOR =
+ Comparator.comparing(ClassReference::getDescriptor);
+
+ public static int compare(ClassReference classReference, ClassReference other) {
+ return getClassReferenceComparator().compare(classReference, other);
+ }
+
+ public static Comparator<ClassReference> getClassReferenceComparator() {
+ return COMPARATOR;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/CompareResult.java b/src/main/java/com/android/tools/r8/utils/CompareResult.java
new file mode 100644
index 0000000..a3a04a1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/CompareResult.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.utils;
+
+import java.util.Comparator;
+
+public enum CompareResult {
+ LESS_THAN(-1),
+ EQUAL(0),
+ GREATER_THAN(1);
+
+ private int comparisonResult;
+
+ CompareResult(int comparisonResult) {
+ this.comparisonResult = comparisonResult;
+ }
+
+ public int getComparisonResult() {
+ return comparisonResult;
+ }
+
+ public boolean isEqual() {
+ return this == EQUAL;
+ }
+
+ public static <T extends Comparable<T>> CompareResult compare(T element, T other) {
+ return fromComparisonResult(element.compareTo(other));
+ }
+
+ public static <T> CompareResult compare(T element, T other, Comparator<T> comparator) {
+ return fromComparisonResult(comparator.compare(element, other));
+ }
+
+ public static CompareResult fromComparisonResult(int comparisonResult) {
+ if (comparisonResult < 0) {
+ return CompareResult.LESS_THAN;
+ }
+ return comparisonResult == 0 ? CompareResult.EQUAL : CompareResult.GREATER_THAN;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java
index cb26884..ebf7821 100644
--- a/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/FieldReferenceUtils.java
@@ -4,10 +4,47 @@
package com.android.tools.r8.utils;
+import static com.android.tools.r8.utils.ClassReferenceUtils.getClassReferenceComparator;
+import static com.android.tools.r8.utils.TypeReferenceUtils.getTypeReferenceComparator;
+
import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.Reference;
+import java.util.Comparator;
public class FieldReferenceUtils {
+ private static final Comparator<FieldReference> COMPARATOR =
+ (field, other) -> {
+ CompareResult holderClassCompareResult =
+ CompareResult.compare(
+ field.getHolderClass(), other.getHolderClass(), getClassReferenceComparator());
+ if (!holderClassCompareResult.isEqual()) {
+ return holderClassCompareResult.getComparisonResult();
+ }
+ CompareResult fieldNameCompareResult =
+ CompareResult.compare(field.getFieldName(), other.getFieldName());
+ if (!fieldNameCompareResult.isEqual()) {
+ return fieldNameCompareResult.getComparisonResult();
+ }
+ return getTypeReferenceComparator().compare(field.getFieldType(), other.getFieldType());
+ };
+
+ public static int compare(FieldReference fieldReference, FieldReference other) {
+ return getFieldReferenceComparator().compare(fieldReference, other);
+ }
+
+ public static FieldReference fieldFromField(Class<?> clazz, String name) {
+ try {
+ return Reference.fieldFromField(clazz.getDeclaredField(name));
+ } catch (NoSuchFieldException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Comparator<FieldReference> getFieldReferenceComparator() {
+ return COMPARATOR;
+ }
+
public static String toSourceString(FieldReference fieldReference) {
return fieldReference.getFieldType().getTypeName()
+ " "
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index d515b20..b60a0e3 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1291,7 +1291,7 @@
public boolean alwaysUsePessimisticRegisterAllocation = false;
public boolean enableCheckCastAndInstanceOfRemoval = true;
public boolean enableDeadSwitchCaseElimination = true;
- public boolean enableExperimentalMissingClassesReporting = false;
+ public boolean enableExperimentalMissingClassesReporting = true;
public boolean enableInvokeSuperToInvokeVirtualRewriting = true;
public boolean enableSwitchToIfRewriting = true;
public boolean enableEnumUnboxingDebugLogs = false;
@@ -1465,12 +1465,20 @@
return !isDesugaring() || hasMinApi(AndroidApiLevel.K);
}
+ public boolean enableBackportedMethodRewriting() {
+ // Disable rewriting if there are no methods to rewrite or if the API level is higher than
+ // the highest known API level when the compiler is built. This ensures that when this is used
+ // by the Android Platform build (which normally use an API level of 10000) there will be
+ // no rewriting of backported methods. See b/147480264.
+ return desugarState.isOn() && minApiLevel <= AndroidApiLevel.LATEST.getLevel();
+ }
+
public boolean enableTryWithResourcesDesugaring() {
switch (tryWithResourcesDesugaring) {
case Off:
return false;
case Auto:
- return !canUseSuppressedExceptions();
+ return desugarState.isOn() && !canUseTwrCloseResourceMethod();
}
throw new Unreachable();
}
@@ -1508,7 +1516,7 @@
}
public boolean canUseJavaUtilObjects() {
- return (isGeneratingClassFiles() && !cfToCfDesugar) || hasMinApi(AndroidApiLevel.K);
+ return !isDesugaring() || hasMinApi(AndroidApiLevel.K);
}
public boolean canUseRequireNonNull() {
@@ -1516,11 +1524,11 @@
}
public boolean canUseSuppressedExceptions() {
- return (isGeneratingClassFiles() && !cfToCfDesugar) || hasMinApi(AndroidApiLevel.K);
+ return !isDesugaring() || hasMinApi(AndroidApiLevel.K);
}
public boolean canUseAssertionErrorTwoArgumentConstructor() {
- return (isGeneratingClassFiles() && !cfToCfDesugar) || hasMinApi(AndroidApiLevel.K);
+ return !isDesugaring() || hasMinApi(AndroidApiLevel.K);
}
public CfVersion classFileVersionAfterDesugaring(CfVersion version) {
@@ -1539,7 +1547,7 @@
//
// https://android.googlesource.com/platform/libcore/+/refs/heads/ics-mr1/luni/src/main/java/java/lang/AssertionError.java#56
public boolean canInitCauseAfterAssertionErrorObjectConstructor() {
- return (isGeneratingClassFiles() && !cfToCfDesugar) || hasMinApi(AndroidApiLevel.J);
+ return !isDesugaring() || hasMinApi(AndroidApiLevel.J);
}
// Dalvik x86-atom backend had a bug that made it crash on filled-new-array instructions for
diff --git a/src/main/java/com/android/tools/r8/utils/IteratorUtils.java b/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
index 35f950a..93b7e4a 100644
--- a/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/IteratorUtils.java
@@ -16,6 +16,12 @@
public class IteratorUtils {
+ public static <T> int countRemaining(Iterator<T> iterator) {
+ IntBox counter = new IntBox();
+ iterator.forEachRemaining(ignore -> counter.increment());
+ return counter.get();
+ }
+
public static <T, S extends T> Iterator<S> filter(
Iterator<? extends T> iterator, Predicate<T> predicate) {
return new Iterator<S>() {
diff --git a/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java
index e76f21a..4d36fb9 100644
--- a/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/MethodReferenceUtils.java
@@ -4,21 +4,80 @@
package com.android.tools.r8.utils;
+import static com.android.tools.r8.utils.ClassReferenceUtils.getClassReferenceComparator;
+import static com.android.tools.r8.utils.TypeReferenceUtils.getTypeReferenceComparator;
+
import com.android.tools.r8.references.ArrayReference;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.references.TypeReference;
import com.google.common.collect.ImmutableList;
+import java.util.Comparator;
import java.util.Iterator;
public class MethodReferenceUtils {
+ private static final Comparator<MethodReference> COMPARATOR =
+ (method, other) -> {
+ CompareResult holderClassCompareResult =
+ CompareResult.compare(
+ method.getHolderClass(), other.getHolderClass(), getClassReferenceComparator());
+ if (!holderClassCompareResult.isEqual()) {
+ return holderClassCompareResult.getComparisonResult();
+ }
+ CompareResult methodNameCompareResult =
+ CompareResult.compare(method.getMethodName(), other.getMethodName());
+ if (!methodNameCompareResult.isEqual()) {
+ return methodNameCompareResult.getComparisonResult();
+ }
+ CompareResult returnTypeCompareResult =
+ CompareResult.compare(
+ method.getReturnType(), other.getReturnType(), getTypeReferenceComparator());
+ if (!returnTypeCompareResult.isEqual()) {
+ return returnTypeCompareResult.getComparisonResult();
+ }
+ for (int i = 0;
+ i < Math.min(method.getFormalTypes().size(), other.getFormalTypes().size());
+ i++) {
+ CompareResult formalTypeCompareResult =
+ CompareResult.compare(
+ method.getFormalTypes().get(i),
+ other.getFormalTypes().get(i),
+ getTypeReferenceComparator());
+ if (!formalTypeCompareResult.isEqual()) {
+ return formalTypeCompareResult.getComparisonResult();
+ }
+ }
+ return method.getFormalTypes().size() - other.getFormalTypes().size();
+ };
+
+ public static int compare(MethodReference methodReference, MethodReference other) {
+ return getMethodReferenceComparator().compare(methodReference, other);
+ }
+
+ public static Comparator<MethodReference> getMethodReferenceComparator() {
+ return COMPARATOR;
+ }
+
+ public static MethodReference mainMethod(Class<?> clazz) {
+ return mainMethod(Reference.classFromClass(clazz));
+ }
+
public static MethodReference mainMethod(ClassReference type) {
ArrayReference stringArrayType = Reference.array(Reference.classFromClass(String.class), 1);
return Reference.method(type, "main", ImmutableList.of(stringArrayType), null);
}
+ public static MethodReference methodFromMethod(
+ Class<?> clazz, String name, Class<?>... parameterTypes) {
+ try {
+ return Reference.methodFromMethod(clazz.getDeclaredMethod(name, parameterTypes));
+ } catch (NoSuchMethodException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
public static String toSourceStringWithoutHolderAndReturnType(MethodReference methodReference) {
return toSourceString(methodReference, false, false);
}
diff --git a/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java b/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
new file mode 100644
index 0000000..76e6f33
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/TypeReferenceUtils.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.utils;
+
+import com.android.tools.r8.references.TypeReference;
+import java.util.Comparator;
+
+public class TypeReferenceUtils {
+
+ private static final Comparator<TypeReference> COMPARATOR =
+ (type, other) -> {
+ // Handle null inputs (void).
+ if (type == null) {
+ return -1;
+ }
+ if (other == null) {
+ return 1;
+ }
+ return type.getDescriptor().compareTo(other.getDescriptor());
+ };
+
+ public static Comparator<TypeReference> getTypeReferenceComparator() {
+ return COMPARATOR;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/utils/WorkList.java b/src/main/java/com/android/tools/r8/utils/WorkList.java
index 8ee6e30..e5fb33f 100644
--- a/src/main/java/com/android/tools/r8/utils/WorkList.java
+++ b/src/main/java/com/android/tools/r8/utils/WorkList.java
@@ -36,6 +36,12 @@
return workList;
}
+ public static <T> WorkList<T> newIdentityWorkList(T item, Set<T> seen) {
+ WorkList<T> workList = new WorkList<>(seen);
+ workList.addIfNotSeen(item);
+ return workList;
+ }
+
public static <T> WorkList<T> newIdentityWorkList(Iterable<T> items) {
WorkList<T> workList = new WorkList<>(EqualityTest.IDENTITY);
workList.addIfNotSeen(items);
@@ -43,11 +49,11 @@
}
private WorkList(EqualityTest equalityTest) {
- if (equalityTest == EqualityTest.HASH) {
- seen = new HashSet<>();
- } else {
- seen = Sets.newIdentityHashSet();
- }
+ this(equalityTest == EqualityTest.HASH ? new HashSet<>() : Sets.newIdentityHashSet());
+ }
+
+ private WorkList(Set<T> seen) {
+ this.seen = seen;
}
public void addAllIgnoringSeenSet(Iterable<T> items) {
diff --git a/src/main/java/com/android/tools/r8/utils/collections/IdentityHashSetFromMap.java b/src/main/java/com/android/tools/r8/utils/collections/IdentityHashSetFromMap.java
new file mode 100644
index 0000000..0322582
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/collections/IdentityHashSetFromMap.java
@@ -0,0 +1,115 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.utils.collections;
+
+import com.android.tools.r8.graph.ProgramDerivedContext;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+
+public class IdentityHashSetFromMap<K, V> implements Set<V> {
+
+ private final Map<K, V> backing = new IdentityHashMap<>();
+ private final Function<V, K> valueToKeyMapping;
+
+ public IdentityHashSetFromMap(Function<V, K> valueToKeyMapping) {
+ this.valueToKeyMapping = valueToKeyMapping;
+ }
+
+ public static Set<ProgramDerivedContext> newProgramDerivedContextSet() {
+ return new IdentityHashSetFromMap<>(context -> context.getContext().getReference());
+ }
+
+ @Override
+ public int size() {
+ return backing.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return backing.isEmpty();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public boolean contains(Object o) {
+ return backing.containsKey(valueToKeyMapping.apply((V) o));
+ }
+
+ @Override
+ public Iterator<V> iterator() {
+ return backing.values().iterator();
+ }
+
+ @Override
+ public Object[] toArray() {
+ return backing.values().toArray();
+ }
+
+ @Override
+ public <T> T[] toArray(T[] ts) {
+ return backing.values().toArray(ts);
+ }
+
+ @Override
+ public boolean add(V v) {
+ return backing.put(valueToKeyMapping.apply(v), v) == null;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public boolean remove(Object o) {
+ return backing.remove(valueToKeyMapping.apply((V) o)) != null;
+ }
+
+ @Override
+ public boolean containsAll(Collection<?> collection) {
+ return backing.values().containsAll(collection);
+ }
+
+ @Override
+ public boolean addAll(Collection<? extends V> collection) {
+ boolean changed = false;
+ for (V element : collection) {
+ changed |= add(element);
+ }
+ return changed;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public boolean retainAll(Collection<?> collection) {
+ Collection<Object> found = new ArrayList<>(collection.size());
+ for (Object element : collection) {
+ if (contains(element)) {
+ found.add(element);
+ }
+ }
+ if (found.size() < size()) {
+ clear();
+ addAll((Collection<V>) found);
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean removeAll(Collection<?> collection) {
+ boolean changed = false;
+ for (Object element : collection) {
+ changed |= remove(element);
+ }
+ return changed;
+ }
+
+ @Override
+ public void clear() {
+ backing.clear();
+ }
+}
diff --git a/src/main/keep.txt b/src/main/keep.txt
index 24d0fbc..f3e6dd4 100644
--- a/src/main/keep.txt
+++ b/src/main/keep.txt
@@ -28,6 +28,4 @@
-keep public class com.android.tools.r8.compatproguard.CompatProguard { public static void main(java.lang.String[]); }
# TODO(b/176783536): Avoid need to use -dontwarn.
--dontwarn com.google.errorprone.annotations.**
--dontwarn com.google.j2objc.annotations.*
--dontwarn javax.annotation.Nullable
+-include dontwarn.txt
diff --git a/src/test/examples/staticinlining/AlwaysInline.java b/src/test/examples/staticinlining/AlwaysInline.java
new file mode 100644
index 0000000..2bdb704
--- /dev/null
+++ b/src/test/examples/staticinlining/AlwaysInline.java
@@ -0,0 +1,10 @@
+// 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.
+package staticinlining;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+public @interface AlwaysInline {}
diff --git a/src/test/examples/staticinlining/Sub1.java b/src/test/examples/staticinlining/Sub1.java
index 2e06601..5904684 100644
--- a/src/test/examples/staticinlining/Sub1.java
+++ b/src/test/examples/staticinlining/Sub1.java
@@ -4,8 +4,6 @@
package staticinlining;
-import inlining.AlwaysInline;
-
public class Sub1 extends SuperClass {
@AlwaysInline
diff --git a/src/test/examples/staticinlining/Sub2.java b/src/test/examples/staticinlining/Sub2.java
index e253f79..54528e9 100644
--- a/src/test/examples/staticinlining/Sub2.java
+++ b/src/test/examples/staticinlining/Sub2.java
@@ -18,5 +18,4 @@
System.out.println("Do not inline me 9");
System.out.println("Do not inline me 10");
}
-
}
diff --git a/src/test/examples/staticinlining/keep-rules.txt b/src/test/examples/staticinlining/keep-rules.txt
index 1de091f..eb98fbe 100644
--- a/src/test/examples/staticinlining/keep-rules.txt
+++ b/src/test/examples/staticinlining/keep-rules.txt
@@ -9,5 +9,5 @@
}
-alwaysinline class * {
- @inlining.AlwaysInline <methods>;
+ @staticinlining.AlwaysInline <methods>;
}
diff --git a/src/test/ignorewarnings.rules b/src/test/ignorewarnings.rules
new file mode 100644
index 0000000..f7766e0
--- /dev/null
+++ b/src/test/ignorewarnings.rules
@@ -0,0 +1 @@
+-ignorewarnings
diff --git a/src/test/java/com/android/tools/r8/JctfTestSpecifications.java b/src/test/java/com/android/tools/r8/JctfTestSpecifications.java
index 899093a..2d21521 100644
--- a/src/test/java/com/android/tools/r8/JctfTestSpecifications.java
+++ b/src/test/java/com/android/tools/r8/JctfTestSpecifications.java
@@ -1831,6 +1831,28 @@
.put("lang.ref.WeakReference.get.WeakReference_get_A01", cf())
.build(); // end of flakyWhenRun
+ public static final Set<String> hasMissingClasses =
+ ImmutableSet.of(
+ "lang.RuntimePermission.Class.RuntimePermission_class_A01",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A03",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A04",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A05",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A06",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A07",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A08",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A09",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A11",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A12",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A14",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A15",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A19",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A20",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A21",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A22",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A24",
+ "lang.RuntimePermission.Class.RuntimePermission_class_A25",
+ "lang.reflect.Proxy.serialization.Proxy_serialization_A02");
+
public static final Multimap<String, TestCondition> timeoutsWhenRun =
new ImmutableListMultimap.Builder<String, TestCondition>()
.put("lang.Thread.interrupt.Thread_interrupt_A01", anyDexVm())
@@ -1956,7 +1978,7 @@
public static final Set<String> compilationFailsWithAsmMethodTooLarge = ImmutableSet.of();
- private static final boolean testMatch(
+ private static boolean testMatch(
Multimap<String, TestCondition> testConditions,
String name,
CompilerUnderTest compilerUnderTest,
@@ -1971,7 +1993,7 @@
return false;
}
- public static final <T> T getExpectedOutcome(
+ public static <T> T getExpectedOutcome(
String name,
CompilerUnderTest compilerUnderTest,
Runtime runtime,
diff --git a/src/test/java/com/android/tools/r8/Jdk11TestUtils.java b/src/test/java/com/android/tools/r8/Jdk11TestUtils.java
new file mode 100644
index 0000000..26da974
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/Jdk11TestUtils.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2021, 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 com.android.tools.r8;
+
+import static com.android.tools.r8.TestRuntime.getCheckedInJdk8;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import org.junit.Assume;
+import org.junit.rules.TemporaryFolder;
+
+public class Jdk11TestUtils {
+
+ public static ThrowableConsumer<R8FullTestBuilder> addJdk11LibraryFiles(
+ TemporaryFolder temporaryFolder) {
+ return builder -> builder.addLibraryFiles(getJdk11LibraryFiles(temporaryFolder));
+ }
+
+ public static Path[] getJdk11LibraryFiles(TemporaryFolder temp) throws IOException {
+ Assume.assumeFalse(ToolHelper.isWindows());
+ // TODO(b/180553597): Add JDK-11 runtime jar instead. As a temporary solution we use the JDK-8
+ // runtime with additional stubs.
+ Path stubs =
+ JavaCompilerTool.create(getCheckedInJdk8(), temp)
+ .addSourceFiles(Paths.get("src", "test", "javaStubs", "StringConcatFactory.java"))
+ .addSourceFiles(Paths.get("src", "test", "javaStubs", "VarHandle.java"))
+ .compile();
+ return new Path[] {stubs, ToolHelper.getJava8RuntimeJar()};
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/Jdk9TestUtils.java b/src/test/java/com/android/tools/r8/Jdk9TestUtils.java
new file mode 100644
index 0000000..891ba09
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/Jdk9TestUtils.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2021, 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 com.android.tools.r8;
+
+import static com.android.tools.r8.TestRuntime.getCheckedInJdk8;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import org.junit.Assume;
+import org.junit.rules.TemporaryFolder;
+
+public class Jdk9TestUtils {
+
+ public static ThrowableConsumer<R8FullTestBuilder> addJdk9LibraryFiles(
+ TemporaryFolder temporaryFolder) {
+ return builder -> builder.addLibraryFiles(getJdk9LibraryFiles(temporaryFolder));
+ }
+
+ public static Path[] getJdk9LibraryFiles(TemporaryFolder temp) throws IOException {
+ Assume.assumeFalse(ToolHelper.isWindows());
+ // TODO(b/180553597): Add JDK-9 runtime jar instead. As a temporary solution we use the JDK-8
+ // runtime with additional stubs.
+ Path stubs =
+ JavaCompilerTool.create(getCheckedInJdk8(), temp)
+ .addSourceFiles(Paths.get("src", "test", "javaStubs", "StringConcatFactory.java"))
+ .addSourceFiles(Paths.get("src", "test", "javaStubs", "VarHandle.java"))
+ .compile();
+ return new Path[] {stubs, ToolHelper.getJava8RuntimeJar()};
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/KotlinCompilerTool.java b/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
index 8e94e5e..f19059b 100644
--- a/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
+++ b/src/test/java/com/android/tools/r8/KotlinCompilerTool.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8;
+import static com.android.tools.r8.ToolHelper.getKotlinC_1_4_20;
import static com.android.tools.r8.ToolHelper.isWindows;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
@@ -60,6 +61,10 @@
this.name = name;
}
+ public static KotlinCompiler latest() {
+ return getKotlinC_1_4_20();
+ }
+
public Path getCompiler() {
return compiler;
}
diff --git a/src/test/java/com/android/tools/r8/MarkersTest.java b/src/test/java/com/android/tools/r8/MarkersTest.java
index 6e99dc4..bad77b5 100644
--- a/src/test/java/com/android/tools/r8/MarkersTest.java
+++ b/src/test/java/com/android/tools/r8/MarkersTest.java
@@ -45,13 +45,12 @@
BooleanUtils.values());
}
- private final TestParameters parameters;
private final CompilationMode compilationMode;
private final boolean shrinkDesugaredLibrary;
public MarkersTest(
TestParameters parameters, CompilationMode compilationMode, boolean shrinkDesugaredLibrary) {
- this.parameters = parameters;
+ assert parameters.isNoneRuntime();
this.compilationMode = compilationMode;
this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
}
diff --git a/src/test/java/com/android/tools/r8/R8CFRunExamplesJava9Test.java b/src/test/java/com/android/tools/r8/R8CFRunExamplesJava9Test.java
index de47d8a..1d45cb1 100644
--- a/src/test/java/com/android/tools/r8/R8CFRunExamplesJava9Test.java
+++ b/src/test/java/com/android/tools/r8/R8CFRunExamplesJava9Test.java
@@ -50,8 +50,7 @@
for (UnaryOperator<R8Command.Builder> transformation : builderTransformations) {
builder = transformation.apply(builder);
}
- // TODO(b/124041175): We should not be linking against the Java 8 runtime for Java 9 inputs.
- builder.addLibraryFiles(ToolHelper.getJava8RuntimeJar());
+ builder.addLibraryFiles(Jdk9TestUtils.getJdk9LibraryFiles(temp));
R8Command command =
builder.addProgramFiles(inputFile).setOutput(out, OutputMode.ClassFile).build();
ToolHelper.runR8(command, this::combinedOptionConsumer);
diff --git a/src/test/java/com/android/tools/r8/R8IgnoreMissingClassesTest.java b/src/test/java/com/android/tools/r8/R8IgnoreMissingClassesTest.java
index 83bc302..5a510c0 100644
--- a/src/test/java/com/android/tools/r8/R8IgnoreMissingClassesTest.java
+++ b/src/test/java/com/android/tools/r8/R8IgnoreMissingClassesTest.java
@@ -19,6 +19,7 @@
private R8Command.Builder config() {
return R8Command.builder()
.addProgramFiles(EXAMPLE)
+ .setDisableTreeShaking(true)
.setMinApiLevel(MIN_API.getLevel())
.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
}
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index f3cbda6..4b095bb 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -1195,17 +1195,38 @@
"435-new-instance"
);
- private static List<String> hasMissingClasses = ImmutableList.of(
- "091-override-package-private-method",
- "003-omnibus-opcodes",
- "608-checker-unresolved-lse",
- "529-checker-unresolved",
- "803-no-super",
- "127-checker-secondarydex",
- "952-invoke-custom-kinds",
- // Depends on java.lang.invoke.Transformers, which is hidden.
- "958-methodhandle-stackframe"
- );
+ private static List<String> hasMissingClasses =
+ ImmutableList.of(
+ "003-omnibus-opcodes",
+ "004-UnsafeTest",
+ "004-checker-UnsafeTest18",
+ "005-annotations",
+ "067-preemptive-unpark",
+ "071-dexfile-map-clean",
+ "091-override-package-private-method",
+ "111-unresolvable-exception",
+ "124-missing-classes",
+ "127-checker-secondarydex",
+ "138-duplicate-classes-check2",
+ "140-field-packing",
+ "143-string-value",
+ "151-OpenFileLimit",
+ "435-new-instance",
+ "528-long-hint",
+ "529-checker-unresolved",
+ "555-UnsafeGetLong-regression",
+ "585-inline-unresolved",
+ "606-erroneous-class",
+ "608-checker-unresolved-lse",
+ "659-unpadded-array",
+ "706-checker-scheduler",
+ "709-checker-varhandles",
+ "803-no-super",
+ "912-classes",
+ "952-invoke-custom-kinds",
+ // Depends on java.lang.invoke.Transformers, which is hidden.
+ "958-methodhandle-stackframe",
+ "1338-gc-no-los");
private static Map<String, List<String>> keepRules =
ImmutableMap.of(
@@ -1352,6 +1373,7 @@
boolean skipRun,
boolean failsOnRun,
boolean disableInlining,
+ boolean hasMissingClasses,
DexVm dexVm) {
this(
name,
@@ -1368,7 +1390,7 @@
false,
disableInlining,
true, // Disable class inlining for JCTF tests.
- false,
+ hasMissingClasses,
true, // Disable desugaring for JCTF tests.
ImmutableList.of(),
null);
@@ -1380,7 +1402,8 @@
File directory,
boolean skipRun,
boolean failsOnRun,
- boolean disableInlining) {
+ boolean disableInlining,
+ boolean hasMissingClasses) {
this(
name,
dexTool,
@@ -1396,7 +1419,7 @@
false,
disableInlining,
true, // Disable class inlining for JCTF tests.
- false,
+ hasMissingClasses,
true, // Disable desugaring for JCTF tests.
ImmutableList.of(),
null);
@@ -1917,6 +1940,7 @@
|| outcome == JctfTestSpecifications.Outcome.FLAKY_WHEN_RUN,
outcome == JctfTestSpecifications.Outcome.FAILS_WHEN_RUN,
noInlining,
+ JctfTestSpecifications.hasMissingClasses.contains(name),
dexVm);
}
@@ -1930,7 +1954,8 @@
outcome == JctfTestSpecifications.Outcome.TIMEOUTS_WHEN_RUN
|| outcome == JctfTestSpecifications.Outcome.FLAKY_WHEN_RUN,
outcome == JctfTestSpecifications.Outcome.FAILS_WHEN_RUN,
- noInlining);
+ noInlining,
+ JctfTestSpecifications.hasMissingClasses.contains(name));
}
private static Runtime getRuntime(TestRuntime vm) {
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java b/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
index e13ddd2..b247acf 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesCommon.java
@@ -103,7 +103,7 @@
}
}
- private R8Command.Builder addInputFile(R8Command.Builder builder) {
+ public R8Command.Builder addInputFile(R8Command.Builder builder) {
if (input == Input.DX) {
// If input is DEX code, use the tool helper to add the DEX sources as R8 disallows them.
ToolHelper.getAppBuilder(builder).addProgramFiles(getOriginalDexFile());
@@ -151,7 +151,7 @@
.addLibraryFiles(
output == Output.CF
? ToolHelper.getJava8RuntimeJar()
- : ToolHelper.getDefaultAndroidJar())
+ : ToolHelper.getMostRecentAndroidJar())
.setOutput(getOutputFile(), outputMode)
.setMode(mode)
.setDisableTreeShaking(true)
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesJava9Test.java b/src/test/java/com/android/tools/r8/R8RunExamplesJava9Test.java
index 11035f5..7c3a605 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesJava9Test.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesJava9Test.java
@@ -9,6 +9,7 @@
import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import java.util.function.UnaryOperator;
+import org.junit.Test;
public class R8RunExamplesJava9Test extends RunExamplesJava9Test<R8Command.Builder> {
@@ -55,4 +56,16 @@
R8TestRunner test(String testName, String packageName, String mainClass) {
return new R8TestRunner(testName, packageName, mainClass);
}
+
+ @Test
+ public void varHandle() throws Throwable {
+ test("varhandle", "varhandle", "VarHandleTests")
+ .withBuilderTransformation(
+ builder ->
+ builder.addProguardConfiguration(
+ ImmutableList.of("-dontwarn java.lang.invoke.VarHandle"), Origin.unknown()))
+ .withMinApiLevel(AndroidApiLevel.P.getLevel())
+ .withKeepAll()
+ .run();
+ }
}
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java
index 0690fa9..74dfeb4 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesKotlinTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8;
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
+import com.android.tools.r8.R8Command.Builder;
import com.android.tools.r8.R8RunArtTestsTest.CompilerUnderTest;
import com.android.tools.r8.utils.InternalOptions;
import java.util.ArrayList;
@@ -21,10 +23,6 @@
@Override
protected void configure(InternalOptions options) {
super.configure(options);
- if (output == Output.CF) {
- // Class inliner is not supported with CF backend yet.
- options.enableClassInlining = false;
- }
}
@Parameters(name = "{0}_{1}_{2}_{3}_{5}_{6}")
@@ -50,6 +48,12 @@
}
@Override
+ public Builder addInputFile(Builder builder) {
+ return super.addInputFile(builder)
+ .addProgramFiles(ToolHelper.getKotlinAnnotationJar(KotlinCompiler.latest()));
+ }
+
+ @Override
protected String getExampleDir() {
return ToolHelper.EXAMPLES_KOTLIN_BUILD_DIR;
}
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
index 04ff03f..d8a62da 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesTest.java
@@ -160,9 +160,6 @@
@Override
protected Set<String> getFailingCompileDxToDex() {
return new ImmutableSet.Builder<String>()
- .add("regress_72361252.Test") // requires desugar
- .add("regress_70703087.Test") // requires desugar
- .add("regress_70737019.Test") // requires desugar
.build();
}
diff --git a/src/test/java/com/android/tools/r8/R8TestCompileResult.java b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
index c9834f8..a1a5f88 100644
--- a/src/test/java/com/android/tools/r8/R8TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestCompileResult.java
@@ -179,6 +179,12 @@
return proguardMap;
}
+ public R8TestCompileResult inspectProguardMap(ThrowableConsumer<String> consumer)
+ throws Throwable {
+ consumer.accept(getProguardMap());
+ return this;
+ }
+
public Path writeProguardMap() throws IOException {
Path file = state.getNewTempFolder().resolve("out.zip");
writeProguardMap(file);
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
index b7bb5d2..2773cf1 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
import static com.android.tools.r8.utils.FileUtils.ZIP_EXTENSION;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.ToolHelper.DexVm;
@@ -426,10 +427,9 @@
@Test
public void repeatAnnotations() throws Throwable {
- // No need to specify minSdk as repeat annotations are handled by javac and we do not have
- // to do anything to support them. The library methods to access them just have to be in
- // the system.
+ // java.lang.annotation.Repeatable is introduced in Android N.
test("repeat_annotations", "repeat_annotations", "RepeatAnnotations")
+ .withAndroidJar(AndroidApiLevel.N)
.withKeepAll()
.run();
}
@@ -437,6 +437,7 @@
@Test
public void testTryWithResources() throws Throwable {
test("try-with-resources-simplified", "trywithresources", "TryWithResourcesNotDesugaredTests")
+ .withAndroidJar(AndroidApiLevel.K)
.withTryWithResourcesDesugaring(OffOrAuto.Off)
.withKeepAll()
.run();
@@ -445,11 +446,13 @@
@Test
public void testTryWithResourcesDesugared() throws Throwable {
test("try-with-resources-simplified", "trywithresources", "TryWithResourcesDesugaredTests")
+ .withAndroidJar(AndroidApiLevel.K)
.withTryWithResourcesDesugaring(OffOrAuto.Auto)
- .withInstructionCheck(InstructionSubject::isInvoke,
+ .withInstructionCheck(
+ InstructionSubject::isInvoke,
(InvokeInstructionSubject invoke) -> {
- Assert.assertFalse(invoke.invokedMethod().name.toString().equals("addSuppressed"));
- Assert.assertFalse(invoke.invokedMethod().name.toString().equals("getSuppressed"));
+ assertNotEquals("addSuppressed", invoke.invokedMethod().name.toString());
+ assertNotEquals("getSuppressed", invoke.invokedMethod().name.toString());
})
.withKeepAll()
.run();
diff --git a/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java b/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java
index 9f20f9e..7f1940e 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesJava9Test.java
@@ -48,8 +48,6 @@
final String mainClass;
final List<String> args = new ArrayList<>();
- Integer androidJarVersion = null;
-
final List<Consumer<InternalOptions>> optionConsumers = new ArrayList<>();
final List<Consumer<CodeInspector>> dexInspectorChecks = new ArrayList<>();
final List<UnaryOperator<B>> builderTransformations = new ArrayList<>();
@@ -83,14 +81,6 @@
return self();
}
- Path build() throws Throwable {
- Path inputFile = getInputJar();
- Path out = temp.getRoot().toPath().resolve(testName + ZIP_EXTENSION);
-
- build(inputFile, out);
- return out;
- }
-
Path getInputJar() {
return Paths.get(EXAMPLE_DIR, packageName + JAR_EXTENSION);
}
@@ -126,12 +116,6 @@
return self();
}
- C withAndroidJar(int androidJarVersion) {
- assert this.androidJarVersion == null;
- this.androidJarVersion = androidJarVersion;
- return self();
- }
-
abstract void build(Path inputFile, Path out) throws Throwable;
}
@@ -274,7 +258,6 @@
test
.withMinApiLevel(AndroidApiLevel.I.getLevel())
.withKeepAll()
- .withAndroidJar(AndroidApiLevel.K.getLevel())
.withArg(test.getInputJar().toAbsolutePath().toString())
.run();
}
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 1b4ca35..cf27791 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -4,6 +4,7 @@
package com.android.tools.r8;
+import static com.android.tools.r8.TestBuilder.getTestingAnnotations;
import static com.android.tools.r8.utils.InternalOptions.ASM_VERSION;
import static com.google.common.collect.Lists.cartesianProduct;
import static org.junit.Assert.assertEquals;
@@ -39,6 +40,7 @@
import com.android.tools.r8.graph.SubtypingInfo;
import com.android.tools.r8.jasmin.JasminBuilder;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.MethodReference;
@@ -131,6 +133,10 @@
CF,
DEX;
+ public boolean isCf() {
+ return this == CF;
+ }
+
public boolean isDex() {
return this == DEX;
}
@@ -551,7 +557,7 @@
}
protected static AndroidApp.Builder buildClasses(Class<?>... programClasses) throws IOException {
- return buildClasses(Arrays.asList(programClasses), Collections.emptyList());
+ return buildClasses(Arrays.asList(programClasses));
}
protected static AndroidApp.Builder buildClasses(Collection<Class<?>> programClasses)
@@ -559,6 +565,20 @@
return buildClasses(programClasses, Collections.emptyList());
}
+ protected static AndroidApp.Builder buildClassesWithTestingAnnotations(Class<?>... programClasses)
+ throws IOException {
+ return buildClassesWithTestingAnnotations(Arrays.asList(programClasses));
+ }
+
+ protected static AndroidApp.Builder buildClassesWithTestingAnnotations(
+ Collection<Class<?>> programClasses) throws IOException {
+ AndroidApp.Builder builder = buildClasses(programClasses, Collections.emptyList());
+ for (Class<?> testingAnnotation : getTestingAnnotations()) {
+ builder.addProgramFile(ToolHelper.getClassFileForTestClass(testingAnnotation));
+ }
+ return builder;
+ }
+
protected static AndroidApp.Builder buildClasses(
Collection<Class<?>> programClasses, Collection<Class<?>> libraryClasses) throws IOException {
AndroidApp.Builder builder = AndroidApp.builder();
@@ -1687,6 +1707,10 @@
return DescriptorUtils.javaTypeToDescriptor(typeName(clazz));
}
+ public static PathOrigin getOrigin(Class<?> clazz) {
+ return new PathOrigin(ToolHelper.getClassFileForTestClass(clazz));
+ }
+
public static String typeName(Class<?> clazz) {
return clazz.getTypeName();
}
diff --git a/src/test/java/com/android/tools/r8/TestBuilder.java b/src/test/java/com/android/tools/r8/TestBuilder.java
index 3d33673..8f5466c 100644
--- a/src/test/java/com/android/tools/r8/TestBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestBuilder.java
@@ -166,8 +166,9 @@
return addLibraryClasses(getTestingAnnotations());
}
- private List<Class<?>> getTestingAnnotations() {
+ public static List<Class<?>> getTestingAnnotations() {
return ImmutableList.of(
+ AlwaysInline.class,
AssumeMayHaveSideEffects.class,
ForceInline.class,
KeepConstantArguments.class,
diff --git a/src/test/java/com/android/tools/r8/TestCompileResult.java b/src/test/java/com/android/tools/r8/TestCompileResult.java
index 80f3234..ba56c6f 100644
--- a/src/test/java/com/android/tools/r8/TestCompileResult.java
+++ b/src/test/java/com/android/tools/r8/TestCompileResult.java
@@ -65,6 +65,20 @@
this.outputMode = outputMode;
}
+ public CR applyIf(boolean condition, ThrowableConsumer<CR> thenConsumer) {
+ return applyIf(condition, thenConsumer, result -> {});
+ }
+
+ public CR applyIf(
+ boolean condition, ThrowableConsumer<CR> thenConsumer, ThrowableConsumer<CR> elseConsumer) {
+ if (condition) {
+ thenConsumer.acceptWithRuntimeException(self());
+ } else {
+ elseConsumer.acceptWithRuntimeException(self());
+ }
+ return self();
+ }
+
public final CR withArt6Plus64BitsLib() {
withArt6Plus64BitsLib = true;
return self();
@@ -75,6 +89,10 @@
return self();
}
+ public final AndroidApp getApp() {
+ return app;
+ }
+
public final Backend getBackend() {
if (outputMode == OutputMode.ClassFile) {
return Backend.CF;
@@ -362,7 +380,7 @@
}
public CR assertAllWarningMessagesMatch(Matcher<String> matcher) {
- getDiagnosticMessages().assertAllWarningsMatch(diagnosticMessage(matcher));
+ getDiagnosticMessages().assertHasWarnings().assertAllWarningsMatch(diagnosticMessage(matcher));
return self();
}
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
index 997faf6..e2ea100 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessages.java
@@ -6,131 +6,176 @@
import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.diagnosticinspector.DiagnosticSubject;
+import com.android.tools.r8.diagnosticinspector.FoundDiagnosticSubject;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
+import java.util.Iterator;
import java.util.List;
import org.hamcrest.Matcher;
-public interface TestDiagnosticMessages {
+public abstract class TestDiagnosticMessages {
- List<Diagnostic> getInfos();
+ public abstract List<Diagnostic> getInfos();
- List<Diagnostic> getWarnings();
+ public abstract List<Diagnostic> getWarnings();
- default <D extends Diagnostic> D getWarning(int index) {
- return (D) getWarnings().get(index);
+ public final TestDiagnosticMessages inspectWarning(
+ int index, ThrowableConsumer<DiagnosticSubject> consumer) {
+ consumer.acceptWithRuntimeException(new FoundDiagnosticSubject<>(getWarnings().get(index)));
+ return this;
}
- List<Diagnostic> getErrors();
-
- default <D extends Diagnostic> D getError(int index) {
- return (D) getErrors().get(index);
+ @SafeVarargs
+ public final TestDiagnosticMessages inspectWarnings(
+ ThrowableConsumer<DiagnosticSubject>... consumers) {
+ return inspectWarnings(Arrays.asList(consumers));
}
- TestDiagnosticMessages assertNoMessages();
+ public final TestDiagnosticMessages inspectWarnings(
+ Collection<ThrowableConsumer<DiagnosticSubject>> consumers) {
+ assertEquals(consumers.size(), getWarnings().size());
+ Iterator<ThrowableConsumer<DiagnosticSubject>> consumerIterator = consumers.iterator();
+ Iterator<Diagnostic> warningIterator = getWarnings().iterator();
+ for (int i = 0; i < consumers.size(); i++) {
+ consumerIterator
+ .next()
+ .acceptWithRuntimeException(new FoundDiagnosticSubject<>(warningIterator.next()));
+ }
+ return this;
+ }
- TestDiagnosticMessages assertOnlyInfos();
+ public abstract List<Diagnostic> getErrors();
- TestDiagnosticMessages assertOnlyWarnings();
+ @SafeVarargs
+ public final TestDiagnosticMessages inspectErrors(
+ ThrowableConsumer<DiagnosticSubject>... consumers) {
+ return inspectErrors(Arrays.asList(consumers));
+ }
- TestDiagnosticMessages assertOnlyErrors();
+ public final TestDiagnosticMessages inspectErrors(
+ Collection<ThrowableConsumer<DiagnosticSubject>> consumers) {
+ assertEquals(consumers.size(), getErrors().size());
+ Iterator<ThrowableConsumer<DiagnosticSubject>> consumerIterator = consumers.iterator();
+ Iterator<Diagnostic> errorIterator = getErrors().iterator();
+ for (int i = 0; i < consumers.size(); i++) {
+ consumerIterator
+ .next()
+ .acceptWithRuntimeException(new FoundDiagnosticSubject<>(errorIterator.next()));
+ }
+ return this;
+ }
- TestDiagnosticMessages assertInfosCount(int count);
+ public abstract TestDiagnosticMessages assertNoMessages();
- TestDiagnosticMessages assertWarningsCount(int count);
+ public abstract TestDiagnosticMessages assertHasWarnings();
- TestDiagnosticMessages assertErrorsCount(int count);
+ public abstract TestDiagnosticMessages assertOnlyInfos();
- default TestDiagnosticMessages assertNoInfos() {
+ public abstract TestDiagnosticMessages assertOnlyWarnings();
+
+ public abstract TestDiagnosticMessages assertOnlyErrors();
+
+ public abstract TestDiagnosticMessages assertInfosCount(int count);
+
+ public abstract TestDiagnosticMessages assertWarningsCount(int count);
+
+ public abstract TestDiagnosticMessages assertErrorsCount(int count);
+
+ public final TestDiagnosticMessages assertNoInfos() {
return assertInfosCount(0);
}
- default TestDiagnosticMessages assertNoWarnings() {
+ public final TestDiagnosticMessages assertNoWarnings() {
return assertWarningsCount(0);
}
- default TestDiagnosticMessages assertNoErrors() {
+ public final TestDiagnosticMessages assertNoErrors() {
return assertErrorsCount(0);
}
// Match exact.
- default TestDiagnosticMessages assertDiagnosticsMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertDiagnosticsMatch(Matcher<Diagnostic> matcher) {
return assertDiagnosticsMatch(Collections.singletonList(matcher));
}
- TestDiagnosticMessages assertDiagnosticsMatch(Collection<Matcher<Diagnostic>> matchers);
+ public abstract TestDiagnosticMessages assertDiagnosticsMatch(
+ Collection<Matcher<Diagnostic>> matchers);
- default TestDiagnosticMessages assertInfosMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertInfosMatch(Matcher<Diagnostic> matcher) {
return assertInfosMatch(Collections.singletonList(matcher));
}
- TestDiagnosticMessages assertInfosMatch(Collection<Matcher<Diagnostic>> matchers);
+ public abstract TestDiagnosticMessages assertInfosMatch(Collection<Matcher<Diagnostic>> matchers);
- default TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic> matcher) {
return assertWarningsMatch(Collections.singletonList(matcher));
}
- @SuppressWarnings("unchecked")
- default TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic>... matchers) {
+ @SafeVarargs
+ public final TestDiagnosticMessages assertWarningsMatch(Matcher<Diagnostic>... matchers) {
return assertWarningsMatch(Arrays.asList(matchers));
}
- TestDiagnosticMessages assertWarningsMatch(Collection<Matcher<Diagnostic>> matchers);
+ public abstract TestDiagnosticMessages assertWarningsMatch(
+ Collection<Matcher<Diagnostic>> matchers);
- default TestDiagnosticMessages assertErrorsMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertErrorsMatch(Matcher<Diagnostic> matcher) {
return assertErrorsMatch(Collections.singletonList(matcher));
}
- TestDiagnosticMessages assertErrorsMatch(Collection<Matcher<Diagnostic>> matchers);
+ public abstract TestDiagnosticMessages assertErrorsMatch(
+ Collection<Matcher<Diagnostic>> matchers);
// Match one.
- TestDiagnosticMessages assertDiagnosticThatMatches(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertDiagnosticThatMatches(Matcher<Diagnostic> matcher);
- TestDiagnosticMessages assertInfoThatMatches(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertInfoThatMatches(Matcher<Diagnostic> matcher);
- TestDiagnosticMessages assertWarningThatMatches(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertWarningThatMatches(Matcher<Diagnostic> matcher);
- TestDiagnosticMessages assertErrorThatMatches(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertErrorThatMatches(Matcher<Diagnostic> matcher);
// Consider removing this helper.
- default TestDiagnosticMessages assertWarningMessageThatMatches(Matcher<String> matcher) {
+ public final TestDiagnosticMessages assertWarningMessageThatMatches(Matcher<String> matcher) {
return assertWarningThatMatches(diagnosticMessage(matcher));
}
// Consider removing this helper.
- default TestDiagnosticMessages assertErrorMessageThatMatches(Matcher<String> matcher) {
+ public final TestDiagnosticMessages assertErrorMessageThatMatches(Matcher<String> matcher) {
return assertErrorThatMatches(diagnosticMessage(matcher));
}
// Match all.
- TestDiagnosticMessages assertAllDiagnosticsMatch(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertAllDiagnosticsMatch(Matcher<Diagnostic> matcher);
- TestDiagnosticMessages assertAllInfosMatch(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertAllInfosMatch(Matcher<Diagnostic> matcher);
- TestDiagnosticMessages assertAllWarningsMatch(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertAllWarningsMatch(Matcher<Diagnostic> matcher);
- TestDiagnosticMessages assertAllErrorsMatch(Matcher<Diagnostic> matcher);
+ public abstract TestDiagnosticMessages assertAllErrorsMatch(Matcher<Diagnostic> matcher);
// Match none.
- default TestDiagnosticMessages assertNoDiagnosticsMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertNoDiagnosticsMatch(Matcher<Diagnostic> matcher) {
return assertAllDiagnosticsMatch(not(matcher));
}
- default TestDiagnosticMessages assertNoInfosMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertNoInfosMatch(Matcher<Diagnostic> matcher) {
return assertAllInfosMatch(not(matcher));
}
- default TestDiagnosticMessages assertNoWarningsMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertNoWarningsMatch(Matcher<Diagnostic> matcher) {
return assertAllWarningsMatch(not(matcher));
}
- default TestDiagnosticMessages assertNoErrorsMatch(Matcher<Diagnostic> matcher) {
+ public final TestDiagnosticMessages assertNoErrorsMatch(Matcher<Diagnostic> matcher) {
return assertAllErrorsMatch(not(matcher));
}
}
diff --git a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
index f1b6e73..b52db8d 100644
--- a/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
+++ b/src/test/java/com/android/tools/r8/TestDiagnosticMessagesImpl.java
@@ -6,6 +6,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.fail;
@@ -19,7 +20,8 @@
import java.util.function.BiFunction;
import org.hamcrest.Matcher;
-public class TestDiagnosticMessagesImpl implements DiagnosticsHandler, TestDiagnosticMessages {
+public class TestDiagnosticMessagesImpl extends TestDiagnosticMessages
+ implements DiagnosticsHandler {
private final List<Diagnostic> infos = new ArrayList<>();
private final List<Diagnostic> warnings = new ArrayList<>();
private final List<Diagnostic> errors = new ArrayList<>();
@@ -106,6 +108,12 @@
}
@Override
+ public TestDiagnosticMessages assertHasWarnings() {
+ assertFalse(warnings.isEmpty());
+ return this;
+ }
+
+ @Override
public TestDiagnosticMessages assertOnlyInfos() {
assertNotEquals(0, getInfos().size());
assertEmpty("warning", getWarnings());
diff --git a/src/test/java/com/android/tools/r8/TestParameters.java b/src/test/java/com/android/tools/r8/TestParameters.java
index 1ac00bb..be45d1c 100644
--- a/src/test/java/com/android/tools/r8/TestParameters.java
+++ b/src/test/java/com/android/tools/r8/TestParameters.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.TestRuntime.NoneRuntime;
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.utils.AndroidApiLevel;
+import java.nio.file.Path;
// Actual test parameters for a specific configuration. Currently just the runtime configuration.
public class TestParameters {
@@ -60,6 +61,12 @@
return apiLevel;
}
+ public Path getDefaultRuntimeLibrary() {
+ return isCfRuntime()
+ ? ToolHelper.getJava8RuntimeJar()
+ : ToolHelper.getFirstSupportedAndroidJar(getApiLevel());
+ }
+
// Access to underlying runtime/wrapper.
public TestRuntime getRuntime() {
return runtime;
diff --git a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
index c0cd551..78ac691 100644
--- a/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestShrinkerBuilder.java
@@ -112,10 +112,6 @@
return self();
}
- public T addDontWarn(String className) {
- return addKeepRules("-dontwarn " + className);
- }
-
public T addDontWarn(Collection<String> classes) {
for (String clazz : classes) {
addKeepRules("-dontwarn " + clazz);
@@ -139,26 +135,6 @@
return addDontWarn("javax.annotation.Nullable");
}
- public T addDontWarnJavaLangInvoke() {
- return addDontWarn("java.lang.invoke.*");
- }
-
- public T addDontWarnJavaNioFile() {
- return addDontWarn("java.nio.file.**");
- }
-
- public T addDontWarnJetBrainsAnnotations() {
- return addDontWarnJetBrainsNotNullAnnotation().addDontWarnJetBrainsNullableAnnotation();
- }
-
- public T addDontWarnJetBrainsNotNullAnnotation() {
- return addDontWarn("org.jetbrains.annotations.NotNull");
- }
-
- public T addDontWarnJetBrainsNullableAnnotation() {
- return addDontWarn("org.jetbrains.annotations.Nullable");
- }
-
public T addIgnoreWarnings() {
return addKeepRules("-ignorewarnings");
}
diff --git a/src/test/java/com/android/tools/r8/ThrowableConsumer.java b/src/test/java/com/android/tools/r8/ThrowableConsumer.java
index f19039b..269ff0e 100644
--- a/src/test/java/com/android/tools/r8/ThrowableConsumer.java
+++ b/src/test/java/com/android/tools/r8/ThrowableConsumer.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8;
+
import java.util.function.Function;
public interface ThrowableConsumer<Formal> {
@@ -18,7 +19,15 @@
}
default void acceptWithRuntimeException(Formal formal) {
- acceptWithHandler(formal, RuntimeException::new);
+ acceptWithHandler(
+ formal,
+ exception -> {
+ if (exception instanceof RuntimeException) {
+ throw (RuntimeException) exception;
+ } else {
+ throw new RuntimeException(exception);
+ }
+ });
}
default ThrowableConsumer<Formal> andThen(ThrowableConsumer<Formal> consumer) {
@@ -27,4 +36,8 @@
consumer.accept(formal);
};
}
+
+ static <Formal> ThrowableConsumer<Formal> empty() {
+ return ignore -> {};
+ }
}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 6c395bf..883a2b4 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -138,7 +138,8 @@
public static final String JAVA_8_RUNTIME = "third_party/openjdk/openjdk-rt-1.8/rt.jar";
public static final String DESUGAR_JDK_LIBS =
- System.getProperty("desugar_jdk_libs", "third_party/openjdk/desugar_jdk_libs/libjava.jar");
+ System.getProperty(
+ "desugar_jdk_libs", "third_party/openjdk/desugar_jdk_libs/desugar_jdk_libs.jar");
public static final String CORE_LAMBDA_STUBS =
"third_party/core-lambda-stubs/core-lambda-stubs.jar";
public static final String JSR223_RI_JAR = "third_party/jsr223-api-1.0/jsr223-api-1.0.jar";
@@ -869,6 +870,10 @@
return annotationJar;
}
+ public static Path getMostRecentKotlinAnnotationJar() {
+ return getKotlinAnnotationJar(KotlinCompiler.latest());
+ }
+
public static Path getJdwpTestsCfJarPath(AndroidApiLevel minSdk) {
if (minSdk.getLevel() >= AndroidApiLevel.N.getLevel()) {
return Paths.get("third_party", "jdwp-tests", "apache-harmony-jdwp-tests-host.jar");
@@ -2147,8 +2152,7 @@
return new KotlinCompiler[] {getKotlinC_1_3_72(), getKotlinC_1_4_20()};
}
- public static void disassemble(AndroidApp app, PrintStream ps)
- throws IOException, ExecutionException {
+ public static void disassemble(AndroidApp app, PrintStream ps) throws IOException {
DexApplication application =
new ApplicationReader(app, new InternalOptions(), Timing.empty()).read().toDirect();
new AssemblyWriter(application, new InternalOptions(), true, false, true).write(ps);
diff --git a/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java b/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java
index d6a696c..550e21f 100644
--- a/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java
+++ b/src/test/java/com/android/tools/r8/annotations/SourceDebugExtensionTest.java
@@ -5,7 +5,9 @@
package com.android.tools.r8.annotations;
import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -18,7 +20,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.TestRuntime.CfRuntime;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.retrace.KotlinInlineFunctionRetraceTest;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
@@ -64,11 +65,11 @@
CodeInspector kotlinInspector = new CodeInspector(kotlinSources);
inspectSourceDebugExtension(kotlinInspector);
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinCompiler))
+ .addClasspathFiles(
+ getKotlinStdlibJar(kotlinCompiler), getKotlinAnnotationJar(kotlinCompiler))
.addProgramFiles(kotlinSources)
.addKeepAttributes(ProguardKeepAttributes.SOURCE_DEBUG_EXTENSION)
.addKeepAllClassesRule()
- .addDontWarnJetBrainsNotNullAnnotation()
.setMode(CompilationMode.RELEASE)
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java b/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
index b0292e3..f99896f 100644
--- a/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/AlwaysNullGetItemTestRunner.java
@@ -4,79 +4,56 @@
package com.android.tools.r8.cf;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
-import com.android.tools.r8.ByteDataView;
-import com.android.tools.r8.ClassFileConsumer;
-import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.DexIndexedConsumer;
-import com.android.tools.r8.R8;
-import com.android.tools.r8.R8Command;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.origin.Origin;
-import com.android.tools.r8.utils.DescriptorUtils;
-import com.android.tools.r8.utils.TestDescriptionWatcher;
-import java.nio.file.Path;
-import org.junit.Rule;
import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
-public class AlwaysNullGetItemTestRunner {
- static final Class CLASS = AlwaysNullGetItemTest.class;
+@RunWith(Parameterized.class)
+public class AlwaysNullGetItemTestRunner extends TestBase {
- @Rule
- public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
+ private static final Class<?> CLASS = AlwaysNullGetItemTest.class;
- @Rule
- public TestDescriptionWatcher watcher = new TestDescriptionWatcher();
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public AlwaysNullGetItemTestRunner(TestParameters parameters) {
+ this.parameters = parameters;
+ }
@Test
public void test() throws Exception {
ProcessResult runInput =
ToolHelper.runJava(ToolHelper.getClassPathForTests(), CLASS.getCanonicalName());
assertEquals(0, runInput.exitCode);
- Path outCf = temp.getRoot().toPath().resolve("cf.jar");
- Path outDex = temp.getRoot().toPath().resolve("dex.zip");
- R8.run(
- R8Command.builder()
- .setMode(CompilationMode.DEBUG)
- .setDisableTreeShaking(true)
- .setDisableMinification(true)
- .addClassProgramData(ToolHelper.getClassAsBytes(CLASS), Origin.unknown())
- .addLibraryFiles(ToolHelper.getAndroidJar(ToolHelper.getMinApiLevelForDexVm()))
- .setProgramConsumer(new DexIndexedConsumer.ArchiveConsumer(outDex))
- .build());
- R8.run(
- R8Command.builder()
- .setMode(CompilationMode.DEBUG)
- .setDisableTreeShaking(true)
- .setDisableMinification(true)
- .addClassProgramData(ToolHelper.getClassAsBytes(CLASS), Origin.unknown())
- .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
- .setProgramConsumer(new ClassFileConsumer.ArchiveConsumer(outCf))
- .build());
- ProcessResult runCf = ToolHelper.runJava(outCf, CLASS.getCanonicalName());
- ProcessResult runDex = ToolHelper.runArtRaw(outDex.toString(), CLASS.getCanonicalName());
- assertEquals(runInput.toString(), runCf.toString());
- // Only compare stdout and exitCode since dex2oat prints to stderr.
- assertEquals(runInput.stdout, runDex.stdout);
- assertEquals(runInput.exitCode, runDex.exitCode);
+ testForR8(parameters.getBackend())
+ .addProgramClassesAndInnerClasses(CLASS)
+ .debug()
+ .noMinification()
+ .noTreeShaking()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), CLASS)
+ .assertSuccessWithOutputLines(NullPointerException.class.getSimpleName());
}
@Test
public void testNoCheckCast() throws Exception {
// Test that JVM accepts javac output when method calls have been replaced by ACONST_NULL.
- Path out = temp.getRoot().toPath().resolve("aaload-null.jar");
- ClassFileConsumer.ArchiveConsumer archiveConsumer = new ClassFileConsumer.ArchiveConsumer(out);
- archiveConsumer.accept(
- ByteDataView.of(AlwaysNullGetItemDump.dump()),
- DescriptorUtils.javaTypeToDescriptor(CLASS.getCanonicalName()),
- null);
- archiveConsumer.finished(null);
- ProcessResult processResult = ToolHelper.runJava(out, CLASS.getCanonicalName());
- if (processResult.exitCode != 0) {
- System.out.println(processResult);
- }
- assertEquals(0, processResult.exitCode);
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .addProgramClassFileData(AlwaysNullGetItemDump.dump())
+ .run(parameters.getRuntime(), CLASS)
+ .assertSuccessWithOutputLines(NullPointerException.class.getSimpleName());
}
}
diff --git a/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java b/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
index 2a6652b..cc9b61a 100644
--- a/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
+++ b/src/test/java/com/android/tools/r8/cf/MethodHandleTestRunner.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.DexIndexedConsumer;
+import com.android.tools.r8.NoVerticalClassMerging;
import com.android.tools.r8.ProgramConsumer;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.R8Command.Builder;
@@ -87,7 +88,7 @@
}
}
- private final Class[] inputClasses = {
+ private final Class<?>[] inputClasses = {
MethodHandleTest.class,
MethodHandleTest.C.class,
MethodHandleTest.I.class,
@@ -95,6 +96,7 @@
MethodHandleTest.D.class,
MethodHandleTest.E.class,
MethodHandleTest.F.class,
+ NoVerticalClassMerging.class
};
private void runInput() throws Exception {
diff --git a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java
index 722e4f6..5d890ab 100644
--- a/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java
+++ b/src/test/java/com/android/tools/r8/cf/bootstrap/BootstrapTest.java
@@ -38,13 +38,14 @@
private static final String[] KEEP_R8 = {
"-keep public class " + R8_NAME + " {", " public static void main(...);", "}",
};
+ private static final Path DONTWARN_R8 = Paths.get("src/main/dontwarn.txt");
private static final String HELLO_NAME = "hello.Hello";
private static final String[] KEEP_HELLO = {
"-keep class " + HELLO_NAME + " {", " public static void main(...);", "}",
};
- private class R8Result {
+ private static class R8Result {
final ProcessResult processResult;
final Path outputJar;
@@ -64,11 +65,12 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withCfRuntimes().build();
+ return getTestParameters().withNoneRuntime().build();
}
public BootstrapTest(TestParameters parameters) {
// TODO: use parameters to fork the right Java.
+ assert parameters.isNoneRuntime();
}
@Test
@@ -96,7 +98,7 @@
String externalOutput)
throws Exception {
// Run R8 on r8.jar.
- Path output = runR8(R8_STABLE_JAR, internalOutput, KEEP_R8, internalMode);
+ Path output = runR8(internalOutput, internalMode);
// Run the resulting compiler on hello.jar.
R8Result runR8R8 = runExternalR8(output, hello, externalOutput, KEEP_HELLO, externalMode);
// Check that the process outputs (exit code, stdout, stderr) are the same.
@@ -105,19 +107,18 @@
assertProgramsEqual(runInputR8.outputJar, runR8R8.outputJar);
}
- private Path runR8(Path inputJar, String outputFolder, String[] keepRules, CompilationMode mode)
- throws Exception {
+ private Path runR8(String outputFolder, CompilationMode mode) throws Exception {
Path outputPath = temp.newFolder(outputFolder).toPath();
Path outputJar = outputPath.resolve("output.jar");
Path pgConfigFile = outputPath.resolve("keep.rules");
- FileUtils.writeTextFile(pgConfigFile, keepRules);
+ FileUtils.writeTextFile(pgConfigFile, BootstrapTest.KEEP_R8);
ToolHelper.runR8(
R8Command.builder()
.setMode(mode)
.addLibraryFiles(ToolHelper.getJava8RuntimeJar())
.setProgramConsumer(new ClassFileConsumer.ArchiveConsumer(outputJar, true))
- .addProgramFiles(inputJar)
- .addProguardConfigurationFiles(pgConfigFile)
+ .addProgramFiles(R8_STABLE_JAR)
+ .addProguardConfigurationFiles(pgConfigFile, DONTWARN_R8)
.build());
return outputJar;
}
diff --git a/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java b/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
index 1b68052..c827c09 100644
--- a/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
+++ b/src/test/java/com/android/tools/r8/classlookup/LibraryClassExtendsProgramClassTest.java
@@ -198,8 +198,7 @@
.addProgramClasses(TestClass.class)
.addProgramClassFileData(junitClasses)
.addKeepAllClassesRule()
- .applyIf(
- libraryContainsJUnit(), builder -> builder.addKeepRules("-dontwarn android.test.**"))
+ .applyIf(libraryContainsJUnit(), builder -> builder.addDontWarn("android.test.**"))
.addOptionsModification(options -> options.lookupLibraryBeforeProgram = false)
.compile()
.assertNoMessages();
diff --git a/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java b/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java
index 8866342..9527564 100644
--- a/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/KeptTargetsIncompleteDiamondTest.java
@@ -10,6 +10,7 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
@@ -37,13 +38,15 @@
}
public KeptTargetsIncompleteDiamondTest(TestParameters parameters) {
- // Empty to satisfy construction of none-runtime.
+ assert parameters.isNoneRuntime();
}
private AppView<AppInfoWithLiveness> computeAppViewWithLiveness(
Class<?> methodToBeKept, Class<?> classToBeKept) throws Exception {
return computeAppViewWithLiveness(
- buildClasses(I.class, J.class, K.class, L.class, A.class, Main.class).build(),
+ buildClasses(I.class, J.class, K.class, L.class, A.class, Main.class)
+ .addLibraryFile(ToolHelper.getJava8RuntimeJar())
+ .build(),
factory ->
buildConfigForRules(
factory,
diff --git a/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java b/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java
index b416826..a043e68 100644
--- a/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/horizontal/NestClassTest.java
@@ -10,6 +10,7 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.notIf;
import static org.hamcrest.MatcherAssert.assertThat;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfVm;
import com.android.tools.r8.classmerging.horizontal.NestClassTest.R.horizontalclassmerging.BasicNestHostHorizontalClassMerging;
@@ -57,6 +58,7 @@
testForR8(parameters.getBackend())
.addKeepMainRule(examplesTypeName(BasicNestHostHorizontalClassMerging.class))
.addExamplesProgramFiles(R.class)
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.addOptionsModification(
options ->
options.horizontalClassMergerOptions().enableIf(enableHorizontalClassMerging))
diff --git a/src/test/java/com/android/tools/r8/code/NativeMethodWithCodeTest.java b/src/test/java/com/android/tools/r8/code/NativeMethodWithCodeTest.java
index 961be33..af127e7 100644
--- a/src/test/java/com/android/tools/r8/code/NativeMethodWithCodeTest.java
+++ b/src/test/java/com/android/tools/r8/code/NativeMethodWithCodeTest.java
@@ -27,7 +27,6 @@
import org.junit.Test;
import org.junit.runner.RunWith;
-@RunWith(VmTestRunner.class)
public class NativeMethodWithCodeTest extends TestBase {
// Test that D8 removes code from native methods (to match the behavior of dx).
diff --git a/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedFieldTest.java b/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedFieldTest.java
index efc344e..588948f 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedFieldTest.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedFieldTest.java
@@ -88,9 +88,7 @@
private TestShrinkerBuilder<?, ?, ?, ?, ?> buildShrinker() throws Exception {
TestShrinkerBuilder<?, ?, ?, ?, ?> builder;
if (shrinker == Shrinker.Proguard) {
- builder =
- testForProguard()
- .addKeepRules("-dontwarn " + ConditionalOnInlinedFieldTest.class.getTypeName());
+ builder = testForProguard().addDontWarn(ConditionalOnInlinedFieldTest.class);
} else if (shrinker == Shrinker.R8Compat) {
builder = testForR8Compat(parameters.getBackend());
} else {
diff --git a/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedTest.java b/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedTest.java
index faa9eda..e1d6571 100644
--- a/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedTest.java
+++ b/src/test/java/com/android/tools/r8/compatproguard/ifrules/ConditionalOnInlinedTest.java
@@ -69,9 +69,7 @@
private TestShrinkerBuilder<?, ?, ?, ?, ?> buildShrinker() throws Exception {
TestShrinkerBuilder<?, ?, ?, ?, ?> builder;
if (shrinker == Shrinker.Proguard) {
- builder =
- testForProguard()
- .addKeepRules("-dontwarn " + ConditionalOnInlinedTest.class.getTypeName());
+ builder = testForProguard().addDontWarn(ConditionalOnInlinedTest.class);
} else if (shrinker == Shrinker.R8Compat) {
builder = testForR8Compat(parameters.getBackend());
} else {
diff --git a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
index 86e11d0..eebed6b 100644
--- a/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
+++ b/src/test/java/com/android/tools/r8/debug/KotlinStdLibCompilationTest.java
@@ -3,7 +3,10 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.debug;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.CompilationFailedException;
@@ -13,7 +16,6 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersBuilder;
-import com.android.tools.r8.ToolHelper;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -42,7 +44,7 @@
public void testD8() throws CompilationFailedException {
assumeTrue(parameters.isDexRuntime());
testForD8()
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.compileWithExpectedDiagnostics(TestDiagnosticMessages::assertNoMessages);
}
@@ -50,13 +52,14 @@
@Test
public void testR8() throws CompilationFailedException {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
+ .addKeepAllAttributes()
+ .allowDiagnosticWarningMessages()
.noMinification()
.noTreeShaking()
- .addKeepAllAttributes()
- .addDontWarnJetBrainsAnnotations()
.setMode(CompilationMode.DEBUG)
.setMinApi(parameters.getApiLevel())
- .compileWithExpectedDiagnostics(TestDiagnosticMessages::assertNoMessages);
+ .compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
}
}
diff --git a/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java b/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java
index a0e9a1d..80a51c8 100644
--- a/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java
+++ b/src/test/java/com/android/tools/r8/debuginfo/KotlinDebugInfoTestRunner.java
@@ -6,21 +6,33 @@
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.ByteDataView;
-import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
-import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.ProgramConsumer;
-import com.android.tools.r8.R8Command;
-import com.android.tools.r8.R8Command.Builder;
+import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.origin.Origin;
-import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinDebugInfoTestRunner extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withCfRuntimes().build();
+ }
+
+ public KotlinDebugInfoTestRunner(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
private Path buildInput(byte[] clazz, String descriptor) {
Path inputJar = temp.getRoot().toPath().resolve("input.jar");
ArchiveConsumer inputJarConsumer = new ArchiveConsumer(inputJar);
@@ -29,19 +41,16 @@
return inputJar;
}
- private Path buildCf(Path inputJar) throws Exception {
- Path cfJar = temp.getRoot().toPath().resolve("r8cf.jar");
- build(inputJar, new ArchiveConsumer(cfJar));
- return cfJar;
- }
-
@Test
public void testRingBuffer() throws Exception {
// This test hits the case where we simplify a DebugLocalWrite v'(x) <- v
// with debug use [live: y], and y is written between v and v'.
// In this case we must not move [live: y] to the definition of v,
// since it causes the live range of y to extend to the entry to the first block.
- test(KotlinRingBufferDump.dump(), KotlinRingBufferDump.CLASS_NAME);
+ test(
+ KotlinRingBufferDump.dump(),
+ KotlinRingBufferDump.CLASS_NAME,
+ builder -> builder.addDontWarn("kotlin.Metadata"));
}
@Test
@@ -56,7 +65,11 @@
test(DebugInfoDump.dump(), DebugInfoDump.CLASS_NAME);
}
- public void test(byte[] bytes, String className) throws Exception {
+ public void test(byte[] bytes, String className) throws Exception {}
+
+ public void test(
+ byte[] bytes, String className, ThrowableConsumer<R8FullTestBuilder> configuration)
+ throws Exception {
String descriptor = 'L' + className.replace('.', '/') + ';';
Path inputJar = buildInput(bytes, descriptor);
ProcessResult runInput = ToolHelper.runJava(inputJar, className);
@@ -64,26 +77,18 @@
System.out.println(runInput);
}
assertEquals(0, runInput.exitCode);
- Path outCf = buildCf(inputJar);
- ProcessResult runCf = ToolHelper.runJava(outCf, className);
- assertEquals(runInput.toString(), runCf.toString());
- }
- private void build(Path inputJar, ProgramConsumer consumer) throws Exception {
- Builder builder =
- R8Command.builder()
- .setMode(CompilationMode.DEBUG)
- .setDisableTreeShaking(true)
- .setDisableMinification(true)
- .addProguardConfiguration(
- ImmutableList.of("-keepattributes SourceFile,LineNumberTable"), Origin.unknown())
- .setProgramConsumer(consumer)
- .addProgramFiles(inputJar);
- if ((consumer instanceof ClassFileConsumer)) {
- builder.addLibraryFiles(ToolHelper.getJava8RuntimeJar());
- } else {
- builder.addLibraryFiles(ToolHelper.getAndroidJar(ToolHelper.getMinApiLevelForDexVm()));
- }
- ToolHelper.runR8(builder.build(), options -> options.invalidDebugInfoFatal = true);
+ testForR8(parameters.getBackend())
+ .addProgramFiles(inputJar)
+ .addKeepAttributeLineNumberTable()
+ .addKeepAttributeSourceFile()
+ .addOptionsModification(options -> options.invalidDebugInfoFatal = true)
+ .apply(configuration)
+ .debug()
+ .noMinification()
+ .noTreeShaking()
+ .compile()
+ .run(parameters.getRuntime(), className)
+ .assertSuccessWithOutput(runInput.stdout);
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
index b38eac1..db361d4 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/ConcurrentHashMapFileSerializationTest.java
@@ -94,6 +94,7 @@
chmTest();
}
+ @SuppressWarnings("unchecked")
private static void chmTest() throws IOException, ClassNotFoundException {
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put("k1", "v1");
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/MyMapFileSerializationTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/MyMapFileSerializationTest.java
index 623cfd0..42844c1 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/MyMapFileSerializationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/gson/MyMapFileSerializationTest.java
@@ -88,6 +88,8 @@
@SuppressWarnings("MismatchedQueryAndUpdateOfCollection")
static class Executor {
+
+ @SuppressWarnings("unchecked")
public static void main(String[] args) throws Exception {
MyMap<String, String> map = new MyMap<>();
map.put("k1", "v1");
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java
index 2c62b8f..6a69902 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11MathTests.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
import static com.android.tools.r8.utils.FileUtils.JAVA_EXTENSION;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -114,6 +115,7 @@
.addKeepMainRule(EXACTARITH)
.addProgramFiles(JDK_11_MATH_TEST_CLASS_FILES)
.addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), EXACTARITH)
.assertSuccessWithOutput("");
@@ -126,6 +128,7 @@
.addKeepMainRule(EXACTARITH)
.addProgramFiles(JDK_11_MATH_TEST_CLASS_FILES)
.addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), DIVMOD)
.assertSuccessWithOutput("");
@@ -137,6 +140,7 @@
.addProgramFiles(JDK_11_STRICT_MATH_TEST_CLASS_FILES)
.addKeepMainRule(EXACTARITH)
.addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), EXACTARITH)
.assertSuccessWithOutput("");
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11ObjectsTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11ObjectsTests.java
index c49e10c..f4bcceb 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11ObjectsTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11ObjectsTests.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.utils.FileUtils.CLASS_EXTENSION;
import static com.android.tools.r8.utils.FileUtils.JAVA_EXTENSION;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -81,6 +82,7 @@
.addLibraryFiles(libraryJar)
.addKeepMainRule(BASIC_OBJECTS_TEST)
.addProgramFiles(JDK_11_OBJECTS_TEST_CLASS_FILES)
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.setMinApi(parameters.getRuntime())
.run(parameters.getRuntime(), BASIC_OBJECTS_TEST)
.assertSuccessWithOutput("");
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java
index 8a37cd0..68f3fcf 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/FullNestOnProgramPathTest.java
@@ -17,12 +17,15 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.D8TestCompileResult;
+import com.android.tools.r8.Jdk9TestUtils;
+import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ThrowableConsumer;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -108,6 +111,7 @@
.setMinApi(parameters.getApiLevel())
.addProgramFiles(classesOfNest(nestID))
.addOptionsModification(options -> options.enableNestReduction = false)
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.compile()
.run(parameters.getRuntime(), getMainClass(nestID))
.assertSuccessWithOutput(getExpectedResult(nestID));
@@ -135,9 +139,16 @@
.compile();
}
- private static R8TestCompileResult compileAllNestsR8(Backend backend, AndroidApiLevel minApi)
+ static R8TestCompileResult compileAllNestsR8(Backend backend, AndroidApiLevel minApi)
+ throws CompilationFailedException {
+ return compileAllNestsR8(backend, minApi, null);
+ }
+
+ static R8TestCompileResult compileAllNestsR8(
+ Backend backend, AndroidApiLevel minApi, ThrowableConsumer<R8FullTestBuilder> configuration)
throws CompilationFailedException {
return testForR8(getStaticTemp(), backend)
+ .apply(configuration)
.noTreeShaking()
.noMinification()
.addKeepAllAttributes()
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8BootstrapTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8BootstrapTest.java
index a756d95..1eac80e 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8BootstrapTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8BootstrapTest.java
@@ -8,6 +8,7 @@
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertTrue;
+import com.android.tools.r8.Jdk11TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -66,6 +67,7 @@
// Shrink R8 11 with R8
return testForR8(TestBase.getStaticTemp(), Backend.CF)
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_11_JAR)
+ .addLibraryFiles(Jdk11TestUtils.getJdk11LibraryFiles(getStaticTemp()))
.addKeepRuleFiles(MAIN_KEEP)
.applyIf(
desugar,
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
index f47e524..cb549f5 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/Java11R8CompilationTest.java
@@ -31,8 +31,8 @@
@Parameters(name = "{0}")
public static TestParametersCollection data() {
return getTestParameters()
- // Use of APIs, such as java.util.functions.* are only available from 24+
- .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+ // Use of APIs, such as java.nio.file.* are only available from 26+.
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.O)
.withDexRuntimes()
.build();
}
@@ -50,11 +50,6 @@
.setMinApi(parameters.getApiLevel())
.addProgramFiles(ToolHelper.R8_WITH_RELOCATED_DEPS_11_JAR)
.addKeepRuleFiles(MAIN_KEEP)
- // TODO(b/177967938): Investigate why this is needed.
- .applyIf(
- parameters.getApiLevel().isLessThan(AndroidApiLevel.O),
- builder -> builder.addDontWarnJavaLangInvoke().addDontWarnJavaNioFile())
- .addOptionsModification(opt -> opt.ignoreMissingClasses = true)
.compile()
.inspect(this::assertNotEmpty)
.inspect(Java11R8CompilationTest::assertNoNests);
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
index 6557f52..b38e710 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/MinimumNumberOfBridgesGenerated.java
@@ -7,6 +7,7 @@
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.getMainClass;
import static org.junit.Assert.assertEquals;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -51,8 +52,11 @@
.apply(parameters.getApiLevel())
.inspect(this::assertOnlyRequiredBridges);
}
- FullNestOnProgramPathTest.r8CompilationResult
- .apply(parameters.getBackend(), parameters.getApiLevel())
+ FullNestOnProgramPathTest.compileAllNestsR8(
+ parameters.getBackend(),
+ parameters.getApiLevel(),
+ builder ->
+ builder.applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp)))
.inspect(this::assertOnlyRequiredBridges);
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java
index aa22447..f1884e9 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestAttributesUpdateTest.java
@@ -11,6 +11,7 @@
import static junit.framework.TestCase.assertSame;
import static junit.framework.TestCase.assertTrue;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -94,6 +95,7 @@
options.enableClassInlining = false;
})
.addProgramFiles(classesMatching(outerNestName))
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.addInliningAnnotations()
.compile()
.inspect(
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestClassMergingTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestClassMergingTest.java
index 9a188cf..073c7b1 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestClassMergingTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestClassMergingTest.java
@@ -3,6 +3,7 @@
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.PACKAGE_NAME;
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.classesMatching;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestBase;
@@ -97,6 +98,7 @@
})
.enableInliningAnnotations()
.addProgramFiles(bothNestsAndOutsideClassToCompile)
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.compile()
.inspect(NestAttributesUpdateTest::assertNestAttributesCorrect);
for (int i = 0; i < mainClasses.length; i++) {
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
index 78904fd..c6df029 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestCompilationExceptionTest.java
@@ -12,23 +12,23 @@
import static org.hamcrest.core.StringContains.containsString;
import static org.hamcrest.core.StringEndsWith.endsWith;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestCompileResult;
import com.android.tools.r8.TestCompilerBuilder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.diagnostic.internal.MissingDefinitionsDiagnosticImpl;
import com.android.tools.r8.errors.IncompleteNestNestDesugarDiagnosic;
import com.android.tools.r8.errors.InterfaceDesugarMissingTypeDiagnostic;
import com.android.tools.r8.errors.MissingNestHostNestDesugarDiagnostic;
+import com.android.tools.r8.references.Reference;
import java.nio.file.Path;
import java.util.List;
import org.hamcrest.Matcher;
@@ -95,7 +95,7 @@
.addKeepAllAttributes()
.setMinApi(parameters.getApiLevel())
.addProgramFiles(matchingClasses)
- .addLibraryFiles(ToolHelper.getMostRecentAndroidJar())
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.addOptionsModification(
options -> {
options.ignoreMissingClasses = ignoreMissingClasses;
@@ -128,14 +128,14 @@
} else {
diagnostics
.assertOnlyErrors()
- .assertErrorsMatch(diagnosticType(MissingDefinitionsDiagnosticImpl.class));
-
- MissingDefinitionsDiagnosticImpl diagnostic =
- (MissingDefinitionsDiagnosticImpl) diagnostics.getErrors().get(0);
- assertEquals(1, diagnostic.getMissingClasses().size());
- assertEquals(
- "nesthostexample.BasicNestHostWithInnerClassMethods",
- diagnostic.getMissingClasses().iterator().next().getTypeName());
+ .inspectErrors(
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .assertIsMissingClass(
+ Reference.classFromTypeName(
+ "nesthostexample.BasicNestHostWithInnerClassMethods"))
+ .assertNumberOfMissingClasses(1));
}
});
} catch (CompilationFailedException e) {
@@ -167,14 +167,14 @@
} else {
diagnostics
.assertOnlyErrors()
- .assertErrorsMatch(diagnosticType(MissingDefinitionsDiagnosticImpl.class));
-
- MissingDefinitionsDiagnosticImpl diagnostic =
- (MissingDefinitionsDiagnosticImpl) diagnostics.getErrors().get(0);
- assertEquals(1, diagnostic.getMissingClasses().size());
- assertEquals(
- "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass",
- diagnostic.getMissingClasses().iterator().next().getTypeName());
+ .inspectErrors(
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .assertIsMissingClass(
+ Reference.classFromTypeName(
+ "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass"))
+ .assertNumberOfMissingClasses(1));
}
});
} catch (Exception e) {
@@ -208,13 +208,15 @@
diagnosticType(MissingDefinitionsDiagnosticImpl.class),
diagnosticType(InterfaceDesugarMissingTypeDiagnostic.class));
}
-
- MissingDefinitionsDiagnosticImpl diagnostic =
- (MissingDefinitionsDiagnosticImpl) diagnostics.getWarnings().get(0);
- assertEquals(1, diagnostic.getMissingClasses().size());
- assertEquals(
- "nesthostexample.BasicNestHostWithInnerClassMethods",
- diagnostic.getMissingClasses().iterator().next().getTypeName());
+ diagnostics.inspectWarning(
+ 0,
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .assertIsMissingClass(
+ Reference.classFromTypeName(
+ "nesthostexample.BasicNestHostWithInnerClassMethods"))
+ .assertNumberOfMissingClasses(1));
});
}
}
@@ -242,14 +244,15 @@
diagnosticType(MissingDefinitionsDiagnosticImpl.class),
diagnosticType(InterfaceDesugarMissingTypeDiagnostic.class));
}
-
- MissingDefinitionsDiagnosticImpl diagnostic =
- (MissingDefinitionsDiagnosticImpl) diagnostics.getWarnings().get(0);
- assertNotNull(diagnostic);
- assertEquals(1, diagnostic.getMissingClasses().size());
- assertEquals(
- "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass",
- diagnostic.getMissingClasses().iterator().next().getTypeName());
+ diagnostics.inspectWarning(
+ 0,
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .assertIsMissingClass(
+ Reference.classFromTypeName(
+ "nesthostexample.BasicNestHostWithInnerClassMethods$BasicNestedClass"))
+ .assertNumberOfMissingClasses(1));
});
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java
index 85bade9..b216639 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestConstructorRemovedArgTest.java
@@ -8,6 +8,7 @@
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.getExpectedResult;
import static com.android.tools.r8.desugar.nestaccesscontrol.NestAccessControlTestUtils.getMainClass;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -44,11 +45,9 @@
.addKeepMainRule(getMainClass(nestID))
.noMinification()
.setMinApi(parameters.getApiLevel())
- .addOptionsModification(
- options -> {
- options.enableClassInlining = false;
- })
+ .addOptionsModification(options -> options.enableClassInlining = false)
.addProgramFiles(classesOfNest(nestID))
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.compile()
.run(parameters.getRuntime(), getMainClass(nestID))
.assertSuccessWithOutput(getExpectedResult(nestID));
@@ -62,11 +61,9 @@
.addKeepMainRule(getMainClass(nestID))
.noMinification()
.setMinApi(parameters.getApiLevel())
- .addOptionsModification(
- options -> {
- options.enableClassInlining = false;
- })
+ .addOptionsModification(options -> options.enableClassInlining = false)
.addProgramFiles(classesOfNest(nestID))
+ .applyIf(parameters.isCfRuntime(), Jdk9TestUtils.addJdk9LibraryFiles(temp))
.compile()
.run(parameters.getRuntime(), getMainClass(nestID))
.assertSuccessWithOutput(getExpectedResult(nestID));
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java b/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
index 245607b..3a0a306 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordTestUtils.java
@@ -52,6 +52,7 @@
JavaCompilerTool.create(getCheckedInJdk8(), temp)
.addSourceFiles(Paths.get("src", "test", "javaStubs", "Record.java"))
.addSourceFiles(Paths.get("src", "test", "javaStubs", "ObjectMethods.java"))
+ .addSourceFiles(Paths.get("src", "test", "javaStubs", "StringConcatFactory.java"))
.addSourceFiles(Paths.get("src", "test", "javaStubs", "TypeDescriptor.java"))
.addSourceFiles(Paths.get("src", "test", "javaStubs", "RecordComponent.java"))
.compile();
diff --git a/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java b/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
index 6d97f29..e6d1444 100644
--- a/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/records/RecordWithMembersTest.java
@@ -6,6 +6,7 @@
import static com.android.tools.r8.desugar.records.RecordTestUtils.RECORD_KEEP_RULE;
+import com.android.tools.r8.Jdk9TestUtils;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime.CfRuntime;
@@ -54,6 +55,7 @@
Path output =
testForR8(parameters.getBackend())
.addProgramClassFileData(PROGRAM_DATA)
+ .addLibraryFiles(Jdk9TestUtils.getJdk9LibraryFiles(temp))
.setMinApi(parameters.getApiLevel())
.addKeepRules(RECORD_KEEP_RULE)
.addKeepMainRule(MAIN_TYPE)
diff --git a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java
index 0ef3bdf..e90e0ab 100644
--- a/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java
+++ b/src/test/java/com/android/tools/r8/dexsplitter/DexSplitterTests.java
@@ -52,6 +52,7 @@
private static final String CLASS2_CLASS = CLASS_DIR + "/Class2.class";
private static final String CLASS3_CLASS = CLASS_DIR + "/Class3.class";
private static final String CLASS3_INNER_CLASS = CLASS_DIR + "/Class3$InnerClass.class";
+ private static final String CLASS3_SYNTHETIC_CLASS = CLASS_DIR + "/Class3$1.class";
private static final String CLASS4_CLASS = CLASS_DIR + "/Class4.class";
private static final String CLASS4_LAMBDA_INTERFACE = CLASS_DIR + "/Class4$LambdaInterface.class";
private static final String TEXT_FILE =
@@ -71,6 +72,7 @@
.addProgramFiles(Paths.get(CLASS2_CLASS))
.addProgramFiles(Paths.get(CLASS3_CLASS))
.addProgramFiles(Paths.get(CLASS3_INNER_CLASS))
+ .addProgramFiles(Paths.get(CLASS3_SYNTHETIC_CLASS))
.addProgramFiles(Paths.get(CLASS4_CLASS))
.addProgramFiles(Paths.get(CLASS4_LAMBDA_INTERFACE))
.build();
@@ -264,6 +266,10 @@
featureStream.putNextEntry(new ZipEntry(name));
featureStream.write(Files.readAllBytes(Paths.get(CLASS3_INNER_CLASS)));
featureStream.closeEntry();
+ name = "dexsplitsample/Class3$1.class";
+ featureStream.putNextEntry(new ZipEntry(name));
+ featureStream.write(Files.readAllBytes(Paths.get(CLASS3_SYNTHETIC_CLASS)));
+ featureStream.closeEntry();
name = "dexsplitsample/Class4";
featureStream.putNextEntry(new ZipEntry(name));
featureStream.write(Files.readAllBytes(Paths.get(CLASS4_CLASS)));
@@ -325,6 +331,7 @@
.addProgramFiles(Paths.get(CLASS2_CLASS))
.addProgramFiles(Paths.get(CLASS3_CLASS))
.addProgramFiles(Paths.get(CLASS3_INNER_CLASS))
+ .addProgramFiles(Paths.get(CLASS3_SYNTHETIC_CLASS))
.addProgramFiles(Paths.get(CLASS4_CLASS))
.addProgramFiles(Paths.get(CLASS4_LAMBDA_INTERFACE))
.addLibraryFiles(ToolHelper.getDefaultAndroidJar())
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/AbsentDiagnosticSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/AbsentDiagnosticSubject.java
new file mode 100644
index 0000000..f94c8f4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/AbsentDiagnosticSubject.java
@@ -0,0 +1,17 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnosticinspector;
+
+import static org.junit.Assert.fail;
+
+import com.android.tools.r8.errors.Unreachable;
+
+public class AbsentDiagnosticSubject implements DiagnosticSubject {
+ @Override
+ public FoundMissingDefinitionsDiagnosticSubject assertIsMissingDefinitionsDiagnostic() {
+ fail("Expected MissingDefinitionsDiagnostic, but was absent");
+ throw new Unreachable();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/DiagnosticSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/DiagnosticSubject.java
new file mode 100644
index 0000000..f7123eb
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/DiagnosticSubject.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnosticinspector;
+
+public interface DiagnosticSubject {
+
+ FoundMissingDefinitionsDiagnosticSubject assertIsMissingDefinitionsDiagnostic();
+}
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundDiagnosticSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundDiagnosticSubject.java
new file mode 100644
index 0000000..427bef0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundDiagnosticSubject.java
@@ -0,0 +1,30 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnosticinspector;
+
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.Diagnostic;
+import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
+
+public class FoundDiagnosticSubject<D extends Diagnostic> implements DiagnosticSubject {
+
+ private final D diagnostic;
+
+ public FoundDiagnosticSubject(D diagnostic) {
+ this.diagnostic = diagnostic;
+ }
+
+ public D getDiagnostic() {
+ return diagnostic;
+ }
+
+ @Override
+ public FoundMissingDefinitionsDiagnosticSubject assertIsMissingDefinitionsDiagnostic() {
+ assertThat(diagnostic, diagnosticType(MissingDefinitionsDiagnostic.class));
+ return new FoundMissingDefinitionsDiagnosticSubject((MissingDefinitionsDiagnostic) diagnostic);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java
new file mode 100644
index 0000000..4178db4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionContextSubject.java
@@ -0,0 +1,44 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnosticinspector;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionClassContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionFieldContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionMethodContext;
+
+public class FoundMissingDefinitionContextSubject {
+
+ private final MissingDefinitionContext context;
+
+ public FoundMissingDefinitionContextSubject(MissingDefinitionContext context) {
+ this.context = context;
+ }
+
+ public FoundMissingDefinitionContextSubject assertEqualTo(
+ MissingDefinitionClassContext expectedContext) {
+ assertTrue(context.isClassContext());
+ assertEquals(expectedContext.getClassReference(), context.asClassContext().getClassReference());
+ return this;
+ }
+
+ public FoundMissingDefinitionContextSubject assertEqualTo(
+ MissingDefinitionFieldContext expectedContext) {
+ assertTrue(context.isFieldContext());
+ assertEquals(expectedContext.getFieldReference(), context.asFieldContext().getFieldReference());
+ return this;
+ }
+
+ public FoundMissingDefinitionContextSubject assertEqualTo(
+ MissingDefinitionMethodContext expectedContext) {
+ assertTrue(context.isMethodContext());
+ assertEquals(
+ expectedContext.getMethodReference(), context.asMethodContext().getMethodReference());
+ return this;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java
new file mode 100644
index 0000000..89a5db5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionInfoSubject.java
@@ -0,0 +1,80 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnosticinspector;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionContextUtils;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.FieldReference;
+import com.android.tools.r8.references.MethodReference;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FoundMissingDefinitionInfoSubject {
+
+ private final MissingDefinitionInfo missingDefinitionInfo;
+
+ private final Map<ClassReference, FoundMissingDefinitionContextSubject> classContexts =
+ new HashMap<>();
+ private final Map<FieldReference, FoundMissingDefinitionContextSubject> fieldContexts =
+ new HashMap<>();
+ private final Map<MethodReference, FoundMissingDefinitionContextSubject> methodContexts =
+ new HashMap<>();
+
+ public FoundMissingDefinitionInfoSubject(MissingDefinitionInfo missingDefinitionInfo) {
+ this.missingDefinitionInfo = missingDefinitionInfo;
+ missingDefinitionInfo
+ .getReferencedFromContexts()
+ .forEach(
+ context ->
+ MissingDefinitionContextUtils.accept(
+ context,
+ classContext ->
+ classContexts.put(
+ classContext.getClassReference(),
+ new FoundMissingDefinitionContextSubject(context)),
+ fieldContext ->
+ fieldContexts.put(
+ fieldContext.getFieldReference(),
+ new FoundMissingDefinitionContextSubject(context)),
+ methodContext ->
+ methodContexts.put(
+ methodContext.getMethodReference(),
+ new FoundMissingDefinitionContextSubject(context))));
+ }
+
+ public FoundMissingDefinitionInfoSubject assertExactContexts(
+ List<MissingDefinitionContext> expectedContexts) {
+ assertEquals(expectedContexts.size(), missingDefinitionInfo.getReferencedFromContexts().size());
+ expectedContexts.forEach(
+ expectedContext ->
+ MissingDefinitionContextUtils.accept(
+ expectedContext,
+ expectedClassContext -> {
+ FoundMissingDefinitionContextSubject subject =
+ classContexts.get(expectedClassContext.getClassReference());
+ assertNotNull(subject);
+ subject.assertEqualTo(expectedClassContext);
+ },
+ expectedFieldContext -> {
+ FoundMissingDefinitionContextSubject subject =
+ fieldContexts.get(expectedFieldContext.getFieldReference());
+ assertNotNull(subject);
+ subject.assertEqualTo(expectedFieldContext);
+ },
+ expectedMethodContext -> {
+ FoundMissingDefinitionContextSubject subject =
+ methodContexts.get(expectedMethodContext.getMethodReference());
+ assertNotNull(subject);
+ subject.assertEqualTo(expectedMethodContext);
+ }));
+ return this;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java
new file mode 100644
index 0000000..84e3f4b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/diagnosticinspector/FoundMissingDefinitionsDiagnosticSubject.java
@@ -0,0 +1,96 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.diagnosticinspector;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingClassInfo;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.MissingDefinitionInfo;
+import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.Reference;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FoundMissingDefinitionsDiagnosticSubject
+ extends FoundDiagnosticSubject<MissingDefinitionsDiagnostic> {
+
+ private final Map<ClassReference, MissingClassInfo> missingClasses = new HashMap<>();
+
+ public FoundMissingDefinitionsDiagnosticSubject(MissingDefinitionsDiagnostic diagnostic) {
+ super(diagnostic);
+ diagnostic.getMissingDefinitions().stream()
+ .filter(MissingDefinitionInfo::isMissingClass)
+ .map(MissingDefinitionInfo::asMissingClass)
+ .forEach(
+ missingClassInfo ->
+ missingClasses.put(missingClassInfo.getClassReference(), missingClassInfo));
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject assertHasMessage(String expectedMessage) {
+ assertEquals(expectedMessage, getDiagnostic().getDiagnosticMessage());
+ return this;
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject assertIsMissingClass(Class<?> clazz) {
+ return assertIsMissingClass(Reference.classFromClass(clazz));
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject assertIsMissingClass(
+ ClassReference classReference) {
+ assertTrue(missingClasses.containsKey(classReference));
+ return this;
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject assertIsMissingClassWithExactContexts(
+ ClassReference classReference, MissingDefinitionContext... expectedContexts) {
+ return assertIsMissingClassWithExactContexts(classReference, Arrays.asList(expectedContexts));
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject assertIsMissingClassWithExactContexts(
+ ClassReference classReference, List<MissingDefinitionContext> expectedContexts) {
+ return inspectMissingClassInfo(
+ classReference,
+ missingClassInfoSubject -> missingClassInfoSubject.assertExactContexts(expectedContexts));
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject assertNumberOfMissingClasses(int expected) {
+ assertEquals(expected, getDiagnostic().getMissingDefinitions().size());
+ return this;
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject applyIf(
+ boolean condition, ThrowableConsumer<FoundMissingDefinitionsDiagnosticSubject> thenConsumer) {
+ return applyIf(condition, thenConsumer, ThrowableConsumer.empty());
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject applyIf(
+ boolean condition,
+ ThrowableConsumer<FoundMissingDefinitionsDiagnosticSubject> thenConsumer,
+ ThrowableConsumer<FoundMissingDefinitionsDiagnosticSubject> elseConsumer) {
+ if (condition) {
+ thenConsumer.acceptWithRuntimeException(this);
+ } else {
+ elseConsumer.acceptWithRuntimeException(this);
+ }
+ return this;
+ }
+
+ public FoundMissingDefinitionsDiagnosticSubject inspectMissingClassInfo(
+ ClassReference classReference,
+ ThrowableConsumer<FoundMissingDefinitionInfoSubject> inspector) {
+ MissingDefinitionInfo missingDefinitionInfo = missingClasses.get(classReference);
+ assertNotNull(missingDefinitionInfo);
+ inspector.acceptWithRuntimeException(
+ new FoundMissingDefinitionInfoSubject(missingDefinitionInfo));
+ return this;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java b/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
index 0011245..2d1be5b 100644
--- a/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/graph/GenericSignatureTest.java
@@ -11,9 +11,11 @@
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.D8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.GenericSignature.ClassSignature;
import com.android.tools.r8.graph.GenericSignature.ClassTypeSignature;
import com.android.tools.r8.graph.GenericSignature.FieldTypeSignature;
@@ -56,7 +58,7 @@
@Test
public void test() throws Exception {
- AndroidApp app =
+ D8TestCompileResult compileResult =
testForD8(parameters.getBackend())
.debug()
.addProgramClassesAndInnerClasses(
@@ -65,8 +67,14 @@
GenericSignatureTestClassCY.class,
GenericSignatureTestClassCYY.class)
.setMinApi(parameters.getApiLevel())
- .compile()
- .app;
+ .compile();
+ AndroidApp app =
+ AndroidApp.builder(compileResult.getApp())
+ .addLibraryFile(
+ parameters.isCfRuntime()
+ ? ToolHelper.getJava8RuntimeJar()
+ : ToolHelper.getMostRecentAndroidJar())
+ .build();
AppView<AppInfoWithLiveness> appView = computeAppViewWithLiveness(app);
DexItemFactory factory = appView.dexItemFactory();
CodeInspector inspector = new CodeInspector(appView.appInfo().app());
diff --git a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
index 2eb88a1..5526415 100644
--- a/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/graph/MissingClassThrowingTest.java
@@ -4,8 +4,6 @@
package com.android.tools.r8.graph;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
-import static org.junit.Assert.assertEquals;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.NoHorizontalClassMerging;
@@ -13,7 +11,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime.CfVm;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionsDiagnosticImpl;
import com.android.tools.r8.utils.InternalOptions.TestingOptions;
import com.android.tools.r8.utils.codeinspector.AssertUtils;
import java.io.IOException;
@@ -82,15 +79,12 @@
diagnostics -> {
diagnostics
.assertOnlyErrors()
- .assertErrorsMatch(
- diagnosticType(MissingDefinitionsDiagnosticImpl.class));
-
- MissingDefinitionsDiagnosticImpl diagnostic =
- (MissingDefinitionsDiagnosticImpl) diagnostics.getErrors().get(0);
- assertEquals(1, diagnostic.getMissingClasses().size());
- assertEquals(
- MissingException.class.getTypeName(),
- diagnostic.getMissingClasses().iterator().next().getTypeName());
+ .inspectErrors(
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .assertIsMissingClass(MissingException.class)
+ .assertNumberOfMissingClasses(1));
}));
}
}
diff --git a/src/test/java/com/android/tools/r8/internal/Regression127524985.java b/src/test/java/com/android/tools/r8/internal/Regression127524985.java
index 5fb64ea..4af8640 100644
--- a/src/test/java/com/android/tools/r8/internal/Regression127524985.java
+++ b/src/test/java/com/android/tools/r8/internal/Regression127524985.java
@@ -50,7 +50,7 @@
.noTreeShaking()
.noMinification()
.addKeepAllAttributes()
- .addKeepRules("-dontwarn *"))
+ .addKeepRules("-dontwarn"))
.addProgramFiles(JAR)
.setMinApi(parameters.getRuntime())
.compile()
diff --git a/src/test/java/com/android/tools/r8/ir/InlineTest.java b/src/test/java/com/android/tools/r8/ir/InlineTest.java
index c141654..909a929 100644
--- a/src/test/java/com/android/tools/r8/ir/InlineTest.java
+++ b/src/test/java/com/android/tools/r8/ir/InlineTest.java
@@ -4,11 +4,13 @@
package com.android.tools.r8.ir;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.DexIndexedConsumer;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.dex.ApplicationReader;
import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
import com.android.tools.r8.graph.AppServices;
import com.android.tools.r8.graph.AppView;
@@ -19,6 +21,7 @@
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.Enqueuer;
import com.android.tools.r8.shaking.EnqueuerFactory;
import com.android.tools.r8.shaking.EnqueuerResult;
@@ -27,6 +30,7 @@
import com.android.tools.r8.shaking.RootSetUtils.RootSet;
import com.android.tools.r8.smali.SmaliBuilder;
import com.android.tools.r8.smali.SmaliBuilder.MethodSignature;
+import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.Reporter;
import com.android.tools.r8.utils.ThreadUtils;
@@ -34,6 +38,7 @@
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
+import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@@ -41,6 +46,7 @@
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
+import org.antlr.runtime.RecognitionException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -446,6 +452,19 @@
application, options, methodSubject, ImmutableList.of(codeA, codeB));
}
+ protected DexApplication buildApplication(SmaliBuilder builder, InternalOptions options) {
+ try {
+ AndroidApp app =
+ AndroidApp.builder()
+ .addDexProgramData(builder.compile(), Origin.unknown())
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build();
+ return new ApplicationReader(app, options, Timing.empty()).read();
+ } catch (IOException | RecognitionException | ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
private void runInlineCallerHasCatchHandlersTest(
int a, int b, boolean twoGuards, int expectedA, int expectedB) throws Exception {
// Run code without inlining.
diff --git a/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java b/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
index 55fcc74..328f9ff 100644
--- a/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/IrInjectionTestBase.java
@@ -30,14 +30,6 @@
public class IrInjectionTestBase extends SmaliTestBase {
- protected DexApplication buildApplication(SmaliBuilder builder, InternalOptions options) {
- try {
- return new ApplicationReader(builder.build(), options, Timing.empty()).read();
- } catch (IOException | RecognitionException | ExecutionException e) {
- throw new RuntimeException(e);
- }
- }
-
protected MethodSubject getMethodSubject(DexApplication application, MethodSignature signature) {
return getMethodSubject(
application,
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java b/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
index 6f24c38..a015fd9 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/AnalysisTestBase.java
@@ -6,6 +6,7 @@
import static org.junit.Assert.fail;
+import com.android.tools.r8.D8TestCompileResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.graph.AppView;
@@ -21,33 +22,60 @@
public abstract class AnalysisTestBase extends TestBase {
- protected final TestParameters parameters;
+ public AppView<?> appView;
private final AndroidApp app;
private final String className;
-
- public AppView<?> appView;
+ protected final TestParameters parameters;
public AnalysisTestBase(TestParameters parameters, Class<?> clazz) throws Exception {
+ if (parameters.isCfRuntime()) {
+ this.app =
+ buildClassesWithTestingAnnotations(clazz)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build();
+ } else {
+ D8TestCompileResult compileResult =
+ testForD8()
+ .release()
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClasses(clazz)
+ .addTestingAnnotationsAsProgramClasses()
+ .compile();
+ this.app =
+ AndroidApp.builder(compileResult.getApp())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build();
+ }
this.parameters = parameters;
- this.app =
- testForD8()
- .release()
- .setMinApi(parameters.getRuntime())
- .addProgramClasses(clazz)
- .compile()
- .app;
this.className = clazz.getTypeName();
}
+ public AnalysisTestBase(TestParameters parameters, Class<?> mainClass, Class<?>... classes)
+ throws Exception {
+ this(parameters, mainClass.getTypeName(), classes);
+ }
+
public AnalysisTestBase(
TestParameters parameters, String mainClassName, Class<?>... classes) throws Exception {
+ if (parameters.isCfRuntime()) {
+ this.app =
+ buildClassesWithTestingAnnotations(classes)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build();
+ } else {
+ D8TestCompileResult compileResult =
+ testForD8()
+ .release()
+ .setMinApi(parameters.getApiLevel())
+ .addProgramClasses(classes)
+ .addTestingAnnotationsAsProgramClasses()
+ .compile();
+ this.app =
+ AndroidApp.builder(compileResult.getApp())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build();
+ }
this.parameters = parameters;
- this.app =
- testForD8()
- .addProgramClasses(classes)
- .setMinApi(parameters.getRuntime())
- .compile()
- .app;
this.className = mainClassName;
}
@@ -67,7 +95,7 @@
public void buildAndCheckIR(String methodName, Consumer<IRCode> irInspector) {
CodeInspector inspector = new CodeInspector(appView.appInfo().app());
MethodSubject methodSubject = inspector.clazz(className).uniqueMethodWithName(methodName);
- irInspector.accept(methodSubject.buildIR());
+ irInspector.accept(methodSubject.buildIR(appView));
}
@SuppressWarnings("unchecked")
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/DeterminismAnalysisTest.java b/src/test/java/com/android/tools/r8/ir/analysis/DeterminismAnalysisTest.java
index 5bd8472..48e0c20 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/DeterminismAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/DeterminismAnalysisTest.java
@@ -18,7 +18,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public DeterminismAnalysisTest(TestParameters parameters) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/escape/EscapeAnalysisForNameReflectionTest.java b/src/test/java/com/android/tools/r8/ir/analysis/escape/EscapeAnalysisForNameReflectionTest.java
index 9362432..408e8d1 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/escape/EscapeAnalysisForNameReflectionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/escape/EscapeAnalysisForNameReflectionTest.java
@@ -34,7 +34,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public EscapeAnalysisForNameReflectionTest(TestParameters parameters) throws Exception {
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java
index bdeda3c..dd3e853 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/ArrayTypeTest.java
@@ -30,7 +30,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
}
public ArrayTypeTest(TestParameters parameters) throws Exception {
@@ -38,12 +38,12 @@
}
@Test
- public void testArray() throws Exception {
+ public void testArray() {
buildAndCheckIR("arrayTest", arrayTestInspector());
}
@Test
- public void testNestedArray() throws Exception {
+ public void testNestedArray() {
buildAndCheckIR("nestedArrayTest", nestedArrayTestInspector());
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/ConstrainedPrimitiveTypeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/ConstrainedPrimitiveTypeTest.java
index e421309..44de35e 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/ConstrainedPrimitiveTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/ConstrainedPrimitiveTypeTest.java
@@ -29,11 +29,11 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public ConstrainedPrimitiveTypeTest(TestParameters parameters) throws Exception {
- super(parameters, TestClass.class);
+ super(parameters, TestClass.class, TestClass.class);
}
@Test
@@ -53,42 +53,42 @@
}
@Test
- public void testIntWithInvokeUser() throws Exception {
+ public void testIntWithInvokeUser() {
buildAndCheckIR("intWithInvokeUserTest", testInspector(getInt(), 1));
}
@Test
- public void testIntWithIndirectInvokeUser() throws Exception {
+ public void testIntWithIndirectInvokeUser() {
buildAndCheckIR("intWithIndirectInvokeUserTest", testInspector(getInt(), 2));
}
@Test
- public void testFloatWithInvokeUser() throws Exception {
+ public void testFloatWithInvokeUser() {
buildAndCheckIR("floatWithInvokeUserTest", testInspector(getFloat(), 1));
}
@Test
- public void testFloatWithIndirectInvokeUser() throws Exception {
+ public void testFloatWithIndirectInvokeUser() {
buildAndCheckIR("floatWithIndirectInvokeUserTest", testInspector(getFloat(), 2));
}
@Test
- public void testLongWithInvokeUser() throws Exception {
+ public void testLongWithInvokeUser() {
buildAndCheckIR("longWithInvokeUserTest", testInspector(getLong(), 1));
}
@Test
- public void testLongWithIndirectInvokeUser() throws Exception {
+ public void testLongWithIndirectInvokeUser() {
buildAndCheckIR("longWithIndirectInvokeUserTest", testInspector(getLong(), 2));
}
@Test
- public void testDoubleWithInvokeUser() throws Exception {
+ public void testDoubleWithInvokeUser() {
buildAndCheckIR("doubleWithInvokeUserTest", testInspector(getDouble(), 1));
}
@Test
- public void testDoubleWithIndirectInvokeUser() throws Exception {
+ public void testDoubleWithIndirectInvokeUser() {
buildAndCheckIR("doubleWithIndirectInvokeUserTest", testInspector(getDouble(), 2));
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
index 3a6f0e4..1769dc9 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/NullabilityTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.analysis.type;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
import static com.android.tools.r8.ir.analysis.type.Nullability.maybeNull;
import static com.android.tools.r8.ir.analysis.type.TypeElement.fromDexType;
@@ -11,6 +12,7 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.AppView;
@@ -26,7 +28,6 @@
import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.AssumeInserter;
-import com.android.tools.r8.ir.optimize.NonNullTrackerTestBase;
import com.android.tools.r8.ir.optimize.nonnull.FieldAccessTest;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterArrayAccess;
import com.android.tools.r8.ir.optimize.nonnull.NonNullAfterFieldAccess;
@@ -37,7 +38,9 @@
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import java.util.Collection;
import java.util.Map;
import java.util.function.BiConsumer;
import org.junit.Test;
@@ -46,7 +49,7 @@
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
-public class NullabilityTest extends NonNullTrackerTestBase {
+public class NullabilityTest extends TestBase {
@Parameters(name = "{0}")
public static TestParametersCollection data() {
@@ -58,12 +61,15 @@
}
private void buildAndTest(
+ Collection<Class<?>> classes,
Class<?> mainClass,
MethodSignature signature,
boolean npeCaught,
BiConsumer<AppView<?>, IRCode> inspector)
throws Exception {
- AppView<AppInfoWithLiveness> appView = build(mainClass);
+ AppView<AppInfoWithLiveness> appView =
+ computeAppViewWithLiveness(
+ buildClasses(classes).addLibraryFile(getMostRecentAndroidJar()).build());
CodeInspector codeInspector = new CodeInspector(appView.appInfo().app());
MethodSubject fooSubject = codeInspector.clazz(mainClass.getName()).method(signature);
IRCode irCode = fooSubject.buildIR();
@@ -131,6 +137,7 @@
MethodSignature signature =
new MethodSignature("foo", "int", new String[]{"java.lang.String"});
buildAndTest(
+ ImmutableList.of(NonNullAfterInvoke.class),
NonNullAfterInvoke.class,
signature,
false,
@@ -158,6 +165,7 @@
MethodSignature signature =
new MethodSignature("bar", "int", new String[]{"java.lang.String"});
buildAndTest(
+ ImmutableList.of(NonNullAfterInvoke.class),
NonNullAfterInvoke.class,
signature,
true,
@@ -185,6 +193,7 @@
MethodSignature signature =
new MethodSignature("foo", "int", new String[]{"java.lang.String[]"});
buildAndTest(
+ ImmutableList.of(NonNullAfterArrayAccess.class),
NonNullAfterArrayAccess.class,
signature,
false,
@@ -227,6 +236,7 @@
MethodSignature signature =
new MethodSignature("bar", "int", new String[]{"java.lang.String[]"});
buildAndTest(
+ ImmutableList.of(NonNullAfterArrayAccess.class),
NonNullAfterArrayAccess.class,
signature,
true,
@@ -269,6 +279,7 @@
MethodSignature signature = new MethodSignature("foo", "int",
new String[]{FieldAccessTest.class.getCanonicalName()});
buildAndTest(
+ ImmutableList.of(FieldAccessTest.class, NonNullAfterFieldAccess.class),
NonNullAfterFieldAccess.class,
signature,
false,
@@ -305,6 +316,7 @@
MethodSignature signature = new MethodSignature("bar", "int",
new String[]{FieldAccessTest.class.getCanonicalName()});
buildAndTest(
+ ImmutableList.of(FieldAccessTest.class, NonNullAfterFieldAccess.class),
NonNullAfterFieldAccess.class,
signature,
true,
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeConstraintOnTrivialPhiTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeConstraintOnTrivialPhiTest.java
index 9fb2f9b..609b2c9 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/TypeConstraintOnTrivialPhiTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/TypeConstraintOnTrivialPhiTest.java
@@ -8,11 +8,13 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.ir.analysis.AnalysisTestBase;
import com.android.tools.r8.ir.code.ConstNumber;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.smali.SmaliBuilder;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.StringUtils;
@@ -85,26 +87,29 @@
"goto :label_1");
smaliBuilder.addStaticMethod("void", config.getTestName(), ImmutableList.of("int"), 4, code);
}
- return smaliBuilder.build();
+ return AndroidApp.builder()
+ .addDexProgramData(smaliBuilder.compile(), Origin.unknown())
+ .addLibraryFile(ToolHelper.getMostRecentAndroidJar())
+ .build();
}
@Test
- public void testIntConstraintOnTrivialPhi() throws Exception {
+ public void testIntConstraintOnTrivialPhi() {
buildAndCheckIR("intConstraintOnTrivialPhiTest", testInspector(TypeElement.getInt()));
}
@Test
- public void testFloatConstraintOnTrivialPhi() throws Exception {
+ public void testFloatConstraintOnTrivialPhi() {
buildAndCheckIR("floatConstraintOnTrivialPhiTest", testInspector(TypeElement.getFloat()));
}
@Test
- public void testLongConstraintOnTrivialPhi() throws Exception {
+ public void testLongConstraintOnTrivialPhi() {
buildAndCheckIR("longConstraintOnTrivialPhiTest", testInspector(TypeElement.getLong()));
}
@Test
- public void testDoubleConstraintOnTrivialPhi() throws Exception {
+ public void testDoubleConstraintOnTrivialPhi() {
buildAndCheckIR("doubleConstraintOnTrivialPhiTest", testInspector(TypeElement.getDouble()));
}
diff --git a/src/test/java/com/android/tools/r8/ir/analysis/type/UnconstrainedPrimitiveTypeTest.java b/src/test/java/com/android/tools/r8/ir/analysis/type/UnconstrainedPrimitiveTypeTest.java
index 961827a..d0b9c70 100644
--- a/src/test/java/com/android/tools/r8/ir/analysis/type/UnconstrainedPrimitiveTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/analysis/type/UnconstrainedPrimitiveTypeTest.java
@@ -8,15 +8,16 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ir.analysis.AnalysisTestBase;
import com.android.tools.r8.ir.code.ConstNumber;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.smali.SmaliBuilder;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Streams;
import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -27,7 +28,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public UnconstrainedPrimitiveTypeTest(TestParameters parameters) throws Exception {
@@ -81,32 +82,35 @@
"void", "unconstrainedWideWithIfUserTest", ImmutableList.of(), 4, code);
}
- return smaliBuilder.build();
+ return AndroidApp.builder()
+ .addDexProgramData(smaliBuilder.compile(), Origin.unknown())
+ .addLibraryFile(ToolHelper.getMostRecentAndroidJar())
+ .build();
}
@Test
- public void testUnconstrainedSingleWithNoUsers() throws Exception {
+ public void testUnconstrainedSingleWithNoUsers() {
buildAndCheckIR("unconstrainedSingleWithNoUsersTest", testInspector(TypeElement.getInt(), 1));
}
@Test
- public void testUnconstrainedSingleWithIfUser() throws Exception {
+ public void testUnconstrainedSingleWithIfUser() {
buildAndCheckIR("unconstrainedSingleWithIfUserTest", testInspector(TypeElement.getInt(), 2));
}
@Test
- public void testUnconstrainedSingleWithIfZeroUser() throws Exception {
+ public void testUnconstrainedSingleWithIfZeroUser() {
buildAndCheckIR(
"unconstrainedSingleWithIfZeroUserTest", testInspector(IntTypeElement.getInt(), 1));
}
@Test
- public void testUnconstrainedWideWithNoUsers() throws Exception {
+ public void testUnconstrainedWideWithNoUsers() {
buildAndCheckIR("unconstrainedWideWithNoUsersTest", testInspector(TypeElement.getLong(), 1));
}
@Test
- public void testUnconstrainedWideWithIfUser() throws Exception {
+ public void testUnconstrainedWideWithIfUser() {
buildAndCheckIR("unconstrainedWideWithIfUserTest", testInspector(TypeElement.getLong(), 2));
}
@@ -122,7 +126,7 @@
assertEquals(
expectedNumberOfConstNumberInstructions,
- Streams.stream(code.instructionIterator()).filter(Instruction::isConstNumber).count());
+ code.streamInstructions().filter(Instruction::isConstNumber).count());
};
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java b/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
index 41c5ef5..009d4e3d 100644
--- a/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.conversion;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static com.android.tools.r8.shaking.ProguardConfigurationSourceStrings.createConfigurationForTesting;
import static org.hamcrest.CoreMatchers.hasItem;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -35,7 +36,10 @@
private final ExecutorService executorService;
public PartialCallGraphTest() throws Exception {
- AndroidApp app = testForD8().addProgramClasses(TestClass.class).compile().app;
+ AndroidApp app =
+ AndroidApp.builder(testForD8().addProgramClasses(TestClass.class).compile().getApp())
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build();
this.appView =
computeAppViewWithLiveness(
app,
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
index f5431bb..19ff50d 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTest.java
@@ -3,10 +3,12 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.graph.AppView;
@@ -25,6 +27,8 @@
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -32,7 +36,7 @@
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
-public class NonNullTrackerTest extends NonNullTrackerTestBase {
+public class NonNullTrackerTest extends TestBase {
@Parameters(name = "{0}")
public static TestParametersCollection data() {
@@ -44,12 +48,15 @@
}
private void buildAndTest(
+ List<Class<?>> classes,
Class<?> testClass,
MethodSignature signature,
int expectedNumberOfNonNull,
Consumer<IRCode> testAugmentedIRCode)
throws Exception {
- AppView<AppInfoWithLiveness> appView = build(testClass);
+ AppView<AppInfoWithLiveness> appView =
+ computeAppViewWithLiveness(
+ buildClasses(classes).addLibraryFile(getMostRecentAndroidJar()).build());
CodeInspector codeInspector = new CodeInspector(appView.appInfo().app());
MethodSubject fooSubject = codeInspector.clazz(testClass.getName()).method(signature);
IRCode code = fooSubject.buildIR();
@@ -127,31 +134,56 @@
public void nonNullAfterSafeInvokes() throws Exception {
MethodSignature foo =
new MethodSignature("foo", "int", new String[]{"java.lang.String"});
- buildAndTest(NonNullAfterInvoke.class, foo, 1, this::checkInvokeGetsNonNullReceiver);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterInvoke.class),
+ NonNullAfterInvoke.class,
+ foo,
+ 1,
+ this::checkInvokeGetsNonNullReceiver);
MethodSignature bar =
new MethodSignature("bar", "int", new String[]{"java.lang.String"});
- buildAndTest(NonNullAfterInvoke.class, bar, 2, this::checkInvokeGetsNullReceiver);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterInvoke.class),
+ NonNullAfterInvoke.class,
+ bar,
+ 2,
+ this::checkInvokeGetsNullReceiver);
}
@Test
public void nonNullAfterSafeArrayAccess() throws Exception {
MethodSignature foo =
new MethodSignature("foo", "int", new String[]{"java.lang.String[]"});
- buildAndTest(NonNullAfterArrayAccess.class, foo, 1, null);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterArrayAccess.class),
+ NonNullAfterArrayAccess.class,
+ foo,
+ 1,
+ null);
}
@Test
public void nonNullAfterSafeArrayLength() throws Exception {
MethodSignature signature =
new MethodSignature("arrayLength", "int", new String[]{"java.lang.String[]"});
- buildAndTest(NonNullAfterArrayAccess.class, signature, 1, null);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterArrayAccess.class),
+ NonNullAfterArrayAccess.class,
+ signature,
+ 1,
+ null);
}
@Test
public void nonNullAfterSafeFieldAccess() throws Exception {
MethodSignature foo = new MethodSignature("foo", "int",
new String[]{FieldAccessTest.class.getCanonicalName()});
- buildAndTest(NonNullAfterFieldAccess.class, foo, 1, null);
+ buildAndTest(
+ ImmutableList.of(FieldAccessTest.class, NonNullAfterFieldAccess.class),
+ NonNullAfterFieldAccess.class,
+ foo,
+ 1,
+ null);
}
@Test
@@ -159,6 +191,7 @@
MethodSignature signature = new MethodSignature("foo2", "int",
new String[]{FieldAccessTest.class.getCanonicalName()});
buildAndTest(
+ ImmutableList.of(FieldAccessTest.class, NonNullAfterFieldAccess.class),
NonNullAfterFieldAccess.class,
signature,
1,
@@ -191,12 +224,27 @@
public void nonNullAfterNullCheck() throws Exception {
MethodSignature foo =
new MethodSignature("foo", "int", new String[]{"java.lang.String"});
- buildAndTest(NonNullAfterNullCheck.class, foo, 1, this::checkInvokeGetsNonNullReceiver);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterNullCheck.class),
+ NonNullAfterNullCheck.class,
+ foo,
+ 1,
+ this::checkInvokeGetsNonNullReceiver);
MethodSignature bar =
new MethodSignature("bar", "int", new String[]{"java.lang.String"});
- buildAndTest(NonNullAfterNullCheck.class, bar, 1, this::checkInvokeGetsNonNullReceiver);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterNullCheck.class),
+ NonNullAfterNullCheck.class,
+ bar,
+ 1,
+ this::checkInvokeGetsNonNullReceiver);
MethodSignature baz =
new MethodSignature("baz", "int", new String[]{"java.lang.String"});
- buildAndTest(NonNullAfterNullCheck.class, baz, 2, this::checkInvokeGetsNullReceiver);
+ buildAndTest(
+ ImmutableList.of(NonNullAfterNullCheck.class),
+ NonNullAfterNullCheck.class,
+ baz,
+ 2,
+ this::checkInvokeGetsNullReceiver);
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java b/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java
deleted file mode 100644
index 7d5e23e..0000000
--- a/src/test/java/com/android/tools/r8/ir/optimize/NonNullTrackerTestBase.java
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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 com.android.tools.r8.ir.optimize;
-
-import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
-
-public abstract class NonNullTrackerTestBase extends TestBase {
-
- protected AppView<AppInfoWithLiveness> build(Class<?> mainClass) throws Exception {
- return computeAppViewWithLiveness(buildAndroidApp(ToolHelper.getClassAsBytes(mainClass)));
- }
-}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
index 235aa07..68991bd 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/Regress131349148.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.ir.optimize.inliner;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.R8TestRunResult;
@@ -64,11 +63,9 @@
ClassWithCatchNonExisting.class,
ExistingException.class)
.addKeepMainRule(TestClassCallingMethodWithNonExisting.class)
- .addKeepRules("-dontwarn " + NonExistingException.class.getTypeName())
+ .addDontWarn(NonExistingException.class)
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- containsString("required for default or static interface methods desugaring"))
.run(parameters.getRuntime(), TestClassCallingMethodWithNonExisting.class)
.assertSuccess();
ClassSubject classSubject =
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NullCheckWithCatchHandlerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NullCheckWithCatchHandlerTest.java
new file mode 100644
index 0000000..3e58794
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/nonnull/NullCheckWithCatchHandlerTest.java
@@ -0,0 +1,56 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.ir.optimize.nonnull;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class NullCheckWithCatchHandlerTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public NullCheckWithCatchHandlerTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Main.class)
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithEmptyOutput();
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ Object alwaysNull = System.currentTimeMillis() > 0 ? null : new Object();
+ notNullCheck(alwaysNull);
+ if (alwaysNull != null) {
+ System.out.println(alwaysNull.toString());
+ }
+ }
+
+ private static void notNullCheck(Object o) {
+ try {
+ o.getClass();
+ } catch (Throwable e) {
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b111893131/B111893131.java b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b111893131/B111893131.java
index ed54024..5db4d92 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/outliner/b111893131/B111893131.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/outliner/b111893131/B111893131.java
@@ -62,7 +62,6 @@
}
}
-@RunWith(VmTestRunner.class)
public class B111893131 extends TestBase {
@Test
@@ -109,5 +108,4 @@
}
}
}
-
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java
index 730c399..974a4fc 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/redundantfieldloadelimination/InstanceFieldLoadsSeparatedByInvokeCustomTest.java
@@ -46,7 +46,6 @@
.addKeepAllClassesRule()
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(containsString("Unknown bootstrap method"))
.run(parameters.getRuntime(), "InstanceFieldLoadsSeparatedByInvokeCustomTestClass")
.assertSuccess();
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisSmaliTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisSmaliTest.java
index 7ddb3bc..8552e48 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisSmaliTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisSmaliTest.java
@@ -9,10 +9,12 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ir.analysis.AnalysisTestBase;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.string.StringBuilderOptimizer.BuilderState;
+import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.smali.SmaliBuilder;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.StringUtils;
@@ -26,7 +28,7 @@
public class StringBuilderOptimizerAnalysisSmaliTest extends AnalysisTestBase {
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
public StringBuilderOptimizerAnalysisSmaliTest(TestParameters parameters) throws Exception {
@@ -61,7 +63,7 @@
"sget-object v2, Ljava/lang/System;->out:Ljava/io/PrintStream;",
"invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;",
"move-result-object v1",
- "invoke-virtual {v2, v1}, Ljava/io/Stream;->println(Ljava/lang/String;)V",
+ "invoke-virtual {v2, v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V",
"return-void");
smaliBuilder.addStaticMethod(
"void", "phiAtInit_5_1_1", ImmutableList.of(), 5, code);
@@ -93,7 +95,7 @@
"sget-object v2, Ljava/lang/System;->out:Ljava/io/PrintStream;",
"invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;",
"move-result-object v1",
- "invoke-virtual {v2, v1}, Ljava/io/Stream;->println(Ljava/lang/String;)V",
+ "invoke-virtual {v2, v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V",
"return-void");
smaliBuilder.addStaticMethod(
"void", "phiWithDifferentNewInstance", ImmutableList.of(), 5, code);
@@ -125,17 +127,20 @@
"sget-object v2, Ljava/lang/System;->out:Ljava/io/PrintStream;",
"invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;",
"move-result-object v1",
- "invoke-virtual {v2, v1}, Ljava/io/Stream;->println(Ljava/lang/String;)V",
+ "invoke-virtual {v2, v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V",
"return-void");
smaliBuilder.addStaticMethod(
"void", "phiAtInit", ImmutableList.of(), 5, code);
}
- return smaliBuilder.build();
+ return AndroidApp.builder()
+ .addDexProgramData(smaliBuilder.compile(), Origin.unknown())
+ .addLibraryFile(ToolHelper.getMostRecentAndroidJar())
+ .build();
}
@Test
- public void testPhiAtInit_5_1_1() throws Exception {
+ public void testPhiAtInit_5_1_1() {
buildAndCheckIR(
"phiAtInit_5_1_1",
checkOptimizerStates(appView, optimizer -> {
@@ -150,7 +155,7 @@
}
@Test
- public void testPhiWithDifferentNewInstance() throws Exception {
+ public void testPhiWithDifferentNewInstance() {
buildAndCheckIR(
"phiWithDifferentNewInstance",
checkOptimizerStates(appView, optimizer -> {
@@ -165,7 +170,7 @@
}
@Test
- public void testPhiAtInit() throws Exception {
+ public void testPhiAtInit() {
buildAndCheckIR(
"phiAtInit",
checkOptimizerStates(appView, optimizer -> {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisTest.java
index eaa9941..e18c8ea 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringBuilderOptimizerAnalysisTest.java
@@ -9,7 +9,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.ToolHelper.DexVm;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.ir.analysis.AnalysisTestBase;
import com.android.tools.r8.ir.code.IRCode;
@@ -17,6 +16,7 @@
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.string.StringBuilderOptimizer.BuilderState;
+import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.InternalOptions;
import java.util.HashSet;
import java.util.Map;
@@ -32,7 +32,7 @@
@Parameterized.Parameters(name = "{0}")
public static TestParametersCollection data() {
- return getTestParameters().withAllRuntimes().build();
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
}
public StringBuilderOptimizerAnalysisTest(TestParameters parameters) throws Exception {
@@ -49,16 +49,7 @@
public void testUnusedBuilder() {
buildAndCheckIR(
"unusedBuilder",
- checkOptimizerStates(appView, optimizer -> {
- assertEquals(1, optimizer.analysis.builderStates.size());
- for (Value builder : optimizer.analysis.builderStates.keySet()) {
- Map<Instruction, BuilderState> perBuilderState =
- optimizer.analysis.builderStates.get(builder);
- checkBuilderState(optimizer, perBuilderState, "42", true);
- }
- assertEquals(1, optimizer.analysis.deadBuilders.size());
- assertEquals(0, optimizer.analysis.simplifiedBuilders.size());
- }));
+ code -> assertTrue(code.streamInstructions().allMatch(Instruction::isReturn)));
}
@Test
@@ -276,8 +267,7 @@
public void testPhiAtInit() {
int expectedNumOfNewBuilder = 2;
boolean expectToMeetToString = false;
- if (parameters.isDexRuntime()
- && parameters.getRuntime().asDex().getVm().isOlderThanOrEqual(DexVm.ART_5_1_1_HOST)) {
+ if (parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.M)) {
expectedNumOfNewBuilder = 1;
expectToMeetToString = true;
}
@@ -315,15 +305,17 @@
public void testConditionalPhiWithoutAppend() {
buildAndCheckIR(
"conditionalPhiWithoutAppend",
- checkOptimizerStates(appView, optimizer -> {
- assertEquals(1, optimizer.analysis.builderStates.size());
- for (Value builder : optimizer.analysis.builderStates.keySet()) {
- Map<Instruction, BuilderState> perBuilderState =
- optimizer.analysis.builderStates.get(builder);
- checkBuilderState(optimizer, perBuilderState, null, true);
- }
- assertEquals(0, optimizer.analysis.simplifiedBuilders.size());
- }));
+ checkOptimizerStates(
+ appView,
+ optimizer -> {
+ assertEquals(1, optimizer.analysis.builderStates.size());
+ for (Value builder : optimizer.analysis.builderStates.keySet()) {
+ Map<Instruction, BuilderState> perBuilderState =
+ optimizer.analysis.builderStates.get(builder);
+ checkBuilderState(optimizer, perBuilderState, "initial:suffix", true);
+ }
+ assertEquals(1, optimizer.analysis.simplifiedBuilders.size());
+ }));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/jsr45/JSR45Tests.java b/src/test/java/com/android/tools/r8/jsr45/JSR45Tests.java
index 0d96a65..cdc4346 100644
--- a/src/test/java/com/android/tools/r8/jsr45/JSR45Tests.java
+++ b/src/test/java/com/android/tools/r8/jsr45/JSR45Tests.java
@@ -3,9 +3,14 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.jsr45;
+import static com.android.tools.r8.ToolHelper.getDefaultAndroidJar;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.D8;
import com.android.tools.r8.D8Command;
+import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
import com.android.tools.r8.OutputMode;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.ToolHelper;
@@ -64,7 +69,10 @@
return ToolHelper.runR8(
R8Command.builder()
.addProgramFiles(inputPath)
- .addLibraryFiles(ToolHelper.getDefaultAndroidJar())
+ .addProgramFiles(
+ getKotlinStdlibJar(KotlinCompiler.latest()),
+ getKotlinAnnotationJar(KotlinCompiler.latest()))
+ .addLibraryFiles(getDefaultAndroidJar())
.setOutput(outputPath, OutputMode.DexIndexed)
.addProguardConfigurationFiles(keepRulesPath)
.build());
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index 33848bb..a4b4d35 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
@@ -233,6 +234,7 @@
classpath.clear();
classpath.add(kotlinJarFile);
classpath.add(getJavaJarFile(folder));
+ classpath.add(getKotlinAnnotationJar(kotlinc));
classpath.addAll(extraClasspath);
// Compare with Java.
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index 3b554fd..16413e0 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.code.NewInstance;
import com.android.tools.r8.code.SgetObject;
import com.android.tools.r8.graph.DexClass;
@@ -83,7 +82,6 @@
testBuilder
// TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
.addKeepRules("-neverinline class * { void test*State*(...); }")
- .addDontWarnJetBrainsNotNullAnnotation()
.addHorizontallyMergedClassesInspector(
inspector ->
inspector
@@ -115,8 +113,7 @@
testBuilder ->
testBuilder
// TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
- .addKeepRules("-neverinline class * { void test*State*(...); }")
- .addDontWarnJetBrainsNotNullAnnotation())
+ .addKeepRules("-neverinline class * { void test*State*(...); }"))
.inspect(
inspector -> {
// TODO(b/173337498): MainKt$testStateless$1 should be class inlined.
@@ -144,7 +141,6 @@
"-neverinline class * { void test*State*(...); }",
"-neverinline class * { void testBigExtraMethod(...); }",
"-neverinline class * { void testBigExtraMethodReturningLambda(...); }")
- .addDontWarnJetBrainsAnnotations()
.addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertIsCompleteMergeGroup(
@@ -177,10 +173,9 @@
testBuilder
// TODO(jsjeon): Introduce @NeverInline to kotlinR8TestResources
.addKeepRules(
- "-neverinline class * { void test*State*(...); }",
- "-neverinline class * { void testBigExtraMethod(...); }",
- "-neverinline class * { void testBigExtraMethodReturningLambda(...); }")
- .addDontWarnJetBrainsAnnotations())
+ "-neverinline class * { void test*State*(...); }",
+ "-neverinline class * { void testBigExtraMethod(...); }",
+ "-neverinline class * { void testBigExtraMethodReturningLambda(...); }"))
.inspect(
inspector -> {
// TODO(b/173337498): Should be absent, but horizontal class merging interferes with
@@ -210,10 +205,7 @@
// TODO(b/179866251): Update tests.
assumeTrue(kotlinc.is(KOTLINC_1_3_72) && testParameters.isDexRuntime());
String mainClassName = "class_inliner_data_class.MainKt";
- runTest(
- "class_inliner_data_class",
- mainClassName,
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
+ runTest("class_inliner_data_class", mainClassName)
.inspect(
inspector -> {
ClassSubject clazz = inspector.clazz(mainClassName);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
index ecf67ae..1b96692 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
@@ -82,7 +82,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.noClassInlining()
.noClassStaticizing(noClassStaticizing));
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
index 068ac79..b76eaa0 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
@@ -4,7 +4,9 @@
package com.android.tools.r8.kotlin;
import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_3_72;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
@@ -55,15 +57,18 @@
// TODO(b/179866251): Update tests.
assumeTrue(kotlinc.is(KOTLINC_1_3_72) || allowAccessModification);
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addKeepRules(
StringUtils.lines(
"-keepclasseswithmembers class " + MAIN + "{", " public static *** *(...);", "}"))
.allowAccessModification(allowAccessModification)
- .addDontWarnJetBrainsNotNullAnnotation()
+ .allowDiagnosticWarningMessages()
.noMinification()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(
inspector -> {
ClassSubject main = inspector.clazz(MAIN);
@@ -103,17 +108,20 @@
private void testSingle(String methodName) throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addKeepRules(
StringUtils.lines(
"-keepclasseswithmembers class " + MAIN + "{",
" public static *** " + methodName + "(...);",
"}"))
- .addDontWarnJetBrainsNotNullAnnotation()
.allowAccessModification(allowAccessModification)
+ .allowDiagnosticWarningMessages()
.noMinification()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(
inspector -> {
ClassSubject main = inspector.clazz(MAIN);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
index e928379..4db441f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
@@ -40,10 +39,7 @@
@Test
public void testMergingKStyleLambdasAfterUnusedArgumentRemoval() throws Exception {
final String mainClassName = "unused_arg_in_lambdas_kstyle.MainKt";
- runTest(
- "unused_arg_in_lambdas_kstyle",
- mainClassName,
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
+ runTest("unused_arg_in_lambdas_kstyle", mainClassName)
.inspect(
inspector ->
inspector.forAllClasses(
@@ -64,10 +60,7 @@
@Test
public void testMergingJStyleLambdasAfterUnusedArgumentRemoval() throws Exception {
final String mainClassName = "unused_arg_in_lambdas_jstyle.MainKt";
- runTest(
- "unused_arg_in_lambdas_jstyle",
- mainClassName,
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
+ runTest("unused_arg_in_lambdas_jstyle", mainClassName)
.inspect(
inspector ->
inspector.forAllClasses(
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
index 4da0c68..9d66188 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.FieldSubject;
@@ -54,10 +53,7 @@
assumeTrue(kotlinc.is(KOTLINC_1_3_72));
final String mainClassName = "unused_singleton.MainKt";
final String moduleName = "unused_singleton.TestModule";
- runTest(
- "unused_singleton",
- mainClassName,
- TestShrinkerBuilder::addDontWarnJetBrainsNotNullAnnotation)
+ runTest("unused_singleton", mainClassName)
.inspect(
inspector -> {
ClassSubject main = inspector.clazz(mainClassName);
diff --git a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
index c2c68e4..679177e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/ProcessKotlinStdlibTest.java
@@ -3,14 +3,13 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.KotlinTestParameters;
-import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
-import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
@@ -35,47 +34,35 @@
}
private void test(Collection<String> rules) throws Exception {
- test(rules, null);
- }
-
- private void test(
- Collection<String> rules,
- ThrowableConsumer<R8FullTestBuilder> consumer)
- throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepRules(rules)
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .apply(consumer)
- .compile();
+ .allowDiagnosticWarningMessages()
+ .compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
}
@Test
public void testAsIs() throws Exception {
- test(
- ImmutableList.of("-dontshrink", "-dontoptimize", "-dontobfuscate"),
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
+ test(ImmutableList.of("-dontshrink", "-dontoptimize", "-dontobfuscate"));
}
@Test
public void testDontShrinkAndDontOptimize() throws Exception {
- test(
- ImmutableList.of("-dontshrink", "-dontoptimize"),
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
+ test(ImmutableList.of("-dontshrink", "-dontoptimize"));
}
@Test
public void testDontShrinkAndDontObfuscate() throws Exception {
- test(
- ImmutableList.of("-dontshrink", "-dontobfuscate"),
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
+ test(ImmutableList.of("-dontshrink", "-dontobfuscate"));
}
@Test
public void testDontShrink() throws Exception {
- test(ImmutableList.of("-dontshrink"), TestShrinkerBuilder::addDontWarnJetBrainsAnnotations);
+ test(ImmutableList.of("-dontshrink"));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
index 8773698..1b2dd74 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -9,8 +9,8 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.KotlinTestParameters;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.jasmin.JasminBuilder;
@@ -86,10 +86,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_usePrimitiveProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -122,10 +119,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_usePrivateProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -160,10 +154,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_useInternalProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -197,10 +188,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionPropertiesKt",
"companionProperties_usePublicProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- builder -> builder.addDontWarnJetBrainsNotNullAnnotation().noClassStaticizing())
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -234,10 +222,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
"companionLateInitProperties_usePrivateLateInitProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- builder -> builder.addDontWarnJetBrainsAnnotations().noClassStaticizing())
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass, R8TestBuilder::noClassStaticizing)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -270,10 +255,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
"companionLateInitProperties_useInternalLateInitProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -302,10 +284,7 @@
final TestKotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
"companionLateInitProperties_usePublicLateInitProp");
- runTest(
- PROPERTIES_PACKAGE_NAME,
- mainClass,
- TestShrinkerBuilder::addDontWarnJetBrainsAnnotations)
+ runTest(PROPERTIES_PACKAGE_NAME, mainClass)
.inspect(
inspector -> {
ClassSubject outerClass =
@@ -389,7 +368,7 @@
String mainClass =
addMainToClasspath(
"accessors.PropertyAccessorForInnerClassKt", "noUseOfPropertyAccessorFromInnerClass");
- runTest("accessors", mainClass, TestShrinkerBuilder::addDontWarnJetBrainsNotNullAnnotation)
+ runTest("accessors", mainClass)
.inspect(
inspector -> {
// Class is removed because the instantiation of the inner class has no side effects.
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index b992613..e2c0a0a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -74,7 +74,6 @@
testBuilder ->
testBuilder
.addKeepRules(extraRules)
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
@@ -120,7 +119,6 @@
testBuilder ->
testBuilder
.addKeepRules(extraRules)
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
@@ -165,7 +163,6 @@
testBuilder ->
testBuilder
.addKeepRules(extraRules)
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
@@ -208,7 +205,6 @@
testBuilder ->
testBuilder
.addKeepRules(extraRules)
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
@@ -231,7 +227,6 @@
testBuilder ->
testBuilder
.addKeepRules(extraRules)
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableClassInliner))
.inspect(
inspector -> {
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
index 9d9fcee..5de5dbd 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
@@ -56,7 +56,6 @@
testBuilder ->
testBuilder
.addKeepRules(extraRules)
- .addDontWarnJetBrainsAnnotations()
.noHorizontalClassMerging(Intrinsics.class))
.inspect(
inspector -> {
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
index c7325b0..65822f7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
@@ -118,7 +118,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -135,7 +134,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -167,7 +165,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -198,7 +195,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -229,7 +225,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -260,7 +255,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -306,7 +300,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -336,7 +329,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -364,7 +356,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -390,7 +381,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -461,7 +451,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -488,7 +477,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -527,7 +515,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -555,7 +542,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -584,7 +570,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -619,7 +604,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -644,7 +628,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -669,7 +652,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -710,7 +692,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -745,7 +726,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -787,7 +767,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -829,7 +808,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -864,7 +842,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -893,7 +870,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -922,7 +898,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -956,7 +931,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -990,7 +964,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -1026,7 +999,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsNotNullAnnotation()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -1061,7 +1033,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -1095,7 +1066,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
@@ -1126,7 +1096,6 @@
mainClass,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(disableAggressiveClassOptimizations))
.inspect(
inspector -> {
diff --git a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
index b3537a9..00c9978 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -48,10 +48,7 @@
final String mainClassName = ex1.getClassName();
final String extraRules = neverInlineMethod(mainClassName, testMethodSignature);
- runTest(
- FOLDER,
- mainClassName,
- testBuilder -> testBuilder.addKeepRules(extraRules).addDontWarnJetBrainsAnnotations())
+ runTest(FOLDER, mainClassName, testBuilder -> testBuilder.addKeepRules(extraRules))
.inspect(
inspector -> {
ClassSubject clazz = checkClassIsKept(inspector, ex1.getClassName());
@@ -78,10 +75,7 @@
final String mainClassName = ex2.getClassName();
final String extraRules = neverInlineMethod(mainClassName, testMethodSignature);
- runTest(
- FOLDER,
- mainClassName,
- testBuilder -> testBuilder.addKeepRules(extraRules).addDontWarnJetBrainsAnnotations())
+ runTest(FOLDER, mainClassName, testBuilder -> testBuilder.addKeepRules(extraRules))
.inspect(
inspector -> {
ClassSubject clazz = checkClassIsKept(inspector, ex2.getClassName());
@@ -106,10 +100,7 @@
final String mainClassName = ex3.getClassName();
final String extraRules = neverInlineMethod(mainClassName, testMethodSignature);
- runTest(
- FOLDER,
- mainClassName,
- testBuilder -> testBuilder.addKeepRules(extraRules).addDontWarnJetBrainsAnnotations())
+ runTest(FOLDER, mainClassName, testBuilder -> testBuilder.addKeepRules(extraRules))
.inspect(
inspector -> {
ClassSubject clazz = checkClassIsKept(inspector, ex3.getClassName());
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
index fe0ef77..5b22795 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KStyleKotlinLambdaMergingWithEnumUnboxingTest.java
@@ -4,14 +4,16 @@
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.ToolHelper.getKotlinCompilers;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import com.android.tools.r8.KotlinCompilerTool.KotlinCompiler;
import com.android.tools.r8.NeverClassInline;
import com.android.tools.r8.NeverInline;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.kotlin.lambda.KStyleKotlinLambdaMergingWithEnumUnboxingTest.Main.EnumUnboxingCandidate;
import java.util.List;
import org.junit.Test;
@@ -42,17 +44,18 @@
public void test() throws Exception {
testForR8(parameters.getBackend())
.addInnerClasses(getClass())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepMainRule(Main.class)
.addHorizontallyMergedClassesInspector(
inspector -> inspector.assertMergedInto(Lambda2.class, Lambda1.class))
.addEnumUnboxingInspector(inspector -> inspector.assertUnboxed(EnumUnboxingCandidate.class))
- .addDontWarnJetBrainsNotNullAnnotation()
+ .allowDiagnosticWarningMessages()
.enableInliningAnnotations()
.enableNeverClassInliningAnnotations()
.noMinification()
.setMinApi(parameters.getApiLevel())
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("Lambda1.method()", "Lambda2.method()");
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
index 9d9f42a..7966656 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
@@ -3,6 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getJava8RuntimeJar;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assume.assumeTrue;
@@ -11,7 +14,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.TestRuntime.CfRuntime;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.DescriptorUtils;
import java.nio.file.Path;
import java.util.Collection;
@@ -43,21 +45,21 @@
String pkg = getClass().getPackage().getName();
String folder = DescriptorUtils.getBinaryNameFromJavaType(pkg);
- CfRuntime cfRuntime =
- parameters.isCfRuntime() ? parameters.getRuntime().asCf() : TestRuntime.getCheckedInJdk9();
+ CfRuntime cfRuntime = parameters.getRuntime().asCf();
Path ktClasses =
kotlinc(cfRuntime, kotlinc, targetVersion)
.addSourceFiles(getKotlinFileInTest(folder, "b143165163"))
.compile();
testForR8(parameters.getBackend())
- .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
- .addLibraryFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
- .addProgramFiles(ktClasses)
+ .addLibraryFiles(getJava8RuntimeJar())
+ .addLibraryFiles(getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(ktClasses, getKotlinAnnotationJar(kotlinc))
.addKeepMainRule("**.B143165163Kt")
- .addDontWarnJetBrainsNotNullAnnotation()
+ .allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
.compile()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc))
.run(parameters.getRuntime(), pkg + ".B143165163Kt")
.assertSuccessWithOutputLines("outer foo bar", "outer foo default");
}
@@ -75,10 +77,9 @@
.addSourceFiles(getKotlinFileInTest(folder, "b143165163"))
.compile();
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(ktClasses)
.addKeepMainRule("**.B143165163Kt")
- .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
.compile()
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java
index 0a49461..1e8065c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingCapturesKotlinStyleTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.PredicateUtils.not;
import static junit.framework.TestCase.assertEquals;
import static org.hamcrest.CoreMatchers.containsString;
@@ -75,7 +76,6 @@
testForR8(parameters.getBackend())
.addProgramFiles(getProgramFiles())
.addKeepMainRule(getMainClassName())
- .addDontWarnJetBrainsAnnotations()
.addHorizontallyMergedClassesInspector(this::inspect)
.allowAccessModification(allowAccessModification)
.allowDiagnosticWarningMessages()
@@ -152,7 +152,7 @@
getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
.configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
.getForConfiguration(kotlinc, targetVersion);
- return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+ return ImmutableList.of(kotlinJarFile, getJavaJarFile(), getKotlinAnnotationJar(kotlinc));
}
private String getTestName() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
index 7aaeade..de923a9 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingDebugTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static org.hamcrest.CoreMatchers.equalTo;
import com.android.tools.r8.CompilationMode;
@@ -47,9 +48,10 @@
public void testMergingKStyleLambdasAndReprocessingInDebug() throws Exception {
testForR8(parameters.getBackend())
.setMode(CompilationMode.DEBUG)
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, KotlinTargetVersion.JAVA_6))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, KotlinTargetVersion.JAVA_6),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
- .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(MAIN_CLASS)
.allowDiagnosticWarningMessages()
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java
index a20a77d..3ccb9ad 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingKeepAttributesKotlinStyleTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.shaking.ProguardKeepAttributes.ENCLOSING_METHOD;
import static com.android.tools.r8.shaking.ProguardKeepAttributes.INNER_CLASSES;
import static com.android.tools.r8.shaking.ProguardKeepAttributes.SIGNATURE;
@@ -82,7 +83,6 @@
.addProgramFiles(getProgramFiles())
.addKeepMainRule(getMainClassName())
.applyIf(!attributes.isEmpty(), builder -> builder.addKeepAttributes(attributes))
- .addDontWarnJetBrainsAnnotations()
.addHorizontallyMergedClassesInspector(this::inspect)
.allowAccessModification(allowAccessModification)
.allowDiagnosticWarningMessages()
@@ -151,7 +151,7 @@
getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
.configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
.getForConfiguration(kotlinc, targetVersion);
- return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+ return ImmutableList.of(kotlinJarFile, getJavaJarFile(), getKotlinAnnotationJar(kotlinc));
}
private String getTestName() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java
index 72abfe3..500f7c1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingSingletonTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.PredicateUtils.not;
import static junit.framework.TestCase.assertEquals;
import static org.hamcrest.CoreMatchers.containsString;
@@ -75,7 +76,6 @@
testForR8(parameters.getBackend())
.addProgramFiles(getProgramFiles())
.addKeepMainRule(getMainClassName())
- .addDontWarnJetBrainsAnnotations()
.addHorizontallyMergedClassesInspector(this::inspect)
.allowAccessModification(allowAccessModification)
.allowDiagnosticWarningMessages()
@@ -146,7 +146,7 @@
getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
.configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
.getForConfiguration(kotlinc, targetVersion);
- return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+ return ImmutableList.of(kotlinJarFile, getJavaJarFile(), getKotlinAnnotationJar(kotlinc));
}
private String getTestName() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java
index 1e83c00..6fbd439 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialJavaStyleTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.PredicateUtils.not;
import static junit.framework.TestCase.assertEquals;
import static org.hamcrest.CoreMatchers.containsString;
@@ -75,7 +76,6 @@
testForR8(parameters.getBackend())
.addProgramFiles(getProgramFiles())
.addKeepMainRule(getMainClassName())
- .addDontWarnJetBrainsAnnotations()
.addHorizontallyMergedClassesInspector(this::inspect)
.allowAccessModification(allowAccessModification)
.allowDiagnosticWarningMessages()
@@ -201,7 +201,7 @@
getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
.configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
.getForConfiguration(kotlinc, targetVersion);
- return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+ return ImmutableList.of(kotlinJarFile, getJavaJarFile(), getKotlinAnnotationJar(kotlinc));
}
private String getTestName() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java
index 3515109..cb79d89 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTrivialKotlinStyleTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin.lambda;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.PredicateUtils.not;
import static junit.framework.TestCase.assertEquals;
import static org.hamcrest.CoreMatchers.containsString;
@@ -75,7 +76,6 @@
testForR8(parameters.getBackend())
.addProgramFiles(getProgramFiles())
.addKeepMainRule(getMainClassName())
- .addDontWarnJetBrainsNotNullAnnotation()
.addHorizontallyMergedClassesInspector(this::inspect)
.allowAccessModification(allowAccessModification)
.allowDiagnosticWarningMessages()
@@ -162,7 +162,7 @@
getCompileMemoizer(getKotlinFilesInResource(getTestName()), getTestName())
.configure(kotlinCompilerTool -> kotlinCompilerTool.includeRuntime().noReflect())
.getForConfiguration(kotlinc, targetVersion);
- return ImmutableList.of(kotlinJarFile, getJavaJarFile());
+ return ImmutableList.of(kotlinJarFile, getJavaJarFile(), getKotlinAnnotationJar(kotlinc));
}
private String getTestName() {
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
index 96135ae..5629f15 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
@@ -5,7 +5,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
import com.android.tools.r8.utils.BooleanUtils;
import java.util.Collection;
@@ -34,9 +33,6 @@
@Test
public void testMergingKStyleLambdasAndReprocessing() throws Exception {
final String mainClassName = "reprocess_merged_lambdas_kstyle.MainKt";
- runTest(
- "reprocess_merged_lambdas_kstyle",
- mainClassName,
- TestShrinkerBuilder::addDontWarnJetBrainsNotNullAnnotation);
+ runTest("reprocess_merged_lambdas_kstyle", mainClassName);
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
index 2700f5e..729869f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
@@ -38,7 +38,6 @@
mainClassName,
testBuilder ->
testBuilder
- .addDontWarnJetBrainsAnnotations()
.addOptionsModification(options -> options.inliningInstructionAllowance = 3));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
index ac22198..23b51d7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b148525512/B148525512.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.lambda.b148525512;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static org.hamcrest.CoreMatchers.equalTo;
import com.android.tools.r8.DexIndexedConsumer.ArchiveConsumer;
@@ -11,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.ArchiveResourceProvider;
import java.io.IOException;
import java.nio.file.Files;
@@ -75,7 +76,7 @@
Path featureCode = temp.newFile("feature.zip").toPath();
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(kotlinBaseClasses.getForConfiguration(kotlinc, targetVersion))
.addProgramClasses(FeatureAPI.class)
.addKeepMainRule(baseKtClassName)
@@ -102,7 +103,6 @@
.setProgramConsumer(new ArchiveConsumer(featureCode, false))
.build())
.allowDiagnosticWarningMessages()
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.assertAllWarningMessagesMatch(
equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
index 8d476be..1f82c8b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaGroupGCLimitTest.java
@@ -4,7 +4,11 @@
package com.android.tools.r8.kotlin.lambda.b159688129;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinC_1_3_72;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -59,7 +63,6 @@
builder.addKeepClassAndMembersRules(PKG_NAME + ".MainKt" + mainId);
}
})
- .addDontWarnJetBrainsNotNullAnnotation()
.addHorizontallyMergedClassesInspector(
inspector -> {
HorizontalClassMergerOptions defaultHorizontalClassMergerOptions =
@@ -73,7 +76,10 @@
mergeGroup.size()
<= defaultHorizontalClassMergerOptions.getMaxGroupSize()));
})
- .compile();
+ .allowDiagnosticWarningMessages()
+ .compile()
+ .assertAllWarningMessagesMatch(
+ equalTo("Resource 'META-INF/MANIFEST.MF' already exists."));
Path path = compileResult.writeToZip();
compileResult
.run(parameters.getRuntime(), PKG_NAME + ".MainKt0")
@@ -97,6 +103,8 @@
}
writeClassFileDataToJar(classFiles, classFileData);
return ImmutableList.of(
- classFiles, ToolHelper.getKotlinStdlibJar(ToolHelper.getKotlinC_1_3_72()));
+ classFiles,
+ getKotlinStdlibJar(getKotlinC_1_3_72()),
+ getKotlinAnnotationJar(getKotlinC_1_3_72()));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
index 67bb203..3ce8beb 100644
--- a/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b159688129/LambdaSplitByCodeCorrectnessTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.lambda.b159688129;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.CodeMatchers.invokesMethod;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.equalTo;
@@ -15,7 +17,6 @@
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.TestRuntime.CfRuntime;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -60,11 +61,10 @@
.addSourceFiles(getKotlinFileInTest(folder, "Simple"))
.compile();
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(ktClasses)
.setMinApi(parameters.getApiLevel())
.addKeepMainRule(PKG_NAME + ".SimpleKt")
- .addDontWarnJetBrainsNotNullAnnotation()
.applyIf(
splitGroup,
b ->
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
index b0a30d7..cfa333f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataPrimitiveTypeRewriteTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
@@ -12,7 +14,6 @@
import com.android.tools.r8.JvmTestRunResult;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -58,7 +59,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutputLines(EXPECTED);
@@ -78,12 +79,12 @@
Path libJar =
testForR8(parameters.getBackend())
.addProgramFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc),
+ getKotlinStdlibJar(kotlinc),
+ getKotlinAnnotationJar(kotlinc),
libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRuleWithAllowObfuscation()
.addKeepRules("-keep class " + PKG_LIB + ".LibKt { *; }")
.addKeepRules("-keep class kotlin.Metadata { *; }")
- .addDontWarnJetBrainsAnnotations()
.applyIf(keepUnit, b -> b.addKeepRules("-keep class kotlin.Unit { *; }"))
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.allowDiagnosticWarningMessages()
@@ -105,7 +106,7 @@
.compile();
final JvmTestRunResult runResult =
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt");
if (keepUnit) {
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
index b4bca5c..a02d225 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAllowAccessModificationTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static junit.framework.TestCase.assertEquals;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -11,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -82,7 +83,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -96,7 +97,7 @@
Path libJar =
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepRules("-keepclassmembers,allowaccessmodification class **.Lib { *; }")
.addKeepRules("-keep,allowaccessmodification,allowobfuscation class **.Lib { *; }")
.addKeepRules("-keepclassmembers,allowaccessmodification class **.Lib$Comp { *; }")
@@ -112,7 +113,6 @@
" void staticPrivate() -> staticPrivateReference",
" void staticInternal() -> staticInternalReference"))
.addKeepRuntimeVisibleAnnotations()
- .addDontWarnJetBrainsNotNullAnnotation()
.allowAccessModification()
.compile()
.inspect(this::inspect)
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
index cb63498..cccbde4 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnnotationTest.java
@@ -4,9 +4,11 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
@@ -96,7 +98,9 @@
public void testMetadataForLib() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ libJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
/// Keep the annotations
.addKeepClassAndMembersRules(PKG_LIB + ".AnnoWithClassAndEnum")
@@ -119,8 +123,10 @@
ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS,
ProguardKeepAttributes.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS,
ProguardKeepAttributes.RUNTIME_VISIBLE_TYPE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
+ .allowDiagnosticWarningMessages()
.compile()
+ .assertAllWarningMessagesMatch(
+ equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(this::inspect)
.writeToZip();
Path output =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
index 374c3fd..0822971 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteAnonymousTest.java
@@ -4,12 +4,13 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.kotlin.KotlinMetadataWriter;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -53,7 +54,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".anonymous_app.MainKt")
.assertSuccessWithOutputLines(EXPECTED);
@@ -63,7 +64,7 @@
public void testMetadataForLib() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRuleWithAllowObfuscation()
.addKeepRules("-keep class " + PKG + ".anonymous_lib.Test$A { *; }")
@@ -73,7 +74,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -84,7 +84,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(main)
.run(parameters.getRuntime(), PKG + ".anonymous_app.MainKt")
.assertSuccessWithOutputLines(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
index 16d3765..1cd0805 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteBoxedTypesTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertNotNull;
@@ -62,7 +64,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".box_primitives_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -80,7 +82,7 @@
testForJvm()
.addVmArguments("-ea")
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".box_primitives_app.Main_reflectKt")
.assertSuccessWithOutput(EXPECTED);
@@ -90,7 +92,7 @@
public void testMetadataForLib() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAttributes(
@@ -98,7 +100,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -110,7 +111,7 @@
.compile();
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(main)
.run(parameters.getRuntime(), PKG + ".box_primitives_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -147,7 +148,7 @@
public void testMetadataForReflect() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAttributes(
@@ -155,7 +156,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsAnnotations()
.compile()
.writeToZip();
Path main =
@@ -167,7 +167,7 @@
testForJvm()
.addVmArguments("-ea")
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(main)
.run(parameters.getRuntime(), PKG + ".box_primitives_app.Main_reflectKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
index a8ccc76..5e64b54 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineAnonFunctionTest.java
@@ -4,9 +4,11 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
import java.nio.file.Path;
@@ -51,7 +53,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -62,10 +64,9 @@
Path libJar =
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAllClassesRule()
.addKeepAllAttributes()
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.writeToZip();
Path output =
@@ -75,7 +76,7 @@
getKotlinFileInTest(DescriptorUtils.getBinaryNameFromJavaType(PKG_APP), "main"))
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addProgramFiles(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
index 9c138bf..8ca888c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteCrossinlineConcreteFunctionTest.java
@@ -4,9 +4,11 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
import java.nio.file.Path;
@@ -51,7 +53,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -62,10 +64,9 @@
Path libJar =
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAllClassesRule()
.addKeepAllAttributes()
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.writeToZip();
Path output =
@@ -76,7 +77,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
index 564cd64..3752a9e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDelegatedPropertyTest.java
@@ -4,9 +4,12 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinReflectJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -51,8 +54,7 @@
@Test
public void smokeTest() throws Exception {
testForJvm()
- .addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc))
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinReflectJar(kotlinc))
.addClasspath(jars.getForConfiguration(kotlinc, targetVersion))
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED_MAIN);
@@ -64,11 +66,12 @@
Path outputJar =
testForR8(parameters.getBackend())
.addClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc))
+ getKotlinStdlibJar(kotlinc),
+ getKotlinReflectJar(kotlinc),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(jars.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(
inspector ->
@@ -77,8 +80,7 @@
inspector))
.writeToZip();
testForJvm()
- .addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc))
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinReflectJar(kotlinc))
.addClasspath(outputJar)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED_MAIN);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
index 3f42968..ef9c705 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDependentKeep.java
@@ -4,13 +4,15 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -43,13 +45,14 @@
@Test
public void testR8() throws CompilationFailedException, IOException, ExecutionException {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepKotlinMetadata()
.addKeepRules(StringUtils.joinLines("-if class *.Metadata", "-keep class <1>.io.** { *; }"))
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
+ .allowDiagnosticWarningMessages()
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(this::inspect);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
index 1caec7d..2558cbb 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteDoNotEmitValuesIfEmpty.java
@@ -4,12 +4,14 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.DexAnnotationElement;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
@@ -45,13 +47,14 @@
@Test
public void testKotlinStdLib() throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepKotlinMetadata()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
+ .allowDiagnosticWarningMessages()
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(this::inspectEmptyValuesAreNotPresent);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
index 91ede26..527269c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteFlexibleUpperBoundTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -64,7 +66,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".flexible_upper_bound_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -74,7 +76,7 @@
public void testMetadataForLib() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
// Allow renaming A to ensure that we rename in the flexible upper bound type.
.addKeepRules("-keep,allowobfuscation class " + PKG_LIB + ".A { *; }")
@@ -85,7 +87,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -97,7 +98,7 @@
.compile();
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(main)
.run(parameters.getRuntime(), PKG + ".flexible_upper_bound_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
index eebb77f..4c712d3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInClasspathTypeTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -12,7 +14,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -70,7 +71,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), baseLibJar, extLibJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), baseLibJar, extLibJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".classpath_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -81,7 +82,8 @@
Path baseLibJar = baseLibJarMap.getForConfiguration(kotlinc, targetVersion);
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(baseLibJar, ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(
+ baseLibJar, getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(extLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the Extra class and its interface (which has the method).
.addKeepRules("-keep class **.Extra")
@@ -91,7 +93,6 @@
// to be called with Kotlin syntax from other kotlin code.
.addKeepRules("-keep class **.ImplKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
@@ -104,7 +105,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), baseLibJar, libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), baseLibJar, libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".classpath_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
index 9106a3b..0cedda8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInCompanionTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -13,7 +15,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -70,7 +71,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".companion_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -80,7 +81,7 @@
public void testMetadataInCompanion_kept() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(companionLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep everything
.addKeepRules("-keep class **.companion_lib.** { *; }")
@@ -90,7 +91,6 @@
// To keep ...$Companion structure
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(codeInspector -> inspect(codeInspector, true))
.writeToZip();
@@ -103,7 +103,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".companion_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -113,7 +113,7 @@
public void testMetadataInCompanion_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(companionLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
@@ -133,7 +133,6 @@
// To keep ...$Companion structure
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(codeInspector -> inspect(codeInspector, false))
.writeToZip();
@@ -146,7 +145,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".companion_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
index f46402b..bc5f909 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionFunctionTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -78,7 +79,9 @@
public void testMetadataInExtensionFunction_merged() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addProgramFiles(extLibJarMap.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ extLibJarMap.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
.addKeepRules("-keep class **.I { <methods>; }")
@@ -89,7 +92,6 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -130,7 +132,8 @@
public void testMetadataInExtensionFunction_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(
+ ToolHelper.getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(extLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
@@ -144,7 +147,6 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
index c2a923f..90e914d 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInExtensionPropertyTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -15,7 +17,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -66,7 +67,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".extension_property_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -77,7 +78,9 @@
public void testMetadataInExtensionProperty_merged() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addProgramFiles(extLibJarMap.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ extLibJarMap.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
.addKeepRules("-keep class **.I { <methods>; }")
@@ -85,7 +88,6 @@
// to be called with Kotlin syntax from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -98,7 +100,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".extension_property_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -138,7 +140,7 @@
public void testMetadataInExtensionProperty_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(extLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
@@ -149,7 +151,6 @@
// to be called with Kotlin syntax from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
@@ -162,7 +163,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".extension_property_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
index 48044e2..24a19d3 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -14,7 +16,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -65,7 +66,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".function_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -76,14 +77,15 @@
public void testMetadataInFunction_merged() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addProgramFiles(funLibJarMap.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ funLibJarMap.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
.addKeepRules("-keep class **.I { <methods>; }")
// Keep the BKt method, which will be called from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -96,7 +98,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".function_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -135,7 +137,7 @@
public void testMetadataInFunction_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(funLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the B class and its interface (which has the doStuff method).
.addKeepRules("-keep class **.B")
@@ -145,7 +147,6 @@
// Keep the BKt method, which will be called from other kotlin code.
.addKeepRules("-keep class **.BKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
@@ -158,7 +159,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".function_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
index 746c690..dc2ddce 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithDefaultValueTest.java
@@ -3,6 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getJava8RuntimeJar;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -13,7 +16,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -65,7 +67,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".default_value_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -76,7 +78,7 @@
Path libJar =
testForR8(parameters.getBackend())
.addLibraryFiles(
- ToolHelper.getJava8RuntimeJar(), ToolHelper.getKotlinStdlibJar(kotlinc))
+ getJava8RuntimeJar(), getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(defaultValueLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep LibKt and applyMap function, along with applyMap$default
.addKeepRules("-keep class **.LibKt { *** applyMap*(...); }")
@@ -84,7 +86,6 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -97,7 +98,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".default_value_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
index 262d8a2..ec249cb 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInFunctionWithVarargTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -14,7 +16,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -66,7 +67,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".vararg_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -76,7 +77,7 @@
public void testMetadataInFunctionWithVararg() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(varargLibJarMap.getForConfiguration(kotlinc, targetVersion))
// keep SomeClass#foo, since there is a method reference in the app.
.addKeepRules("-keep class **.SomeClass { *** foo(...); }")
@@ -86,7 +87,6 @@
.addKeepAttributes(ProguardKeepAttributes.SIGNATURE)
.addKeepAttributes(ProguardKeepAttributes.INNER_CLASSES)
.addKeepAttributes(ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -99,7 +99,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".vararg_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
index 5b7d4e6..598087a 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInLibraryTypeTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static org.hamcrest.CoreMatchers.anyOf;
@@ -86,7 +87,8 @@
// Intentionally not providing baseLibJar as lib file nor classpath file.
.addProgramFiles(
extLibJarMap.getForConfiguration(kotlinc, targetVersion),
- appJarMap.getForConfiguration(kotlinc, targetVersion))
+ appJarMap.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
// Keep Ext extension method which requires metadata to be called with Kotlin syntax
// from other kotlin code.
.addKeepRules("-keep class **.ExtKt { <methods>; }")
@@ -94,7 +96,6 @@
.addKeepMainRule(main)
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.addDontWarn(PKG + ".**")
- .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
// -dontoptimize so that basic code structure is kept.
.noOptimization()
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
index 6411cfc..593b124 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInMultifileClassTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -17,7 +19,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -72,7 +73,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".multifileclass_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -82,13 +83,12 @@
public void testMetadataInMultifileClass_merged() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(multifileLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep UtilKt#comma*Join*(). Let R8 optimize (inline) others, such as joinOf*(String).
.addKeepRules("-keep class **.UtilKt")
.addKeepRules("-keepclassmembers class * { ** comma*Join*(...); }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectMerged)
.writeToZip();
@@ -124,7 +124,7 @@
public void testMetadataInMultifileClass_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(multifileLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep UtilKt#comma*Join*().
.addKeepRules("-keep class **.UtilKt")
@@ -133,7 +133,6 @@
// Keep yet rename joinOf*(String).
.addKeepRules("-keepclassmembers,allowobfuscation class * { ** joinOf*(...); }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectRenamed)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
index abce684..27ee400 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInParameterTypeTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -11,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -58,7 +59,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".parametertype_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -68,14 +69,13 @@
public void testMetadataInParameterType_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(parameterTypeLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
// Keep Itf, but allow minification.
.addKeepRules("-keep,allowobfuscation class **.Itf")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -88,7 +88,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".parametertype_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
index 693c7fc..401087b 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionProperty;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -15,7 +17,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -65,7 +66,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".fragile_property_only_getter.Getter_userKt")
.assertSuccessWithOutput(EXPECTED_GETTER);
@@ -75,13 +76,12 @@
public void testMetadataInProperty_getterOnly() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(propertyTypeLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep property getters
.addKeepRules("-keep class **.Person { <init>(...); }")
.addKeepRules("-keepclassmembers class **.Person { *** get*(); }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectGetterOnly)
.writeToZip();
@@ -95,7 +95,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".fragile_property_only_getter.Getter_userKt")
.assertSuccessWithOutput(EXPECTED_GETTER);
@@ -157,7 +157,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".fragile_property_only_setter.Setter_userKt")
.assertSuccessWithOutputLines();
@@ -167,7 +167,7 @@
public void testMetadataInProperty_setterOnly() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(propertyTypeLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep property setters (and users)
.addKeepRules("-keep class **.Person { <init>(...); }")
@@ -177,7 +177,6 @@
// Keep LibKt extension methods
.addKeepRules("-keep class **.LibKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectSetterOnly)
.writeToZip();
@@ -191,7 +190,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".fragile_property_only_setter.Setter_userKt")
.assertSuccessWithOutputLines();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
index cb18acb..28721c8 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInPropertyTypeTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -11,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -58,7 +59,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".propertytype_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -68,12 +69,11 @@
public void testMetadataInProperty_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(propertyTypeLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -86,7 +86,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".propertytype_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
index dbaf933..225ac74 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInReturnTypeTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -11,7 +13,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -58,7 +59,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".returntype_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -68,14 +69,13 @@
public void testMetadataInReturnType_renamed() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(returnTypeLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
// Keep Itf, but allow minification.
.addKeepRules("-keep,allowobfuscation class **.Itf")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -88,7 +88,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".returntype_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
index e479bba..defd730 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassNestedTest.java
@@ -3,6 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
@@ -57,7 +60,7 @@
.compile();
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -67,13 +70,12 @@
public void testMetadataInSealedClass_nested() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(sealedLibJarMap.getForConfiguration(kotlinc, targetVersion))
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
.addKeepAttributes(
ProguardKeepAttributes.INNER_CLASSES, ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsAnnotations()
.compile()
.writeToZip();
Path output =
@@ -85,7 +87,7 @@
.compile();
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
index 5156b72..90907da 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInSealedClassTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -16,7 +18,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
@@ -65,7 +66,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".sealed_app.ValidKt")
.assertSuccessWithOutput(EXPECTED);
@@ -75,7 +76,7 @@
public void testMetadataInSealedClass_valid() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(sealedLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the Expr class
.addKeepRules("-keep class **.Expr")
@@ -84,7 +85,6 @@
// Keep the factory object and utils
.addKeepRules("-keep class **.ExprFactory { *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(this::inspectValid)
.writeToZip();
@@ -97,7 +97,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".sealed_app.ValidKt")
.assertSuccessWithOutput(EXPECTED);
@@ -143,14 +143,13 @@
public void testMetadataInSealedClass_invalid() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(sealedLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep the Expr class
.addKeepRules("-keep class **.Expr")
// Keep the extension function
.addKeepRules("-keep class **.LibKt { <methods>; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspectInvalid)
.writeToZip();
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
index 98102c5..0585af6 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeAliasTest.java
@@ -3,6 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinReflectJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isDexClass;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
@@ -14,7 +17,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.kotlin.Kotlin.ClassClassifiers;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -89,8 +91,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinReflectJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".typealias_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -103,7 +104,9 @@
Path libJar =
testForR8(parameters.getBackend())
.addClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc))
+ getKotlinStdlibJar(kotlinc),
+ getKotlinReflectJar(kotlinc),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(typeAliasLibJarMap.getForConfiguration(kotlinc, targetVersion))
// Keep non-private members of Impl
.addKeepRules("-keep class **.Impl { !private *; }")
@@ -126,7 +129,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -138,8 +140,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinReflectJar(kotlinc), libJar)
.addClasspath(appJar)
.run(parameters.getRuntime(), PKG + ".typealias_app.MainKt")
.assertSuccessWithOutput(EXPECTED.replace(superTypeName, renamedSuperTypeName));
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
index 097c832..eddf514 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInTypeArgumentsTest.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isDexClass;
import static com.android.tools.r8.utils.codeinspector.Matchers.isExtensionFunction;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
@@ -13,7 +15,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -103,7 +104,7 @@
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".typeargument_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -113,7 +114,7 @@
public void testMetadataInTypeAliasWithR8() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(jarMap.getForConfiguration(kotlinc, targetVersion))
// Keep ClassThatWillBeObfuscated, but allow minification.
.addKeepRules("-keep,allowobfuscation class **ClassThatWillBeObfuscated")
@@ -130,7 +131,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -140,7 +140,7 @@
.addSourceFiles(getKotlinFileInTest(PKG_PREFIX + "/typeargument_app", "main"))
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(mainJar)
.run(parameters.getRuntime(), PKG + ".typeargument_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
index d5e9e1a..ab449b7 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteInlinePropertyTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNull;
@@ -59,7 +61,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG + ".inline_property_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -69,7 +71,7 @@
public void testMetadataForLib() throws Exception {
Path libJar =
testForR8(parameters.getBackend())
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
// Allow renaming A to ensure that we rename in the flexible upper bound type.
.addKeepAllClassesRule()
@@ -78,7 +80,6 @@
ProguardKeepAttributes.SIGNATURE,
ProguardKeepAttributes.INNER_CLASSES,
ProguardKeepAttributes.ENCLOSING_METHOD)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -90,7 +91,7 @@
.compile();
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
+ getKotlinStdlibJar(kotlinc), ToolHelper.getKotlinReflectJar(kotlinc), libJar)
.addClasspath(main)
.run(parameters.getRuntime(), PKG + ".inline_property_app.MainKt")
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
index b31c838..605b16c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteJvmStaticTest.java
@@ -3,13 +3,14 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.kotlin.metadata.jvmstatic_app.MainJava;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
@@ -69,8 +70,7 @@
.compile();
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc),
- kotlincLibJar.getForConfiguration(kotlinc, targetVersion))
+ getKotlinStdlibJar(kotlinc), kotlincLibJar.getForConfiguration(kotlinc, targetVersion))
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -80,8 +80,7 @@
public void smokeTestJava() throws Exception {
testForJvm()
.addRunClasspathFiles(
- ToolHelper.getKotlinStdlibJar(kotlinc),
- kotlincLibJar.getForConfiguration(kotlinc, targetVersion))
+ getKotlinStdlibJar(kotlinc), kotlincLibJar.getForConfiguration(kotlinc, targetVersion))
.addProgramClassFileData(MainJava.dump())
.run(parameters.getRuntime(), MainJava.class)
.assertSuccessWithOutput(EXPECTED);
@@ -92,10 +91,9 @@
Path libJar =
testForR8(parameters.getBackend())
.addProgramFiles(kotlincLibJar.getForConfiguration(kotlinc, targetVersion))
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(this::inspect)
.writeToZip();
@@ -112,7 +110,7 @@
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), PKG_APP + ".MainKt")
.assertSuccessWithOutput(EXPECTED);
@@ -120,7 +118,7 @@
private void testJava(Path libJar) throws Exception {
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc), libJar)
+ .addRunClasspathFiles(getKotlinStdlibJar(kotlinc), libJar)
.addProgramClassFileData(MainJava.dump())
.run(parameters.getRuntime(), MainJava.class)
.assertSuccessWithOutput(EXPECTED);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
index 1d6a41f..8d01e2e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepPathTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -49,12 +51,11 @@
public void testProgramPath() throws Exception {
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.applyIf(keepMetadata, TestShrinkerBuilder::addKeepKotlinMetadata)
.addKeepRuntimeVisibleAnnotations()
.allowDiagnosticWarningMessages()
- .addDontWarnJetBrainsAnnotations()
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(inspector -> inspect(inspector, keepMetadata));
@@ -64,10 +65,9 @@
public void testClassPathPath() throws Exception {
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.addKeepRuntimeVisibleAnnotations()
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(inspector -> inspect(inspector, true));
}
@@ -76,11 +76,10 @@
public void testLibraryPath() throws Exception {
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addLibraryFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addLibraryFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addLibraryFiles(ToolHelper.getJava8RuntimeJar())
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.addKeepRuntimeVisibleAnnotations()
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(inspector -> inspect(inspector, true));
}
@@ -89,10 +88,9 @@
public void testMissing() throws Exception {
testForR8(parameters.getBackend())
.addProgramFiles(libJars.getForConfiguration(kotlinc, targetVersion))
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addClasspathFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepRules("-keep class " + LIB_CLASS_NAME)
.addKeepRuntimeVisibleAnnotations()
- .addDontWarnJetBrainsNotNullAnnotation()
.compile()
.inspect(inspector -> inspect(inspector, true));
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
index c8dd873..b49f740 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewriteKeepTest.java
@@ -4,12 +4,14 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
@@ -38,26 +40,28 @@
@Test
public void testR8() throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepKotlinMetadata()
.addKeepRules("-keep class kotlin.io.** { *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
+ .allowDiagnosticWarningMessages()
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(this::inspect);
}
@Test
public void testR8KeepIf() throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepRules("-keep class kotlin.io.** { *; }")
.addKeepRules("-if class *", "-keep class kotlin.Metadata { *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
+ .allowDiagnosticWarningMessages()
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(this::inspect);
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
index 99586b1..137d6f5 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRewritePassThroughTest.java
@@ -4,9 +4,12 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
+
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.util.Collection;
@@ -35,16 +38,16 @@
@Test
public void testKotlinStdLib() throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepKotlinMetadata()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
+ .allowDiagnosticWarningMessages()
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(
inspector ->
- assertEqualMetadata(
- new CodeInspector(ToolHelper.getKotlinStdlibJar(kotlinc)), inspector));
+ assertEqualMetadata(new CodeInspector(getKotlinStdlibJar(kotlinc)), inspector));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
index 7afbd44..0e03e02 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
@@ -4,6 +4,8 @@
package com.android.tools.r8.kotlin.metadata;
import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_4_20;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinReflectJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndRenamed;
@@ -13,7 +15,6 @@
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
@@ -53,11 +54,10 @@
testForR8(parameters.getBackend())
.addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
.addProgramFiles(getJavaJarFile(FOLDER))
- .addProgramFiles(ToolHelper.getKotlinReflectJar(kotlinc))
+ .addProgramFiles(getKotlinReflectJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepMainRule(mainClassName)
.addKeepKotlinMetadata()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
.allowUnusedDontWarnKotlinReflectJvmInternal(kotlinc.is(KOTLINC_1_4_20))
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
index a7886b2..4cf9124 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataVersionNumberBumpTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.kotlin.metadata;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.ToolHelper.getKotlinC_1_3_72;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
@@ -60,10 +61,10 @@
final R8FullTestBuilder testBuilder = testForR8(parameters.getBackend());
rewriteMetadataVersion(testBuilder::addProgramClassFileData, new int[] {1, 1, 16});
testBuilder
+ .addProgramFiles(getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(inspector -> inspectMetadataVersion(inspector, "1.4.0"));
}
@@ -73,10 +74,10 @@
final R8FullTestBuilder testBuilder = testForR8(parameters.getBackend());
rewriteMetadataVersion(testBuilder::addProgramClassFileData, new int[] {1, 4, 0});
testBuilder
+ .addProgramFiles(getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(inspector -> inspectMetadataVersion(inspector, "1.4.0"));
}
@@ -86,10 +87,10 @@
final R8FullTestBuilder testBuilder = testForR8(parameters.getBackend());
rewriteMetadataVersion(testBuilder::addProgramClassFileData, new int[] {1, 4, 2});
testBuilder
+ .addProgramFiles(getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.addKeepAllClassesRule()
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.compile()
.inspect(inspector -> inspectMetadataVersion(inspector, "1.4.2"));
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java b/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java
index fe05714..265aa24 100644
--- a/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/optimize/switches/KotlinEnumSwitchTest.java
@@ -4,7 +4,9 @@
package com.android.tools.r8.kotlin.optimize.switches;
+import static com.android.tools.r8.ToolHelper.getMostRecentKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotEquals;
@@ -28,7 +30,8 @@
@Parameters(name = "{1}, enable switch map removal: {0}")
public static List<Object[]> data() {
- return buildParameters(BooleanUtils.values(), getTestParameters().withAllRuntimes().build());
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
public KotlinEnumSwitchTest(boolean enableSwitchMapRemoval, TestParameters parameters) {
@@ -39,17 +42,20 @@
@Test
public void test() throws Exception {
testForR8(parameters.getBackend())
- .addProgramFiles(Paths.get(ToolHelper.EXAMPLES_KOTLIN_BUILD_DIR, "enumswitch.jar"))
+ .addProgramFiles(
+ Paths.get(ToolHelper.EXAMPLES_KOTLIN_BUILD_DIR, "enumswitch.jar"),
+ getMostRecentKotlinAnnotationJar())
.addKeepMainRule("enumswitch.EnumSwitchKt")
.addOptionsModification(
options -> {
options.enableEnumValueOptimization = enableSwitchMapRemoval;
options.enableEnumSwitchMapRemoval = enableSwitchMapRemoval;
})
- .addDontWarnJetBrainsNotNullAnnotation()
- .setMinApi(parameters.getRuntime())
+ .allowDiagnosticWarningMessages()
+ .setMinApi(parameters.getApiLevel())
.noMinification()
.compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.inspect(
inspector -> {
ClassSubject classSubject = inspector.clazz("enumswitch.EnumSwitchKt");
diff --git a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
index 47f9463..3422030 100644
--- a/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/sealed/SealedClassTest.java
@@ -4,15 +4,15 @@
package com.android.tools.r8.kotlin.sealed;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticMessage;
import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
-import static org.hamcrest.CoreMatchers.containsString;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
+import static org.hamcrest.CoreMatchers.equalTo;
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Collection;
@@ -58,7 +58,7 @@
public void testRuntime() throws ExecutionException, CompilationFailedException, IOException {
testForRuntime(parameters)
.addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
- .addRunClasspathFiles(buildOnDexRuntime(parameters, ToolHelper.getKotlinStdlibJar(kotlinc)))
+ .addRunClasspathFiles(buildOnDexRuntime(parameters, getKotlinStdlibJar(kotlinc)))
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines(EXPECTED);
}
@@ -67,17 +67,14 @@
public void testR8() throws ExecutionException, CompilationFailedException, IOException {
testForR8(parameters.getBackend())
.addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
- .addProgramFiles(buildOnDexRuntime(parameters, ToolHelper.getKotlinStdlibJar(kotlinc)))
+ .addProgramFiles(buildOnDexRuntime(parameters, getKotlinStdlibJar(kotlinc)))
+ .addProgramFiles(getKotlinAnnotationJar(kotlinc))
.setMinApi(parameters.getApiLevel())
.allowAccessModification()
- .allowDiagnosticWarningMessages(parameters.isCfRuntime())
+ .allowDiagnosticWarningMessages()
.addKeepMainRule(MAIN)
- .addDontWarnJetBrainsNotNullAnnotation()
- .compileWithExpectedDiagnostics(
- diagnostics ->
- diagnostics.assertAllWarningsMatch(
- diagnosticMessage(
- containsString("Resource 'META-INF/MANIFEST.MF' already exists."))))
+ .compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.run(parameters.getRuntime(), MAIN)
.assertSuccessWithOutputLines(EXPECTED);
}
diff --git a/src/test/java/com/android/tools/r8/maindexlist/b72312389/B72312389.java b/src/test/java/com/android/tools/r8/maindexlist/b72312389/B72312389.java
index 1978867..05e769d 100644
--- a/src/test/java/com/android/tools/r8/maindexlist/b72312389/B72312389.java
+++ b/src/test/java/com/android/tools/r8/maindexlist/b72312389/B72312389.java
@@ -6,6 +6,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeFalse;
import com.android.tools.r8.BaseCommand;
import com.android.tools.r8.CompatProguardCommandBuilder;
@@ -18,7 +19,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm;
-import com.android.tools.r8.VmTestRunner;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.Box;
@@ -28,9 +28,7 @@
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
-import org.junit.runner.RunWith;
-@RunWith(VmTestRunner.class)
public class B72312389 extends TestBase {
// TODO(120884788): Remove this when default is true.
private static boolean lookupLibraryBeforeProgram = false;
@@ -53,6 +51,7 @@
@Test
public void testGenerateMainDexList() throws Exception {
+ assumeFalse(ToolHelper.isWindows());
CollectingDiagnosticHandler diagnostics = new CollectingDiagnosticHandler();
GenerateMainDexListCommand.Builder builder = GenerateMainDexListCommand.builder(diagnostics);
buildInstrumentationTestCaseApplication(builder);
@@ -70,6 +69,7 @@
@Test
public void testR8ForceProguardCompatibility() throws Exception {
+ assumeFalse(ToolHelper.isWindows());
Box<String> mainDexList = new Box<>();
// Build a app with a class extending InstrumentationTestCase and including both the junit
// and the Android library.
@@ -98,6 +98,7 @@
@Test
public void testR8() throws Exception {
+ assumeFalse(ToolHelper.isWindows());
testForR8(Backend.DEX)
.apply(b -> buildInstrumentationTestCaseApplication(b.getBuilder()))
.setMinApi(AndroidApiLevel.B)
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
index e9bc43b..f45220d 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCatchHandlerTest.java
@@ -7,15 +7,18 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromCatchHandlerTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromCatchHandlerTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
index b10a231..37df585 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromCheckCastTest.java
@@ -7,15 +7,18 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromCheckCastTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromCheckCastTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java
index 0af31a3..d114dc0 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationTest.java
@@ -7,6 +7,8 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import org.junit.Test;
@@ -15,7 +17,11 @@
// we retain missing annotations even if there is no -keepattributes *Annotations*.
public class MissingClassReferencedFromClassAnnotationTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromClassAnnotationTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java
index 0918d76..10663fa 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromClassAnnotationWithDataTest.java
@@ -9,7 +9,8 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.Reference;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@@ -17,7 +18,11 @@
public class MissingClassReferencedFromClassAnnotationWithDataTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromClassAnnotationWithDataTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
index cb6287c..94550b8 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromConstClassTest.java
@@ -7,15 +7,18 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromConstClassTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromConstClassTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
index 74f00d4..40408ee 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromEnclosingMethodAttributeTest.java
@@ -11,6 +11,8 @@
import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.BooleanUtils;
@@ -20,7 +22,11 @@
public class MissingClassReferencedFromEnclosingMethodAttributeTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(getMainClass());
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(getMainClass()))
+ .setOrigin(getOrigin(getMainClass()))
+ .build();
@Parameters(name = "{1}, report: {0}")
public static List<Object[]> data() {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java
index 7788831..7638885 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromFieldAnnotationTest.java
@@ -7,17 +7,22 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.FieldReferenceUtils;
import org.junit.Test;
// TODO(b/179456539): This test should fail without -keepattributes RuntimeVisibleAnnotations, but
// we retain missing annotations even if there is no -keepattributes *Annotations*.
public class MissingClassReferencedFromFieldAnnotationTest extends MissingClassesTestBase {
- private static final FieldReference referencedFrom =
- Reference.field(Reference.classFromClass(Main.class), "FIELD", Reference.INT);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromFieldAnnotationTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
index 490efdc..51da805 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromImplementsClauseTest.java
@@ -8,13 +8,19 @@
import com.android.tools.r8.TestCompilerBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import org.junit.Test;
public class MissingClassReferencedFromImplementsClauseTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromImplementsClauseTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
index aa64ab8..f421eb1 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInnerClassAttributeTest.java
@@ -11,6 +11,8 @@
import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.BooleanUtils;
@@ -20,7 +22,11 @@
public class MissingClassReferencedFromInnerClassAttributeTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
@Parameters(name = "{1}, report: {0}")
public static List<Object[]> data() {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
index 6c7f620..1ce5f9f 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToExistingFieldTest.java
@@ -7,8 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
import org.junit.Test;
/**
@@ -18,11 +19,11 @@
public class MissingClassReferencedFromInstanceGetToExistingFieldTest
extends MissingClassesTestBase {
- private static final FieldReference referencedFrom =
- Reference.field(
- Reference.classFromClass(Main.class),
- "field",
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "field"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInstanceGetToExistingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
index 851d65d..f367fed 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceGetToMissingFieldTest.java
@@ -7,8 +7,8 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
@@ -19,8 +19,11 @@
public class MissingClassReferencedFromInstanceGetToMissingFieldTest
extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInstanceGetToMissingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
index 2d05aac..7ec1e09 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstanceOfTest.java
@@ -7,15 +7,18 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromInstanceOfTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInstanceOfTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
index b69625e..1f0e5a7 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToExistingFieldTest.java
@@ -7,8 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
import org.junit.Test;
/**
@@ -18,11 +19,11 @@
public class MissingClassReferencedFromInstancePutToExistingFieldTest
extends MissingClassesTestBase {
- private static final FieldReference referencedFrom =
- Reference.field(
- Reference.classFromClass(Main.class),
- "field",
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "field"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInstancePutToExistingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
index ec615f1..b4dd5a1 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInstancePutToMissingFieldTest.java
@@ -7,8 +7,8 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
@@ -19,8 +19,11 @@
public class MissingClassReferencedFromInstancePutToMissingFieldTest
extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInstancePutToMissingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java
index 21e18bf..31e1942 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest.java
@@ -9,9 +9,8 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.missingclasses.MissingClassReferencedFromNestMemberAttributeTest.Main;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
@@ -25,8 +24,11 @@
public class MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest
extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInvokeVirtualToAbsentMethodParameterTest(
TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java
index d40d191..4c62ad2 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest.java
@@ -9,8 +9,8 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import com.google.common.collect.ImmutableList;
import java.io.IOException;
@@ -24,8 +24,11 @@
public class MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest
extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInvokeVirtualToAbsentMethodReturnTest(
TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java
index f5b82ad..28c1a79 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest.java
@@ -7,9 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
-import com.google.common.collect.ImmutableList;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
/**
@@ -19,12 +19,12 @@
public class MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest
extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- Reference.method(
- Reference.classFromClass(Main.class),
- "get",
- ImmutableList.of(Reference.classFromClass(MissingClass.class)),
- null);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ MethodReferenceUtils.methodFromMethod(Main.class, "get", MissingClass.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInvokeVirtualToPresentMethodParameterTest(
TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java
index b675c8a..396117f 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest.java
@@ -7,9 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
-import java.util.Collections;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
/**
@@ -19,12 +19,11 @@
public class MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest
extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- Reference.method(
- Reference.classFromClass(Main.class),
- "get",
- Collections.emptyList(),
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.methodFromMethod(Main.class, "get"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromInvokeVirtualToPresentMethodReturnTest(
TestParameters parameters) {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
index 19dfdea..c212d86 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptFieldTest.java
@@ -8,18 +8,19 @@
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
import org.junit.Test;
/** If a field definition refers to a missing class, then the field definition is to be blamed. */
public class MissingClassReferencedFromKeptFieldTest extends MissingClassesTestBase {
- private static final FieldReference referencedFrom =
- Reference.field(
- Reference.classFromClass(Main.class),
- "FIELD",
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromKeptFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java
index a86e57a..fc2d8d3 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodParameterTest.java
@@ -8,20 +8,20 @@
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
-import com.google.common.collect.ImmutableList;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
/** If a method definition refers to a missing class, then the method definition is to be blamed. */
public class MissingClassReferencedFromKeptMethodParameterTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- Reference.method(
- Reference.classFromClass(Main.class),
- "get",
- ImmutableList.of(Reference.classFromClass(MissingClass.class)),
- null);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ MethodReferenceUtils.methodFromMethod(Main.class, "get", MissingClass.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromKeptMethodParameterTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java
index f211d14..6dc3edb 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromKeptMethodReturnTest.java
@@ -8,20 +8,19 @@
import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
-import java.util.Collections;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
/** If a method definition refers to a missing class, then the method definition is to be blamed. */
public class MissingClassReferencedFromKeptMethodReturnTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- Reference.method(
- Reference.classFromClass(Main.class),
- "get",
- Collections.emptyList(),
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.methodFromMethod(Main.class, "get"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromKeptMethodReturnTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java
new file mode 100644
index 0000000..860bce2
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryInstanceFieldTest.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromLibraryInstanceFieldTest extends MissingClassesTestBase {
+
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Library.class, "field"))
+ .setOrigin(getOrigin(Library.class))
+ .build();
+
+ public MissingClassReferencedFromLibraryInstanceFieldTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test(expected = CompilationFailedException.class)
+ public void testNoRules() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary());
+ }
+
+ /**
+ * Main is the closest program context to the missing class reference, but it is not the context
+ * of the missing class reference (Library is). Therefore, compilation still fails in this case.
+ */
+ @Test(expected = CompilationFailedException.class)
+ public void testDontWarnMainClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary().andThen(addDontWarn(Main.class)));
+ }
+
+ @Test
+ public void testDontWarnLibraryClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(Library.class)));
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(MissingClass.class)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+ addLibrary().andThen(addIgnoreWarnings()));
+ }
+
+ private ThrowableConsumer<R8FullTestBuilder> addLibrary() {
+ return builder ->
+ builder.addLibraryClasses(Library.class).addLibraryFiles(getMostRecentAndroidJar());
+ }
+
+ static class Main extends Library {
+
+ public static void main(String[] args) {}
+ }
+
+ public static class Library {
+
+ public MissingClass field;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java
new file mode 100644
index 0000000..c5c7950
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryStaticFieldTest.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromLibraryStaticFieldTest extends MissingClassesTestBase {
+
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Library.class, "field"))
+ .setOrigin(getOrigin(Library.class))
+ .build();
+
+ public MissingClassReferencedFromLibraryStaticFieldTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test(expected = CompilationFailedException.class)
+ public void testNoRules() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary());
+ }
+
+ /**
+ * Main is the closest program context to the missing class reference, but it is not the context
+ * of the missing class reference (Library is). Therefore, compilation still fails in this case.
+ */
+ @Test(expected = CompilationFailedException.class)
+ public void testDontWarnMainClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary().andThen(addDontWarn(Main.class)));
+ }
+
+ @Test
+ public void testDontWarnLibraryClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(Library.class)));
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(MissingClass.class)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+ addLibrary().andThen(addIgnoreWarnings()));
+ }
+
+ private ThrowableConsumer<R8FullTestBuilder> addLibrary() {
+ return builder ->
+ builder.addLibraryClasses(Library.class).addLibraryFiles(getMostRecentAndroidJar());
+ }
+
+ static class Main extends Library {
+
+ public static void main(String[] args) {}
+ }
+
+ public static class Library {
+
+ public static MissingClass field;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java
new file mode 100644
index 0000000..4a56add
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodParameterTest.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromLibraryVirtualMethodParameterTest
+ extends MissingClassesTestBase {
+
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ MethodReferenceUtils.methodFromMethod(Library.class, "method", MissingClass.class))
+ .setOrigin(getOrigin(Library.class))
+ .build();
+
+ public MissingClassReferencedFromLibraryVirtualMethodParameterTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test(expected = CompilationFailedException.class)
+ public void testNoRules() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary());
+ }
+
+ /**
+ * Main is the closest program context to the missing class reference, but it is not the context
+ * of the missing class reference (Library is). Therefore, compilation still fails in this case.
+ */
+ @Test(expected = CompilationFailedException.class)
+ public void testDontWarnMainClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary().andThen(addDontWarn(Main.class)));
+ }
+
+ @Test
+ public void testDontWarnLibraryClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(Library.class)));
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(MissingClass.class)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+ addLibrary().andThen(addIgnoreWarnings()));
+ }
+
+ private ThrowableConsumer<R8FullTestBuilder> addLibrary() {
+ return builder ->
+ builder.addLibraryClasses(Library.class).addLibraryFiles(getMostRecentAndroidJar());
+ }
+
+ static class Main extends Library {
+
+ public static void main(String[] args) {}
+ }
+
+ public static class Library {
+
+ public void method(MissingClass mc) {}
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java
new file mode 100644
index 0000000..5c627ef
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromLibraryVirtualMethodReturnTest.java
@@ -0,0 +1,92 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import org.junit.Test;
+
+public class MissingClassReferencedFromLibraryVirtualMethodReturnTest
+ extends MissingClassesTestBase {
+
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.methodFromMethod(Library.class, "method"))
+ .setOrigin(getOrigin(Library.class))
+ .build();
+
+ public MissingClassReferencedFromLibraryVirtualMethodReturnTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test(expected = CompilationFailedException.class)
+ public void testNoRules() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary());
+ }
+
+ /**
+ * Main is the closest program context to the missing class reference, but it is not the context
+ * of the missing class reference (Library is). Therefore, compilation still fails in this case.
+ */
+ @Test(expected = CompilationFailedException.class)
+ public void testDontWarnMainClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addLibrary().andThen(addDontWarn(Main.class)));
+ }
+
+ @Test
+ public void testDontWarnLibraryClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(Library.class)));
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addLibrary().andThen(addDontWarn(MissingClass.class)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+ addLibrary().andThen(addIgnoreWarnings()));
+ }
+
+ private ThrowableConsumer<R8FullTestBuilder> addLibrary() {
+ return builder ->
+ builder.addLibraryClasses(Library.class).addLibraryFiles(getMostRecentAndroidJar());
+ }
+
+ static class Main extends Library {
+
+ public static void main(String[] args) {}
+ }
+
+ public static class Library {
+
+ public MissingClass method() {
+ return null;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java
index 189b49e..5130304 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromMethodAnnotationTest.java
@@ -7,8 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
@@ -17,8 +18,11 @@
// we retain missing annotations even if there is no -keepattributes *Annotations*.
public class MissingClassReferencedFromMethodAnnotationTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromMethodAnnotationTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
index fc1ac99..194e12d 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestHostAttributeTest.java
@@ -9,6 +9,8 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.missingclasses.MissingClassReferencedFromNestHostAttributeTest.MissingClass.Main;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
@@ -19,7 +21,11 @@
public class MissingClassReferencedFromNestHostAttributeTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromNestHostAttributeTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
index a151dce..540620e 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNestMemberAttributeTest.java
@@ -9,6 +9,8 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
import com.google.common.collect.ImmutableList;
@@ -18,7 +20,11 @@
public class MissingClassReferencedFromNestMemberAttributeTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromNestMemberAttributeTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
index 66242bf..003b28e 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewArrayTest.java
@@ -7,15 +7,18 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromNewArrayTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromNewArrayTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
index 2af5045..ee919b2 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromNewInstanceTest.java
@@ -7,15 +7,18 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromNewInstanceTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromNewInstanceTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
index d707f74..21d5683 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromOuterClassAttributeTest.java
@@ -11,6 +11,8 @@
import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.missingclasses.MissingClassReferencedFromOuterClassAttributeTest.MissingClass.Main;
import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.Reference;
@@ -21,7 +23,11 @@
public class MissingClassReferencedFromOuterClassAttributeTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
@Parameters(name = "{1}, report: {0}")
public static List<Object[]> data() {
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java
index 0017aa7..a5b5432 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromParameterAnnotationTest.java
@@ -7,8 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
@@ -17,8 +18,11 @@
// we retain missing annotations even if there is no -keepattributes *Annotations*.
public class MissingClassReferencedFromParameterAnnotationTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromParameterAnnotationTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
index e76c4c9..332da9c 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToExistingFieldTest.java
@@ -7,8 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
import org.junit.Test;
/**
@@ -17,11 +18,11 @@
*/
public class MissingClassReferencedFromStaticGetToExistingFieldTest extends MissingClassesTestBase {
- private static final FieldReference referencedFrom =
- Reference.field(
- Reference.classFromClass(Main.class),
- "FIELD",
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromStaticGetToExistingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
index 36f8a29..9028167 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticGetToMissingFieldTest.java
@@ -7,8 +7,8 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
@@ -18,8 +18,11 @@
*/
public class MissingClassReferencedFromStaticGetToMissingFieldTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromStaticGetToMissingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
index 542c928..cbbd217 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToExistingFieldTest.java
@@ -7,8 +7,9 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionFieldContextImpl;
+import com.android.tools.r8.utils.FieldReferenceUtils;
import org.junit.Test;
/**
@@ -17,11 +18,11 @@
*/
public class MissingClassReferencedFromStaticPutToExistingFieldTest extends MissingClassesTestBase {
- private static final FieldReference referencedFrom =
- Reference.field(
- Reference.classFromClass(Main.class),
- "FIELD",
- Reference.classFromClass(MissingClass.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionFieldContextImpl.builder()
+ .setFieldContext(FieldReferenceUtils.fieldFromField(Main.class, "FIELD"))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromStaticPutToExistingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
index 542d509..e1ba4c6 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromStaticPutToMissingFieldTest.java
@@ -7,8 +7,8 @@
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
@@ -18,8 +18,11 @@
*/
public class MissingClassReferencedFromStaticPutToMissingFieldTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromStaticPutToMissingFieldTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
index 7aeb068..79cff47 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromSuperClassTest.java
@@ -8,13 +8,18 @@
import com.android.tools.r8.TestCompilerBuilder;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionClassContextImpl;
import com.android.tools.r8.references.Reference;
import org.junit.Test;
public class MissingClassReferencedFromSuperClassTest extends MissingClassesTestBase {
- private static final ClassReference referencedFrom = Reference.classFromClass(Main.class);
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionClassContextImpl.builder()
+ .setClassContext(Reference.classFromClass(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromSuperClassTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
index 1708330..275e6f2 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromThrowsClauseTest.java
@@ -8,15 +8,18 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestShrinkerBuilder;
-import com.android.tools.r8.references.MethodReference;
-import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
import com.android.tools.r8.utils.MethodReferenceUtils;
import org.junit.Test;
public class MissingClassReferencedFromThrowsClauseTest extends MissingClassesTestBase {
- private static final MethodReference referencedFrom =
- MethodReferenceUtils.mainMethod(Reference.classFromClass(Main.class));
+ private static final MissingDefinitionContext referencedFrom =
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build();
public MissingClassReferencedFromThrowsClauseTest(TestParameters parameters) {
super(parameters);
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java
new file mode 100644
index 0000000..31ca7d1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaParameterTest.java
@@ -0,0 +1,125 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilationIf;
+
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+
+public class MissingClassReferencedFromUnusedLambdaParameterTest extends MissingClassesTestBase {
+
+ private static final MissingDefinitionContext[] referencedFrom =
+ new MissingDefinitionContext[] {
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ Reference.method(
+ Reference.classFromClass(Main.class),
+ "lambda$main$0",
+ ImmutableList.of(Reference.classFromClass(MissingClass.class)),
+ null))
+ .setOrigin(getOrigin(Main.class))
+ .build(),
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build(),
+ };
+
+ public MissingClassReferencedFromUnusedLambdaParameterTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test
+ public void testNoRules() throws Exception {
+ assertFailsCompilationIf(
+ parameters.isCfRuntime(),
+ () ->
+ compileWithExpectedDiagnostics(
+ Main.class,
+ parameters.isCfRuntime()
+ ? diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom)
+ : TestDiagnosticMessages::assertNoMessages,
+ addInterface()));
+ }
+
+ // The lambda is never called, therefore the lambda class' virtual method is dead, and therefore
+ // we never trace into lambda$main$0(). Therefore, we need allowUnusedDontWarnPatterns() here.
+ @Test
+ public void testDontWarnMainClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface()
+ .andThen(
+ builder ->
+ builder
+ .addDontWarn(Main.class)
+ .applyIf(
+ parameters.isDexRuntime(),
+ R8TestBuilder::allowUnusedDontWarnPatterns)));
+ }
+
+ // The lambda is never called, therefore the lambda class' virtual method is dead, and therefore
+ // we never trace into lambda$main$0(). Therefore, we need allowUnusedDontWarnPatterns() here.
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface()
+ .andThen(
+ builder ->
+ builder
+ .addDontWarn(Main.class)
+ .applyIf(
+ parameters.isDexRuntime(),
+ R8TestBuilder::allowUnusedDontWarnPatterns)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ parameters.isCfRuntime()
+ ? diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom)
+ : TestDiagnosticMessages::assertNoMessages,
+ addInterface()
+ .andThen(
+ builder ->
+ builder
+ .addIgnoreWarnings()
+ .applyIf(
+ parameters.isCfRuntime(),
+ R8TestBuilder::allowDiagnosticWarningMessages)));
+ }
+
+ ThrowableConsumer<R8FullTestBuilder> addInterface() {
+ return builder -> builder.addProgramClasses(I.class);
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ I ignore = mc -> {};
+ }
+
+ /* private static synthetic void lambda$main$0(MissingClass mc) {} */
+ }
+
+ interface I {
+
+ void m(MissingClass mc);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java
new file mode 100644
index 0000000..8859780
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUnusedLambdaReturnTest.java
@@ -0,0 +1,125 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import static com.android.tools.r8.utils.codeinspector.AssertUtils.assertFailsCompilationIf;
+
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.R8TestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import java.util.Collections;
+import org.junit.Test;
+
+public class MissingClassReferencedFromUnusedLambdaReturnTest extends MissingClassesTestBase {
+
+ private static final MissingDefinitionContext[] referencedFrom =
+ new MissingDefinitionContext[] {
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ Reference.method(
+ Reference.classFromClass(Main.class),
+ "lambda$main$0",
+ Collections.emptyList(),
+ Reference.classFromClass(MissingClass.class)))
+ .setOrigin(getOrigin(Main.class))
+ .build(),
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build(),
+ };
+
+ public MissingClassReferencedFromUnusedLambdaReturnTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test
+ public void testNoRules() throws Exception {
+ assertFailsCompilationIf(
+ parameters.isCfRuntime(),
+ () ->
+ compileWithExpectedDiagnostics(
+ Main.class,
+ parameters.isCfRuntime()
+ ? diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom)
+ : TestDiagnosticMessages::assertNoMessages,
+ addInterface()));
+ }
+
+ // The lambda is never called, therefore the lambda class' virtual method is dead, and therefore
+ // we never trace into lambda$main$0(). Therefore, we need allowUnusedDontWarnPatterns() here.
+ @Test
+ public void testDontWarnMainClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface()
+ .andThen(
+ builder ->
+ builder
+ .addDontWarn(Main.class)
+ .applyIf(
+ parameters.isDexRuntime(),
+ R8TestBuilder::allowUnusedDontWarnPatterns)));
+ }
+
+ // The lambda is never called, therefore the lambda class' virtual method is dead, and therefore
+ // we never trace into lambda$main$0(). Therefore, we need allowUnusedDontWarnPatterns() here.
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface()
+ .andThen(
+ builder ->
+ builder
+ .addDontWarn(MissingClass.class)
+ .applyIf(
+ parameters.isDexRuntime(),
+ R8TestBuilder::allowUnusedDontWarnPatterns)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ parameters.isCfRuntime()
+ ? diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom)
+ : TestDiagnosticMessages::assertNoMessages,
+ addInterface()
+ .andThen(
+ builder ->
+ builder
+ .addIgnoreWarnings()
+ .applyIf(
+ parameters.isCfRuntime(),
+ R8TestBuilder::allowDiagnosticWarningMessages)));
+ }
+
+ ThrowableConsumer<R8FullTestBuilder> addInterface() {
+ return builder -> builder.addProgramClasses(I.class);
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ I ignore = () -> null;
+ }
+
+ /* private static synthetic MissingClass lambda$main$0() { return null; } */
+ }
+
+ interface I {
+
+ MissingClass m();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java
new file mode 100644
index 0000000..a9ece97
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaParameterTest.java
@@ -0,0 +1,97 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+
+public class MissingClassReferencedFromUsedLambdaParameterTest extends MissingClassesTestBase {
+
+ private final MissingDefinitionContext[] referencedFrom =
+ new MissingDefinitionContext[] {
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ MethodReferenceUtils.methodFromMethod(I.class, "m", MissingClass.class))
+ .setOrigin(getOrigin(I.class))
+ .build(),
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ Reference.method(
+ Reference.classFromClass(Main.class),
+ "lambda$main$0",
+ ImmutableList.of(Reference.classFromClass(MissingClass.class)),
+ null))
+ .setOrigin(getOrigin(Main.class))
+ .build(),
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build()
+ };
+
+ public MissingClassReferencedFromUsedLambdaParameterTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test(expected = CompilationFailedException.class)
+ public void testNoRules() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addInterface());
+ }
+
+ @Test
+ public void testDontWarnMainClassAndInterface() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface().andThen(addDontWarn(Main.class, I.class)));
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface().andThen(addDontWarn(MissingClass.class)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+ addInterface().andThen(addIgnoreWarnings()));
+ }
+
+ ThrowableConsumer<R8FullTestBuilder> addInterface() {
+ return builder -> builder.addProgramClasses(I.class);
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ I i = mc -> {};
+ i.m(null);
+ }
+
+ /* private static synthetic void lambda$main$0(MissingClass mc) {} */
+ }
+
+ interface I {
+
+ void m(MissingClass mc);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java
new file mode 100644
index 0000000..ba46bfc
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassReferencedFromUsedLambdaReturnTest.java
@@ -0,0 +1,96 @@
+// Copyright (c) 2020, 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 com.android.tools.r8.missingclasses;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.TestDiagnosticMessages;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ThrowableConsumer;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionMethodContextImpl;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.MethodReferenceUtils;
+import java.util.Collections;
+import org.junit.Test;
+
+public class MissingClassReferencedFromUsedLambdaReturnTest extends MissingClassesTestBase {
+
+ private final MissingDefinitionContext[] referencedFrom =
+ new MissingDefinitionContext[] {
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.methodFromMethod(I.class, "m"))
+ .setOrigin(getOrigin(I.class))
+ .build(),
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(
+ Reference.method(
+ Reference.classFromClass(Main.class),
+ "lambda$main$0",
+ Collections.emptyList(),
+ Reference.classFromClass(MissingClass.class)))
+ .setOrigin(getOrigin(Main.class))
+ .build(),
+ MissingDefinitionMethodContextImpl.builder()
+ .setMethodContext(MethodReferenceUtils.mainMethod(Main.class))
+ .setOrigin(getOrigin(Main.class))
+ .build()
+ };
+
+ public MissingClassReferencedFromUsedLambdaReturnTest(TestParameters parameters) {
+ super(parameters);
+ }
+
+ @Test(expected = CompilationFailedException.class)
+ public void testNoRules() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithNoRules(diagnostics, referencedFrom),
+ addInterface());
+ }
+
+ @Test
+ public void testDontWarnMainClassAndInterface() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface().andThen(addDontWarn(Main.class, I.class)));
+ }
+
+ @Test
+ public void testDontWarnMissingClass() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ TestDiagnosticMessages::assertNoMessages,
+ addInterface().andThen(addDontWarn(MissingClass.class)));
+ }
+
+ @Test
+ public void testIgnoreWarnings() throws Exception {
+ compileWithExpectedDiagnostics(
+ Main.class,
+ diagnostics -> inspectDiagnosticsWithIgnoreWarnings(diagnostics, referencedFrom),
+ addInterface().andThen(addIgnoreWarnings()));
+ }
+
+ ThrowableConsumer<R8FullTestBuilder> addInterface() {
+ return builder -> builder.addProgramClasses(I.class);
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ I i = () -> null;
+ i.m();
+ }
+
+ /* private static synthetic MissingClass lambda$main$0() { return null; } */
+ }
+
+ interface I {
+
+ MissingClass m();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
index 3968b75..f9941c0 100644
--- a/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
+++ b/src/test/java/com/android/tools/r8/missingclasses/MissingClassesTestBase.java
@@ -4,8 +4,7 @@
package com.android.tools.r8.missingclasses;
-import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.R8FullTestBuilder;
@@ -14,19 +13,14 @@
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ThrowableConsumer;
-import com.android.tools.r8.diagnostic.internal.MissingDefinitionsDiagnosticImpl;
+import com.android.tools.r8.diagnostic.MissingDefinitionContext;
+import com.android.tools.r8.diagnostic.internal.MissingDefinitionContextUtils;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.FieldReference;
-import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.Reference;
-import com.android.tools.r8.utils.FieldReferenceUtils;
import com.android.tools.r8.utils.InternalOptions.TestingOptions;
-import com.android.tools.r8.utils.MethodReferenceUtils;
-import com.google.common.collect.ImmutableSet;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.List;
-import java.util.function.Function;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
@@ -46,7 +40,7 @@
interface MissingInterface {}
- private final TestParameters parameters;
+ protected final TestParameters parameters;
@Parameters(name = "{0}")
public static List<Object[]> data() {
@@ -57,8 +51,8 @@
this.parameters = parameters;
}
- public ThrowableConsumer<R8FullTestBuilder> addDontWarn(Class<?> clazz) {
- return builder -> builder.addDontWarn(clazz);
+ public ThrowableConsumer<R8FullTestBuilder> addDontWarn(Class<?>... classes) {
+ return builder -> builder.addDontWarn(classes);
}
public ThrowableConsumer<R8FullTestBuilder> addIgnoreWarnings() {
@@ -109,92 +103,79 @@
}
void inspectDiagnosticsWithIgnoreWarnings(
- TestDiagnosticMessages diagnostics, ClassReference referencedFrom) {
+ TestDiagnosticMessages diagnostics, MissingDefinitionContext... referencedFrom) {
+ assertTrue(referencedFrom.length > 0);
inspectDiagnosticsWithIgnoreWarnings(
diagnostics,
- getExpectedDiagnosticMessageWithIgnoreWarnings(
- referencedFrom, ClassReference::getTypeName));
+ referencedFrom,
+ getExpectedDiagnosticMessage(
+ MissingDefinitionContextUtils.toSourceString(referencedFrom[0]),
+ referencedFrom.length));
}
void inspectDiagnosticsWithIgnoreWarnings(
- TestDiagnosticMessages diagnostics, FieldReference referencedFrom) {
- inspectDiagnosticsWithIgnoreWarnings(
- diagnostics,
- getExpectedDiagnosticMessageWithIgnoreWarnings(
- referencedFrom, FieldReferenceUtils::toSourceString));
- }
-
- void inspectDiagnosticsWithIgnoreWarnings(
- TestDiagnosticMessages diagnostics, MethodReference referencedFrom) {
- inspectDiagnosticsWithIgnoreWarnings(
- diagnostics,
- getExpectedDiagnosticMessageWithIgnoreWarnings(
- referencedFrom, MethodReferenceUtils::toSourceString));
- }
-
- void inspectDiagnosticsWithIgnoreWarnings(
- TestDiagnosticMessages diagnostics, String expectedDiagnosticMessage) {
- MissingDefinitionsDiagnosticImpl diagnostic =
- diagnostics
- .assertOnlyWarnings()
- .assertWarningsCount(1)
- .assertAllWarningsMatch(diagnosticType(MissingDefinitionsDiagnosticImpl.class))
- .getWarning(0);
- assertEquals(ImmutableSet.of(getMissingClassReference()), diagnostic.getMissingClasses());
- assertEquals(expectedDiagnosticMessage, diagnostic.getDiagnosticMessage());
- }
-
- private <T> String getExpectedDiagnosticMessageWithIgnoreWarnings(
- T referencedFrom, Function<T, String> toSourceStringFunction) {
- return "Missing class "
- + getMissingClassReference().getTypeName()
- + " (referenced from: "
- + toSourceStringFunction.apply(referencedFrom)
- + ")";
+ TestDiagnosticMessages diagnostics,
+ MissingDefinitionContext[] referencedFrom,
+ String expectedDiagnosticMessage) {
+ diagnostics
+ .assertOnlyWarnings()
+ .inspectWarnings(
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .applyIf(
+ referencedFrom != null,
+ checker ->
+ checker.assertIsMissingClassWithExactContexts(
+ getMissingClassReference(), referencedFrom),
+ checker -> checker.assertIsMissingClass(getMissingClassReference()))
+ .assertHasMessage(expectedDiagnosticMessage)
+ .assertNumberOfMissingClasses(1));
}
void inspectDiagnosticsWithNoRules(
- TestDiagnosticMessages diagnostics, ClassReference referencedFrom) {
+ TestDiagnosticMessages diagnostics, MissingDefinitionContext... referencedFrom) {
+ assertTrue(referencedFrom.length > 0);
inspectDiagnosticsWithNoRules(
diagnostics,
- getExpectedDiagnosticMessageWithNoRules(referencedFrom, ClassReference::getTypeName));
+ referencedFrom,
+ getExpectedDiagnosticMessage(
+ MissingDefinitionContextUtils.toSourceString(referencedFrom[0]),
+ referencedFrom.length));
}
void inspectDiagnosticsWithNoRules(
- TestDiagnosticMessages diagnostics, FieldReference referencedFrom) {
- inspectDiagnosticsWithNoRules(
- diagnostics,
- getExpectedDiagnosticMessageWithNoRules(
- referencedFrom, FieldReferenceUtils::toSourceString));
+ TestDiagnosticMessages diagnostics,
+ MissingDefinitionContext[] referencedFrom,
+ String expectedDiagnosticMessage) {
+ diagnostics
+ .assertOnlyErrors()
+ .inspectErrors(
+ diagnostic ->
+ diagnostic
+ .assertIsMissingDefinitionsDiagnostic()
+ .applyIf(
+ referencedFrom != null,
+ checker ->
+ checker.assertIsMissingClassWithExactContexts(
+ getMissingClassReference(), referencedFrom),
+ checker -> checker.assertIsMissingClass(getMissingClassReference()))
+ .assertHasMessage(expectedDiagnosticMessage)
+ .assertNumberOfMissingClasses(1));
}
- void inspectDiagnosticsWithNoRules(
- TestDiagnosticMessages diagnostics, MethodReference referencedFrom) {
- inspectDiagnosticsWithNoRules(
- diagnostics,
- getExpectedDiagnosticMessageWithNoRules(
- referencedFrom, MethodReferenceUtils::toSourceString));
- }
-
- void inspectDiagnosticsWithNoRules(
- TestDiagnosticMessages diagnostics, String expectedDiagnosticMessage) {
- MissingDefinitionsDiagnosticImpl diagnostic =
- diagnostics
- .assertOnlyErrors()
- .assertErrorsCount(1)
- .assertAllErrorsMatch(diagnosticType(MissingDefinitionsDiagnosticImpl.class))
- .getError(0);
- assertEquals(ImmutableSet.of(getMissingClassReference()), diagnostic.getMissingClasses());
- assertEquals(expectedDiagnosticMessage, diagnostic.getDiagnosticMessage());
- }
-
- private <T> String getExpectedDiagnosticMessageWithNoRules(
- T referencedFrom, Function<T, String> toSourceStringFunction) {
- return "Compilation can't be completed because the following class is missing: "
- + getMissingClassReference().getTypeName()
- + " (referenced from: "
- + toSourceStringFunction.apply(referencedFrom)
- + ")"
- + ".";
+ private String getExpectedDiagnosticMessage(String referencedFrom, int numberOfContexts) {
+ StringBuilder builder =
+ new StringBuilder("Missing class ")
+ .append(getMissingClassReference().getTypeName())
+ .append(" (referenced from: ")
+ .append(referencedFrom);
+ if (numberOfContexts > 1) {
+ builder.append(", and ").append(numberOfContexts - 1).append(" other context");
+ if (numberOfContexts > 2) {
+ builder.append("s");
+ }
+ }
+ return builder.append(")").toString();
}
}
diff --git a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
index f911ce6..413a4fd 100644
--- a/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/naming/EnumMinificationKotlinTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.naming;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isAbsent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.equalTo;
@@ -52,11 +53,12 @@
public void b121221542() throws Exception {
CodeInspector inspector =
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepClassRulesWithAllowObfuscation(ENUM_CLASS_NAME)
- .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
index 8775bd7..6597cb0 100644
--- a/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/IdentifierMinifierTest.java
@@ -72,8 +72,11 @@
.enableProguardTestOptions()
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- containsString("Cannot determine what identifier string flows to"))
+ .applyIf(
+ hasWarning,
+ result ->
+ result.assertAllWarningMessagesMatch(
+ containsString("Cannot determine what identifier string flows to")))
.inspector();
inspection.accept(parameters, codeInspector);
}
diff --git a/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java b/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
index ecbafd6..f40e8b3 100644
--- a/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/InterfaceRenamingTestRunner.java
@@ -22,7 +22,6 @@
import org.junit.Test;
import org.junit.runner.RunWith;
-@RunWith(VmTestRunner.class)
public class InterfaceRenamingTestRunner extends TestBase {
private static final Class<?> CLASS = InterfaceRenamingTest.class;
diff --git a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
index 3aff7c9..3c52044 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.naming;
import static com.android.tools.r8.KotlinCompilerTool.KotlinCompilerVersion.KOTLINC_1_3_72;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -91,10 +92,11 @@
String mainClassName = ex3.getClassName();
TestCompileResult<?, ?> result =
testForR8(Backend.DEX)
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(mainClassName)
- .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
.minification(minification)
.compile()
@@ -145,7 +147,9 @@
String mainClassName = testMain.getClassName();
SingleTestRunResult<?> result =
testForR8(Backend.DEX)
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.enableProguardTestOptions()
.addKeepMainRule(mainClassName)
@@ -155,7 +159,6 @@
"-" + NoVerticalClassMergingRule.RULE_NAME + " class **." + targetClassName,
"-" + NoHorizontalClassMergingRule.RULE_NAME + " class **." + targetClassName,
"-neverinline class **." + targetClassName + " { <methods>; }"))
- .addDontWarnJetBrainsNotNullAnnotation()
.allowDiagnosticWarningMessages()
.minification(minification)
.compile()
diff --git a/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java b/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java
index 7c25445..bdd3603 100644
--- a/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/LambdaRenamingTestRunner.java
@@ -5,126 +5,106 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.ByteDataView;
-import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
-import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.DexIndexedConsumer;
-import com.android.tools.r8.ProgramConsumer;
-import com.android.tools.r8.R8Command;
-import com.android.tools.r8.R8Command.Builder;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.VmTestRunner;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.StringUtils;
import java.io.IOException;
import java.nio.file.Path;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
-@RunWith(VmTestRunner.class)
+@RunWith(Parameterized.class)
public class LambdaRenamingTestRunner extends TestBase {
- static final Class CLASS = LambdaRenamingTest.class;
- static final Class[] CLASSES = LambdaRenamingTest.CLASSES;
+
+ private static final Class<?> CLASS = LambdaRenamingTest.class;
+ private static final Class<?>[] CLASSES = LambdaRenamingTest.CLASSES;
+ private static final String EXPECTED =
+ StringUtils.lines(
+ "null", "null", "null", "null", "10", "null", "null", "null", "null", "11", "10", "30",
+ "10", "30", "101", "301", "101", "301", "102", "302", "102", "302");
+
+ private final TestParameters parameters;
private Path inputJar;
- private ProcessResult runInput;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public LambdaRenamingTestRunner(TestParameters parameters) {
+ this.parameters = parameters;
+ }
@Before
public void writeAndRunInputJar() throws IOException {
inputJar = temp.getRoot().toPath().resolve("input.jar");
ArchiveConsumer buildInput = new ArchiveConsumer(inputJar);
- for (Class clazz : CLASSES) {
+ for (Class<?> clazz : CLASSES) {
buildInput.accept(
ByteDataView.of(ToolHelper.getClassAsBytes(clazz)),
DescriptorUtils.javaTypeToDescriptor(clazz.getName()),
null);
}
buildInput.finished(null);
- runInput = ToolHelper.runJava(inputJar, CLASS.getCanonicalName());
- assertEquals(0, runInput.exitCode);
- }
-
- private Path writeProguardRules(boolean aggressive) throws IOException {
- Path pgConfig = temp.getRoot().toPath().resolve("keep.txt");
- FileUtils.writeTextFile(
- pgConfig,
- "-keep public class " + CLASS.getCanonicalName() + " {",
- " public static void main(...);",
- "}",
- "-keep interface " + CLASS.getCanonicalName() + "$ReservedNameObjectInterface1 {",
- " public java.lang.Object reservedMethod1();",
- "}",
- "-keep interface " + CLASS.getCanonicalName() + "$ReservedNameIntegerInterface2 {",
- " public java.lang.Integer reservedMethod2();",
- "}",
- aggressive ? "-overloadaggressively" : "# Not overloading aggressively");
- return pgConfig;
}
@Test
public void testProguard() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
buildAndRunProguard("pg.jar", false);
}
@Test
public void testProguardAggressive() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
buildAndRunProguard("pg-aggressive.jar", true);
}
@Test
- public void testCf() throws Exception {
- buildAndRunCf("cf.zip", false);
+ public void testR8() throws Exception {
+ testR8(false);
}
@Test
- public void testCfAggressive() throws Exception {
- buildAndRunCf("cf-aggressive.zip", true);
+ public void testR8Aggressive() throws Exception {
+ testR8(true);
}
- @Test
- public void testDex() throws Exception {
- buildAndRunDex("dex.zip", false);
- }
-
- @Test
- public void testDexAggressive() throws Exception {
- buildAndRunDex("dex-aggressive.zip", true);
- }
-
- private void buildAndRunCf(String outName, boolean aggressive) throws Exception {
- Path outCf = temp.getRoot().toPath().resolve(outName);
- build(new ClassFileConsumer.ArchiveConsumer(outCf), aggressive);
- ProcessResult runCf = ToolHelper.runJava(outCf, CLASS.getCanonicalName());
- assertEquals(runInput.toString(), runCf.toString());
- }
-
- private void buildAndRunDex(String outName, boolean aggressive) throws Exception {
- Path outDex = temp.getRoot().toPath().resolve(outName);
- build(new DexIndexedConsumer.ArchiveConsumer(outDex), aggressive);
- ProcessResult runDex =
- ToolHelper.runArtNoVerificationErrorsRaw(outDex.toString(), CLASS.getCanonicalName());
- assertEquals(runInput.stdout, runDex.stdout);
- assertEquals(runInput.exitCode, runDex.exitCode);
- }
-
- private void build(ProgramConsumer consumer, boolean aggressive) throws Exception {
- Builder builder =
- ToolHelper.addProguardConfigurationConsumer(
- R8Command.builder(), configuration -> configuration.setPrintMapping(true))
- .setMode(CompilationMode.DEBUG)
- .addLibraryFiles(ToolHelper.getAndroidJar(ToolHelper.getMinApiLevelForDexVm()))
- .addProgramFiles(inputJar)
- .setProgramConsumer(consumer)
- .addProguardConfigurationFiles(writeProguardRules(aggressive));
- if (!(consumer instanceof ClassFileConsumer)) {
- builder.setMinApiLevel(ToolHelper.getMinApiLevelForDexVm().getLevel());
- }
- ToolHelper.runR8(builder.build());
+ private void testR8(boolean aggressive) throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramFiles(inputJar)
+ .addKeepMainRule(CLASS)
+ .addKeepRules(
+ "-keep interface " + CLASS.getCanonicalName() + "$ReservedNameObjectInterface1 {",
+ " public java.lang.Object reservedMethod1();",
+ "}",
+ "-keep interface " + CLASS.getCanonicalName() + "$ReservedNameIntegerInterface2 {",
+ " public java.lang.Integer reservedMethod2();",
+ "}")
+ .applyIf(aggressive, builder -> builder.addKeepRules("-overloadaggressively"))
+ .debug()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .apply(
+ compileResult ->
+ compileResult.run(parameters.getRuntime(), CLASS).assertSuccessWithOutput(EXPECTED))
+ .applyIf(
+ parameters.isDexRuntime(),
+ compileResult ->
+ compileResult.runDex2Oat(parameters.getRuntime()).assertNoVerificationErrors());
}
private void buildAndRunProguard(String outName, boolean aggressive) throws Exception {
@@ -144,4 +124,21 @@
assertNotEquals(-1, runPg.stderr.indexOf("AbstractMethodError"));
assertNotEquals(0, runPg.exitCode);
}
+
+ private Path writeProguardRules(boolean aggressive) throws IOException {
+ Path pgConfig = temp.getRoot().toPath().resolve("keep.txt");
+ FileUtils.writeTextFile(
+ pgConfig,
+ "-keep public class " + CLASS.getCanonicalName() + " {",
+ " public static void main(...);",
+ "}",
+ "-keep interface " + CLASS.getCanonicalName() + "$ReservedNameObjectInterface1 {",
+ " public java.lang.Object reservedMethod1();",
+ "}",
+ "-keep interface " + CLASS.getCanonicalName() + "$ReservedNameIntegerInterface2 {",
+ " public java.lang.Integer reservedMethod2();",
+ "}",
+ aggressive ? "-overloadaggressively" : "# Not overloading aggressively");
+ return pgConfig;
+ }
}
diff --git a/src/test/java/com/android/tools/r8/naming/NamingTestBase.java b/src/test/java/com/android/tools/r8/naming/NamingTestBase.java
index e461666..087e5d2 100644
--- a/src/test/java/com/android/tools/r8/naming/NamingTestBase.java
+++ b/src/test/java/com/android/tools/r8/naming/NamingTestBase.java
@@ -3,6 +3,8 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.naming;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
+
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.graph.AppView;
@@ -43,7 +45,10 @@
protected NamingLens runMinifier(List<Path> configPaths) throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- AndroidApp.builder().addProgramFile(Paths.get(appFileName)).build(),
+ AndroidApp.builder()
+ .addProgramFile(Paths.get(appFileName))
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
factory -> ToolHelper.loadProguardConfiguration(factory, configPaths));
dexItemFactory = appView.dexItemFactory();
ExecutorService executor = Executors.newSingleThreadExecutor();
diff --git a/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java b/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java
index a5a165b..a55e7da 100644
--- a/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b116840216/ReserveOuterClassNameTest.java
@@ -50,6 +50,7 @@
@RunWith(Parameterized.class)
public class ReserveOuterClassNameTest extends TestBase {
+
private Backend backend;
@Parameters(name = "Backend: {0}")
@@ -68,7 +69,8 @@
ToolHelper.getClassFileForTestClass(mainClass),
ToolHelper.getClassFileForTestClass(Outer.class),
ToolHelper.getClassFileForTestClass(Outer.Inner.class),
- ToolHelper.getClassFileForTestClass(NeverInline.class));
+ ToolHelper.getClassFileForTestClass(NeverInline.class),
+ ToolHelper.getClassFileForTestClass(NoHorizontalClassMerging.class));
builder.setProgramConsumer(emptyConsumer(backend));
builder.addLibraryFiles(runtimeJar(backend));
builder.addProguardConfiguration(
diff --git a/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java b/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
index 665e410..10ce37d 100644
--- a/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
+++ b/src/test/java/com/android/tools/r8/naming/b139991218/TestRunner.java
@@ -4,7 +4,9 @@
package com.android.tools.r8.naming.b139991218;
+import static com.android.tools.r8.ToolHelper.getMostRecentKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.CompilationFailedException;
@@ -54,7 +56,8 @@
ToolHelper.TESTS_BUILD_DIR,
"kotlinR8TestResources",
"JAVA_8",
- "lambdas_kstyle_generics" + FileUtils.JAR_EXTENSION))
+ "lambdas_kstyle_generics" + FileUtils.JAR_EXTENSION),
+ getMostRecentKotlinAnnotationJar())
.addKeepMainRule(Main.class)
.addKeepAllAttributes()
.addOptionsModification(
@@ -67,13 +70,15 @@
.skipNoClassesOrMembersWithAnnotationsPolicyForTesting =
true;
})
- .addDontWarnJetBrainsAnnotations()
.addHorizontallyMergedClassesInspector(
inspector ->
inspector.assertIsCompleteMergeGroup(
"com.android.tools.r8.naming.b139991218.Lambda1",
"com.android.tools.r8.naming.b139991218.Lambda2"))
+ .allowDiagnosticWarningMessages()
.setMinApi(parameters.getApiLevel())
+ .compile()
+ .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
.run(parameters.getRuntime(), Main.class)
.assertSuccessWithOutputLines("11", "12")
.inspect(
diff --git a/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java b/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
index fccc7b2..470b542 100644
--- a/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/b173184123/ClassExtendsInterfaceNamingTest.java
@@ -54,6 +54,7 @@
parameters.getBackend(),
parameters.isCfRuntime() ? parameters.getRuntime() : TestRuntime.getCheckedInJdk11())
.addProgramFiles(classFiles)
+ .addTestingAnnotationsAsProgramClasses()
.enableAssertions(false)
.useR8WithRelocatedDeps()
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/naming/b80083341/B80083341.java b/src/test/java/com/android/tools/r8/naming/b80083341/B80083341.java
index e192b8e..3f77e2b 100644
--- a/src/test/java/com/android/tools/r8/naming/b80083341/B80083341.java
+++ b/src/test/java/com/android/tools/r8/naming/b80083341/B80083341.java
@@ -19,7 +19,6 @@
import org.junit.Test;
import org.junit.runner.RunWith;
-@RunWith(VmTestRunner.class)
public class B80083341 extends TestBase {
@Test
diff --git a/src/test/java/com/android/tools/r8/proguard/configuration/RepackagingCompatibilityTest.java b/src/test/java/com/android/tools/r8/proguard/configuration/RepackagingCompatibilityTest.java
index b078b2f..c09d730 100644
--- a/src/test/java/com/android/tools/r8/proguard/configuration/RepackagingCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/proguard/configuration/RepackagingCompatibilityTest.java
@@ -62,7 +62,7 @@
@Test
public void testProguard() throws Exception {
- runTest(testForProguard().addKeepRules("-dontwarn " + getClass().getTypeName()), "Proguard");
+ runTest(testForProguard().addDontWarn(getClass()), "Proguard");
}
private void runTest(TestShrinkerBuilder<?, ?, ?, ?, ?> builder, String shrinker)
diff --git a/src/test/java/com/android/tools/r8/regress/b111080693/B111080693.java b/src/test/java/com/android/tools/r8/regress/b111080693/B111080693.java
index 46700f1..542e7e5 100644
--- a/src/test/java/com/android/tools/r8/regress/b111080693/B111080693.java
+++ b/src/test/java/com/android/tools/r8/regress/b111080693/B111080693.java
@@ -23,7 +23,6 @@
import org.junit.Test;
import org.junit.runner.RunWith;
-@RunWith(VmTestRunner.class)
public class B111080693 extends TestBase {
@Test
public void test() throws Exception {
diff --git a/src/test/java/com/android/tools/r8/regress/b72485384/Regress72485384Test.java b/src/test/java/com/android/tools/r8/regress/b72485384/Regress72485384Test.java
index 57e7343..2a7889d 100644
--- a/src/test/java/com/android/tools/r8/regress/b72485384/Regress72485384Test.java
+++ b/src/test/java/com/android/tools/r8/regress/b72485384/Regress72485384Test.java
@@ -3,68 +3,64 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.regress.b72485384;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.regress.b72485384.GenericOuter.GenericInner;
-import com.android.tools.r8.utils.AndroidApp;
-import com.google.common.collect.ImmutableList;
-import java.util.Arrays;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
-import org.junit.Rule;
import org.junit.Test;
-import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
public class Regress72485384Test extends TestBase {
- @Rule public ExpectedException thrown = ExpectedException.none();
- @Parameters(name = "{0}")
+ @Parameters(name = "{1}, allowUnusedProguardConfigurationRules: {0}")
public static Collection<Object[]> getParameters() {
String baseConfig =
keepMainProguardConfiguration(Main.class)
+ "-keepattributes Signature,InnerClasses,EnclosingMethod ";
- return Arrays.asList(
- new Object[][] {
- {baseConfig, null},
- {baseConfig + "-dontshrink", null},
- {baseConfig + "-dontshrink -dontobfuscate", null},
- {baseConfig + "-dontobfuscate", null},
- {"-keep class DoesNotExist -dontshrink", "ClassNotFoundException"}
- });
+ TestParametersCollection parametersCollection =
+ getTestParameters()
+ .withDexRuntimes()
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+ .build();
+ List<Object[]> tests = new ArrayList<>();
+ for (TestParameters parameters : parametersCollection) {
+ Collections.addAll(
+ tests,
+ new Object[][] {
+ {parameters, baseConfig},
+ {parameters, baseConfig + "-dontshrink"},
+ {parameters, baseConfig + "-dontshrink -dontobfuscate"},
+ {parameters, baseConfig + "-dontobfuscate"}
+ });
+ }
+ return tests;
}
- private static final List<Class<?>> CLASSES =
- ImmutableList.of(GenericOuter.class, GenericInner.class, Main.class);
-
+ private final TestParameters parameters;
private final String proguardConfig;
- private final String expectedErrorMessage;
- public Regress72485384Test(String proguardConfig, String expectedErrorMessage) {
+ public Regress72485384Test(TestParameters parameters, String proguardConfig) {
+ this.parameters = parameters;
this.proguardConfig = proguardConfig;
- this.expectedErrorMessage = expectedErrorMessage;
}
@Test
public void testSignatureRewrite() throws Exception {
- AndroidApp app = compileWithR8(CLASSES, proguardConfig);
-
- if (expectedErrorMessage == null) {
- if (ToolHelper.getDexVm().getVersion().isOlderThanOrEqual(ToolHelper.DexVm.Version.V6_0_1)) {
- // Resolution of java.util.function.Function fails.
- thrown.expect(AssertionError.class);
- }
-
- runOnArt(app, Main.class.getCanonicalName());
- } else {
- ToolHelper.ProcessResult result = runOnArtRaw(app, Main.class.getCanonicalName());
- assertThat(result.stderr, containsString(expectedErrorMessage));
- }
+ testForR8(parameters.getBackend())
+ .addProgramClasses(GenericOuter.class, GenericInner.class, Main.class)
+ .addKeepRules(proguardConfig)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Hello World!", "Hello World!");
}
}
diff --git a/src/test/java/com/android/tools/r8/regress/b77496850/B77496850.java b/src/test/java/com/android/tools/r8/regress/b77496850/B77496850.java
index 84e470e..f3ab264 100644
--- a/src/test/java/com/android/tools/r8/regress/b77496850/B77496850.java
+++ b/src/test/java/com/android/tools/r8/regress/b77496850/B77496850.java
@@ -406,7 +406,7 @@
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
- System.out.println(new Reproduction().test());
+ System.out.println(new ReproductionWithExceptionHandler().test());
}
}
}
diff --git a/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java b/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java
new file mode 100644
index 0000000..a203729
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/RepackageFeatureWithSyntheticsTest.java
@@ -0,0 +1,147 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.repackage;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class RepackageFeatureWithSyntheticsTest extends RepackageTestBase {
+
+ public RepackageFeatureWithSyntheticsTest(
+ String flattenPackageHierarchyOrRepackageClasses, TestParameters parameters) {
+ super(flattenPackageHierarchyOrRepackageClasses, parameters);
+ }
+
+ private static final Class<?> FIRST_FOO =
+ com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.Foo.class;
+
+ private static final Class<?> FIRST_PKG_PRIVATE =
+ com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first
+ .PkgProtectedMethod.class;
+
+ private static final List<Class<?>> FIRST_CLASSES =
+ ImmutableList.of(FIRST_FOO, FIRST_PKG_PRIVATE);
+
+ private static final List<Class<?>> FIRST_FIRST_CLASSES =
+ ImmutableList.of(
+ com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first.Foo
+ .class,
+ com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first
+ .PkgProtectedMethod.class);
+
+ private static List<Class<?>> getTestClasses() {
+ return ImmutableList.<Class<?>>builder()
+ .addAll(getBaseClasses())
+ .add(TestClass.class)
+ .add(I.class)
+ .build();
+ }
+
+ private static List<Class<?>> getBaseClasses() {
+ return FIRST_CLASSES;
+ }
+
+ private static List<Class<?>> getFeatureClasses() {
+ return FIRST_FIRST_CLASSES;
+ }
+
+ private static String EXPECTED = StringUtils.lines("first.Foo", "first.first.Foo");
+
+ @Override
+ public String getRepackagePackage() {
+ return "dest";
+ }
+
+ @Test
+ public void testReference() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClasses(getTestClasses())
+ .addProgramClasses(getFeatureClasses())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void test() throws Exception {
+ assumeTrue("Feature splits require DEX output.", parameters.isDexRuntime());
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(getTestClasses())
+ .addFeatureSplit(getFeatureClasses().toArray(new Class<?>[0]))
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassAndMembersRules(
+ com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first
+ .PkgProtectedMethod.class,
+ com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first
+ .first.PkgProtectedMethod.class)
+ .addKeepClassAndMembersRules(I.class)
+ .addKeepMethodRules(
+ Reference.methodFromMethod(TestClass.class.getDeclaredMethod("run", I.class)))
+ .addKeepAttributeInnerClassesAndEnclosingMethod()
+ .noMinification()
+ .apply(this::configureRepackaging)
+ .enableNeverClassInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+
+ // Each Foo class will give rise to a single lambda.
+ int expectedSyntheticsInBase = 1;
+ int expectedSyntheticsInFeature = 1;
+
+ // Check that the first.Foo is repackaged but that the pkg private access class is not.
+ // The implies that the lambda which is doing a package private access cannot be repackaged.
+ // If it is, the access will fail resulting in a runtime exception.
+ CodeInspector baseInspector = compileResult.inspector();
+ assertThat(FIRST_FOO, isRepackagedAsExpected(baseInspector, "first"));
+ assertThat(FIRST_PKG_PRIVATE, isNotRepackaged(baseInspector));
+ assertEquals(
+ getTestClasses().size() + expectedSyntheticsInBase, baseInspector.allClasses().size());
+
+ // The feature first.first.Foo is not repackaged and neither is the lambda.
+ // TODO(b/180086194): first.first.Foo should have been repackaged, but is currently identified
+ // as being in 'base' when inlining takes place.
+ CodeInspector featureInspector = new CodeInspector(compileResult.getFeature(0));
+ getFeatureClasses().forEach(c -> assertThat(c, isNotRepackaged(featureInspector)));
+ assertEquals(
+ getFeatureClasses().size() + expectedSyntheticsInFeature,
+ featureInspector.allClasses().size());
+
+ compileResult
+ .addFeatureSplitsToRunClasspathFiles()
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("first.Foo", "first.first.Foo");
+ }
+
+ public interface I {
+ void run();
+ }
+
+ public static class TestClass {
+
+ // Public kept run method to accept a lambda ensuring desugaring which cannot be optimized out.
+ public static void run(I i) {
+ i.run();
+ }
+
+ public static void main(String[] args) {
+ new com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.Foo();
+ new com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first
+ .Foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/Foo.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/Foo.java
new file mode 100644
index 0000000..e7b1cf9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/Foo.java
@@ -0,0 +1,16 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.repackage.RepackageFeatureWithSyntheticsTest.TestClass;
+
+@NeverClassInline
+public class Foo {
+
+ public Foo() {
+ TestClass.run(() -> PkgProtectedMethod.getStream().println("first.Foo"));
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/PkgProtectedMethod.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/PkgProtectedMethod.java
new file mode 100644
index 0000000..10ddc99
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/PkgProtectedMethod.java
@@ -0,0 +1,14 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first;
+
+import java.io.PrintStream;
+
+public class PkgProtectedMethod {
+
+ /* package protected */
+ static PrintStream getStream() {
+ return System.out;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/first/Foo.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/first/Foo.java
new file mode 100644
index 0000000..dcee445
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/first/Foo.java
@@ -0,0 +1,16 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first;
+
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.repackage.RepackageFeatureWithSyntheticsTest.TestClass;
+
+@NeverClassInline
+public class Foo {
+
+ public Foo() {
+ TestClass.run(() -> PkgProtectedMethod.getStream().println("first.first.Foo"));
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/first/PkgProtectedMethod.java b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/first/PkgProtectedMethod.java
new file mode 100644
index 0000000..0473a26
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/repackage/testclasses/repackagefeaturewithsynthetics/first/first/PkgProtectedMethod.java
@@ -0,0 +1,14 @@
+// Copyright (c) 2021, 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 com.android.tools.r8.repackage.testclasses.repackagefeaturewithsynthetics.first.first;
+
+import java.io.PrintStream;
+
+public class PkgProtectedMethod {
+
+ /* package protected */
+ static PrintStream getStream() {
+ return System.out;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/InvokeSuperCallInStaticTest.java b/src/test/java/com/android/tools/r8/resolution/InvokeSuperCallInStaticTest.java
index 74f834d..f1ea8f0 100644
--- a/src/test/java/com/android/tools/r8/resolution/InvokeSuperCallInStaticTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/InvokeSuperCallInStaticTest.java
@@ -54,6 +54,7 @@
computeAppViewWithLiveness(
buildClasses(Base.class, Main.class)
.addClassProgramData(getAWithRewrittenInvokeSpecialToBase())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
index a702874..2b560e2 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.resolution;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@@ -87,7 +88,13 @@
@BeforeClass
public static void computeAppInfo() throws Exception {
- appView = computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, ASM_CLASSES), Main.class);
+ appView =
+ computeAppViewWithLiveness(
+ buildClassesWithTestingAnnotations(CLASSES)
+ .addClassProgramData(ASM_CLASSES)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
+ Main.class);
appInfo = appView.appInfo();
}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
index c0996fe..75d4bbc 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.resolution;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertTrue;
@@ -57,7 +58,10 @@
@BeforeClass
public static void computeAppInfo() throws Exception {
- appInfo = computeAppViewWithLiveness(readClasses(CLASSES), Main.class).appInfo();
+ appInfo =
+ computeAppViewWithLiveness(
+ buildClasses(CLASSES).addLibraryFile(getMostRecentAndroidJar()).build(), Main.class)
+ .appInfo();
}
private static DexMethod buildMethod(Class clazz, String name) {
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
index 1d6dc16..6be194c 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.resolution;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertTrue;
@@ -78,7 +79,11 @@
public static void computeAppInfo() throws Exception {
appInfo =
computeAppViewWithLiveness(
- buildClasses(CLASSES).addClassProgramData(getDumps()).build(), Main.class)
+ buildClasses(CLASSES)
+ .addClassProgramData(getDumps())
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
+ Main.class)
.appInfo();
}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
index 5b08461..c92f813 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentInterfaceTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.resolution;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -90,14 +91,20 @@
public static List<Class<?>> CLASSES = ImmutableList.of(A.class, C.class, Main.class);
- public static List<byte[]> DUMPS = ImmutableList.of(BDump.dump());
+ public static byte[] DUMP = BDump.dump();
private static AppInfoWithLiveness appInfo;
@BeforeClass
public static void computeAppInfo() throws Exception {
appInfo =
- computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, DUMPS), Main.class).appInfo();
+ computeAppViewWithLiveness(
+ buildClasses(CLASSES)
+ .addClassProgramData(DUMP)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
+ Main.class)
+ .appInfo();
}
private static DexMethod buildMethod(Class clazz, String name) {
@@ -148,13 +155,13 @@
runResult =
testForJvm()
.addProgramClasses(CLASSES)
- .addProgramClassFileData(DUMPS)
+ .addProgramClassFileData(DUMP)
.run(parameters.getRuntime(), Main.class);
} else {
runResult =
testForD8()
.addProgramClasses(CLASSES)
- .addProgramClassFileData(DUMPS)
+ .addProgramClassFileData(DUMP)
.setMinApi(parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class);
}
@@ -175,7 +182,7 @@
R8TestRunResult runResult =
testForR8(parameters.getBackend())
.addProgramClasses(CLASSES)
- .addProgramClassFileData(DUMPS)
+ .addProgramClassFileData(DUMP)
.addKeepMainRule(Main.class)
.setMinApi(parameters.getApiLevel())
.addOptionsModification(o -> o.enableVerticalClassMerging = enableVerticalClassMerging)
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
index fe66478..2ffd43d 100644
--- a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.resolution;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -143,7 +144,13 @@
@BeforeClass
public static void computeAppInfo() throws Exception {
appInfo =
- computeAppViewWithLiveness(readClassesAndAsmDump(CLASSES, DUMPS), Main.class).appInfo();
+ computeAppViewWithLiveness(
+ buildClasses(CLASSES)
+ .addClassProgramData(DUMPS)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
+ Main.class)
+ .appInfo();
}
private static DexMethod buildMethod(Class clazz, String name) {
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
index 7d30885..ada12fe 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestInvokeSpecialMethodPublicAccessWithIntermediateTest.java
@@ -137,7 +137,10 @@
private AppView<AppInfoWithLiveness> getAppView() throws Exception {
return computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ buildClasses(getClasses())
+ .addClassProgramData(getTransformedClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java
index 2000456..9785c92 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java
@@ -64,7 +64,10 @@
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ buildClasses(getClasses())
+ .addClassProgramData(getTransformedClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass bClass =
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java
index 9ceaddc..1df6b63 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java
@@ -63,7 +63,10 @@
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ buildClasses(getClasses())
+ .addClassProgramData(getTransformedClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass bClass =
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
index e172db4..7ab3821 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
@@ -67,7 +67,10 @@
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ buildClassesWithTestingAnnotations(getClasses())
+ .addClassProgramData(getTransformedClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass bClass =
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java
index da00722..2c0dbca 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java
@@ -62,7 +62,10 @@
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ buildClasses(getClasses())
+ .addClassProgramData(getTransformedClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass bClass =
diff --git a/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
index f2d4c5c..cd2679e 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
@@ -50,7 +50,10 @@
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ buildClasses(getClasses())
+ .addClassProgramData(getTransformedClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass aClass =
diff --git a/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java
index 4d0f445..ea51b57 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java
@@ -49,7 +49,11 @@
@Test
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(readClasses(getClasses()), Main.class);
+ computeAppViewWithLiveness(
+ buildClasses(getClasses())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass cClass =
appInfo.definitionFor(buildType(C.class, appInfo.dexItemFactory())).asProgramClass();
diff --git a/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java
index 6e51158..008a478 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java
@@ -56,7 +56,11 @@
public void testResolutionAccess() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getClasses()).addClassProgramData(getTransforms()).build(), Main.class);
+ buildClasses(getClasses())
+ .addClassProgramData(getTransforms())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexProgramClass cClass =
appInfo.definitionFor(buildType(C.class, appInfo.dexItemFactory())).asProgramClass();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java
index 44f969f..6c6d9fe 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/AbstractAllTest.java
@@ -35,13 +35,14 @@
}
private static final List<Class<?>> CLASSES =
- ImmutableList.of(T.class, L.class, R.class, B.class, Main.class);
+ ImmutableList.of(T.class, L.class, R.class, B.class, C.class, Main.class);
@Test
public void testResolution() throws Exception {
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
- AndroidApp app = readClasses(CLASSES);
+ AndroidApp app =
+ buildClasses(CLASSES).addLibraryFile(parameters.getDefaultRuntimeLibrary()).build();
AppInfoWithLiveness appInfo = computeAppViewWithLiveness(app, Main.class).appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
index 990d146..273fb50 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultLeftAbstractRightTest.java
@@ -45,6 +45,7 @@
computeAppViewWithLiveness(
buildClasses(CLASSES)
.addClassProgramData(Collections.singletonList(transformB()))
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class)
.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
index 32d88b3..9897acd 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultRightAbstractLeftTest.java
@@ -45,6 +45,7 @@
computeAppViewWithLiveness(
buildClasses(CLASSES)
.addClassProgramData(Collections.singletonList(transformB()))
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class)
.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java
index 91b71ce..baa7747 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractLeftTest.java
@@ -48,6 +48,7 @@
computeAppViewWithLiveness(
buildClasses(CLASSES)
.addClassProgramData(Collections.singletonList(transformB()))
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class)
.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java
index 61f9725..904640e 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAbstractRightTest.java
@@ -48,6 +48,7 @@
computeAppViewWithLiveness(
buildClasses(CLASSES)
.addClassProgramData(Collections.singletonList(transformB()))
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class)
.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
index 5c8f813..6406ea0 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndBothTest.java
@@ -47,6 +47,7 @@
computeAppViewWithLiveness(
buildClasses(CLASSES)
.addClassProgramData(Collections.singletonList(transformB()))
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class)
.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
index 74fb903..de6da74 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndLeftTest.java
@@ -41,7 +41,10 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(readClasses(CLASSES), Main.class).appInfo();
+ computeAppViewWithLiveness(
+ buildClasses(CLASSES).addLibraryFile(parameters.getDefaultRuntimeLibrary()).build(),
+ Main.class)
+ .appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
index 13f9340..7325cc1 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/DefaultTopAndRightTest.java
@@ -41,7 +41,10 @@
// The resolution is runtime independent, so just run it on the default CF VM.
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppInfoWithLiveness appInfo =
- computeAppViewWithLiveness(readClasses(CLASSES), Main.class).appInfo();
+ computeAppViewWithLiveness(
+ buildClasses(CLASSES).addLibraryFile(parameters.getDefaultRuntimeLibrary()).build(),
+ Main.class)
+ .appInfo();
DexMethod method = buildNullaryVoidMethod(B.class, "f", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
index 8bc64cf..296f95f 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacediamonds/TwoDefaultMethodsWithoutTopTest.java
@@ -48,6 +48,7 @@
computeAppViewWithLiveness(
buildClasses(CLASSES)
.addClassProgramData(Collections.singletonList(transformB()))
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class)
.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
index 8f800f6..fbece8f 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodAsOverrideWithLambdaTest.java
@@ -54,7 +54,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, A.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java
index 169c255..8d0eb98 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultMethodLambdaTest.java
@@ -52,7 +52,11 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(buildClasses(I.class, A.class, Main.class).build(), Main.class);
+ computeAppViewWithLiveness(
+ buildClassesWithTestingAnnotations(I.class, A.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java
index 16c1401..e7532b1 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DefaultWithoutTopTest.java
@@ -53,8 +53,9 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, Main.class)
+ buildClassesWithTestingAnnotations(I.class, J.class, Main.class)
.addClassProgramData(setAImplementsIAndJ())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
@@ -99,8 +100,9 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, K.class, Main.class)
+ buildClassesWithTestingAnnotations(I.class, J.class, K.class, Main.class)
.addClassProgramData(setAimplementsIandK())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java
index 8b1f615..63d9316 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/DuplicateImportsTest.java
@@ -54,7 +54,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, A.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java
index 3d20751..b15d446 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceClInitTest.java
@@ -52,6 +52,7 @@
computeAppViewWithLiveness(
buildClasses(A.class, B.class)
.addClassProgramData(transformI(), transformMain())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
index b4009fb..0ec1ce8 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/InvokeInterfaceWithStaticTargetTest.java
@@ -46,7 +46,10 @@
assumeTrue(parameters.getRuntime().equals(TestRuntime.getDefaultJavaRuntime()));
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, I.class).addClassProgramData(transformMain()).build(),
+ buildClasses(A.class, I.class)
+ .addClassProgramData(transformMain())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "bar", appInfo.dexItemFactory());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java
index 958e785..5f35faa 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/LambdaMultipleInterfacesTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, A.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(J.class, "bar", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java
index eb88c69..112c684 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/MultipleImplementsTest.java
@@ -53,7 +53,11 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, B.class, C.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(
+ I.class, J.class, A.class, B.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java
index ec16d6d..d011624 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SimpleInterfaceInvokeTest.java
@@ -54,7 +54,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, B.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, A.class, B.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java
index 3e582c5..9caa8d2 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubInterfaceOverridesTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, A.class, B.class, C.class, Main.class).build(),
+ buildClassesWithTestingAnnotations(
+ I.class, J.class, A.class, B.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java
index 5628ea2..aef0b3d 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeMissingOverridesTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, B.class, C.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, A.class, B.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
@@ -65,11 +68,7 @@
Set<String> targets = new HashSet<>();
lookupResult
.asLookupResultSuccess()
- .forEach(
- target -> targets.add(target.getDefinition().qualifiedName()),
- lambda -> {
- fail();
- });
+ .forEach(target -> targets.add(target.getDefinition().qualifiedName()), lambda -> fail());
ImmutableSet<String> expected =
ImmutableSet.of(B.class.getTypeName() + ".foo", C.class.getTypeName() + ".foo");
assertEquals(expected, targets);
diff --git a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java
index 65d8bca..d6230c7 100644
--- a/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/interfacetargets/SubTypeOverridesTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, B.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, A.class, B.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method.holder, method);
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java
index 1033136..129c033 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateClasspathWidenTest.java
@@ -65,7 +65,11 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(C.class, Main.class).addClasspathFiles(classPathJar).build(), Main.class);
+ buildClasses(C.class, Main.class)
+ .addClasspathFiles(classPathJar)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(Abstract.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryTest.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryTest.java
index 3a20a43..9d06f40 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, C.class, D.class, Main.class).build(), Main.class);
+ buildClasses(A.class, B.class, C.class, D.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "bar", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryWithNarrowingTest.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryWithNarrowingTest.java
index 81920cb..a9eddd1 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryWithNarrowingTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateReentryWithNarrowingTest.java
@@ -57,7 +57,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, C.class, D.class, Main.class).build(), Main.class);
+ buildClasses(A.class, B.class, C.class, D.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "bar", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethod2Test.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethod2Test.java
index a964f73..fd40588 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethod2Test.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethod2Test.java
@@ -68,6 +68,7 @@
J.class,
Main.class)
.addClassProgramData(getNonAbstractWithoutDeclaredMethods())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethodTest.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethodTest.java
index 3920cc8..58f4f6d 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/PackagePrivateWithDefaultMethodTest.java
@@ -62,6 +62,7 @@
J.class,
Main.class)
.addClassProgramData(getNonAbstractWithoutDeclaredMethods())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/packageprivate/WidenAccessOutsidePackageTest.java b/src/test/java/com/android/tools/r8/resolution/packageprivate/WidenAccessOutsidePackageTest.java
index d86de60..d5b9556 100644
--- a/src/test/java/com/android/tools/r8/resolution/packageprivate/WidenAccessOutsidePackageTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/packageprivate/WidenAccessOutsidePackageTest.java
@@ -54,7 +54,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, C.class, Main.class).build(), Main.class);
+ buildClasses(A.class, B.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "bar", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/singletarget/InstantiatedLowerBoundTest.java b/src/test/java/com/android/tools/r8/resolution/singletarget/InstantiatedLowerBoundTest.java
index 4e19a05..9e89194 100644
--- a/src/test/java/com/android/tools/r8/resolution/singletarget/InstantiatedLowerBoundTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/singletarget/InstantiatedLowerBoundTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.resolution.singletarget;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertNotNull;
import static junit.framework.TestCase.assertTrue;
@@ -46,7 +47,9 @@
public void testSingleTargetLowerBoundInstantiated() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, Main.class).build(),
+ buildClasses(A.class, B.class, Main.class)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
factory ->
buildConfigForRules(factory, buildKeepRuleForClassAndMethods(Main.class, factory)));
AppInfoWithLiveness appInfo = appView.appInfo();
@@ -71,7 +74,9 @@
public void testSingleTargetLowerBoundInMiddleInstantiated() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, C.class, Main.class).build(),
+ buildClasses(A.class, B.class, C.class, Main.class)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
factory ->
buildConfigForRules(factory, buildKeepRuleForClassAndMethods(Main.class, factory)));
AppInfoWithLiveness appInfo = appView.appInfo();
@@ -96,7 +101,9 @@
public void testSingleTargetLowerAllInstantiated() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, C.class, MainAllInstantiated.class).build(),
+ buildClasses(A.class, B.class, C.class, MainAllInstantiated.class)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
factory ->
buildConfigForRules(
factory, buildKeepRuleForClassAndMethods(MainAllInstantiated.class, factory)));
diff --git a/src/test/java/com/android/tools/r8/resolution/singletarget/SuccessAndInvalidLookupTest.java b/src/test/java/com/android/tools/r8/resolution/singletarget/SuccessAndInvalidLookupTest.java
index 593670d..916c7a0 100644
--- a/src/test/java/com/android/tools/r8/resolution/singletarget/SuccessAndInvalidLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/singletarget/SuccessAndInvalidLookupTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.resolution.singletarget;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertNotNull;
import static junit.framework.TestCase.assertNull;
@@ -31,14 +32,16 @@
}
public SuccessAndInvalidLookupTest(TestParameters parameters) {
- // Empty to satisfy construction of none-runtime.
+ assert parameters.isNoneRuntime();
}
@Test
public void testSingleTargetWithInvalidInvokeInterfaceInvoke() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, Main.class).build(),
+ buildClasses(I.class, A.class, Main.class)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
factory ->
buildConfigForRules(factory, buildKeepRuleForClassAndMethods(Main.class, factory)));
AppInfoWithLiveness appInfo = appView.appInfo();
@@ -62,7 +65,9 @@
public void testSingleTargetWithInvalidInvokeVirtualInvoke() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, Main.class).build(),
+ buildClasses(I.class, A.class, Main.class)
+ .addLibraryFile(getMostRecentAndroidJar())
+ .build(),
factory ->
buildConfigForRules(factory, buildKeepRuleForClassAndMethods(Main.class, factory)));
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java
index 787f992..ee3387e 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/AbstractInMiddleTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, B.class, C.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(A.class, B.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java
index 80b6908..73b0af5 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceSubTypeTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, A.class, B.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, J.class, A.class, B.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java
index a4966b4..1f27130 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultInterfaceMethodInSubInterfaceTest.java
@@ -53,7 +53,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, A.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, J.class, A.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java
index 1e23ae3..11e259c 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/DefaultWithoutTopTest.java
@@ -53,8 +53,9 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, J.class, Main.class)
+ buildClassesWithTestingAnnotations(I.class, J.class, Main.class)
.addClassProgramData(setAImplementsIAndJ())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvalidResolutionToThisTarget.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvalidResolutionToThisTarget.java
index b75b7ac..f19413c 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvalidResolutionToThisTarget.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvalidResolutionToThisTarget.java
@@ -54,6 +54,7 @@
computeAppViewWithLiveness(
buildClasses(A.class)
.addClassProgramData(getMainWithModifiedReceiverCall())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java
index dcb03f9..511d697 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/InvokeVirtualToInterfaceDefinitionTest.java
@@ -52,7 +52,11 @@
public void testResolution() throws Exception {
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(buildClasses(A.class, I.class, Main.class).build(), Main.class);
+ computeAppViewWithLiveness(
+ buildClassesWithTestingAnnotations(A.class, I.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java
index bc35d2b..7df1ec6 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/KeptTargetsIncompleteLookupTest.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.resolution.virtualtargets;
+import static com.android.tools.r8.ToolHelper.getMostRecentAndroidJar;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -62,7 +63,7 @@
methodToBeKept,
classToBeKept,
Arrays.asList(expectedMethodHolders),
- Arrays.asList(I.class, A.class, B.class, C.class, Main.class),
+ Arrays.asList(I.class, A.class, B.class, C.class, Main.class, Unrelated.class),
Main.class);
}
@@ -76,7 +77,7 @@
throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(classes).build(),
+ buildClasses(classes).addLibraryFile(getMostRecentAndroidJar()).build(),
factory -> {
List<ProguardConfigurationRule> rules = new ArrayList<>();
rules.addAll(buildKeepRuleForClassAndMethods(methodToBeKept, factory));
@@ -267,7 +268,9 @@
// private foo() <-- kept
// }
AppView<AppInfoWithLiveness> appView =
- computeAppViewWithLiveness(buildClasses(Unrelated.class).build(), Unrelated.class);
+ computeAppViewWithLiveness(
+ buildClasses(Unrelated.class).addLibraryFile(getMostRecentAndroidJar()).build(),
+ Unrelated.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(Unrelated.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateChainTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateChainTest.java
index c74b196..3fc0355 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateChainTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateChainTest.java
@@ -57,6 +57,7 @@
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
buildClasses(Top.class, Middle.class, Bottom.class, TopRunner.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java
index 00f9b0b..f081ef1 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PackagePrivateFinalOverrideTest.java
@@ -61,7 +61,9 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(MyViewModel.class, ViewModel.class, Main.class, ViewModelRunner.class)
+ buildClassesWithTestingAnnotations(
+ MyViewModel.class, ViewModel.class, Main.class, ViewModelRunner.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
@@ -110,7 +112,9 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(MyViewModel.class, ViewModel.class, Main.class, ViewModelRunner.class)
+ buildClassesWithTestingAnnotations(
+ MyViewModel.class, ViewModel.class, Main.class, ViewModelRunner.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
@@ -156,8 +160,13 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(
- MyViewModel.class, ViewModel.class, Main.class, ViewModelRunnerWithCast.class)
+ buildClassesWithTestingAnnotations(
+ MyViewModel.class,
+ ViewModel.class,
+ Main.class,
+ ViewModelRunner.class,
+ ViewModelRunnerWithCast.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PrivateOverrideOfVirtualTargetTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PrivateOverrideOfVirtualTargetTest.java
index e7319cd..86e9ecb 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/PrivateOverrideOfVirtualTargetTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/PrivateOverrideOfVirtualTargetTest.java
@@ -56,6 +56,7 @@
computeAppViewWithLiveness(
buildClasses(A.class, Main.class)
.addClassProgramData(getBWithModifiedInvokes())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedDifferentPackageLookupTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedDifferentPackageLookupTest.java
index 37b4dc8..092f9b5 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedDifferentPackageLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedDifferentPackageLookupTest.java
@@ -50,6 +50,7 @@
builder.addProgramFiles(ToolHelper.getClassFileForTestClass(A.class));
builder.addClassProgramData(
ImmutableList.of(getBInAnotherPackage(), getMainWithCallToRelocatedB()));
+ builder.addLibraryFile(parameters.getDefaultRuntimeLibrary());
AppView<AppInfoWithLiveness> appView = computeAppViewWithLiveness(builder.build(), Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedSamePackageLookupTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedSamePackageLookupTest.java
index ea86d8a..8915fa5 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedSamePackageLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/ProtectedSamePackageLookupTest.java
@@ -44,7 +44,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(A.class, C.class, Main.class).build(), PackagePrivateChainTest.Main.class);
+ buildClasses(A.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ PackagePrivateChainTest.Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(A.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnClass(method);
diff --git a/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java b/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java
index c1f2301..092bcb8 100644
--- a/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/virtualtargets/TargetInDefaultMethodTest.java
@@ -54,7 +54,10 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(I.class, A.class, B.class, C.class, Main.class).build(), Main.class);
+ buildClassesWithTestingAnnotations(I.class, A.class, B.class, C.class, Main.class)
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
+ .build(),
+ Main.class);
AppInfoWithLiveness appInfo = appView.appInfo();
DexMethod method = buildNullaryVoidMethod(I.class, "foo", appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethodOnInterface(method);
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
index b16dc35..b65563e 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionInSameFileRetraceTests.java
@@ -5,6 +5,8 @@
import static com.android.tools.r8.Collectors.toSingle;
import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.containsLinePositions;
import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
@@ -19,7 +21,6 @@
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.naming.retrace.StackTrace;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
@@ -74,7 +75,7 @@
assumeTrue(kotlinc.is(KotlinCompilerVersion.KOTLINC_1_3_72));
testForRuntime(parameters)
.addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
- .addRunClasspathFiles(buildOnDexRuntime(parameters, ToolHelper.getKotlinStdlibJar(kotlinc)))
+ .addRunClasspathFiles(buildOnDexRuntime(parameters, getKotlinStdlibJar(kotlinc)))
.run(parameters.getRuntime(), MAIN)
.assertFailureWithErrorThatMatches(containsString("foo"))
.assertFailureWithErrorThatMatches(
@@ -90,8 +91,7 @@
CodeInspector kotlinInspector = new CodeInspector(kotlinSources);
testForR8(parameters.getBackend())
.addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
- .addProgramFiles(ToolHelper.getKotlinStdlibJar(kotlinc))
- .addDontWarnJetBrainsNotNullAnnotation()
+ .addProgramFiles(getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAttributes("SourceFile", "LineNumberTable")
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(MAIN)
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
index ffc5515..17d4dc6 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -6,6 +6,8 @@
import static com.android.tools.r8.Collectors.toSingle;
import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.containsLinePositions;
import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
@@ -20,7 +22,6 @@
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.KotlinTestParameters;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.naming.retrace.StackTrace;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
@@ -87,7 +88,7 @@
public void testRuntime() throws Exception {
testForRuntime(parameters)
.addProgramFiles(compilationResults.getForConfiguration(kotlinc, targetVersion))
- .addRunClasspathFiles(buildOnDexRuntime(parameters, ToolHelper.getKotlinStdlibJar(kotlinc)))
+ .addRunClasspathFiles(buildOnDexRuntime(parameters, getKotlinStdlibJar(kotlinc)))
.run(parameters.getRuntime(), "retrace.MainKt")
.assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
.assertFailureWithErrorThatMatches(containsString("at retrace.MainKt.main(Main.kt:15)"));
@@ -102,12 +103,12 @@
Path kotlinSources = compilationResults.getForConfiguration(kotlinc, targetVersion);
CodeInspector kotlinInspector = new CodeInspector(kotlinSources);
testForR8(parameters.getBackend())
- .addProgramFiles(kotlinSources, ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(
+ kotlinSources, getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAttributes("SourceFile", "LineNumberTable")
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
- .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
@@ -134,12 +135,12 @@
Path kotlinSources = compilationResults.getForConfiguration(kotlinc, targetVersion);
CodeInspector kotlinInspector = new CodeInspector(kotlinSources);
testForR8(parameters.getBackend())
- .addProgramFiles(kotlinSources, ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(
+ kotlinSources, getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAttributes("SourceFile", "LineNumberTable")
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
- .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
@@ -169,12 +170,12 @@
Path kotlinSources = compilationResults.getForConfiguration(kotlinc, targetVersion);
CodeInspector kotlinInspector = new CodeInspector(kotlinSources);
testForR8(parameters.getBackend())
- .addProgramFiles(kotlinSources, ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(
+ kotlinSources, getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAttributes("SourceFile", "LineNumberTable")
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
- .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
@@ -203,12 +204,12 @@
Path kotlinSources = compilationResults.getForConfiguration(kotlinc, targetVersion);
CodeInspector kotlinInspector = new CodeInspector(kotlinSources);
testForR8(parameters.getBackend())
- .addProgramFiles(kotlinSources, ToolHelper.getKotlinStdlibJar(kotlinc))
+ .addProgramFiles(
+ kotlinSources, getKotlinStdlibJar(kotlinc), getKotlinAnnotationJar(kotlinc))
.addKeepAttributes("SourceFile", "LineNumberTable")
.allowDiagnosticWarningMessages()
.setMode(CompilationMode.RELEASE)
.addKeepMainRule(main)
- .addDontWarnJetBrainsNotNullAnnotation()
.setMinApi(parameters.getApiLevel())
.compile()
.assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
diff --git a/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java b/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java
index 0078c1b..e59bfb9 100644
--- a/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/JavaScriptScriptEngineTest.java
@@ -66,11 +66,15 @@
}
})
.compile()
- .assertAllWarningMessagesMatch(
- anyOf(
- containsString("Missing class "),
- containsString("required for default or static interface methods desugaring"),
- equalTo("Resource 'META-INF/MANIFEST.MF' already exists.")))
+ .applyIf(
+ parameters.isDexRuntime(),
+ result ->
+ result.assertAllWarningMessagesMatch(
+ anyOf(
+ containsString("Missing class "),
+ containsString(
+ "required for default or static interface methods desugaring"),
+ equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))))
.run(parameters.getRuntime(), TestClass.class)
.assertSuccessWithOutput(
parameters.isCfRuntime() ? EXPECTED_NASHORN_OUTPUT : EXPECTED_RHINO_OUTPUT);
diff --git a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
index 0077cef..dd55c22 100644
--- a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTest.java
@@ -79,11 +79,15 @@
// TODO(b/136633154): This should work both with and without -dontshrink.
.noTreeShaking()
.compile()
- .assertAllWarningMessagesMatch(
- anyOf(
- containsString("Missing class "),
- containsString("it is required for default or static interface methods desugaring"),
- equalTo("Resource 'META-INF/MANIFEST.MF' already exists.")))
+ .applyIf(
+ parameters.isDexRuntime(),
+ result ->
+ result.assertAllWarningMessagesMatch(
+ anyOf(
+ containsString("Missing class "),
+ containsString(
+ "it is required for default or static interface methods desugaring"),
+ equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))))
.writeToZip(path)
.run(parameters.getRuntime(), TestClass.class)
// TODO(b/136633154): This should provide 2 script engines on both runtimes. The use of
diff --git a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTestBase.java b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTestBase.java
index af0878b..5e411be 100644
--- a/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTestBase.java
+++ b/src/test/java/com/android/tools/r8/rewrite/ScriptEngineTestBase.java
@@ -4,15 +4,15 @@
package com.android.tools.r8.rewrite;
-import com.android.tools.r8.R8FullTestBuilder;
import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestShrinkerBuilder;
import com.android.tools.r8.ToolHelper;
import java.nio.file.Paths;
public class ScriptEngineTestBase extends TestBase {
- public void addRhinoForAndroid(TestBuilder builder) {
+ public void addRhinoForAndroid(TestBuilder<?, ?> builder) {
builder
// JSR 223: Scripting for the JavaTM Platform (https://jcp.org/en/jsr/detail?id=223).
.addProgramFiles(Paths.get(ToolHelper.JSR223_RI_JAR))
@@ -21,10 +21,10 @@
// The rhino-android contains concrete implementation of sun.misc.Service
// used by the JSR 223 RI, which is not in the Android runtime (except for N?).
.addProgramFiles(Paths.get(ToolHelper.RHINO_ANDROID_JAR));
- if (builder instanceof R8FullTestBuilder) {
- ((R8FullTestBuilder) builder)
+ if (builder instanceof TestShrinkerBuilder) {
+ ((TestShrinkerBuilder<?, ?, ?, ?, ?>) builder)
// The rhino-android library have references to missing classes.
- .addOptionsModification(options -> options.ignoreMissingClasses = true);
+ .addIgnoreWarnings();
}
}
diff --git a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
index 0298ecd..22ba711 100644
--- a/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/assertions/AssertionConfigurationKotlinTest.java
@@ -170,7 +170,11 @@
.allowDiagnosticWarningMessages(!kotlinStdlibAsLibrary)
.addRunClasspathFiles(kotlinStdlibLibraryForRuntime())
.compile()
- .assertAllWarningMessagesMatch(equalTo("Resource 'META-INF/MANIFEST.MF' already exists."))
+ .applyIf(
+ !kotlinStdlibAsLibrary,
+ result ->
+ result.assertAllWarningMessagesMatch(
+ equalTo("Resource 'META-INF/MANIFEST.MF' already exists.")))
.enableRuntimeAssertions(enableJvmAssertions)
.run(parameters.getRuntime(), testClassKt)
.inspect(inspector)
diff --git a/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java b/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java
index 512a9ff..df19a94 100644
--- a/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/FieldTypeTest.java
@@ -27,7 +27,6 @@
import org.junit.Test;
import org.junit.runner.RunWith;
-@RunWith(VmTestRunner.class)
public class FieldTypeTest extends TestBase {
private ClassBuilder addImplementor(
@@ -222,5 +221,4 @@
ClassSubject itf1Subject = inspector.clazz(itf1.name);
assertThat(itf1Subject, not(isPresent()));
}
-
}
diff --git a/src/test/java/com/android/tools/r8/shaking/InstantiatedLambdasTestRunner.java b/src/test/java/com/android/tools/r8/shaking/InstantiatedLambdasTestRunner.java
index c7ab1b7..88dd300 100644
--- a/src/test/java/com/android/tools/r8/shaking/InstantiatedLambdasTestRunner.java
+++ b/src/test/java/com/android/tools/r8/shaking/InstantiatedLambdasTestRunner.java
@@ -4,117 +4,96 @@
package com.android.tools.r8.shaking;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.ByteDataView;
-import com.android.tools.r8.ClassFileConsumer;
import com.android.tools.r8.ClassFileConsumer.ArchiveConsumer;
-import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.DexIndexedConsumer;
-import com.android.tools.r8.ProgramConsumer;
-import com.android.tools.r8.R8Command;
-import com.android.tools.r8.R8Command.Builder;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.StringUtils;
import java.io.IOException;
import java.nio.file.Path;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+@RunWith(Parameterized.class)
public class InstantiatedLambdasTestRunner extends TestBase {
- static final Class CLASS = InstantiatedLambdasTest.class;
- static final Class[] CLASSES = InstantiatedLambdasTest.CLASSES;
+
+ static final Class<?> CLASS = InstantiatedLambdasTest.class;
+ static final Class<?>[] CLASSES = InstantiatedLambdasTest.CLASSES;
+ static final String EXPECTED = StringUtils.lines("Class implementation", "Lambda implementation");
+
+ private final TestParameters parameters;
private Path inputJar;
- private ProcessResult runInput;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public InstantiatedLambdasTestRunner(TestParameters parameters) {
+ this.parameters = parameters;
+ }
@Before
public void writeAndRunInputJar() throws IOException {
inputJar = temp.getRoot().toPath().resolve("input.jar");
ArchiveConsumer buildInput = new ArchiveConsumer(inputJar);
- for (Class clazz : CLASSES) {
+ for (Class<?> clazz : CLASSES) {
buildInput.accept(
ByteDataView.of(ToolHelper.getClassAsBytes(clazz)),
DescriptorUtils.javaTypeToDescriptor(clazz.getName()),
null);
}
buildInput.finished(null);
- runInput = ToolHelper.runJava(inputJar, CLASS.getCanonicalName());
- assertEquals(0, runInput.exitCode);
- }
-
- private Path writeProguardRules(boolean aggressive) throws IOException {
- Path pgConfig = temp.getRoot().toPath().resolve("keep.txt");
- FileUtils.writeTextFile(
- pgConfig,
- "-keep public class " + CLASS.getCanonicalName() + " {",
- " public static void main(...);",
- "}",
- aggressive ? "-overloadaggressively" : "# Not overloading aggressively");
- return pgConfig;
}
@Test
public void testProguard() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
buildAndRunProguard("pg.jar", false);
}
@Test
public void testProguardAggressive() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
buildAndRunProguard("pg-aggressive.jar", true);
}
@Test
- public void testCf() throws Exception {
- buildAndRunCf("cf.zip", false);
+ public void testR8() throws Exception {
+ testR8(false);
}
@Test
- public void testCfAggressive() throws Exception {
- buildAndRunCf("cf-aggressive.zip", true);
+ public void testR8Aggressive() throws Exception {
+ testR8(true);
}
- @Test
- public void testDex() throws Exception {
- buildAndRunDex("dex.zip", false);
- }
-
- @Test
- public void testDexAggressive() throws Exception {
- buildAndRunDex("dex-aggressive.zip", true);
- }
-
- private void buildAndRunCf(String outName, boolean aggressive) throws Exception {
- Path outCf = temp.getRoot().toPath().resolve(outName);
- build(new ClassFileConsumer.ArchiveConsumer(outCf), aggressive);
- ProcessResult runCf = ToolHelper.runJava(outCf, CLASS.getCanonicalName());
- assertEquals(runInput.toString(), runCf.toString());
- }
-
- private void buildAndRunDex(String outName, boolean aggressive) throws Exception {
- Path outDex = temp.getRoot().toPath().resolve(outName);
- build(new DexIndexedConsumer.ArchiveConsumer(outDex), aggressive);
- ProcessResult runDex =
- ToolHelper.runArtNoVerificationErrorsRaw(outDex.toString(), CLASS.getCanonicalName());
- assertEquals(runInput.stdout, runDex.stdout);
- assertEquals(runInput.exitCode, runDex.exitCode);
- }
-
- private void build(ProgramConsumer consumer, boolean aggressive) throws Exception {
- Builder builder =
- ToolHelper.addProguardConfigurationConsumer(
- R8Command.builder(), configuration -> configuration.setPrintMapping(true))
- .setMode(CompilationMode.DEBUG)
- .addLibraryFiles(ToolHelper.getAndroidJar(ToolHelper.getMinApiLevelForDexVm()))
- .addProgramFiles(inputJar)
- .setProgramConsumer(consumer)
- .addProguardConfigurationFiles(writeProguardRules(aggressive));
- if (!(consumer instanceof ClassFileConsumer)) {
- builder.setMinApiLevel(ToolHelper.getMinApiLevelForDexVm().getLevel());
- }
- ToolHelper.runR8(builder.build());
+ private void testR8(boolean aggressive) throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramFiles(inputJar)
+ .addKeepMainRule(CLASS)
+ .applyIf(aggressive, builder -> builder.addKeepRules("-overloadaggressively"))
+ .debug()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .apply(
+ compileResult ->
+ compileResult.run(parameters.getRuntime(), CLASS).assertSuccessWithOutput(EXPECTED))
+ .applyIf(
+ parameters.isDexRuntime(),
+ compileResult ->
+ compileResult.runDex2Oat(parameters.getRuntime()).assertNoVerificationErrors());
}
private void buildAndRunProguard(String outName, boolean aggressive) throws Exception {
@@ -131,4 +110,15 @@
ProcessResult runPg = ToolHelper.runJava(outPg, CLASS.getCanonicalName());
assertEquals(0, runPg.exitCode);
}
+
+ private Path writeProguardRules(boolean aggressive) throws IOException {
+ Path pgConfig = temp.getRoot().toPath().resolve("keep.txt");
+ FileUtils.writeTextFile(
+ pgConfig,
+ "-keep public class " + CLASS.getCanonicalName() + " {",
+ " public static void main(...);",
+ "}",
+ aggressive ? "-overloadaggressively" : "# Not overloading aggressively");
+ return pgConfig;
+ }
}
diff --git a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
index ecb398a..efa7b4e 100644
--- a/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/InvalidTypesTest.java
@@ -286,6 +286,8 @@
checkTestRunResult(d8Result, Compiler.D8);
}
+ boolean allowDiagnosticWarningMessages =
+ mode == Mode.INVOKE_UNVERIFIABLE_METHOD && !useInterface;
R8TestRunResult r8Result =
testForR8(parameters.getBackend())
.addProgramFiles(inputJar)
@@ -300,14 +302,16 @@
options.testing.allowTypeErrors = true;
}
})
- .allowDiagnosticWarningMessages(
- mode == Mode.INVOKE_UNVERIFIABLE_METHOD && !useInterface)
+ .allowDiagnosticWarningMessages(allowDiagnosticWarningMessages)
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- equalTo(
- "The method `void UnverifiableClass.unverifiableMethod()` does not type check"
- + " and will be assumed to be unreachable."))
+ .applyIf(
+ allowDiagnosticWarningMessages,
+ result ->
+ result.assertAllWarningMessagesMatch(
+ equalTo(
+ "The method `void UnverifiableClass.unverifiableMethod()` does not"
+ + " type check and will be assumed to be unreachable.")))
.run(parameters.getRuntime(), mainClass.name);
checkTestRunResult(r8Result, Compiler.R8);
@@ -326,14 +330,16 @@
}
options.enableUninstantiatedTypeOptimizationForInterfaces = true;
})
- .allowDiagnosticWarningMessages(
- mode == Mode.INVOKE_UNVERIFIABLE_METHOD && !useInterface)
+ .allowDiagnosticWarningMessages(allowDiagnosticWarningMessages)
.setMinApi(parameters.getApiLevel())
.compile()
- .assertAllWarningMessagesMatch(
- equalTo(
- "The method `void UnverifiableClass.unverifiableMethod()` does not type check"
- + " and will be assumed to be unreachable."))
+ .applyIf(
+ allowDiagnosticWarningMessages,
+ result ->
+ result.assertAllWarningMessagesMatch(
+ equalTo(
+ "The method `void UnverifiableClass.unverifiableMethod()` does not"
+ + " type check and will be assumed to be unreachable.")))
.run(parameters.getRuntime(), mainClass.name);
checkTestRunResult(
r8ResultWithUninstantiatedTypeOptimizationForInterfaces,
diff --git a/src/test/java/com/android/tools/r8/shaking/LibraryClassExtendingProgramClassSuperTest.java b/src/test/java/com/android/tools/r8/shaking/LibraryClassExtendingProgramClassSuperTest.java
index 584d3ae..c2c9f80 100644
--- a/src/test/java/com/android/tools/r8/shaking/LibraryClassExtendingProgramClassSuperTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/LibraryClassExtendingProgramClassSuperTest.java
@@ -70,7 +70,7 @@
.addLibraryClasses(LibraryClass.class)
.addProgramClasses(ProgramDirectSuper.class, ProgramIndirectSuper.class, Main.class)
.addKeepMainRule(Main.class)
- .applyIf(dontWarn, b -> b.addKeepRules("-dontwarn " + LibraryClass.class.getTypeName()))
+ .applyIf(dontWarn, b -> b.addDontWarn(LibraryClass.class))
.setMinApi(parameters.getApiLevel())
.addRunClasspathFiles(
compileToZip(
diff --git a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
index 63c9f40..2fac539 100644
--- a/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/TreeShakingSpecificTest.java
@@ -3,23 +3,24 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking;
+import static com.android.tools.r8.DiagnosticsMatcher.diagnosticType;
import static com.android.tools.r8.ToolHelper.EXAMPLES_BUILD_DIR;
import static com.android.tools.r8.ToolHelper.EXAMPLES_DIR;
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.Diagnostic;
-import com.android.tools.r8.DiagnosticsHandler;
import com.android.tools.r8.OutputMode;
-import com.android.tools.r8.R8;
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersBuilder;
import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.diagnostic.MissingDefinitionsDiagnostic;
import java.io.BufferedReader;
import java.io.IOException;
-import java.io.PrintStream;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
@@ -30,7 +31,6 @@
import java.util.stream.Stream;
import org.junit.Rule;
import org.junit.Test;
-import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -52,13 +52,16 @@
parameters.assertNoneRuntime();
}
- private static final String VALID_PROGUARD_DIR = "src/test/proguard/valid/";
-
@Rule
public TemporaryFolder temp = ToolHelper.getTemporaryFolderForTest();
- @Rule
- public ExpectedException thrown = ExpectedException.none();
+ private Path getProgramFiles(String test) {
+ return Paths.get(EXAMPLES_BUILD_DIR, test + ".jar");
+ }
+
+ private byte[] getProgramDexFileData(String test) throws IOException {
+ return Files.readAllBytes(Paths.get(EXAMPLES_BUILD_DIR, test, "classes.dex"));
+ }
private void finishBuild(R8Command.Builder builder, Path out, String test) throws IOException {
Path input;
@@ -75,79 +78,77 @@
@Test
public void testIgnoreWarnings() throws Exception {
// Generate R8 processed version without library option.
- Path out = temp.getRoot().toPath();
String test = "shaking2";
- Path keepRules = Paths.get(EXAMPLES_DIR, test, "keep-rules.txt");
- Path ignoreWarnings = Paths.get(VALID_PROGUARD_DIR, "ignorewarnings.flags");
- R8Command.Builder builder = R8Command.builder()
- .addProguardConfigurationFiles(keepRules, ignoreWarnings);
- finishBuild(builder, out, test);
- R8.run(builder.build());
+ testForR8(backend)
+ .applyIf(
+ backend.isCf(),
+ builder -> builder.addProgramFiles(getProgramFiles(test)),
+ builder -> builder.addProgramDexFileData(getProgramDexFileData(test)))
+ .addKeepRuleFiles(Paths.get(EXAMPLES_DIR, test, "keep-rules.txt"))
+ .addIgnoreWarnings()
+ .compile();
}
@Test(expected = CompilationFailedException.class)
public void testMissingLibrary() throws Exception {
// Generate R8 processed version without library option.
- Path out = temp.getRoot().toPath();
String test = "shaking2";
- Path keepRules = Paths.get(EXAMPLES_DIR, test, "keep-rules.txt");
- DiagnosticsHandler handler =
- new DiagnosticsHandler() {
- @Override
- public void error(Diagnostic error) {
- assertEquals(
- "Compilation can't be completed because the following class is missing: "
- + "java.lang.Object.",
- error.getDiagnosticMessage());
- }
- };
- R8Command.Builder builder = R8Command.builder(handler)
- .addProguardConfigurationFiles(keepRules);
- finishBuild(builder, out, test);
- R8.run(builder.build());
+ testForR8(backend)
+ .applyIf(
+ backend.isCf(),
+ builder -> builder.addProgramFiles(getProgramFiles(test)),
+ builder -> builder.addProgramDexFileData(getProgramDexFileData(test)))
+ .addLibraryFiles()
+ .addKeepRuleFiles(Paths.get(EXAMPLES_DIR, test, "keep-rules.txt"))
+ .allowDiagnosticErrorMessages()
+ .compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics
+ .assertOnlyErrors()
+ .assertErrorsMatch(diagnosticType(MissingDefinitionsDiagnostic.class));
+
+ MissingDefinitionsDiagnostic diagnostic =
+ (MissingDefinitionsDiagnostic) diagnostics.getErrors().get(0);
+ assertThat(
+ diagnostic.getDiagnosticMessage(),
+ allOf(
+ containsString("Missing class java.io.PrintStream"),
+ containsString("Missing class java.lang.Object"),
+ containsString("Missing class java.lang.String"),
+ containsString("Missing class java.lang.StringBuilder"),
+ containsString("Missing class java.lang.System")));
+ });
}
@Test
- public void testPrintMapping() throws Exception {
+ public void testPrintMapping() throws Throwable {
// Generate R8 processed version without library option.
String test = "shaking1";
- Path out = temp.getRoot().toPath();
- Path keepRules = Paths.get(EXAMPLES_DIR, test, "keep-rules.txt");
-
- // Create a flags file in temp dir requesting dump of the mapping.
- // The mapping file will be created alongside the flags file in temp dir.
- Path printMapping = out.resolve("printmapping.flags");
- try (PrintStream mapping = new PrintStream(printMapping.toFile())) {
- mapping.println("-printmapping mapping.txt");
- }
-
- R8Command.Builder builder = R8Command.builder()
- .addProguardConfigurationFiles(keepRules, printMapping);
- // Turn off inlining, as we want the mapping that is printed to be stable.
- finishBuild(builder, out, test);
- if (backend == Backend.DEX) {
- builder.addLibraryFiles(ToolHelper.getDefaultAndroidJar());
- } else {
- assert backend == Backend.CF;
- builder.addLibraryFiles(ToolHelper.getJava8RuntimeJar());
- }
- ToolHelper.runR8(builder.build(), options -> options.enableInlining = false);
-
- Path outputmapping = out.resolve("mapping.txt");
- // Remove comments.
- String actualMapping =
- Stream.of(new String(Files.readAllBytes(outputmapping), StandardCharsets.UTF_8).split("\n"))
- .filter(line -> !line.startsWith("#"))
- .collect(Collectors.joining("\n"));
- String refMapping =
- new String(
- Files.readAllBytes(
- Paths.get(
- EXAMPLES_DIR,
- "shaking1",
- "print-mapping-" + backend.name().toLowerCase() + ".ref")),
- StandardCharsets.UTF_8);
- assertEquals(sorted(refMapping), sorted(actualMapping));
+ testForR8(backend)
+ .applyIf(
+ backend.isCf(),
+ builder -> builder.addProgramFiles(getProgramFiles(test)),
+ builder -> builder.addProgramDexFileData(getProgramDexFileData(test)))
+ .addKeepRuleFiles(Paths.get(EXAMPLES_DIR, test, "keep-rules.txt"))
+ .addOptionsModification(options -> options.enableInlining = false)
+ .compile()
+ .inspectProguardMap(
+ proguardMap -> {
+ // Remove comments.
+ String actualMapping =
+ Stream.of(proguardMap.split("\n"))
+ .filter(line -> !line.startsWith("#"))
+ .collect(Collectors.joining("\n"));
+ String refMapping =
+ new String(
+ Files.readAllBytes(
+ Paths.get(
+ EXAMPLES_DIR,
+ "shaking1",
+ "print-mapping-" + backend.name().toLowerCase() + ".ref")),
+ StandardCharsets.UTF_8);
+ assertEquals(sorted(refMapping), sorted(actualMapping));
+ });
}
private static String sorted(String str) {
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
index 904c0cd..e78d675 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/LibraryAndMissingAnnotationsTest.java
@@ -115,7 +115,7 @@
if (includeOnLibraryPath) {
t.addLibraryClasses(LibraryAnnotation.class);
} else {
- t.addKeepRules("-dontwarn " + LibraryAnnotation.class.getTypeName());
+ t.addDontWarn(LibraryAnnotation.class);
}
t.compile()
.addRunClasspathFiles(compilationResults.apply(parameters))
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
index 8eaee28..f102535 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/ReflectiveAnnotationUseTest.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking.annotations;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresentAndNotRenamed;
import static org.hamcrest.CoreMatchers.containsString;
@@ -95,12 +96,13 @@
public void b120951621_keepAll() throws Exception {
CodeInspector inspector =
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepRules(KEEP_ANNOTATIONS)
.addKeepRules("-keep @interface " + ANNOTATION_NAME + " {", " *;", "}")
- .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
@@ -132,7 +134,9 @@
public void b120951621_partiallyKeep() throws Exception {
CodeInspector inspector =
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepRules(KEEP_ANNOTATIONS)
@@ -140,7 +144,6 @@
"-keep,allowobfuscation @interface " + ANNOTATION_NAME + " {",
" java.lang.String *f2();",
"}")
- .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
@@ -173,11 +176,12 @@
public void b120951621_keepAnnotation() throws Exception {
CodeInspector inspector =
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
.addKeepRules(KEEP_ANNOTATIONS)
- .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
@@ -210,10 +214,11 @@
public void b120951621_noKeep() throws Exception {
CodeInspector inspector =
testForR8(parameters.getBackend())
- .addProgramFiles(compiledJars.getForConfiguration(kotlinc, targetVersion))
+ .addProgramFiles(
+ compiledJars.getForConfiguration(kotlinc, targetVersion),
+ getKotlinAnnotationJar(kotlinc))
.addProgramFiles(getJavaJarFile(FOLDER))
.addKeepMainRule(MAIN_CLASS_NAME)
- .addDontWarnJetBrainsAnnotations()
.allowDiagnosticWarningMessages()
.minification(minify)
.setMinApi(parameters.getApiLevel())
diff --git a/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java b/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
index 073a085..ddc9a2b 100644
--- a/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
+++ b/src/test/java/com/android/tools/r8/shaking/annotations/b137392797/B137392797.java
@@ -4,13 +4,15 @@
package com.android.tools.r8.shaking.annotations.b137392797;
+import static com.android.tools.r8.ToolHelper.getKotlinAnnotationJar;
+import static com.android.tools.r8.ToolHelper.getKotlinC_1_3_72;
+import static com.android.tools.r8.ToolHelper.getKotlinStdlibJar;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -63,8 +65,8 @@
classWireFieldLabel(),
classTest(defaultEnumValueInAnnotation))
.addProgramClasses(TestClass.class)
- .addClasspathFiles(ToolHelper.getKotlinStdlibJar(ToolHelper.getKotlinC_1_3_72()))
- .addDontWarnJetBrainsAnnotations()
+ .addClasspathFiles(
+ getKotlinStdlibJar(getKotlinC_1_3_72()), getKotlinAnnotationJar(getKotlinC_1_3_72()))
.addKeepClassAndMembersRules(
"com.squareup.wire.WireField", "com.squareup.demo.myapplication.Test")
.addKeepMainRule(TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/B152492625.java b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/B152492625.java
index 8da32bc..1baeed5 100644
--- a/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/B152492625.java
+++ b/src/test/java/com/android/tools/r8/shaking/assumenosideeffects/B152492625.java
@@ -110,7 +110,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
- .applyIf(dontWarnObject, tb -> tb.addKeepRules("-dontwarn java.lang.Object"))
+ .applyIf(dontWarnObject, tb -> tb.addDontWarn(Object.class))
.addKeepRules("-assumenosideeffects class " + B.class.getTypeName() + " { *; }")
.setMinApi(parameters.getApiLevel())
.allowDiagnosticWarningMessages(!dontWarnObject)
@@ -159,7 +159,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
- .applyIf(dontWarnObject, tb -> tb.addKeepRules("-dontwarn java.lang.Object"))
+ .applyIf(dontWarnObject, tb -> tb.addDontWarn(Object.class))
.apply(
b ->
b.getBuilder().addProguardConfiguration(ImmutableList.of(starRule), starRuleOrigin))
@@ -181,7 +181,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
- .applyIf(dontWarnObject, tb -> tb.addKeepRules("-dontwarn java.lang.Object"))
+ .applyIf(dontWarnObject, tb -> tb.addDontWarn(Object.class))
.addKeepRules("-assumenosideeffects class " + B.class.getTypeName() + " { hash*(); }")
.setMinApi(parameters.getApiLevel())
.compile()
@@ -198,7 +198,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
- .applyIf(dontWarnObject, tb -> tb.addKeepRules("-dontwarn java.lang.Object"))
+ .applyIf(dontWarnObject, tb -> tb.addDontWarn(Object.class))
.addKeepRules("-assumenosideeffects class " + B.class.getTypeName() + " { <methods>; }")
.setMinApi(parameters.getApiLevel())
.allowDiagnosticWarningMessages(!dontWarnObject)
@@ -217,7 +217,7 @@
testForR8(parameters.getBackend())
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
- .applyIf(dontWarnObject, tb -> tb.addKeepRules("-dontwarn java.lang.Object"))
+ .applyIf(dontWarnObject, tb -> tb.addDontWarn(Object.class))
.addKeepRules("-assumenosideeffects class " + B.class.getTypeName() + " { *** w*(...); }")
.setMinApi(parameters.getApiLevel())
.allowDiagnosticWarningMessages(!dontWarnObject)
@@ -279,7 +279,7 @@
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
.addKeepRules("-assumenosideeffects class " + B.class.getTypeName() + " { *; }")
- .addKeepRules("-dontwarn " + B152492625.class.getTypeName())
+ .addDontWarn(B152492625.class)
.setMinApi(parameters.getApiLevel())
.compile()
.run(parameters.getRuntime(), TestClass.class)
@@ -295,7 +295,7 @@
.addProgramClasses(TestClass.class, B.class)
.addKeepMainRule(TestClass.class)
.addKeepRules("-assumenosideeffects class java.lang.Object { void wait(); }")
- .addKeepRules("-dontwarn " + B152492625.class.getTypeName())
+ .addDontWarn(B152492625.class)
.setMinApi(parameters.getApiLevel())
.compile()
.inspect(inspector -> checkIfWaitIsInvokedFromMain(inspector, false))
diff --git a/src/test/java/com/android/tools/r8/shaking/b169045091/B169045091.java b/src/test/java/com/android/tools/r8/shaking/b169045091/B169045091.java
index 29a7280..1c6a438 100644
--- a/src/test/java/com/android/tools/r8/shaking/b169045091/B169045091.java
+++ b/src/test/java/com/android/tools/r8/shaking/b169045091/B169045091.java
@@ -83,8 +83,9 @@
assumeTrue(parameters.useRuntimeAsNoneRuntime());
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses(getProgramClasses())
+ buildClassesWithTestingAnnotations(getProgramClasses())
.addClassProgramData(getWorldGreeterClassFileData())
+ .addLibraryFile(parameters.getDefaultRuntimeLibrary())
.build(),
TestClass.class);
AppInfoWithLiveness appInfo = appView.appInfo();
diff --git a/src/test/java/com/android/tools/r8/shaking/b169045091/NestMemberAccessibilityTest.java b/src/test/java/com/android/tools/r8/shaking/b169045091/NestMemberAccessibilityTest.java
index 62923a7..3d157d4 100644
--- a/src/test/java/com/android/tools/r8/shaking/b169045091/NestMemberAccessibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/b169045091/NestMemberAccessibilityTest.java
@@ -21,6 +21,7 @@
import com.android.tools.r8.shaking.b169045091.examples.NestHost;
import com.android.tools.r8.shaking.b169045091.examples.NestHost.NestMember;
import com.android.tools.r8.shaking.b169045091.examples.NonNestMember;
+import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.DescriptorUtils;
import com.google.common.collect.ImmutableList;
import java.nio.file.Path;
@@ -52,7 +53,7 @@
public void testAccessibility() throws Exception {
AppView<AppInfoWithLiveness> appView =
computeAppViewWithLiveness(
- buildClasses()
+ AndroidApp.builder()
.addProgramFiles(getProgramFiles())
.addClassProgramData(getNestHostClassFileData())
.build(),
diff --git a/src/test/java/com/android/tools/r8/smali/OutlineTest.java b/src/test/java/com/android/tools/r8/smali/OutlineTest.java
index efe3826..a7b67bf 100644
--- a/src/test/java/com/android/tools/r8/smali/OutlineTest.java
+++ b/src/test/java/com/android/tools/r8/smali/OutlineTest.java
@@ -1622,6 +1622,8 @@
" sput-object v0, LA;->L:Ljava/util/Hashtable;",
" return-void");
+ builder.addClass("A");
+
Consumer<InternalOptions> options = configureOutlineOptions(outline -> outline.threshold = 2);
AndroidApp originalApplication = buildApplicationWithAndroidJar(builder);
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
index ec133d7..9299e7f 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentMethodSubject.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.utils.codeinspector;
import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ProgramMethod;
@@ -20,6 +21,11 @@
}
@Override
+ public IRCode buildIR(AppView<?> appView) {
+ throw new Unreachable("Cannot build IR for an absent method");
+ }
+
+ @Override
public boolean isPresent() {
return false;
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
index 17fffc3..dfccf5a 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
@@ -62,9 +62,13 @@
@Override
public IRCode buildIR() {
+ return buildIR(AppView.createForD8(AppInfo.createInitialAppInfo(codeInspector.application)));
+ }
+
+ @Override
+ public IRCode buildIR(AppView<?> appView) {
assert codeInspector.application.options.programConsumer != null;
- return getProgramMethod()
- .buildIR(AppView.createForD8(AppInfo.createInitialAppInfo(codeInspector.application)));
+ return getProgramMethod().buildIR(appView);
}
@Override
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
index 536fa58..6803e16 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.utils.codeinspector;
+import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ProgramMethod;
@@ -18,6 +19,8 @@
public abstract IRCode buildIR();
+ public abstract IRCode buildIR(AppView<?> appView);
+
public final boolean isAbsent() {
return !isPresent();
}
diff --git a/src/test/javaStubs/StringConcatFactory.java b/src/test/javaStubs/StringConcatFactory.java
new file mode 100644
index 0000000..9863857
--- /dev/null
+++ b/src/test/javaStubs/StringConcatFactory.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2021, 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 java.lang.invoke;
+
+public class StringConcatFactory {}
diff --git a/src/test/javaStubs/VarHandle.java b/src/test/javaStubs/VarHandle.java
new file mode 100644
index 0000000..c12d32a
--- /dev/null
+++ b/src/test/javaStubs/VarHandle.java
@@ -0,0 +1,7 @@
+// Copyright (c) 2021, 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 java.lang.invoke;
+
+public class VarHandle {}
diff --git a/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1 b/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1
index 7b8d748..1fe619a 100644
--- a/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1
+++ b/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1
@@ -1 +1 @@
-2fdc16c4253420d7e240d5cf109bda5856984a8d
\ No newline at end of file
+653b4fe97b5dface6a31b9a6d94063a91a7f80be
\ No newline at end of file
diff --git a/tools/chrome_data.py b/tools/chrome_data.py
index 20ddb21..7649257 100644
--- a/tools/chrome_data.py
+++ b/tools/chrome_data.py
@@ -271,7 +271,8 @@
{ 'inputs': [os.path.join(V200520_MINIMAL_BASE, 'feature-7.jar')] },
{ 'inputs': [os.path.join(V200520_MINIMAL_BASE, 'feature-8.jar')] }
],
- 'pgconf': [os.path.join(V200520_MINIMAL_BASE, 'proguard.config')],
+ 'pgconf': [os.path.join(V200520_MINIMAL_BASE, 'proguard.config'),
+ utils.IGNORE_WARNINGS_RULES],
'libraries': [os.path.join(V200520_MINIMAL_BASE, 'library.jar')],
'min-api': ANDROID_N_API
},
diff --git a/tools/gmail_data.py b/tools/gmail_data.py
index 4683458..4d1b250 100644
--- a/tools/gmail_data.py
+++ b/tools/gmail_data.py
@@ -27,7 +27,8 @@
},
'deploy' : {
'inputs': ['%s_deploy.jar' % V170604_16_PREFIX],
- 'pgconf': ['%s_proguard.config' % V170604_16_PREFIX],
+ 'pgconf': ['%s_proguard.config' % V170604_16_PREFIX,
+ utils.IGNORE_WARNINGS_RULES],
},
'proguarded' : {
'inputs': ['%s_proguard.jar' % V170604_16_PREFIX],
@@ -47,7 +48,8 @@
'inputs': ['%s_deploy.jar' % V180826_15_PREFIX],
'pgconf': [
'%s_proguard.config' % V180826_15_PREFIX,
- '%s/proguardsettings/Gmail_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/Gmail_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'min-api' : ANDROID_L_API,
'allow-type-errors' : 1,
},
diff --git a/tools/gmscore_data.py b/tools/gmscore_data.py
index 44971c1..bef5ba3 100644
--- a/tools/gmscore_data.py
+++ b/tools/gmscore_data.py
@@ -77,7 +77,8 @@
'pgmap': '%s_proguard.map' % V9_PREFIX,
},
'deploy' : {
- 'pgconf': ['%s_proguard.config' % V9_PREFIX],
+ 'pgconf': ['%s_proguard.config' % V9_PREFIX,
+ utils.IGNORE_WARNINGS_RULES],
'inputs': ['%s_deploy.jar' % V9_PREFIX],
'min-api' : ANDROID_L_API,
},
@@ -97,7 +98,8 @@
},
'deploy' : {
'inputs': ['%s_deploy.jar' % V10_PREFIX],
- 'pgconf': ['%s_proguard.config' % V10_PREFIX],
+ 'pgconf': ['%s_proguard.config' % V10_PREFIX,
+ utils.IGNORE_WARNINGS_RULES],
'min-api' : ANDROID_L_API,
},
'proguarded' : {
@@ -112,7 +114,8 @@
'inputs': ['%s_deploy.jar' % LATEST_PREFIX],
'pgconf': [
'%s_proguard.config' % LATEST_PREFIX,
- '%s/proguardsettings/GmsCore_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/GmsCore_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'min-api' : ANDROID_L_API,
},
'proguarded' : {
diff --git a/tools/nest_data.py b/tools/nest_data.py
index a87761d..5724e43 100644
--- a/tools/nest_data.py
+++ b/tools/nest_data.py
@@ -28,7 +28,8 @@
'pgconf': [
os.path.join(V20180926_BASE, 'proguard', 'proguard.cfg'),
os.path.join(V20180926_BASE, 'proguard', 'proguard-no-optimizations.cfg'),
- os.path.join(V20180926_BASE, 'proguard', 'proguard-ignore-warnings.cfg')],
+ os.path.join(V20180926_BASE, 'proguard', 'proguard-ignore-warnings.cfg'),
+ utils.IGNORE_WARNINGS_RULES],
# Build for native multi dex
'min-api' : ANDROID_L_API,
}
diff --git a/tools/r8_release.py b/tools/r8_release.py
index 783b30d..d356586 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -577,7 +577,7 @@
# [INFO] 06/19/2020 09:35:12 CEST: Release ID = 9171d015-18f6-4a90-9984-1c362589dc1b
# [INFO] 06/19/2020 09:35:12 CEST: Stage Path = /bigstore/studio_staging/maven2/sgjesse/9171d015-18f6-4a90-9984-1c362589dc1b
- matches = GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN.findall(output)
+ matches = GMAVEN_PUBLISH_STAGE_RELEASE_ID_PATTERN.findall(output.decode("utf-8"))
if matches == None or len(matches) > 1:
print("Could not determine the release ID from the gmaven_publisher " +
"output. Expected a line with 'Release ID = <release id>'.")
diff --git a/tools/utils.py b/tools/utils.py
index dcfa4f8..8b7acb7 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -63,7 +63,7 @@
DESUGAR_CONFIGURATION = os.path.join(
'src', 'library_desugar', 'desugar_jdk_libs.json')
DESUGAR_IMPLEMENTATION = os.path.join(
- 'third_party', 'openjdk', 'desugar_jdk_libs', 'libjava.jar')
+ 'third_party', 'openjdk', 'desugar_jdk_libs', 'desugar_jdk_libs.jar')
DESUGAR_CONFIGURATION_MAVEN_ZIP = os.path.join(
LIBS, 'desugar_jdk_libs_configuration.zip')
GENERATED_LICENSE = os.path.join(GENERATED_LICENSE_DIR, 'LICENSE')
@@ -82,6 +82,7 @@
BAZEL_SHA_FILE = os.path.join(THIRD_PARTY, 'bazel.tar.gz.sha1')
BAZEL_TOOL = os.path.join(THIRD_PARTY, 'bazel')
JAVA8_SHA_FILE = os.path.join(THIRD_PARTY, 'openjdk', 'jdk8', 'linux-x86.tar.gz.sha1')
+IGNORE_WARNINGS_RULES = os.path.join(REPO_ROOT, 'src', 'test', 'ignorewarnings.rules')
ANDROID_HOME_ENVIROMENT_NAME = "ANDROID_HOME"
ANDROID_TOOLS_VERSION_ENVIRONMENT_NAME = "ANDROID_TOOLS_VERSION"
diff --git a/tools/youtube_data.py b/tools/youtube_data.py
index 46b0b9d..eafe5bb 100644
--- a/tools/youtube_data.py
+++ b/tools/youtube_data.py
@@ -52,7 +52,8 @@
'deploy' : {
'inputs': ['%s_deploy.jar' % V12_10_PREFIX],
'pgconf': ['%s_proguard.config' % V12_10_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'min-api' : ANDROID_L_API,
}
# The 'proguarded' version cannot be handled by D8/R8 because there are
@@ -74,7 +75,8 @@
'deploy' : {
'inputs': ['%s_deploy.jar' % V12_17_PREFIX],
'pgconf': ['%s_proguard.config' % V12_17_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'min-api' : ANDROID_L_API,
},
'proguarded' : {
@@ -94,7 +96,8 @@
'inputs': ['%s_deploy.jar' % V12_22_PREFIX],
'pgconf': [
'%s_proguard.config' % V12_22_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'maindexrules' : [
os.path.join(V12_22_BASE, 'mainDexClasses.rules'),
os.path.join(V12_22_BASE, 'main-dex-classes-release.cfg'),
@@ -117,7 +120,8 @@
'inputs': ['%s_deploy.jar' % V13_37_PREFIX],
'pgconf': [
'%s_proguard.config' % V13_37_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
# Build for native multi dex, as Currently R8 cannot meet the main-dex
# constraints.
#'maindexrules' : [
@@ -143,7 +147,8 @@
'inputs': ['%s_deploy.jar' % V14_19_PREFIX],
'pgconf': [
'%s_proguard.config' % V14_19_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'maindexrules' : [
os.path.join(V14_19_BASE, 'mainDexClasses.rules'),
os.path.join(V14_19_BASE, 'main-dex-classes-release-optimized.pgcfg'),
@@ -172,7 +177,8 @@
'libraries' : [os.path.join(V14_44_BASE, 'legacy_YouTubeRelease_combined_library_jars.jar')],
'pgconf': [
'%s_proguard.config' % V14_44_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'maindexrules' : [
os.path.join(V14_44_BASE, 'mainDexClasses.rules'),
os.path.join(V14_44_BASE, 'main-dex-classes-release-optimized.pgcfg'),
@@ -202,7 +208,8 @@
'pgconf': [
'%s_proguard.config' % V15_08_PREFIX,
'%s_proto_safety.pgcfg' % V15_08_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'maindexrules' : [
os.path.join(V15_08_BASE, 'mainDexClasses.rules'),
os.path.join(V15_08_BASE, 'main-dex-classes-release-optimized.pgcfg'),
@@ -231,7 +238,8 @@
'libraries' : [os.path.join(V15_09_BASE, 'legacy_YouTubeRelease_combined_library_jars.jar')],
'pgconf': [
'%s_proguard.config' % V15_09_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'maindexrules' : [
os.path.join(V15_09_BASE, 'mainDexClasses.rules'),
os.path.join(V15_09_BASE, 'main-dex-classes-release-optimized.pgcfg'),
@@ -261,7 +269,8 @@
'pgconf': [
'%s_proguard.config' % V15_33_PREFIX,
'%s_proguard_missing_classes.config' % V15_33_PREFIX,
- '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+ '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY,
+ utils.IGNORE_WARNINGS_RULES],
'maindexrules' : [
os.path.join(V15_33_BASE, 'mainDexClasses.rules'),
os.path.join(V15_33_BASE, 'main-dex-classes-release-optimized.pgcfg'),
