chore(release): 1.0.0-dev.9 [skip ci]

# [1.0.0-dev.9](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.8...v1.0.0-dev.9) (2022-05-07)

### Bug Fixes

* `compareSignatureToMethod` not matching correctly in case opcodes are null ([5ae5e98](5ae5e98f1f))
* `ConcurrentModificationException` while iterating through `proxies` and modifying it ([bfeeaf4](bfeeaf4435))
* `PackageMetadata` ([305a817](305a81793a))
* `replaceWith` not replacing classes with used class proxies ([f0f3403](f0f34031dd))
* adding existing classes to the patchers cache ([4281546](4281546f69))
* always return PatchResultSuccess on patch success ([866b03a](866b03af21))
* applying no patches throwing error ([f88c118](f88c11820d))
* applyPatches not returning successful patches ([8b70bb4](8b70bb4290))
* Classes not being written properly because of array shifting ([1471956](147195647c))
* failing tests temporarily ([66b08f8](66b08f8b3a))
* fix classes having multiple instances of fields ([b711b80](b711b8001e))
* fix classes having multiple method instances ([12c10d8](12c10d8c64))
* Fixed writer & signature resolver, improved tests & speed, minor refactoring ([bb42fa3](bb42fa3c6f))
* fuzzy resolver warning params were turned around ([d49df10](d49df10a3c))
* incorrect pattern offset ([03700ff](03700ffa51))
* make `methodMetadata` nullable in `MethodSignatureMetadata` ([864e38c](864e38c069))
* make warnings nullable instead of lateinit ([04b49b8](04b49b8b66))
* match to correct signature method parameters ([c49071a](c49071aff7))
* MethodSignature#resolved throwing an exception ([82b1e66](82b1e66d54))
* Move proxy package out of cache package ([6bc4e7e](6bc4e7eab7))
* null check causing an exception ([560c485](560c485ab0))
* Patcher not writing resolved methods ([d15240d](d15240d033))
* reaching all constructors not possible ([37fa994](37fa9949ec))
* remove leftover debug code ([4458141](4458141d6d))
* return mutable set of classes ([84bc7e0](84bc7e0dc7))
* returning failure on success ([3b68d5c](3b68d5c65e))
* Search method map for existing class proxy ([d5e694c](d5e694c306))
* string signature in `SignatureResolver` ([ac36d19](ac36d19693))
* Suppress unused for addFiles ([a0d6d46](a0d6d46217))
* throwing in case the opcode patterns do not match ([f72dd68](f72dd68ec5))
* use Array instead of Iterable for methodParameters ([312235b](312235b194))
* write all classes ([6ad51aa](6ad51aad9a))

### Code Refactoring

* bump multidexlib2 to 2.5.2.r2 ([32e6458](32e645850d))
* Change all references from Array to Iterable ([264989f](264989f488))

### Features

