Java tutorial
// 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(); } } } }