Package de.geolykt.starloader.deobf.remapper

# Class Remapper

java.lang.Object
de.geolykt.starloader.deobf.remapper.Remapper

public final class Remapper extends Object
Simple in-memory remapping engine. Unlike many other remappers it is able to take in already parsed `Objectweb ASM Classnodes` as input and output them without having to go through an intermediary store-to-file mode. Additionally, this is a no-bullshit remapper. It will only remap, not change your Access flags, LVT entries or anything like that. If you want a deobfuscator, use `Oaktree` after remapping.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Remapper()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addTarget(org.objectweb.asm.tree.ClassNode node)`
  Adds a single class node to remap
  `void`
  `addTargets(Collection<org.objectweb.asm.tree.ClassNode> nodes)`
  Adds multiple class nodes to remap
  `void`
  `clearTargets()`
  `Map<String,String>`
  `fixICNNames(StringBuilder sharedBuilder)`
  Fixes remapped `InnerClassNode` by remapping any child classes alongside their parent class, even if only the parent class was remapped.
  `List<org.objectweb.asm.tree.ClassNode>`
  `getOutput()`
  Note: due to the circumstances of how the remapper works, this method call may be not required as the remapper remaps the input ClassNodes without cloning them in any capacity.
  `@NotNull String`
  `getRemappedClassName(@NotNull String name)`
  Remaps a class name.
  `@NotNull String`
  `getRemappedFieldDescriptor(@NotNull String fieldDesc, @NotNull StringBuilder sharedBuilder)`
  Remaps a field descriptor.
  `@NotNull String`
  `getRemappedFieldName(@NotNull String owner, @NotNull String name, @NotNull String desc)`
  Remaps a field name.
  `@NotNull String`
  `getRemappedMethodDescriptor(@NotNull String methodDesc, @NotNull StringBuilder sharedBuilder)`
  Remaps a method descriptor.
  `@NotNull String`
  `getRemappedMethodName(@NotNull String owner, @NotNull String name, @NotNull String desc)`
  Remaps a method name.
  `void`
  `process()`
  Processes all remap orders and clears the remap orders afterwards.
  `void`
  `remapClassName(String oldName, String newName)`
  Remaps the name of all target class nodes once `process()` is called.
  `void`
  `remapClassNames(Map<String,String> mappings)`
  Remaps the name of all target class nodes once `process()` is called.
  `void`
  `remapField(String owner, String desc, String oldName, String newName)`
  Inserts a field renaming entry to the remapping list.
  `void`
  `remapMethod(String owner, String desc, String oldName, String newName)`
  Inserts a method renaming entry to the remapping list.
  `void`
  `removeMethodRemap(String owner, String desc, String name)`
  Removes a method remapping entry from the method remapping list.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### Remapper

    public Remapper()

- ## Method Details

  - ### addTarget

    public void addTarget(org.objectweb.asm.tree.ClassNode node)
    Adds a single class node to remap
    Parameters:
      `node` - The class node

  - ### addTargets

    public void addTargets(Collection<org.objectweb.asm.tree.ClassNode> nodes)
    Adds multiple class nodes to remap
    Parameters:
      `nodes` - The class nodes

  - ### clearTargets

    public void clearTargets()

  - ### fixICNNames

    public Map<String,String> fixICNNames(StringBuilder sharedBuilder)
    Fixes remapped `InnerClassNode` by remapping any child classes alongside their parent class, even if only the parent class was remapped. Due to the potentially destructive properties of this action, this method must be explicitly invoked for it to do anything.

    More specifically if the class "OuterClass" is remapped to "RootClass", but "OuterClass$Inner" is not remapped, then after `process()` the classes "RootClass" and "OuterClass$Inner" will exist. As the names contradict the relation given by their `InnerClassNode`, most decompilers will discard the `InnerClassNode`.

    To fix this issue, this method will look for such changes and renames the inner classes accordingly.

    This method will only do anything if it is called before `process()` and will modify the internal collection of remapped classes.

    The more `ClassNodes` there are, the more efficient this method is at doing what it should do.

    This method can be destructive as it will not check for collisions.

    Parameters:
      `sharedBuilder` - A shared `StringBuilder` to reduce memory consumption created by string operations
    Returns:
      A map that contains ALL additional mappings where as the key is the old name and the value the new name.

  - ### getOutput

    public List<org.objectweb.asm.tree.ClassNode> getOutput()
    Note: due to the circumstances of how the remapper works, this method call may be not required as the remapper remaps the input ClassNodes without cloning them in any capacity.
    Returns:
      Returns the targets

  - ### getRemappedClassName

    @NotNull public @NotNull String getRemappedClassName(@NotNull @NotNull String name)
    Remaps a class name.
    Parameters:
      `name` - The old (unmapped) class name
    Returns:
      The new (remapped) class name

  - ### getRemappedFieldDescriptor

    @NotNull public @NotNull String getRemappedFieldDescriptor(@NotNull @NotNull String fieldDesc, @NotNull @NotNull StringBuilder sharedBuilder)
    Remaps a field descriptor.
    Parameters:
      `fieldDesc` - The old (unmapped) field descriptor
      `sharedBuilder` - A shared cached string builder. The contents of the string builder are wiped and after the invocation the contents are undefined
    Returns:
      The new (remapped) field descriptor. It can be identity identical to the "fieldDesc" if it didn't need to be altered

  - ### getRemappedFieldName

    @NotNull public @NotNull String getRemappedFieldName(@NotNull @NotNull String owner, @NotNull @NotNull String name, @NotNull @NotNull String desc)
    Remaps a field name.
    Parameters:
      `owner` - The old (unmapped) class name
      `name` - The old (unmapped) field name
      `desc` - The old (unmapped) field descriptor
    Returns:
      The new (remapped) field name
    Since:
      0.1.0

  - ### getRemappedMethodDescriptor

    @NotNull public @NotNull String getRemappedMethodDescriptor(@NotNull @NotNull String methodDesc, @NotNull @NotNull StringBuilder sharedBuilder)
    Remaps a method descriptor.
    Parameters:
      `methodDesc` - The old (unmapped) method descriptor
      `sharedBuilder` - A shared cached string builder. The contents of the string builder are wiped and after the invocation the contents are undefined
    Returns:
      The new (remapped) method descriptor. It can be identity identical to the "methodDesc" if it didn't need to be altered

  - ### getRemappedMethodName

    @NotNull public @NotNull String getRemappedMethodName(@NotNull @NotNull String owner, @NotNull @NotNull String name, @NotNull @NotNull String desc)
    Remaps a method name.
    Parameters:
      `owner` - The old (unmapped) class name
      `name` - The old (unmapped) method name
      `desc` - The old (unmapped) method descriptor
    Returns:
      The new (remapped) method name
    Since:
      0.1.0

  - ### process

    public void process()
    Processes all remap orders and clears the remap orders afterwards. The classes that need to be processed remain in the targets list until `clearTargets()` is invoked. This allows for reusability of the same remapper instance. Class names are remapped last.

  - ### remapClassName

    public void remapClassName(String oldName, String newName)
    Remaps the name of all target class nodes once `process()` is called. Class names are remapped alongside method / fields however technically they are remapped last.
    Parameters:
      `oldName` - The old internal class name of the class to remap
      `newName` - The new internal class name of the class to remap

  - ### remapClassNames

    public void remapClassNames(Map<String,String> mappings)
    Remaps the name of all target class nodes once `process()` is called. Class names are remapped alongside method / fields however technically they are remapped last. This is a bulk method. And is similar to calling `remapClassName(String, String)`.
    Parameters:
      `mappings` - A map that represents all the class remaps. Keys are old names, values are new names.

  - ### remapField

    public void remapField(String owner, String desc, String oldName, String newName)
    Inserts a field renaming entry to the remapping list. The owner and desc strings must be valid for the current class names, i. e. without `remapClassName(String, String)` and `process()` applied. The fields are not actually renamed until `process()` is invoked. These tasks are however removed as soon as `process()` is invoked. Unlike `remapMethod(String, String, String, String)`, this method will do it's best to propagate field renames to child classes. However it may miss a few if not all classes are declared as targets. However one would still be able to explicitly add a remap via this method.
    Parameters:
      `owner` - The internal name of the current owner of the field
      `desc` - The descriptor string of the field entry
      `oldName` - The old name of the field
      `newName` - The new name of the field
    See Also:
      - `Type.getInternalName()`

  - ### remapMethod

    public void remapMethod(String owner, String desc, String oldName, String newName) throws ConflicitingMappingException
    Inserts a method renaming entry to the remapping list. The owner and desc strings must be valid for the current class names, i. e. without `remapClassName(String, String)` and `process()` applied. The method are not actually renamed until `process()` is invoked.

    WARNING: if the method is non-static and non-private and the owning class non-final then it is recommended that the change is propagated through the entire tree. Renaming a method will only affect one class, not multiple - which may void overrides or other similar behaviours.

    Parameters:
      `owner` - The internal name of the current owner of the method
      `desc` - The descriptor string of the method entry
      `oldName` - The old name of the method
      `newName` - The new name of the method
    Throws:
      `ConflicitingMappingException` - If a mapping error occurs.
    See Also:
      - `Type.getInternalName()`

  - ### removeMethodRemap

    public void removeMethodRemap(String owner, String desc, String name)
    Removes a method remapping entry from the method remapping list. This method practically undoes `remapMethod(String, String, String, String)`. Like it it only affects a SINGLE method in a SINGLE class and it's references. Note that implicitly declared/inherited methods must also be added to the remap list.
    Parameters:
      `owner` - The class of the method that should not be remapped
      `desc` - The descriptor of the method to not remap
      `name` - The name of the method that should not be remapped