* add `MethodWalker` ([659e108](659e1087c9))
* add `p` naming scheme to smali compiler ([38556d6](38556d61ab))
* add extensions for cloning methods ([df7503b](df7503b47b))
* add findClass method with className ([78235d1](78235d1abe))
* Add first tests ([6767c8f](6767c8fbc1))
* add fuzzy resolver ([a492808](a492808021))
* add immutableMethod ([eed1cfd](eed1cfda7b))
* add inline smali compiler ([dbafe2a](dbafe2ab37))
* add missing test for fields ([4022b8b](4022b8b847))
* add or extension for AccessFlags ([aec5eeb](aec5eeb597))
* Add patch metadata ([8544fc4](8544fc4cbc)), closes [ReVancedTeam/revanced-patches#1](https://github.com/ReVancedTeam/revanced-patches/issues/1)
* Add warnings for Fuzzy resolver ([643a14e](643a14e664))
* allow classes to be overwritten in addFiles and resolve signatures when applyPatches is called ([5f71a34](5f71a342ac))
* Allow unknown opcodes using `null` ([f4a47d4](f4a47d4dc8))
* Finish first patcher test ([a9e4e8a](a9e4e8ac32))
* Improve `SignatureResolver` ([88a6a27](88a6a27302))
* migrate to dexlib ([be51f42](be51f42710))
* Minor refactor and return proxy, if class has been proxied already ([2d3c611](2d3c61113d))
* properly manage `ClassProxy` & add `ProxyBackedClassList` ([2319787](23197879b2))
* remaining mutable `EncodedValue` classes ([7d38bb0](7d38bb0baa))
* string signature ([#22](https://github.com/revanced/revanced-patcher/issues/22)) ([c245edb](c245edb0c5))

### Performance Improvements

* depend on `androlib` instead of `ApkDecoder` ([e5c054a](e5c054ac2f))
* do not resolve empty signatures list ([1f7bf3a](1f7bf3ac6c))
* lazy-ify all mutable clones ([05e4400](05e44007d8))
* optimize indexOf call away ([f8e978a](f8e978af88))
* use Set instead of List since there are no dupes ([6221387](622138736d))
* use String List and compare instead of any lambda ([aed4fd9](aed4fd9a3c))

### Reverts

* AccessFlag extensions not working with IDE ([e161f7f](e161f7fea4))
* previous commits check for dupes in dexFile, not cache ([433914f](433914feda))

### BREAKING CHANGES

* arrayOf has to be changed to listOf.
* Method signature of Patcher#save() was changed to comply with the changes of multidexlib2.
* Removed usage of ASM library

.github/workflows/release.yml

@@ -1,6 +1,5 @@
 name: Release
 on:
-  workflow_dispatch:
   push:
     branches:
       - main
@@ -21,7 +20,7 @@ jobs:
       - name: Setup JDK
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '8'
           distribution: 'adopt'
           cache: gradle
       - name: Setup Node.js

.idea/misc.xml

@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="azul-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

build.gradle.kts

@@ -1,31 +1,30 @@
 plugins {
-    kotlin("jvm") version "1.7.0"
+    kotlin("jvm") version "1.6.20"
     java
     `maven-publish`
 }
 
 group = "app.revanced"
 
-val githubUsername: String = project.findProperty("gpr.user") as? String ?: System.getenv("GITHUB_ACTOR")
-val githubPassword: String = project.findProperty("gpr.key") as? String ?: System.getenv("GITHUB_TOKEN")
-
 repositories {
     mavenCentral()
     maven {
         url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
         credentials {
-            username = githubUsername
-            password = githubPassword
+            // DO NOT set these variables in the project's gradle.properties.
+            // Instead, you should set them in:
+            // Windows: %homepath%\.gradle\gradle.properties
+            // Linux: ~/.gradle/gradle.properties
+            username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR") // DO NOT CHANGE!
+            password = project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN") // DO NOT CHANGE!
         }
     }
 }
 
 dependencies {
     implementation(kotlin("stdlib"))
-    implementation(kotlin("reflect"))
 
-    api("xpp3:xpp3:1.1.4c")
-    api("org.apktool:apktool-lib:2.6.5-SNAPSHOT")
+    api("org.apktool:apktool-lib:2.6.1")
     api("app.revanced:multidexlib2:2.5.2.r2")
     api("org.smali:smali:2.5.2")
 
@@ -43,10 +42,14 @@ tasks {
 
 java {
     withSourcesJar()
+    withJavadocJar()
 }
 
+val isGitHubCI = System.getenv("GITHUB_ACTOR") != null
+
 publishing {
     repositories {
+        if (isGitHubCI) {
             maven {
                 name = "GitHubPackages"
                 url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
@@ -55,10 +58,13 @@ publishing {
                     password = System.getenv("GITHUB_TOKEN")
                 }
             }
+        } else {
+            mavenLocal()
+        }
     }
     publications {
         register<MavenPublication>("gpr") {
             from(components["java"])
         }
     }
-}
+}

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.3.1
+version = 1.0.0-dev.9

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/kotlin/app/revanced/patcher/PatcherOptions.kt

@@ -1,19 +0,0 @@
-package app.revanced.patcher
-
-import java.io.File
-
-/**
- * Options for a patcher.
- * @param inputFile The input file (usually an apk file).
- * @param resourceCacheDirectory Directory to cache resources.
- * @param patchResources Weather to use the resource patcher. Resources will still need to be decoded.
- * @param aaptPath Optional path to a custom aapt binary.
- * @param frameworkFolderLocation Optional path to a custom framework folder.
- */
-data class PatcherOptions(
-    internal val inputFile: File,
-    internal val resourceCacheDirectory: String,
-    internal val patchResources: Boolean = false,
-    internal val aaptPath: String = "",
-    internal val frameworkFolderLocation: String? = null
-)

src/main/kotlin/app/revanced/patcher/PatcherResult.kt

@@ -1,13 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.util.dex.DexFile
-
-/**
- * The result of a patcher.
- * @param dexFiles The patched dex files.
- * @param doNotCompress List of relative paths to files to exclude from compressing.
- */
-data class PatcherResult(
-    val dexFiles: List<DexFile>,
-    val doNotCompress: List<String>? = null
-)

src/main/kotlin/app/revanced/patcher/annotation/CompatibilityAnnotation.kt

@@ -1,28 +0,0 @@
-package app.revanced.patcher.annotation
-
-import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.signature.implementation.method.MethodSignature
-
-/**
- * Annotation to constrain a [Patch] or [MethodSignature] to compatible packages.
- * @param compatiblePackages A list of packages a [Patch] or [MethodSignature] is compatible with.
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Compatibility(
-    val compatiblePackages: Array<Package>,
-)
-
-/**
- * Annotation to represent packages a patch can be compatible with.
- * @param name The package identifier name.
- * @param versions The versions of the package the [Patch] or [MethodSignature]is compatible with.
- */
-@Target()
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Package(
-    val name: String,
-    val versions: Array<String>
-)

src/main/kotlin/app/revanced/patcher/annotation/MetadataAnnotation.kt

@@ -1,38 +0,0 @@
-package app.revanced.patcher.annotation
-
-import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.signature.implementation.method.MethodSignature
-
-/**
- * Annotation to name a [Patch] or [MethodSignature].
- * @param name A suggestive name for the [Patch] or [MethodSignature].
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Name(
-    val name: String,
-)
-
-/**
- * Annotation to describe a [Patch] or [MethodSignature].
- * @param description A description for the [Patch] or [MethodSignature].
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Description(
-    val description: String,
-)
-
-
-/**
- * Annotation to version a [Patch] or [MethodSignature].
- * @param version The version of a [Patch] or [MethodSignature].
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Version(
-    val version: String,
-)

src/main/kotlin/app/revanced/patcher/data/PackageMetadata.kt

@@ -1,13 +0,0 @@
-package app.revanced.patcher.data
-
-import brut.androlib.meta.MetaInfo
-
-/**
- * Metadata about a package.
- */
-class PackageMetadata {
-    lateinit var packageName: String
-    lateinit var packageVersion: String
-
-    internal val metaInfo: MetaInfo = MetaInfo()
-}

src/main/kotlin/app/revanced/patcher/data/PatcherData.kt

@@ -7,14 +7,12 @@ import app.revanced.patcher.patch.base.Patch
 import org.jf.dexlib2.iface.ClassDef
 import java.io.File
 
-data class PatcherData(
-    internal val internalClasses: MutableList<ClassDef>,
-    internal val resourceCacheDirectory: String,
-    val packageMetadata: PackageMetadata
+internal data class PatcherData(
+    val internalClasses: MutableList<ClassDef>,
+    val resourceCacheDirectory: String
 ) {
+    internal val patches = mutableListOf<Patch<Data>>()
 
-    internal val patches = mutableListOf<Class<out Patch<Data>>>()
-
-    internal val bytecodeData = BytecodeData(internalClasses)
+    internal val bytecodeData = BytecodeData(patches, internalClasses)
     internal val resourceData = ResourceData(File(resourceCacheDirectory))
 }

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

@@ -1,33 +1,56 @@
 package app.revanced.patcher.data.implementation
 
 import app.revanced.patcher.data.base.Data
+import app.revanced.patcher.methodWalker.MethodWalker
+import app.revanced.patcher.patch.base.Patch
+import app.revanced.patcher.patch.implementation.BytecodePatch
+import app.revanced.patcher.proxy.ClassProxy
+import app.revanced.patcher.signature.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.
-     * @param className The name of the class.
-     * @return A proxy for the first class that matches the class name.
+     * Find a class by a given class name
+     * @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.
-     * @param predicate A predicate to match the class.
-     * @return A proxy for the first class that matches the predicate.
+     * Find a class by a given predicate
+     * @return A proxy for the first class that matches the predicate
      */
-    fun findClass(predicate: (ClassDef) -> Boolean) =
+    fun findClass(predicate: (ClassDef) -> Boolean): ClassProxy? {
         // if we already proxied the class matching the predicate...
-        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
+        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
+            }
+        }
         // else resolve the class to a proxy and return it, if the predicate is matching a class
-        classes.find(predicate)?.let { proxy(it) }
+        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")
+    }
 }
 
 internal class MethodNotFoundException(s: String) : Exception(s)
@@ -41,11 +64,6 @@ 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)
 }
