// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.

package org.objectweb.asm.commons;

import org.objectweb.asm.ConstantDynamic;
import org.objectweb.asm.Handle;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.signature.SignatureReader;
import org.objectweb.asm.signature.SignatureVisitor;
import org.objectweb.asm.signature.SignatureWriter;

A class responsible for remapping types and names.
Author:Eugene Kuleshov
/** * A class responsible for remapping types and names. * * @author Eugene Kuleshov */
public abstract class Remapper {
Returns the given descriptor, remapped with map(String).
Params:
  • descriptor – a type descriptor.
Returns:the given descriptor, with its [array element type] internal name remapped with map(String) (if the descriptor corresponds to an array or object type, otherwise the descriptor is returned as is).
/** * Returns the given descriptor, remapped with {@link #map(String)}. * * @param descriptor a type descriptor. * @return the given descriptor, with its [array element type] internal name remapped with {@link * #map(String)} (if the descriptor corresponds to an array or object type, otherwise the * descriptor is returned as is). */
public String mapDesc(final String descriptor) { return mapType(Type.getType(descriptor)).getDescriptor(); }
Returns the given Type, remapped with map(String) or mapMethodDesc(String).
Params:
  • type – a type, which can be a method type.
Returns:the given type, with its [array element type] internal name remapped with map(String) (if the type is an array or object type, otherwise the type is returned as is) or, of the type is a method type, with its descriptor remapped with mapMethodDesc(String).
/** * Returns the given {@link Type}, remapped with {@link #map(String)} or {@link * #mapMethodDesc(String)}. * * @param type a type, which can be a method type. * @return the given type, with its [array element type] internal name remapped with {@link * #map(String)} (if the type is an array or object type, otherwise the type is returned as * is) or, of the type is a method type, with its descriptor remapped with {@link * #mapMethodDesc(String)}. */
private Type mapType(final Type type) { switch (type.getSort()) { case Type.ARRAY: StringBuilder remappedDescriptor = new StringBuilder(); for (int i = 0; i < type.getDimensions(); ++i) { remappedDescriptor.append('['); } remappedDescriptor.append(mapType(type.getElementType()).getDescriptor()); return Type.getType(remappedDescriptor.toString()); case Type.OBJECT: String remappedInternalName = map(type.getInternalName()); return remappedInternalName != null ? Type.getObjectType(remappedInternalName) : type; case Type.METHOD: return Type.getMethodType(mapMethodDesc(type.getDescriptor())); default: return type; } }
Returns the given internal name, remapped with map(String).
Params:
  • internalName – the internal name (or array type descriptor) of some (array) class.
Returns:the given internal name, remapped with map(String).
/** * Returns the given internal name, remapped with {@link #map(String)}. * * @param internalName the internal name (or array type descriptor) of some (array) class. * @return the given internal name, remapped with {@link #map(String)}. */
public String mapType(final String internalName) { if (internalName == null) { return null; } return mapType(Type.getObjectType(internalName)).getInternalName(); }
Returns the given internal names, remapped with map(String).
Params:
  • internalNames – the internal names (or array type descriptors) of some (array) classes.
Returns:the given internal name, remapped with map(String).
/** * Returns the given internal names, remapped with {@link #map(String)}. * * @param internalNames the internal names (or array type descriptors) of some (array) classes. * @return the given internal name, remapped with {@link #map(String)}. */
public String[] mapTypes(final String[] internalNames) { String[] remappedInternalNames = null; for (int i = 0; i < internalNames.length; ++i) { String internalName = internalNames[i]; String remappedInternalName = mapType(internalName); if (remappedInternalName != null) { if (remappedInternalNames == null) { remappedInternalNames = internalNames.clone(); } remappedInternalNames[i] = remappedInternalName; } } return remappedInternalNames != null ? remappedInternalNames : internalNames; }
Returns the given method descriptor, with its argument and return type descriptors remapped with mapDesc(String).
Params:
  • methodDescriptor – a method descriptor.
Returns:the given method descriptor, with its argument and return type descriptors remapped with mapDesc(String).
/** * Returns the given method descriptor, with its argument and return type descriptors remapped * with {@link #mapDesc(String)}. * * @param methodDescriptor a method descriptor. * @return the given method descriptor, with its argument and return type descriptors remapped * with {@link #mapDesc(String)}. */
public String mapMethodDesc(final String methodDescriptor) { if ("()V".equals(methodDescriptor)) { return methodDescriptor; } StringBuilder stringBuilder = new StringBuilder("("); for (Type argumentType : Type.getArgumentTypes(methodDescriptor)) { stringBuilder.append(mapType(argumentType).getDescriptor()); } Type returnType = Type.getReturnType(methodDescriptor); if (returnType == Type.VOID_TYPE) { stringBuilder.append(")V"); } else { stringBuilder.append(')').append(mapType(returnType).getDescriptor()); } return stringBuilder.toString(); }
Returns the given value, remapped with this remapper. Possible values are Boolean, Byte, Short, Character, Integer, Long, Double, Float, String, Type, Handle, ConstantDynamic or arrays of primitive types .
Params:
Returns:the given value, remapped with this remapper.
/** * Returns the given value, remapped with this remapper. Possible values are {@link Boolean}, * {@link Byte}, {@link Short}, {@link Character}, {@link Integer}, {@link Long}, {@link Double}, * {@link Float}, {@link String}, {@link Type}, {@link Handle}, {@link ConstantDynamic} or arrays * of primitive types . * * @param value an object. Only {@link Type}, {@link Handle} and {@link ConstantDynamic} values * are remapped. * @return the given value, remapped with this remapper. */
public Object mapValue(final Object value) { if (value instanceof Type) { return mapType((Type) value); } if (value instanceof Handle) { Handle handle = (Handle) value; return new Handle( handle.getTag(), mapType(handle.getOwner()), mapMethodName(handle.getOwner(), handle.getName(), handle.getDesc()), handle.getTag() <= Opcodes.H_PUTSTATIC ? mapDesc(handle.getDesc()) : mapMethodDesc(handle.getDesc()), handle.isInterface()); } if (value instanceof ConstantDynamic) { ConstantDynamic constantDynamic = (ConstantDynamic) value; int bootstrapMethodArgumentCount = constantDynamic.getBootstrapMethodArgumentCount(); Object[] remappedBootstrapMethodArguments = new Object[bootstrapMethodArgumentCount]; for (int i = 0; i < bootstrapMethodArgumentCount; ++i) { remappedBootstrapMethodArguments[i] = mapValue(constantDynamic.getBootstrapMethodArgument(i)); } String descriptor = constantDynamic.getDescriptor(); return new ConstantDynamic( mapInvokeDynamicMethodName(constantDynamic.getName(), descriptor), mapDesc(descriptor), (Handle) mapValue(constantDynamic.getBootstrapMethod()), remappedBootstrapMethodArguments); } return value; }
Returns the given signature, remapped with the SignatureVisitor returned by createSignatureRemapper(SignatureVisitor).
Params:
  • signature – a JavaTypeSignature, ClassSignature or MethodSignature.
  • typeSignature – whether the given signature is a JavaTypeSignature.
Returns:signature the given signature, remapped with the SignatureVisitor returned by createSignatureRemapper(SignatureVisitor).
/** * Returns the given signature, remapped with the {@link SignatureVisitor} returned by {@link * #createSignatureRemapper(SignatureVisitor)}. * * @param signature a <i>JavaTypeSignature</i>, <i>ClassSignature</i> or <i>MethodSignature</i>. * @param typeSignature whether the given signature is a <i>JavaTypeSignature</i>. * @return signature the given signature, remapped with the {@link SignatureVisitor} returned by * {@link #createSignatureRemapper(SignatureVisitor)}. */
public String mapSignature(final String signature, final boolean typeSignature) { if (signature == null) { return null; } SignatureReader signatureReader = new SignatureReader(signature); SignatureWriter signatureWriter = new SignatureWriter(); SignatureVisitor signatureRemapper = createSignatureRemapper(signatureWriter); if (typeSignature) { signatureReader.acceptType(signatureRemapper); } else { signatureReader.accept(signatureRemapper); } return signatureWriter.toString(); }
Constructs a new remapper for signatures. The default implementation of this method returns a new SignatureRemapper.
Params:
  • signatureVisitor – the SignatureVisitor the remapper must delegate to.
Returns:the newly created remapper.
Deprecated:use createSignatureRemapper instead.
/** * Constructs a new remapper for signatures. The default implementation of this method returns a * new {@link SignatureRemapper}. * * @param signatureVisitor the SignatureVisitor the remapper must delegate to. * @return the newly created remapper. * @deprecated use {@link #createSignatureRemapper} instead. */
@Deprecated protected SignatureVisitor createRemappingSignatureAdapter( final SignatureVisitor signatureVisitor) { return createSignatureRemapper(signatureVisitor); }
Constructs a new remapper for signatures. The default implementation of this method returns a new SignatureRemapper.
Params:
  • signatureVisitor – the SignatureVisitor the remapper must delegate to.
Returns:the newly created remapper.
/** * Constructs a new remapper for signatures. The default implementation of this method returns a * new {@link SignatureRemapper}. * * @param signatureVisitor the SignatureVisitor the remapper must delegate to. * @return the newly created remapper. */
protected SignatureVisitor createSignatureRemapper(final SignatureVisitor signatureVisitor) { return new SignatureRemapper(signatureVisitor, this); }
Maps an inner class name to its new name. The default implementation of this method provides a strategy that will work for inner classes produced by Java, but not necessarily other languages. Subclasses can override.
Params:
  • name – the fully-qualified internal name of the inner class.
  • ownerName – the internal name of the owner class of the inner class.
  • innerName – the internal name of the inner class.
Returns:the new inner name of the inner class.
/** * Maps an inner class name to its new name. The default implementation of this method provides a * strategy that will work for inner classes produced by Java, but not necessarily other * languages. Subclasses can override. * * @param name the fully-qualified internal name of the inner class. * @param ownerName the internal name of the owner class of the inner class. * @param innerName the internal name of the inner class. * @return the new inner name of the inner class. */
public String mapInnerClassName( final String name, final String ownerName, final String innerName) { final String remappedInnerName = this.mapType(name); if (remappedInnerName.contains("$")) { int index = remappedInnerName.lastIndexOf('$') + 1; while (index < remappedInnerName.length() && Character.isDigit(remappedInnerName.charAt(index))) { index++; } return remappedInnerName.substring(index); } else { return innerName; } }
Maps a method name to its new name. The default implementation of this method returns the given name, unchanged. Subclasses can override.
Params:
  • owner – the internal name of the owner class of the method.
  • name – the name of the method.
  • descriptor – the descriptor of the method.
Returns:the new name of the method.
/** * Maps a method name to its new name. The default implementation of this method returns the given * name, unchanged. Subclasses can override. * * @param owner the internal name of the owner class of the method. * @param name the name of the method. * @param descriptor the descriptor of the method. * @return the new name of the method. */
public String mapMethodName(final String owner, 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.
Params:
  • name – the name of the method.
  • descriptor – the descriptor of the method.
Returns:the new name of the method.
/** * 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. * @return the new name of the method. */
public String mapInvokeDynamicMethodName(final String name, final String descriptor) { 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.
Params:
  • owner – the internal name of the owner class of the field.
  • name – the name of the field.
  • descriptor – the descriptor of the field.
Returns:the new name of the field.
/** * Maps a record component name to its new name. The default implementation of this method returns * the given name, unchanged. Subclasses can override. * * @param owner the internal name of the owner class of the field. * @param name the name of the field. * @param descriptor the descriptor of the field. * @return the new name of the field. */
public String mapRecordComponentName( final String owner, final String name, final String descriptor) { return name; }
Maps a field name to its new name. The default implementation of this method returns the given name, unchanged. Subclasses can override.
Params:
  • owner – the internal name of the owner class of the field.
  • name – the name of the field.
  • descriptor – the descriptor of the field.
Returns:the new name of the field.
/** * Maps a field name to its new name. The default implementation of this method returns the given * name, unchanged. Subclasses can override. * * @param owner the internal name of the owner class of the field. * @param name the name of the field. * @param descriptor the descriptor of the field. * @return the new name of the field. */
public String mapFieldName(final String owner, final String name, final String descriptor) { return name; }
Maps a package name to its new name. The default implementation of this method returns the given name, unchanged. Subclasses can override.
Params:
  • name – the fully qualified name of the package (using dots).
Returns:the new name of the package.
/** * Maps a package name to its new name. The default implementation of this method returns the * given name, unchanged. Subclasses can override. * * @param name the fully qualified name of the package (using dots). * @return the new name of the package. */
public String mapPackageName(final String name) { return name; }
Maps a module name to its new name. The default implementation of this method returns the given name, unchanged. Subclasses can override.
Params:
  • name – the fully qualified name (using dots) of a module.
Returns:the new name of the module.
/** * Maps a module name to its new name. The default implementation of this method returns the given * name, unchanged. Subclasses can override. * * @param name the fully qualified name (using dots) of a module. * @return the new name of the module. */
public String mapModuleName(final String name) { return name; }
Maps the internal name of a class to its new name. The default implementation of this method returns the given name, unchanged. Subclasses can override.
Params:
  • internalName – the internal name of a class.
Returns:the new internal name.
/** * Maps the internal name of a class to its new name. The default implementation of this method * returns the given name, unchanged. Subclasses can override. * * @param internalName the internal name of a class. * @return the new internal name. */
public String map(final String internalName) { return internalName; } }