// Copyright 2017 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.android.desugar;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import javax.annotation.Nullable;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.TypePath;
/**
* Visitor that moves methods with bodies from interfaces into a companion class and rewrites
* call sites accordingly (which is only needed for static interface methods). Default methods
* are kept as abstract methods with all their annotations.
*
* <p>Any necessary companion classes will be added to the given {@link GeneratedClassStore}. It's
* the caller's responsibility to write those out.
*
* <p>Relies on {@link DefaultMethodClassFixer} to stub in method bodies for moved default methods.
* Assumes that lambdas are already desugared. Ignores bridge methods, which are handled specially.
*/
class InterfaceDesugaring extends ClassVisitor {
static final String COMPANION_SUFFIX = "$$CC";
private final ClassReaderFactory bootclasspath;
private final GeneratedClassStore store;
private String internalName;
private int bytecodeVersion;
private int accessFlags;
@Nullable private ClassVisitor companion;
public InterfaceDesugaring(ClassVisitor dest, ClassReaderFactory bootclasspath,
GeneratedClassStore store) {
super(Opcodes.ASM5, dest);
this.bootclasspath = bootclasspath;
this.store = store;
}
@Override
public void visit(
int version,
int access,
String name,
String signature,
String superName,
String[] interfaces) {
companion = null;
internalName = name;
bytecodeVersion = version;
accessFlags = access;
super.visit(version, access, name, signature, superName, interfaces);
}
@Override
public void visitEnd() {
if (companion != null) {
companion.visitEnd();
}
super.visitEnd();
}
@Override
public MethodVisitor visitMethod(
int access, String name, String desc, String signature, String[] exceptions) {
MethodVisitor result;
if (BitFlags.isSet(accessFlags, Opcodes.ACC_INTERFACE)
&& BitFlags.noneSet(access, Opcodes.ACC_ABSTRACT | Opcodes.ACC_BRIDGE)
&& !"<clinit>".equals(name)) {
checkArgument(BitFlags.noneSet(access, Opcodes.ACC_NATIVE), "Forbidden per JLS ch 9.4");
boolean isLambdaBody =
name.startsWith("lambda$") && BitFlags.isSet(access, Opcodes.ACC_SYNTHETIC);
if (isLambdaBody) {
access &= ~Opcodes.ACC_PUBLIC; // undo visibility change from LambdaDesugaring
// Rename lambda method to reflect the new owner. Not doing so confuses LambdaDesugaring
// if it's run over this class again.
name += COMPANION_SUFFIX;
}
if (BitFlags.isSet(access, Opcodes.ACC_STATIC)) {
// Completely move static interface methods, which requires rewriting call sites
result =
companion()
.visitMethod(access & ~Opcodes.ACC_PRIVATE, name, desc, signature, exceptions);
} else {
MethodVisitor abstractDest;
if (isLambdaBody) {
// Completely move lambda bodies, which requires rewriting call sites
access &= ~Opcodes.ACC_PRIVATE;
abstractDest = null;
} else {
// Make default methods abstract but move their implementation into a static method with
// corresponding signature. Doesn't require callsite rewriting but implementing classes
// may need to implement default methods explicitly.
checkArgument(BitFlags.noneSet(access, Opcodes.ACC_PRIVATE),
"Unexpected private interface method %s.%s : %s", name, internalName, desc);
abstractDest = super.visitMethod(
access | Opcodes.ACC_ABSTRACT, name, desc, signature, exceptions);
}
// TODO(b/37110951): adjust signature with explicit receiver type, which may be generic
MethodVisitor codeDest =
companion()
.visitMethod(
access | Opcodes.ACC_STATIC,
name,
companionDefaultMethodDescriptor(internalName, desc),
(String) null, // drop signature, since given one doesn't include the new param
exceptions);
result = abstractDest != null ? new MultiplexAnnotations(codeDest, abstractDest) : codeDest;
}
} else {
result = super.visitMethod(access, name, desc, signature, exceptions);
}
return result != null ? new InterfaceInvocationRewriter(result) : null;
}
/**
* Returns the descriptor of a static method for an instance method with the given receiver and
* description, simply by pre-pending the given descriptor's parameter list with the given
* receiver type.
*/
static String companionDefaultMethodDescriptor(String interfaceName, String desc) {
Type type = Type.getMethodType(desc);
Type[] companionArgs = new Type[type.getArgumentTypes().length + 1];
companionArgs[0] = Type.getObjectType(interfaceName);
System.arraycopy(type.getArgumentTypes(), 0, companionArgs, 1, type.getArgumentTypes().length);
return Type.getMethodDescriptor(type.getReturnType(), companionArgs);
}
private ClassVisitor companion() {
if (companion == null) {
checkState(BitFlags.isSet(accessFlags, Opcodes.ACC_INTERFACE));
String companionName = internalName + COMPANION_SUFFIX;
companion = store.add(companionName);
companion.visit(
bytecodeVersion,
// Companion class must be public so moved methods can be called from anywhere
(accessFlags | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_PUBLIC) & ~Opcodes.ACC_INTERFACE,
companionName,
(String) null, // signature
"java/lang/Object",
new String[0]);
}
return companion;
}
/**
* Rewriter for calls to static interface methods and super calls to default methods, unless
* they're part of the bootclasspath, as well as all lambda body methods. Keeps calls to
* interface methods declared in the bootclasspath as-is (but note that these would presumably
* fail on devices without those methods).
*/
private class InterfaceInvocationRewriter extends MethodVisitor {
public InterfaceInvocationRewriter(MethodVisitor dest) {
super(Opcodes.ASM5, dest);
}
@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
// Assume that any static interface methods on the classpath are moved
if (itf) {
if (name.startsWith("lambda$")) {
// Redirect lambda invocations to completely remove all lambda methods from interfaces.
checkArgument(!owner.endsWith(COMPANION_SUFFIX),
"%s shouldn't consider %s an interface", internalName, owner);
checkArgument(!bootclasspath.isKnown(owner)); // must be in current input
if (opcode == Opcodes.INVOKEINTERFACE) {
opcode = Opcodes.INVOKESTATIC;
desc = companionDefaultMethodDescriptor(owner, desc);
} else {
checkArgument(opcode == Opcodes.INVOKESTATIC,
"Unexpected opcode %s to invoke %s.%s", opcode, owner, name);
}
// Reflect that InterfaceDesugaring moves and renames the lambda body method
owner += COMPANION_SUFFIX;
name += COMPANION_SUFFIX;
checkState(name.equals(LambdaDesugaring.uniqueInPackage(owner, name)),
"Unexpected lambda body method name %s for %s", name, owner);
itf = false;
} else if ((opcode == Opcodes.INVOKESTATIC || opcode == Opcodes.INVOKESPECIAL)
&& !bootclasspath.isKnown(owner)) {
checkArgument(!owner.endsWith(COMPANION_SUFFIX),
"%s shouldn't consider %s an interface", internalName, owner);
if (opcode == Opcodes.INVOKESPECIAL) {
// Turn Interface.super.m() into Interface$$CC.m(receiver)
opcode = Opcodes.INVOKESTATIC;
desc = companionDefaultMethodDescriptor(owner, desc);
}
owner += COMPANION_SUFFIX;
itf = false;
}
}
super.visitMethodInsn(opcode, owner, name, desc, itf);
}
}
/**
* Method visitor that behaves like a passthrough but additionally duplicates all annotations
* into a second given {@link MethodVisitor}.
*/
private static class MultiplexAnnotations extends MethodVisitor {
private final MethodVisitor annotationOnlyDest;
public MultiplexAnnotations(@Nullable MethodVisitor dest, MethodVisitor annotationOnlyDest) {
super(Opcodes.ASM5, dest);
this.annotationOnlyDest = annotationOnlyDest;
}
@Override
public void visitParameter(String name, int access) {
super.visitParameter(name, access);
annotationOnlyDest.visitParameter(name, access);
}
@Override
public AnnotationVisitor visitTypeAnnotation(
int typeRef, TypePath typePath, String desc, boolean visible) {
AnnotationVisitor dest = super.visitTypeAnnotation(typeRef, typePath, desc, visible);
AnnotationVisitor annoDest =
annotationOnlyDest.visitTypeAnnotation(typeRef, typePath, desc, visible);
return new MultiplexAnnotationVisitor(dest, annoDest);
}
@Override
public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) {
AnnotationVisitor dest = super.visitParameterAnnotation(parameter, desc, visible);
AnnotationVisitor annoDest =
annotationOnlyDest.visitParameterAnnotation(parameter, desc, visible);
return new MultiplexAnnotationVisitor(dest, annoDest);
}
}
/**
* Annotation visitor that recursively passes the visited annotations to any number of given
* {@link AnnotationVisitor}s.
*/
private static class MultiplexAnnotationVisitor extends AnnotationVisitor {
private final AnnotationVisitor[] moreDestinations;
public MultiplexAnnotationVisitor(@Nullable AnnotationVisitor dest,
AnnotationVisitor... moreDestinations) {
super(Opcodes.ASM5, dest);
this.moreDestinations = moreDestinations;
}
@Override
public void visit(String name, Object value) {
super.visit(name, value);
for (AnnotationVisitor dest : moreDestinations) {
dest.visit(name, value);
}
}
@Override
public void visitEnum(String name, String desc, String value) {
super.visitEnum(name, desc, value);
for (AnnotationVisitor dest : moreDestinations) {
dest.visitEnum(name, desc, value);
}
}
@Override
public AnnotationVisitor visitAnnotation(String name, String desc) {
AnnotationVisitor[] subVisitors = new AnnotationVisitor[moreDestinations.length];
AnnotationVisitor dest = super.visitAnnotation(name, desc);
for (int i = 0; i < subVisitors.length; ++i) {
subVisitors[i] = moreDestinations[i].visitAnnotation(name, desc);
}
return new MultiplexAnnotationVisitor(dest, subVisitors);
}
@Override
public AnnotationVisitor visitArray(String name) {
AnnotationVisitor[] subVisitors = new AnnotationVisitor[moreDestinations.length];
AnnotationVisitor dest = super.visitArray(name);
for (int i = 0; i < subVisitors.length; ++i) {
subVisitors[i] = moreDestinations[i].visitArray(name);
}
return new MultiplexAnnotationVisitor(dest, subVisitors);
}
@Override
public void visitEnd() {
super.visitEnd();
for (AnnotationVisitor dest : moreDestinations) {
dest.visitEnd();
}
}
}
}