@@ -59,11 +77,11 @@ internal inline fun <T> Iterable<T>.findIndexed(predicate: (T) -> Boolean): Pair
     return null
 }
 
-fun BytecodeData.proxy(classDef: ClassDef): app.revanced.patcher.util.proxy.ClassProxy {
+fun BytecodeData.proxy(classDef: ClassDef): ClassProxy {
     var proxy = this.classes.proxies.find { it.immutableClass.type == classDef.type }
     if (proxy == null) {
-        proxy = app.revanced.patcher.util.proxy.ClassProxy(classDef)
-        this.classes.add(proxy)
+        proxy = ClassProxy(classDef)
+        this.classes.proxies.add(proxy)
     }
     return proxy
 }

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

@@ -14,7 +14,8 @@ class ResourceData(private val resourceCacheDirectory: File) : Data {
     private fun resolve(path: String) = resourceCacheDirectory.resolve(path)
 
     fun forEach(action: (File) -> Unit) = resourceCacheDirectory.walkTopDown().forEach(action)
-    fun get(path: String) = resolve(path)
+    fun reader(path: String) = resolve(path).reader()
+    fun writer(path: String) = resolve(path).writer()
 
     fun replace(path: String, oldValue: String, newValue: String, oldValueIsRegex: Boolean = false) {
         // TODO: buffer this somehow
@@ -34,6 +35,7 @@ class DomFileEditor internal constructor(private val domFile: File) : Closeable
 
     init {
         val factory = DocumentBuilderFactory.newInstance()
+        factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true)
 
         val builder = factory.newDocumentBuilder()
 

src/main/kotlin/app/revanced/patcher/extensions/AnnotationExtensions.kt

@@ -1,59 +0,0 @@
-package app.revanced.patcher.extensions
-
-import app.revanced.patcher.annotation.Compatibility
-import app.revanced.patcher.annotation.Description
-import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.annotation.Version
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.signature.implementation.method.MethodSignature
-import app.revanced.patcher.signature.implementation.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.signature.implementation.method.annotation.MatchingMethod
-import kotlin.reflect.KClass
-
-/**
- * Recursively find a given annotation on a class.
- * @param targetAnnotation The annotation to find.
- * @return The annotation.
- */
-private fun <T : Annotation> Class<*>.recursiveAnnotation(targetAnnotation: KClass<T>) =
-    this.findAnnotationRecursively(targetAnnotation.java, mutableSetOf())
-
-
-private fun <T : Annotation> Class<*>.findAnnotationRecursively(
-    targetAnnotation: Class<T>, traversed: MutableSet<Annotation>
-): T? {
-    val found = this.annotations.firstOrNull { it.annotationClass.java.name == targetAnnotation.name }
-
-    @Suppress("UNCHECKED_CAST") if (found != null) return found as T
-
-    for (annotation in this.annotations) {
-        if (traversed.contains(annotation)) continue
-        traversed.add(annotation)
-
-        return (annotation.annotationClass.java.findAnnotationRecursively(targetAnnotation, traversed)) ?: continue
-    }
-
-    return null
-}
-
-object PatchExtensions {
-    val Class<out Patch<Data>>.patchName: String
-        get() = recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
-    val Class<out Patch<Data>>.version get() = recursiveAnnotation(Version::class)?.version
-    val Class<out Patch<Data>>.include get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Patch::class)!!.include
-    val Class<out Patch<Data>>.description get() = recursiveAnnotation(Description::class)?.description
-    val Class<out Patch<Data>>.dependencies get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Dependencies::class)?.dependencies
-    val Class<out Patch<Data>>.compatiblePackages get() = recursiveAnnotation(Compatibility::class)?.compatiblePackages
-}
-
-object MethodSignatureExtensions {
-    val MethodSignature.name: String
-        get() = javaClass.recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
-    val MethodSignature.version get() = javaClass.recursiveAnnotation(Version::class)?.version ?: "0.0.1"
-    val MethodSignature.description get() = javaClass.recursiveAnnotation(Description::class)?.description
-    val MethodSignature.compatiblePackages get() = javaClass.recursiveAnnotation(Compatibility::class)?.compatiblePackages
-    val MethodSignature.matchingMethod get() = javaClass.recursiveAnnotation(MatchingMethod::class)
-    val MethodSignature.fuzzyPatternScanMethod get() = javaClass.recursiveAnnotation(FuzzyPatternScanMethod::class)
-    val MethodSignature.fuzzyThreshold get() = fuzzyPatternScanMethod?.threshold ?: 0
-}

src/main/kotlin/app/revanced/patcher/extensions/Extensions.kt

@@ -1,9 +1,6 @@
 package app.revanced.patcher.extensions
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import app.revanced.patcher.util.smali.toInstruction
-import app.revanced.patcher.util.smali.toInstructions
+import app.revanced.patcher.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.builder.BuilderInstruction
 import org.jf.dexlib2.builder.MutableMethodImplementation
@@ -12,7 +9,6 @@ import org.jf.dexlib2.iface.reference.MethodReference
 import org.jf.dexlib2.immutable.ImmutableMethod
 import org.jf.dexlib2.immutable.ImmutableMethodImplementation
 import org.jf.dexlib2.util.MethodUtil
-import java.io.OutputStream
 
 infix fun AccessFlags.or(other: AccessFlags) = this.value or other.value
 infix fun Int.or(other: AccessFlags) = this or other.value
@@ -23,19 +19,6 @@ fun MutableMethodImplementation.addInstructions(index: Int, instructions: List<B
     }
 }
 
