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

# [1.0.0-dev.8](https://github.com/ReVancedTeam/revanced-patcher/compare/v1.0.0-dev.7...v1.0.0-dev.8) (2022-03-24)

### Performance Improvements

* check type instead of class ([47eb493](47eb493f54))

.github/workflows/release.yml

@@ -1,6 +1,5 @@
 name: Release
 on:
-  workflow_dispatch:
   push:
     branches:
       - main
@@ -21,16 +20,16 @@ jobs:
       - name: Setup JDK
         uses: actions/setup-java@v2
         with:
-          java-version: '17'
+          java-version: '8'
           distribution: 'adopt'
           cache: gradle
       - name: Setup Node.js
         uses: actions/setup-node@v2
         with:
           node-version: "lts/*"
+      - name: Make gradlew executable
+        run: chmod +x gradlew
       - name: Build with Gradle
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: ./gradlew build
       - name: Setup semantic-release
         run: npm install -g semantic-release @semantic-release/git @semantic-release/changelog gradle-semantic-release-plugin -D

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="UnusedSymbol" enabled="false" level="WARNING" enabled_by_default="false" />
-  </profile>
-</component>

.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,57 +1,48 @@
 plugins {
-    kotlin("jvm") version "1.7.0"
+    kotlin("jvm") version "1.6.10"
     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
-        }
-    }
 }
 
 dependencies {
-    implementation("xpp3:xpp3:1.1.4c")
-    implementation("app.revanced:multidexlib2:2.5.2.r2")
-    implementation("org.smali:smali:2.5.2")
-    implementation("org.apktool:apktool-lib:2.6.5-SNAPSHOT")
-
+    implementation(kotlin("stdlib"))
+    implementation("org.ow2.asm:asm:9.2")
+    implementation("org.ow2.asm:asm-util:9.2")
+    implementation("org.ow2.asm:asm-tree:9.2")
+    implementation("org.ow2.asm:asm-commons:9.2")
+    implementation("io.github.microutils:kotlin-logging:2.1.21")
+    testImplementation("ch.qos.logback:logback-classic:1.2.11") // use your own logger!
     testImplementation(kotlin("test"))
 }
 
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
+tasks.test {
+    useJUnitPlatform()
+    testLogging {
+        events("PASSED", "SKIPPED", "FAILED")
     }
 }
 
 java {
     withSourcesJar()
+    withJavadocJar()
 }
 
 publishing {
     repositories {
-            maven {
-                name = "GitHubPackages"
-                url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
-                credentials {
-                    username = System.getenv("GITHUB_ACTOR")
-                    password = System.getenv("GITHUB_TOKEN")
-                }
+        maven {
+            name = "GitHubPackages"
+            url = uri("https://maven.pkg.github.com/ReVancedTeam/revanced-patcher")
+            credentials {
+                username = System.getenv("GITHUB_ACTOR")
+                password = System.getenv("GITHUB_TOKEN")
             }
+        }
     }
     publications {
         register<MavenPublication>("gpr") {

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.10.1
+version = 1.0.0-dev.8

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,23 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.logging.impl.NopLogger
-import app.revanced.patcher.logging.Logger
-import java.io.File
-
-/**
- * Options for the [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.
- * @param logger Custom logger implementation for the [Patcher].
- */
-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,
-    internal val logger: Logger = NopLogger
-)

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

@@ -1,16 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.util.dex.DexFile
-import java.io.File
-
-/**
- * The result of a patcher.
- * @param dexFiles The patched dex files.
- * @param doNotCompress List of relative paths to files to exclude from compressing.
- * @param resourceFile File containing resources that need to be extracted into the APK.
- */
-data class PatcherResult(
-    val dexFiles: List<DexFile>,
-    val doNotCompress: List<String>? = null,
-    val resourceFile: File?
-)

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/cache/Cache.kt

@@ -0,0 +1,16 @@
+package app.revanced.patcher.cache
+
+import org.objectweb.asm.tree.ClassNode
+
+class Cache(
+    val classes: List<ClassNode>,
+    val methods: MethodMap
+)
+
+class MethodMap : LinkedHashMap<String, PatchData>() {
+    override fun get(key: String): PatchData {
+        return super.get(key) ?: throw MethodNotFoundException("Method $key was not found in the method cache")
+    }
+}
+
+class MethodNotFoundException(s: String) : Exception(s)

src/main/kotlin/app/revanced/patcher/cache/PatchData.kt

@@ -0,0 +1,22 @@
+package app.revanced.patcher.cache
+
+import app.revanced.patcher.resolver.MethodResolver
+import app.revanced.patcher.signature.Signature
+import org.objectweb.asm.tree.ClassNode
+import org.objectweb.asm.tree.MethodNode
+
+data class PatchData(
+    val declaringClass: ClassNode,
+    val method: MethodNode,
+    val scanData: PatternScanData
+) {
+    @Suppress("Unused") // TODO(Sculas): remove this when we have coverage for this method.
+    fun findParentMethod(signature: Signature): PatchData? {
+        return MethodResolver.resolveMethod(declaringClass, signature)
+    }
+}
+
+data class PatternScanData(
+    val startIndex: Int,
+    val endIndex: Int
+)

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

@@ -1,20 +0,0 @@
-package app.revanced.patcher.data
-
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.data.implementation.BytecodeData
-import app.revanced.patcher.data.implementation.ResourceData
-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 val patches = mutableListOf<Class<out Patch<Data>>>()
-
-    internal val bytecodeData = BytecodeData(internalClasses)
-    internal val resourceData = ResourceData(File(resourceCacheDirectory))
-}

src/main/kotlin/app/revanced/patcher/data/base/Data.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.data.base
-
-import app.revanced.patcher.data.implementation.BytecodeData
-import app.revanced.patcher.data.implementation.ResourceData
-
-/**
- * Constraint interface for [BytecodeData] and [ResourceData]
- */
-interface Data

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

@@ -1,69 +0,0 @@
-package app.revanced.patcher.data.implementation
-
-import app.revanced.patcher.data.base.Data
-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(
-    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.
-     */
-    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.
-     */
-    fun findClass(predicate: (ClassDef) -> Boolean) =
-        // if we already proxied the class matching the predicate...
-        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
-        // else resolve the class to a proxy and return it, if the predicate is matching a class
-        classes.find(predicate)?.let { proxy(it) }
-}
-
-internal class MethodNotFoundException(s: String) : Exception(s)
-
-internal inline fun <reified T> Iterable<T>.find(predicate: (T) -> Boolean): T? {
-    for (element in this) {
-        if (predicate(element)) {
-            return element
-        }
-    }
-    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)
-}
-
-internal inline fun <T> Iterable<T>.findIndexed(predicate: (T) -> Boolean): Pair<T, Int>? {
-    for ((index, element) in this.withIndex()) {
-        if (predicate(element)) {
-            return element to index
-        }
-    }
-    return null
-}
-
-fun BytecodeData.proxy(classDef: ClassDef): app.revanced.patcher.util.proxy.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)
-    }
-    return proxy
-}

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

