@Override public void visitInnerClass(String name, String outerName, String innerName, int access) { // TODO should innerName be changed? super.visitInnerClass(remapper.mapType(name), outerName == null ? null : remapper.mapType(outerName), innerName, access); }
public void visitMethodInsn(int opcode, String owner, String name, String desc) { super.visitMethodInsn( opcode, remapper.mapType(owner), remapper.mapMethodName(owner, name, desc), remapper.mapMethodDesc(desc)); }
@Override public void visitOuterClass(String owner, String name, String desc) { super.visitOuterClass( remapper.mapType(owner), name == null ? null : remapper.mapMethodName(owner, name, desc), desc == null ? null : remapper.mapMethodDesc(desc)); }
@Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { this.className = name; super.visit(version, access, remapper.mapType(name), remapper .mapSignature(signature, false), remapper.mapType(superName), interfaces == null ? null : remapper.mapTypes(interfaces)); }
@Override public void visitFieldInsn(int opcode, String owner, String name, String desc) { super.visitFieldInsn( opcode, remapper.mapType(owner), remapper.mapFieldName(owner, name, desc), remapper.mapDesc(desc)); }
@Override public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { FieldVisitor fv = super.visitField(access, remapper.mapFieldName(className, name, desc), remapper.mapDesc(desc), remapper.mapSignature(signature, true), remapper.mapValue(value)); return fv == null ? null : createRemappingFieldAdapter(fv); }
@Override public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) { for (int i = 0; i < bsmArgs.length; i++) { bsmArgs[i] = remapper.mapValue(bsmArgs[i]); } super.visitInvokeDynamicInsn( remapper.mapInvokeDynamicMethodName(name, desc), remapper.mapMethodDesc(desc), (Handle) remapper.mapValue(bsm), bsmArgs); }
@Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { String newDesc = remapper.mapMethodDesc(desc); MethodVisitor mv = super.visitMethod(access, remapper.mapMethodName( className, name, desc), newDesc, remapper.mapSignature( signature, false), exceptions == null ? null : remapper.mapTypes(exceptions)); return mv == null ? null : createRemappingMethodAdapter(access, newDesc, mv); }
@Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, remapper.mapDesc(desc), visible); return av == null ? null : createRemappingAnnotationAdapter(av); }
private void doVisitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) { // Calling super.visitMethodInsn requires to call the correct version // depending on this.api (otherwise infinite loops can occur). To // simplify and to make it easier to automatically remove the backward // compatibility code, we inline the code of the overridden method here. // IMPORTANT: THIS ASSUMES THAT visitMethodInsn IS NOT OVERRIDDEN IN // LocalVariableSorter. if (mv != null) { mv.visitMethodInsn( opcode, remapper.mapType(owner), remapper.mapMethodName(owner, name, desc), remapper.mapMethodDesc(desc), itf); } }
public void visitTryCatchBlock(Label start, Label end, Label handler, String type) { super.visitTryCatchBlock( start, end, handler, // type == null ? null : remapper.mapType(type)); }
@Override public AnnotationVisitor visitLocalVariableAnnotation( int typeRef, TypePath typePath, Label[] start, Label[] end, int[] index, String desc, boolean visible) { AnnotationVisitor av = super.visitLocalVariableAnnotation( typeRef, typePath, start, end, index, remapper.mapDesc(desc), visible); return av == null ? av : new RemappingAnnotationAdapter(av, remapper); }
private Object[] remapEntries(int n, Object[] entries) { for (int i = 0; i < n; i++) { if (entries[i] instanceof String) { Object[] newEntries = new Object[n]; if (i > 0) { System.arraycopy(entries, 0, newEntries, 0, i); } do { Object t = entries[i]; newEntries[i++] = t instanceof String ? remapper.mapType((String) t) : t; } while (i < n); return newEntries; } } return entries; }
@Override public void visit(String name, Object value) { av.visit(name, remapper.mapValue(value)); }
@Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { AnnotationVisitor av = super.visitAnnotation(remapper.mapDesc(desc), visible); return av == null ? null : createRemappingAnnotationAdapter(av); }
@Override public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { AnnotationVisitor av = super.visitParameterAnnotation(parameter, remapper.mapDesc(desc), visible); return av == null ? av : new RemappingAnnotationAdapter(av, remapper); }
public void visitTypeInsn(int opcode, String type) { super.visitTypeInsn(opcode, remapper.mapType(type)); }
public void visitInnerClassType(String name) { className = className + '$' + name; String remappedName = remapper.mapType(className); v.visitInnerClassType(remappedName.substring(remappedName.lastIndexOf('$') + 1)); }
public void visitClassType(String name) { className = name; v.visitClassType(remapper.mapType(name)); }
@Override public AnnotationVisitor visitAnnotation(String name, String desc) { AnnotationVisitor v = av.visitAnnotation(name, remapper.mapDesc(desc)); return v == null ? null : (v == av ? this : new RemappingAnnotationAdapter(v, remapper)); }
@Override public void visitEnum(String name, String desc, String value) { av.visitEnum(name, remapper.mapDesc(desc), value); }
public void visitLocalVariable( String name, String desc, String signature, Label start, Label end, int index) { super.visitLocalVariable( name, remapper.mapDesc(desc), remapper.mapSignature(signature, true), start, end, index); }
public void visitMultiANewArrayInsn(String desc, int dims) { super.visitMultiANewArrayInsn(remapper.mapDesc(desc), dims); }
public void visitLdcInsn(Object cst) { super.visitLdcInsn(remapper.mapValue(cst)); }