-/**
- * Compare a method to another, considering constructors and parameters.
- * @param otherMethod The method to compare against.
- * @return True if the methods match given the conditions.
- */
-fun Method.softCompareTo(
-    otherMethod: MethodReference
-): Boolean {
-    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
-        return false
-    return this.name == otherMethod.name
-}
-
 /**
  * Clones the method.
  * @param registerCount This parameter allows you to change the register count of the method.
@@ -65,22 +48,6 @@ internal fun Method.clone(
     )
 }
 
-/**
- * Add smali instructions to the method.
- * @param index The index to insert the instructions at.
- * @param instruction The smali instruction to add.
- */
-fun MutableMethod.addInstruction(index: Int, instruction: String) =
-    this.implementation!!.addInstruction(index, instruction.toInstruction(this))
-
-/**
- * Add smali instructions to the method.
- * @param index The index to insert the instructions at.
- * @param instructions The smali instructions to add.
- */
-fun MutableMethod.addInstructions(index: Int, instructions: String) =
-    this.implementation!!.addInstructions(index, instructions.toInstructions(this))
-
 /**
  * Clones the method.
  * @param registerCount This parameter allows you to change the register count of the method.
@@ -91,6 +58,14 @@ internal fun Method.cloneMutable(
     registerCount: Int = 0,
 ) = clone(registerCount).toMutable()
 
+internal fun Method.softCompareTo(
+    otherMethod: MethodReference
+): Boolean {
+    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
+        return false
+    return this.name == otherMethod.name
+}
+
 // FIXME: also check the order of parameters as different order equals different method overload
 internal fun parametersEqual(
     parameters1: Iterable<CharSequence>,
@@ -103,9 +78,4 @@ internal fun parametersEqual(
             )
         }
     }
-}
-
-internal val nullOutputStream: OutputStream =
-    object : OutputStream() {
-        override fun write(b: Int) {}
-    }
+}

src/main/kotlin/app/revanced/patcher/methodWalker/MethodWalker.kt

@@ -1,9 +1,9 @@
-package app.revanced.patcher.util.method
+package app.revanced.patcher.methodWalker
 
 import app.revanced.patcher.data.implementation.BytecodeData
 import app.revanced.patcher.data.implementation.MethodNotFoundException
 import app.revanced.patcher.extensions.softCompareTo
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
+import app.revanced.patcher.proxy.mutableTypes.MutableMethod
 import org.jf.dexlib2.Format
 import org.jf.dexlib2.iface.Method
 import org.jf.dexlib2.iface.instruction.formats.Instruction35c
@@ -33,7 +33,7 @@ class MethodWalker internal constructor(
      * @param walkMutable If this is true, the class of the method will be resolved mutably.
      * The current method will be mutable.
      */