@@ -1,47 +0,0 @@
-package app.revanced.patcher.data.implementation
-
-import app.revanced.patcher.data.base.Data
-import org.w3c.dom.Document
-import java.io.Closeable
-import java.io.File
-import javax.xml.XMLConstants
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.transform.TransformerFactory
-import javax.xml.transform.dom.DOMSource
-import javax.xml.transform.stream.StreamResult
-
-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 replace(path: String, oldValue: String, newValue: String, oldValueIsRegex: Boolean = false) {
-        // TODO: buffer this somehow
-        val content = resolve(path).readText()
-
-        if (oldValueIsRegex) {
-            content.replace(Regex(oldValue), newValue)
-            return
-        }
-    }
-
-    fun getXmlEditor(path: String) = DomFileEditor(resolve(path))
-}
-
-class DomFileEditor internal constructor(private val domFile: File) : Closeable {
-    val file: Document
-
-    init {
-        val factory = DocumentBuilderFactory.newInstance()
-
-        val builder = factory.newDocumentBuilder()
-
-        // this will expectedly throw
-        file = builder.parse(domFile)
-        file.normalize()
-    }
-
-    override fun close() = TransformerFactory.newInstance().newTransformer()
-        .transform(DOMSource(file), StreamResult(domFile.outputStream()))
-}

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,111 +0,0 @@
-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 org.jf.dexlib2.AccessFlags
-import org.jf.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.iface.Method
-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
-
-fun MutableMethodImplementation.addInstructions(index: Int, instructions: List<BuilderInstruction>) {
-    for (i in instructions.lastIndex downTo 0) {
-        this.addInstruction(index, instructions[i])
-    }
-}
-
-/**
- * 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.
- * This may be a positive or negative number.
- * @return The **immutable** cloned method. Call [toMutable] or [cloneMutable] to get a **mutable** copy.
- */
-internal fun Method.clone(
-    registerCount: Int = 0,
-): ImmutableMethod {
-    val clonedImplementation = implementation?.let {
-        ImmutableMethodImplementation(
-            it.registerCount + registerCount,
-            it.instructions,
-            it.tryBlocks,
-            it.debugItems,
-        )
-    }
-    return ImmutableMethod(
-        returnType,
-        name,
-        parameters,
-        returnType,
-        accessFlags,
-        annotations,
-        hiddenApiRestrictions,
-        clonedImplementation
-    )
-}
-
-/**
- * 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.
- * This may be a positive or negative number.
- * @return The **mutable** cloned method. Call [clone] to get an **immutable** copy.
- */
-internal fun Method.cloneMutable(
-    registerCount: Int = 0,
-) = clone(registerCount).toMutable()
-
-// FIXME: also check the order of parameters as different order equals different method overload
-internal fun parametersEqual(
-    parameters1: Iterable<CharSequence>,
-    parameters2: Iterable<CharSequence>
-): Boolean {
-    return parameters1.count() == parameters2.count() && parameters1.all { parameter ->
-        parameters2.any {
-            it.startsWith(
-                parameter
-            )
-        }
-    }
-}
-
-internal val nullOutputStream: OutputStream =
-    object : OutputStream() {
-        override fun write(b: Int) {}
-    }

