Merge branch 'new-map-invokedynamicmethodname-method' into 'master'

Add a new mapInvokeDynamicMethodName method.

See merge request asm/asm!431

Author: ebruneton

asm-commons/src/main/java/org/objectweb/asm/commons/MethodRemapper.java

@@ -170,17 +170,26 @@ public void visitMethodInsn(
   }
 
   @Override
+  @SuppressWarnings("deprecation")
   public void visitInvokeDynamicInsn(
       final String name,
       final String descriptor,
       final Handle bootstrapMethodHandle,
       final Object... bootstrapMethodArguments) {
+    String remappedName;
+    if (remapper.api == 0) {
+      remappedName = remapper.mapInvokeDynamicMethodName(name, descriptor);
+    } else {
+      remappedName =
+          remapper.mapInvokeDynamicMethodName(
+              name, descriptor, bootstrapMethodHandle, bootstrapMethodArguments);
+    }
     Object[] remappedBootstrapMethodArguments = new Object[bootstrapMethodArguments.length];
     for (int i = 0; i < bootstrapMethodArguments.length; ++i) {
       remappedBootstrapMethodArguments[i] = remapper.mapValue(bootstrapMethodArguments[i]);
     }
     super.visitInvokeDynamicInsn(
-        remapper.mapInvokeDynamicMethodName(name, descriptor),
+        remappedName,
         remapper.mapMethodDesc(descriptor),
         (Handle) remapper.mapValue(bootstrapMethodHandle),
         remappedBootstrapMethodArguments);

asm-commons/src/main/java/org/objectweb/asm/commons/Remapper.java

@@ -43,6 +43,41 @@
  */
 public abstract class Remapper {
 
+  /**
+   * The ASM API version supported by this remapper, or 0 for instances created with the deprecated
+   * constructor.
+   */
+  final int api;
+
+  /**
+   * Creates a new {@link Remapper}.
+   *
+   * @deprecated use {@link #Remapper(int)} instead.
+   */
+  @Deprecated
+  public Remapper() {
+    this.api = 0;
+  }
+
+  /**
+   * Creates a new {@link Remapper}.
+   *
+   * @param api the ASM API version supported by this remapper. Must be one of the {@code
+   *     ASM}<i>x</i> values in {@link Opcodes}.
+   */
+  public Remapper(final int api) {
+    if (api != Opcodes.ASM9
+        && api != Opcodes.ASM8
+        && api != Opcodes.ASM7
+        && api != Opcodes.ASM6
+        && api != Opcodes.ASM5
+        && api != Opcodes.ASM4
+        && api != Opcodes.ASM10_EXPERIMENTAL) {
+      throw new IllegalArgumentException("Unsupported api " + api);
+    }
+    this.api = api;
+  }
+
   /**
    * Returns the given descriptor, remapped with {@link #map(String)}.
    *
@@ -177,17 +212,26 @@ public Object mapValue(final Object value) {
     }
     if (value instanceof ConstantDynamic) {
       ConstantDynamic constantDynamic = (ConstantDynamic) value;
+      String name = constantDynamic.getName();
+      String descriptor = constantDynamic.getDescriptor();
+      Handle bootstrapMethod = constantDynamic.getBootstrapMethod();
       int bootstrapMethodArgumentCount = constantDynamic.getBootstrapMethodArgumentCount();
+      Object[] bootstrapMethodArguments = new Object[bootstrapMethodArgumentCount];
       Object[] remappedBootstrapMethodArguments = new Object[bootstrapMethodArgumentCount];
       for (int i = 0; i < bootstrapMethodArgumentCount; ++i) {
-        remappedBootstrapMethodArguments[i] =
-            mapValue(constantDynamic.getBootstrapMethodArgument(i));
+        bootstrapMethodArguments[i] = constantDynamic.getBootstrapMethodArgument(i);
+        remappedBootstrapMethodArguments[i] = mapValue(bootstrapMethodArguments[i]);
+      }
+      if (api == 0) {
+        name = mapInvokeDynamicMethodName(name, descriptor);
+      } else {
+        name =
+            mapInvokeDynamicMethodName(name, descriptor, bootstrapMethod, bootstrapMethodArguments);
       }
-      String descriptor = constantDynamic.getDescriptor();
       return new ConstantDynamic(
-          mapInvokeDynamicMethodName(constantDynamic.getName(), descriptor),
+          name,
           mapDesc(descriptor),
-          (Handle) mapValue(constantDynamic.getBootstrapMethod()),
+          (Handle) mapValue(bootstrapMethod),
           remappedBootstrapMethodArguments);
     }
     return value;
@@ -316,11 +360,34 @@ public String mapMethodName(final String owner, final String name, final String
    * @param name the name of the method.
    * @param descriptor the descriptor of the method.
    * @return the new name of the method.
+   * @deprecated use {@link #mapInvokeDynamicMethodName(String, String, Handle, Object...)} instead.
    */
+  @Deprecated
   public String mapInvokeDynamicMethodName(final String name, final String descriptor) {
     return name;
   }
 
+  /**
+   * Maps an invokedynamic or a constant dynamic method name to its new name. The default
+   * implementation of this method returns the given name, unchanged. Subclasses can override.
+   *
+   * @param name the name of the method.
+   * @param descriptor the descriptor of the method.
+   * @param bootstrapMethodHandle the bootstrap method.
+   * @param bootstrapMethodArguments the bootstrap method constant arguments. Each argument must be
+   *     an {@link Integer}, {@link Float}, {@link Long}, {@link Double}, {@link String}, {@link
+   *     Type}, {@link Handle} or {@link ConstantDynamic} value. This method is allowed to modify
+   *     the content of the array so a caller should expect that this array may change.
+   * @return the new name of the method.
+   */
+  public String mapInvokeDynamicMethodName(
+      final String name,
+      final String descriptor,
+      final Handle bootstrapMethodHandle,
+      final Object... bootstrapMethodArguments) {
+    return name;
+  }
+
   /**
    * Maps a record component name to its new name. The default implementation of this method returns
    * the given name, unchanged. Subclasses can override.

asm-commons/src/main/java/org/objectweb/asm/commons/SimpleRemapper.java

@@ -30,6 +30,8 @@
 
 import java.util.Collections;
 import java.util.Map;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Opcodes;
 
 /**
  * A {@link Remapper} using a {@link Map} to define its mapping.
@@ -58,23 +60,69 @@ public class SimpleRemapper extends Remapper {
    *       <li>for internal names, the key is the old internal name, and the value is the new
    *           internal name (see {@link org.objectweb.asm.Type#getInternalName()}).
    *     </ul>
+   *
+   * @deprecated use {@link #SimpleRemapper(int, Map)} instead.
    */
+  @Deprecated
   public SimpleRemapper(final Map<String, String> mapping) {
     this.mapping = mapping;
   }
 
+  /**
+   * Constructs a new {@link SimpleRemapper} with the given mapping.
+   *
+   * @param api the ASM API version supported by this remapper. Must be one of the {@code
+   *     ASM}<i>x</i> values in {@link Opcodes}.
+   * @param mapping a map specifying a remapping as follows:
+   *     <ul>
+   *       <li>for method names, the key is the owner, name and descriptor of the method (in the
+   *           form &lt;owner&gt;.&lt;name&gt;&lt;descriptor&gt;), and the value is the new method
+   *           name.
+   *       <li>for invokedynamic method names, the key is the name and descriptor of the method (in
+   *           the form .&lt;name&gt;&lt;descriptor&gt;), and the value is the new method name.
+   *       <li>for field names, the key is the owner and name of the field or attribute (in the form
+   *           &lt;owner&gt;.&lt;name&gt;), and the value is the new field name.
+   *       <li>for attribute names, the key is the annotation descriptor and the name of the
+   *           attribute (in the form &lt;descriptor&gt;.&lt;name&gt;), and the value is the new
+   *           attribute name.
+   *       <li>for internal names, the key is the old internal name, and the value is the new
+   *           internal name (see {@link org.objectweb.asm.Type#getInternalName()}).
+   *     </ul>
+   */
+  public SimpleRemapper(final int api, final Map<String, String> mapping) {
+    super(api);
+    this.mapping = mapping;
+  }
+
   /**
    * Constructs a new {@link SimpleRemapper} with the given mapping.
    *
    * @param oldName the key corresponding to a method, field or internal name (see {@link
    *     #SimpleRemapper(Map)} for the format of these keys).
    * @param newName the new method, field or internal name (see {@link
    *     org.objectweb.asm.Type#getInternalName()}).
+   * @deprecated use {@link #SimpleRemapper(int, String, String)} instead.
    */
+  @Deprecated
   public SimpleRemapper(final String oldName, final String newName) {
     this.mapping = Collections.singletonMap(oldName, newName);
   }
 
+  /**
+   * Constructs a new {@link SimpleRemapper} with the given mapping.
+   *
+   * @param api the ASM API version supported by this remapper. Must be one of the {@code
+   *     ASM}<i>x</i> values in {@link Opcodes}.
+   * @param oldName the key corresponding to a method, field or internal name (see {@link
+   *     #SimpleRemapper(Map)} for the format of these keys).
+   * @param newName the new method, field or internal name (see {@link
+   *     org.objectweb.asm.Type#getInternalName()}).
+   */
+  public SimpleRemapper(final int api, final String oldName, final String newName) {
+    super(api);
+    this.mapping = Collections.singletonMap(oldName, newName);
+  }
+
   @Override
   public String mapMethodName(final String owner, final String name, final String descriptor) {
     String remappedName = map(owner + '.' + name + descriptor);
@@ -87,6 +135,16 @@ public String mapInvokeDynamicMethodName(final String name, final String descrip
     return remappedName == null ? name : remappedName;
   }
 
+  @Override
+  public String mapInvokeDynamicMethodName(
+      final String name,
+      final String descriptor,
+      final Handle bootstrapMethodHandle,
+      final Object... bootstrapMethodArguments) {
+    String remappedName = map('.' + name + descriptor);
+    return remappedName == null ? name : remappedName;
+  }
+
   @Override
   public String mapAnnotationAttributeName(final String descriptor, final String name) {
     String remappedName = map(descriptor + '.' + name);