feat: patch dependencies annotation and PatcherOptions

src/main/kotlin/app/revanced/patcher/data/implementation/BytecodeData.kt

@@ -1,55 +1,33 @@
 package app.revanced.patcher.data.implementation
 
 import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.patch.implementation.BytecodePatch
-import app.revanced.patcher.signature.implementation.method.resolver.SignatureResolverResult
 import app.revanced.patcher.util.ProxyBackedClassList
 import app.revanced.patcher.util.method.MethodWalker
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
 
 class BytecodeData(
-    // FIXME: ugly solution due to design.
-    //  It does not make sense for a BytecodeData instance to have access to the patches
-    private val patches: List<Patch<Data>>,
     internalClasses: MutableList<ClassDef>
 ) : Data {
     val classes = ProxyBackedClassList(internalClasses)
 
     /**
-     * Find a class by a given class name
-     * @return A proxy for the first class that matches the class name
+     * Find a class by a given class name.
+     * @param className The name of the class.
+     * @return A proxy for the first class that matches the class name.
      */
     fun findClass(className: String) = findClass { it.type.contains(className) }
 
     /**
-     * Find a class by a given predicate
-     * @return A proxy for the first class that matches the predicate
+     * Find a class by a given predicate.
+     * @param predicate A predicate to match the class.
+     * @return A proxy for the first class that matches the predicate.
      */
-    fun findClass(predicate: (ClassDef) -> Boolean): app.revanced.patcher.util.proxy.ClassProxy? {
+    fun findClass(predicate: (ClassDef) -> Boolean) =
         // if we already proxied the class matching the predicate...
-        for (patch in patches) {
-            if (patch !is BytecodePatch) continue
-            for (signature in patch.signatures) {
-                val result = signature.result
-                result ?: continue
-
-                if (predicate(result.definingClassProxy.immutableClass)) return result.definingClassProxy  // ...then return that proxy
-            }
-        }
+        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
         // else resolve the class to a proxy and return it, if the predicate is matching a class
-        return classes.find(predicate)?.let {
-            proxy(it)
-        }
-    }
-}
-
-
-class MethodMap : LinkedHashMap<String, SignatureResolverResult>() {
-    override fun get(key: String): SignatureResolverResult {
-        return super.get(key) ?: throw MethodNotFoundException("Method $key was not found in the method cache")
-    }
+        classes.find(predicate)?.let { proxy(it) }
 }
 
 internal class MethodNotFoundException(s: String) : Exception(s)
@@ -63,6 +41,11 @@ internal inline fun <reified T> Iterable<T>.find(predicate: (T) -> Boolean): T?
     return null
 }
 
+/**
+ * Create a [MethodWalker] instance for the current [BytecodeData].
+ * @param startMethod The method to start at.
+ * @return A [MethodWalker] instance.
+ */
 fun BytecodeData.toMethodWalker(startMethod: Method): MethodWalker {
     return MethodWalker(this, startMethod)
 }
@@ -80,7 +63,7 @@ fun BytecodeData.proxy(classDef: ClassDef): app.revanced.patcher.util.proxy.Clas
     var proxy = this.classes.proxies.find { it.immutableClass.type == classDef.type }
     if (proxy == null) {
         proxy = app.revanced.patcher.util.proxy.ClassProxy(classDef)
-        this.classes.proxies.add(proxy)
+        this.classes.add(proxy)
     }
     return proxy
 }