src/main/kotlin/app/revanced/patcher/logging/Logger.kt

@@ -1,8 +0,0 @@
-package app.revanced.patcher.logging
-
-interface Logger {
-    fun error(msg: String) {}
-    fun warn(msg: String) {}
-    fun info(msg: String) {}
-    fun trace(msg: String) {}
-}

src/main/kotlin/app/revanced/patcher/logging/impl/NopLogger.kt

@@ -1,5 +0,0 @@
-package app.revanced.patcher.logging.impl
-
-import app.revanced.patcher.logging.Logger
-
-object NopLogger : Logger

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

@@ -0,0 +1,7 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.cache.Cache
+
+abstract class Patch(val patchName: String) {
+    abstract fun execute(cache: Cache): PatchResult
+}

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

@@ -1,4 +1,4 @@
-package app.revanced.patcher.patch.implementation.misc
+package app.revanced.patcher.patch
 
 interface PatchResult {
     fun error(): PatchResultError? {
@@ -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/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

@@ -1,19 +0,0 @@
-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.misc.PatchResult
-
-
-/**
- * A ReVanced patch.
- * Can either be a [ResourcePatch] or a [BytecodePatch].
- */
-abstract class Patch<out T : Data> {
-
-    /**
-     * The main function of the [Patch] which the patcher will call.
-     */
-    abstract fun execute(data: @UnsafeVariance T): PatchResult
-}

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

@@ -1,13 +0,0 @@
-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
-
-/**
- * Bytecode patch for the Patcher.
- * @param signatures A list of [MethodSignature] this patch relies on.
- */
-abstract class BytecodePatch(
-    internal val signatures: Iterable<MethodSignature>
-) : Patch<BytecodeData>()

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

@@ -1,9 +0,0 @@
-package app.revanced.patcher.patch.implementation
-
-import app.revanced.patcher.data.implementation.ResourceData
-import app.revanced.patcher.patch.base.Patch
-
-/**
- * Resource patch for the Patcher.
- */
-abstract class ResourcePatch : Patch<ResourceData>()

src/main/kotlin/app/revanced/patcher/resolver/MethodResolver.kt

@@ -0,0 +1,156 @@
+package app.revanced.patcher.resolver
+
+import app.revanced.patcher.cache.MethodMap
+import app.revanced.patcher.cache.PatchData
+import app.revanced.patcher.cache.PatternScanData
+import app.revanced.patcher.signature.Signature
+import app.revanced.patcher.util.ExtraTypes
+import mu.KotlinLogging
+import org.objectweb.asm.Type
+import org.objectweb.asm.tree.*
+
+private val logger = KotlinLogging.logger("MethodResolver")
+
+internal class MethodResolver(private val classList: List<ClassNode>, private val signatures: Array<Signature>) {
+    fun resolve(): MethodMap {
+        val methodMap = MethodMap()
+
+        for ((classNode, methods) in classList) {
+            for (method in methods) {
+                for (signature in signatures) {
+                    if (methodMap.containsKey(signature.name)) { // method already found for this sig
+                        logger.trace { "Sig ${signature.name} already found, skipping." }
+                        continue
+                    }
+                    logger.trace { "Resolving sig ${signature.name}: ${classNode.name} / ${method.name}" }
+                    val (r, sr) = cmp(method, signature)
+                    if (!r || sr == null) {
+                        logger.trace { "Compare result for sig ${signature.name} has failed!" }
+                        continue
+                    }
+                    logger.trace { "Method for sig ${signature.name} found!" }
+                    methodMap[signature.name] = PatchData(
+                        classNode,
+                        method,
+                        PatternScanData(
+                            // sadly we cannot create contracts for a data class, so we must assert
+                            sr.startIndex!!,
+                            sr.endIndex!!
+                        )
+                    )
+                }
+            }
+        }
+
+        for (signature in signatures) {
+            if (methodMap.containsKey(signature.name)) continue
+            logger.error { "Could not find method for sig ${signature.name}!" }
+        }
+
+        return methodMap
+    }
+
+    // These functions do not require the constructor values, so they can be static.
+    companion object {
+        fun resolveMethod(classNode: ClassNode, signature: Signature): PatchData? {
+            for (method in classNode.methods) {
+                val (r, sr) = cmp(method, signature)
+                if (!r || sr == null) continue
+                return PatchData(
+                    classNode,
+                    method,
+                    PatternScanData(0, 0) // opcode list is always ignored.
+                )
+            }
+            return null
+        }
+
+        private fun cmp(method: MethodNode, signature: Signature): Pair<Boolean, ScanResult?> {
+            signature.returns?.let { _ ->
+                val methodReturns = Type.getReturnType(method.desc).convertObject()
+                if (signature.returns != methodReturns) {
+                    logger.trace {
+                        """
+                            Comparing sig ${signature.name}: invalid return type:
+                            expected ${signature.returns},
+                            got $methodReturns
+                        """.trimIndent()
+                    }
+                    return@cmp false to null
+                }
+            }
+
+            signature.accessors?.let { _ ->
+                if (signature.accessors != method.access) {
+                    logger.trace {
+                        """
+                            Comparing sig ${signature.name}: invalid accessors:
+                            expected ${signature.accessors},
+                            got ${method.access}
+                        """.trimIndent()
+                    }
+                    return@cmp false to null
+                }
+            }
+
+            signature.parameters?.let { _ ->
+                val parameters = Type.getArgumentTypes(method.desc).convertObjects()
+                if (!signature.parameters.contentEquals(parameters)) {
+                    logger.trace {
+                        """
+                            Comparing sig ${signature.name}: invalid parameter types:
+                            expected ${signature.parameters.joinToString()}},
+                            got ${parameters.joinToString()}
+                        """.trimIndent()
+                    }
+                    return@cmp false to null
+                }
+            }
+
+            signature.opcodes?.let { _ ->
+                val result = method.instructions.scanFor(signature.opcodes)
+                if (!result.found) {
+                    logger.trace { "Comparing sig ${signature.name}: invalid opcode pattern" }
+                    return@cmp false to null
+                }
+                return@cmp true to result
+            }
+
+            return true to ScanResult(true)
+        }
+    }
+}
+
+private operator fun ClassNode.component1() = this
+private operator fun ClassNode.component2() = this.methods
+
+private fun InsnList.scanFor(pattern: IntArray): ScanResult {
+    for (i in 0 until this.size()) {
+        var occurrence = 0
+        while (i + occurrence < this.size()) {
+            val n = this[i + occurrence]
+            if (!n.shouldSkip() && n.opcode != pattern[occurrence]) break
+            if (++occurrence >= pattern.size) {
+                val current = i + occurrence
+                return ScanResult(true, current - pattern.size, current)
+            }
+        }
+    }
+
+    return ScanResult(false)
+}
+
+private fun Type.convertObject(): Type {
+    return when (this.sort) {
+        Type.OBJECT -> ExtraTypes.Any
+        Type.ARRAY -> ExtraTypes.ArrayAny
+        else -> this
+    }
+}
+
+private fun Array<Type>.convertObjects(): Array<Type> {
+    return this.map { it.convertObject() }.toTypedArray()
+}
+
+private fun AbstractInsnNode.shouldSkip() =
+    type == AbstractInsnNode.LABEL || type == AbstractInsnNode.LINE

src/main/kotlin/app/revanced/patcher/resolver/ScanResult.kt

@@ -0,0 +1,7 @@
+package app.revanced.patcher.resolver
+
+internal data class ScanResult(
+    val found: Boolean,
+    val startIndex: Int? = 0,
+    val endIndex: Int? = 0
+)