feat: InsnListUtils as replacements for InsnSequence

Author: zaaarf

src/main/java/ftbsc/lll/utils/DescriptorBuilder.java

@@ -118,8 +118,7 @@ public DescriptorBuilder addParameter(String param, int arrayLevel) {
 	public String build() {
 		StringBuilder sb = new StringBuilder();
 		sb.append('(');
-		for(String p : params)
-			sb.append(p);
+		for(String p : params) sb.append(p);
 		sb.append(')').append(returnType);
 		return sb.toString();
 	}
@@ -133,8 +132,7 @@ public String build() {
 	 */
 	public static String nameToDescriptor(String name, int arrayLevel) {
 		StringBuilder sb = new StringBuilder();
-		for(int i = 0; i < arrayLevel; i++)
-			sb.append('[');
+		for(int i = 0; i < arrayLevel; i++) sb.append('[');
 		sb.append('L').append(name.replace('.', '/')).append(';');
 		return sb.toString();
 	}

src/main/java/ftbsc/lll/utils/InsnListUtils.java

@@ -0,0 +1,96 @@
+package ftbsc.lll.utils;
+
+import ftbsc.lll.exceptions.InstructionMismatchException;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.InsnList;
+
+/**
+ * A collection of utilities for manipulating {@link InsnList}s.
+ */
+public class InsnListUtils {
+
+	/**
+	 * Factory method that builds an {@link InsnList} with the given nodes.
+	 * @param nodes the nodes in question
+	 * @return the resulting {@link InsnList}
+	 */
+	public static InsnList of(AbstractInsnNode... nodes) {
+		InsnList list = new InsnList();
+		for(AbstractInsnNode node : nodes) {
+		list.add(node);
+		}
+		return list;
+	}
+
+	/**
+	 * Creates a sublist with all the nodes between the given extremes.
+	 * @param startNode the starting node of the pattern, must be non-null
+	 * @param endNode the first node of the pattern, must be non-null
+	 * @return the resulting {@link InsnList}
+	 */
+	public static InsnList between(AbstractInsnNode startNode, AbstractInsnNode endNode) {
+		InsnList list = new InsnList();
+		for(; startNode != null; startNode = startNode.getNext()) {
+			list.add(startNode);
+			if(startNode == endNode) {
+				return list;
+			}
+		}
+
+		throw new InstructionMismatchException(String.format(
+			"Nodes %s and %s are not connected.",
+			list.getFirst(),
+			list.getLast()
+		));
+	}
+
+	/**
+	 * Replaces a node with another one. Mostly used internally.
+	 * @param list the list to perform the operation on
+	 * @param oldNode node to replace
+	 * @param newNode new node
+	 */
+	public static void replaceNode(InsnList list, AbstractInsnNode oldNode, AbstractInsnNode newNode) {
+		list.insert(oldNode, newNode);
+		list.remove(oldNode);
+	}
+
+	/**
+	 * Replaces n occurrences of said opcode with the given node.
+	 * @param list the list to perform the operation on
+	 * @param opcode the opcode to replace
+	 * @param newNode the replacement node
+	 * @param reverse whether the search should be done from the end
+	 * @param amount how many occurrences to replace, set to 0 to replace all
+	 * @return true if anything was changed, false otherwise
+	 */
+	public static boolean replace(InsnList list, int opcode, AbstractInsnNode newNode, int amount, boolean reverse) {
+		boolean changed = false;
+		for(
+			AbstractInsnNode cur = list.getFirst();
+			cur != null && cur.getPrevious() != list.getLast() && cur.getNext() != list.getFirst();
+			cur = reverse ? cur.getPrevious() : cur.getNext()
+		) {
+			if(cur.getOpcode() == opcode) {
+				replaceNode(list, cur, newNode);
+				changed = true;
+				amount--; // will go to negative if it was already 0, causing it to go on until for loop finishes
+				if(amount == 0) {
+					return changed;
+				}
+			}
+		}
+		return changed;
+	}
+
+	/**
+	 * Cut a number of nodes from the list.
+	 * @param amount how many nodes to cut
+	 * @param reverse true if it should cut from the end, false otherwise
+	 */
+	public static void cut(InsnList list, int amount, boolean reverse) {
+		for(int i = 0; i < amount; i++) {
+			list.remove(reverse ? list.getLast() : list.getFirst());
+		}
+	}
+}

src/main/java/ftbsc/lll/utils/InsnSequence.java

@@ -9,7 +9,10 @@
 /**
  * Represents a sequence of instructions contained within two given nodes.
  * Extends {@link InsnList}, but provides additional flexibility and features.
+ * @deprecated Riddled with bugs, poorly named and hardly useful.
+ *             Will be removed (or possibly replaced) in an upcoming release.
  */
+@Deprecated
 public class InsnSequence extends InsnList {
 	/**
 	 * Public constructor.

src/main/java/ftbsc/lll/utils/PatternMatcher.java

@@ -80,7 +80,7 @@ public InsnList find(MethodNode node) {
 	 * @param node the node to start the search on
 	 * @return the {@link InsnList} object representing the matched pattern
 	 */
-	public InsnSequence find(AbstractInsnNode node) {
+	public InsnList find(AbstractInsnNode node) {
 		if(node != null) {
 			AbstractInsnNode first, last;
 			for(AbstractInsnNode cur = node; cur != null; cur = this.reverse ? cur.getPrevious() : cur.getNext()) {

src/main/java/ftbsc/lll/utils/StackUtils.java

@@ -20,7 +20,9 @@ public class StackUtils implements Opcodes {
 	 * @param desc the descriptor of the constructor to call
 	 * @param args nodes containing instructions to load the constructor arguments, in the right order
 	 * @return an instruction list containing the opcodes needed to create the new object and load it on the stack.
+	 * @deprecated very redundant
 	 */
+	@Deprecated
 	public static InsnList instantiate(String name, String desc, AbstractInsnNode... args) {
 		InsnSequence is = new InsnSequence();
 		is.add(args);