-    fun nextMethod(offset: Int, walkMutable: Boolean = false): MethodWalker {
+    fun walk(offset: Int, walkMutable: Boolean = false): MethodWalker {
         currentMethod.implementation?.instructions?.let { instructions ->
             val instruction = instructions.elementAt(offset)
 

src/main/kotlin/app/revanced/patcher/patch/annotations/PatchAnnotation.kt

@@ -1,24 +0,0 @@
-package app.revanced.patcher.patch.annotations
-
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import kotlin.reflect.KClass
-
-/**
- * Annotation to mark a Class as a patch.
- * @param include If false, the patch should be treated as optional by default.
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Patch(val include: Boolean = true)
-
-/**
- * Annotation for dependencies of [Patch]es .
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Dependencies(
-    val dependencies: Array<KClass<out Patch<Data>>> = []
-)

src/main/kotlin/app/revanced/patcher/patch/base/Patch.kt

@@ -3,17 +3,20 @@ package app.revanced.patcher.patch.base
 import app.revanced.patcher.data.base.Data
 import app.revanced.patcher.patch.implementation.BytecodePatch
 import app.revanced.patcher.patch.implementation.ResourcePatch
+import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
 import app.revanced.patcher.patch.implementation.misc.PatchResult
 
 
 /**
  * A ReVanced patch.
- * Can either be a [ResourcePatch] or a [BytecodePatch].
+ * Can either be a [ResourcePatch] or a [BytecodePatch]
  */
-abstract class Patch<out T : Data> {
-
+abstract class Patch<out T : Data>(
+    open val metadata: PatchMetadata
+) {
     /**
      * The main function of the [Patch] which the patcher will call.
      */
-    abstract fun execute(data: @UnsafeVariance T): PatchResult
+    abstract fun execute(data: @UnsafeVariance T): PatchResult // FIXME: remove the UnsafeVariance annotation
+
 }

src/main/kotlin/app/revanced/patcher/patch/implementation/BytecodePatch.kt

@@ -2,12 +2,15 @@ package app.revanced.patcher.patch.implementation
 
 import app.revanced.patcher.data.implementation.BytecodeData
 import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.signature.implementation.method.MethodSignature
+import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
+import app.revanced.patcher.signature.MethodSignature
 
 /**
  * Bytecode patch for the Patcher.
+ * @param metadata [PatchMetadata] for the patch.
  * @param signatures A list of [MethodSignature] this patch relies on.
  */
 abstract class BytecodePatch(
-    internal val signatures: Iterable<MethodSignature>
-) : Patch<BytecodeData>()
+    override val metadata: PatchMetadata,
+    val signatures: Iterable<MethodSignature>
+) : Patch<BytecodeData>(metadata)

src/main/kotlin/app/revanced/patcher/patch/implementation/ResourcePatch.kt

@@ -2,8 +2,12 @@ package app.revanced.patcher.patch.implementation
 
 import app.revanced.patcher.data.implementation.ResourceData
 import app.revanced.patcher.patch.base.Patch
+import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
 
 /**
  * Resource patch for the Patcher.
+ * @param metadata [PatchMetadata] for the patch.
  */
-abstract class ResourcePatch : Patch<ResourceData>()
+abstract class ResourcePatch(
+    override val metadata: PatchMetadata
+) : Patch<ResourceData>(metadata)

src/main/kotlin/app/revanced/patcher/patch/implementation/metadata/PatchMetadata.kt

@@ -0,0 +1,29 @@
+package app.revanced.patcher.patch.implementation.metadata
+
+import app.revanced.patcher.patch.base.Patch
+
+/**
+ * Metadata about a [Patch].
+ * @param shortName A suggestive short name for the [Patch].
+ * @param name A suggestive name for the [Patch].
+ * @param description A description for the [Patch].
+ * @param compatiblePackages A list of packages this [Patch] is compatible with.
+ * @param version The version of the [Patch].
+ */
+data class PatchMetadata(
+    val shortName: String,
+    val name: String,
+    val description: String,
+    val compatiblePackages: Iterable<PackageMetadata>,
+    val version: String,
+)
+
+/**
+ * Metadata about a package.
+ * @param name The package name.
+ * @param versions Compatible versions of the package.
+ */
+data class PackageMetadata(
+    val name: String,
+    val versions: Iterable<String>
+)

src/main/kotlin/app/revanced/patcher/patch/implementation/misc/PatchResult.kt

@@ -24,12 +24,10 @@ interface PatchResult {
     }
 }
 
-class PatchResultError(
-    errorMessage: String?, cause: Exception?
-) : Exception(errorMessage, cause), PatchResult {
-    constructor(errorMessage: String) : this(errorMessage, null)
-    constructor(cause: Exception) : this(cause.message, cause)
-
+class PatchResultError(private val errorMessage: String) : PatchResult {
+    fun errorMessage(): String {
+        return errorMessage
+    }
 }
 
 class PatchResultSuccess : PatchResult

src/main/kotlin/app/revanced/patcher/proxy/ClassProxy.kt

@@ -1,6 +1,6 @@
-package app.revanced.patcher.util.proxy
+package app.revanced.patcher.proxy
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
+import app.revanced.patcher.proxy.mutableTypes.MutableClass
 import org.jf.dexlib2.iface.ClassDef
 
 /**

src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableAnnotation.kt

@@ -1,6 +1,6 @@
-package app.revanced.patcher.util.proxy.mutableTypes
+package app.revanced.patcher.proxy.mutableTypes
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
 import org.jf.dexlib2.base.BaseAnnotation
 import org.jf.dexlib2.iface.Annotation
 

src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableAnnotationElement.kt

@@ -1,7 +1,7 @@
-package app.revanced.patcher.util.proxy.mutableTypes
+package app.revanced.patcher.proxy.mutableTypes
 
-import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue
-import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue
+import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
 import org.jf.dexlib2.base.BaseAnnotationElement
 import org.jf.dexlib2.iface.AnnotationElement
 import org.jf.dexlib2.iface.value.EncodedValue

src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableClass.kt

@@ -1,8 +1,8 @@
-package app.revanced.patcher.util.proxy.mutableTypes
+package app.revanced.patcher.proxy.mutableTypes
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableField.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import com.google.common.collect.Iterables
 import org.jf.dexlib2.base.reference.BaseTypeReference
 import org.jf.dexlib2.iface.ClassDef

src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableField.kt

@@ -1,8 +1,8 @@
-package app.revanced.patcher.util.proxy.mutableTypes
+package app.revanced.patcher.proxy.mutableTypes
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue
-import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue
+import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
 import org.jf.dexlib2.HiddenApiRestriction
 import org.jf.dexlib2.base.reference.BaseFieldReference
 import org.jf.dexlib2.iface.Field

src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableMethod.kt

@@ -1,7 +1,7 @@
-package app.revanced.patcher.util.proxy.mutableTypes
+package app.revanced.patcher.proxy.mutableTypes
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethodParameter.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableMethodParameter.Companion.toMutable
 import org.jf.dexlib2.HiddenApiRestriction
 import org.jf.dexlib2.base.reference.BaseMethodReference
 import org.jf.dexlib2.builder.MutableMethodImplementation

src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableMethodParameter.kt

@@ -1,6 +1,6 @@
-package app.revanced.patcher.util.proxy.mutableTypes
+package app.revanced.patcher.proxy.mutableTypes
 
-import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
+import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
 import org.jf.dexlib2.base.BaseMethodParameter
 import org.jf.dexlib2.iface.MethodParameter