chore(release): 5.0.0 [skip ci]

# [5.0.0](https://github.com/revanced/revanced-patcher/compare/v4.5.0...v5.0.0) (2022-09-21)

### Bug Fixes

* **tests:** access `patternScanResult` through `scanResult` ([76676fb](76676fb567))

* refactor!: move utility methods from `MethodFingerprintUtils` `MethodFingerprint` ([d802ef8](d802ef844e))
* feat(fingerprint)!: `StringsScanResult` for `MethodFingerprint` ([3813e28](3813e28ac2))

### BREAKING CHANGES

* Imports will have to be updated from `MethodFingerprintUtils` to `MethodFingerprint.Companion`.

Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
* `MethodFingerprint` now has a field for `MethodFingerprintScanResult`. `MethodFingerprintScanResult` now holds the previous field `MethodFingerprint.patternScanResult`.

Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -58,3 +58,15 @@ body:
       description: Add additional context here.
     validations:
       required: false
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your issue will be closed if you haven't done these steps.
+      options:
+        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: I filled out all of the requested information in this issue properly.
+          required: true

.github/ISSUE_TEMPLATE/feature-issue.yml

@@ -43,4 +43,16 @@ body:
       label: Additional context
       description: Add additional context here.
     validations:
-      required: false
+      required: false
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your issue will be closed if you haven't done these steps.
+      options:
+        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: I filled out all of the requested information in this issue properly.
+          required: true

CHANGELOG.md

@@ -1,3 +1,71 @@
+# [5.0.0](https://github.com/revanced/revanced-patcher/compare/v4.5.0...v5.0.0) (2022-09-21)
+
+
+### Bug Fixes
+
+* **tests:** access `patternScanResult` through `scanResult` ([76676fb](https://github.com/revanced/revanced-patcher/commit/76676fb5673a9e92517ee3a13943cdc98dd5102a))
+
+
+* refactor!: move utility methods from `MethodFingerprintUtils` `MethodFingerprint` ([d802ef8](https://github.com/revanced/revanced-patcher/commit/d802ef844edf65d4d26328d6ca72e3ddd5a52b15))
+* feat(fingerprint)!: `StringsScanResult` for `MethodFingerprint` ([3813e28](https://github.com/revanced/revanced-patcher/commit/3813e28ac2ad6710d8d935526ca679e7b1b5980e))
+
+
+### BREAKING CHANGES
+
+* Imports will have to be updated from `MethodFingerprintUtils` to `MethodFingerprint.Companion`.
+
+Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
+* `MethodFingerprint` now has a field for `MethodFingerprintScanResult`. `MethodFingerprintScanResult` now holds the previous field `MethodFingerprint.patternScanResult`.
+
+Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
+
+# [4.5.0](https://github.com/revanced/revanced-patcher/compare/v4.4.2...v4.5.0) (2022-09-20)
+
+
+### Features
+
+* section `acknowledgements` for issue templates ([a0cb449](https://github.com/revanced/revanced-patcher/commit/a0cb449c60310917141e2809abaa16b4174dc002))
+
+## [4.4.2](https://github.com/revanced/revanced-patcher/compare/v4.4.1...v4.4.2) (2022-09-18)
+
+
+### Bug Fixes
+
+* **fingerprint:** do not throw on `MethodFingerprint.result` getter ([2f7e62e](https://github.com/revanced/revanced-patcher/commit/2f7e62ef65422f2c75ef8b09b9cd27076e172b30))
+
+
+### Performance Improvements
+
+* **fingerprint:** do not resolve already resolved fingerprints ([4bfd7eb](https://github.com/revanced/revanced-patcher/commit/4bfd7ebff8b6623b0da4a46d6048bed08c5070d4))
+
+## [4.4.1](https://github.com/revanced/revanced-patcher/compare/v4.4.0...v4.4.1) (2022-09-14)
+
+
+### Bug Fixes
+
+* compare any methods parameters ([#101](https://github.com/revanced/revanced-patcher/issues/101)) ([085a3a4](https://github.com/revanced/revanced-patcher/commit/085a3a479d7bd411dcb0492b283daca538c824a1))
+
+# [4.4.0](https://github.com/revanced/revanced-patcher/compare/v4.3.0...v4.4.0) (2022-09-09)
+
+
+### Features
+
+* add PathOption back ([172655b](https://github.com/revanced/revanced-patcher/commit/172655bde06efdb0955431b44d269e6a64fe317a))
+
+# [4.3.0](https://github.com/revanced/revanced-patcher/compare/v4.2.3...v4.3.0) (2022-09-09)
+
+
+### Features
+
+* improved Patch Options ([e722e3f](https://github.com/revanced/revanced-patcher/commit/e722e3f4f9dc64acf53595802a0a83cf46ee96b8))
+
+## [4.2.3](https://github.com/revanced/revanced-patcher/compare/v4.2.2...v4.2.3) (2022-09-08)
+
+
+### Bug Fixes
+
+* wrong value for iterator in PatchOptions ([e31ac1f](https://github.com/revanced/revanced-patcher/commit/e31ac1f132df56ba7d2f8446d289ae03ef28f67d))
+
 ## [4.2.2](https://github.com/revanced/revanced-patcher/compare/v4.2.1...v4.2.2) (2022-09-08)
 
 

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 4.2.2
+version = 5.0.0

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

@@ -8,7 +8,7 @@ import app.revanced.patcher.extensions.PatchExtensions.deprecated
 import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.extensions.PatchExtensions.sincePatcherVersion
 import app.revanced.patcher.extensions.nullOutputStream
-import app.revanced.patcher.fingerprint.method.utils.MethodFingerprintUtils.resolve
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolve
 import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchResult
 import app.revanced.patcher.patch.PatchResultError

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

@@ -16,7 +16,6 @@ import org.jf.dexlib2.iface.instruction.Instruction
 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
@@ -47,16 +46,14 @@ fun MutableMethodImplementation.removeInstructions(index: Int, count: Int) {
 }
 
 /**
- * Compare a method to another, considering constructors and parameters.
+ * Compare a method to another, considering name 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(
+    return this.name == otherMethod.name && parametersEqual(
-            this.parameterTypes, otherMethod.parameterTypes
+        this.parameterTypes, otherMethod.parameterTypes
-        )
+    )
-    ) return false
-    return this.name == otherMethod.name
 }
 
 /**

src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt

@@ -1,15 +1,19 @@
 package app.revanced.patcher.fingerprint.method.impl
 
 import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.data.impl.MethodNotFoundException
+import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.name
+import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyScanThreshold
+import app.revanced.patcher.extensions.parametersEqual
 import app.revanced.patcher.extensions.softCompareTo
 import app.revanced.patcher.fingerprint.Fingerprint
-import app.revanced.patcher.fingerprint.method.utils.MethodFingerprintUtils
+import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
 import app.revanced.patcher.util.proxy.ClassProxy
 import org.jf.dexlib2.Opcode
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
+import org.jf.dexlib2.iface.instruction.Instruction
+import org.jf.dexlib2.iface.instruction.ReferenceInstruction
+import org.jf.dexlib2.iface.reference.StringReference
 
 /**
  * Represents the [MethodFingerprint] for a method.
@@ -31,31 +35,254 @@ abstract class MethodFingerprint(
 ) : Fingerprint {
     /**
      * The result of the [MethodFingerprint] the [Method].
-     * @throws MethodNotFoundException If the resolution of the [Method] has not happened.
      */
     var result: MethodFingerprintResult? = null
-        get() = field ?: throw Exception("${this.name} has not been resolved yet.")
+
+    companion object {
+        /**
+         * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
+         * @param context The classes on which to resolve the [MethodFingerprint].
+         * @param forData The [BytecodeData] to host proxies.
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun Iterable<MethodFingerprint>.resolve(forData: BytecodeData, context: Iterable<ClassDef>) {
+            for (fingerprint in this) // For each fingerprint
+                classes@ for (classDef in context) // search through all classes for the fingerprint
+                    if (fingerprint.resolve(forData, classDef))
+                        break@classes // if the resolution succeeded, continue with the next fingerprint
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] against a [ClassDef].
+         * @param context The class on which to resolve the [MethodFingerprint].
+         * @param forData The [BytecodeData] to host proxies.
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun MethodFingerprint.resolve(forData: BytecodeData, context: ClassDef): Boolean {
+            for (method in context.methods)
+                if (this.resolve(forData, method, context))
+                    return true
+            return false
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] against a [Method].
+         * @param context The context on which to resolve the [MethodFingerprint].
+         * @param classDef The class of the matching [Method].
+         * @param forData The [BytecodeData] to host proxies.
+         * @return True if the resolution was successful or if the fingerprint is already resolved, false otherwise.
+         */
+        fun MethodFingerprint.resolve(forData: BytecodeData, context: Method, classDef: ClassDef): Boolean {
+            val methodFingerprint = this
+
+            if (methodFingerprint.result != null) return true
+
+            if (methodFingerprint.returnType != null && !context.returnType.startsWith(methodFingerprint.returnType))
+                return false
+
+            if (methodFingerprint.access != null && methodFingerprint.access != context.accessFlags)
+                return false
+
+
+            if (methodFingerprint.parameters != null && !parametersEqual(
+                    methodFingerprint.parameters, // TODO: parseParameters()
+                    context.parameterTypes
+                )
+            ) return false
+
+            @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+            if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(context))
+                return false
+
+            val stringsScanResult: StringsScanResult? =
+                if (methodFingerprint.strings != null) {
+                    StringsScanResult(
+                        buildList {
+                            val implementation = context.implementation ?: return false
+
+                            val stringsList = methodFingerprint.strings.toMutableList()
+
+                            implementation.instructions.forEach { instruction ->
+                                if (instruction.opcode.ordinal != Opcode.CONST_STRING.ordinal) return@forEach
+
+                                val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+                                val index = stringsList.indexOfFirst { it == string }
+                                if (index == -1) return@forEach
+
+                                add(
+                                    StringMatch(
+                                        string,
+                                        index
+                                    )
+                                )
+                                stringsList.removeAt(index)
+                            }
+
+                            if (stringsList.isNotEmpty()) return false
+                        }
+                    )
+                } else null
+
+            val patternScanResult = if (methodFingerprint.opcodes != null) {
+                context.implementation?.instructions ?: return false
+
+                context.patternScan(methodFingerprint) ?: return false
+            } else null
+
+            methodFingerprint.result = MethodFingerprintResult(
+                context,
+                classDef,
+                MethodFingerprintResult.MethodFingerprintScanResult(
+                    patternScanResult,
+                    stringsScanResult
+                ),
+                forData
+            )
+
+            return true
+        }
+
+        private fun Method.patternScan(
+            fingerprint: MethodFingerprint
+        ): MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult? {
+            val instructions = this.implementation!!.instructions
+            val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyScanThreshold
+
+            val pattern = fingerprint.opcodes!!
+            val instructionLength = instructions.count()
+            val patternLength = pattern.count()
+
+            for (index in 0 until instructionLength) {
+                var patternIndex = 0
+                var threshold = fingerprintFuzzyPatternScanThreshold
+
+                while (index + patternIndex < instructionLength) {
+                    val originalOpcode = instructions.elementAt(index + patternIndex).opcode
+                    val patternOpcode = pattern.elementAt(patternIndex)
+
+                    if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
+                        // reaching maximum threshold (0) means,
+                        // the pattern does not match to the current instructions
+                        if (threshold-- == 0) break
+                    }
+
+                    if (patternIndex < patternLength - 1) {
+                        // if the entire pattern has not been scanned yet
+                        // continue the scan
+                        patternIndex++
+                        continue
+                    }
+                    // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
+                    val result =
+                        MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult(
+                            index,
+                            index + patternIndex
+                        )
+                    if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
+                    result.warnings = result.createWarnings(pattern, instructions)
+
+                    return result
+                }
+            }
+
+            return null
+        }
+
+        private fun MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.createWarnings(
+            pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
+        ) = buildList {
+            for ((patternIndex, instructionIndex) in (this@createWarnings.startIndex until this@createWarnings.endIndex).withIndex()) {
+                val originalOpcode = instructions.elementAt(instructionIndex).opcode
+                val patternOpcode = pattern.elementAt(patternIndex)
+
+                if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
+
+                this.add(
+                    MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.Warning(
+                        originalOpcode,
+                        patternOpcode,
+                        instructionIndex,
+                        patternIndex
+                    )
+                )
+            }
+        }
+    }
 }
 
+private typealias StringMatch = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult.StringMatch
+private typealias StringsScanResult = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult
+
 /**
- * Represents the result of a [MethodFingerprintUtils].
+ * Represents the result of a [MethodFingerprintResult].
  * @param method The matching method.
  * @param classDef The [ClassDef] that contains the matching [method].
- * @param patternScanResult Opcodes pattern scan result.
+ * @param scanResult The result of scanning for the [MethodFingerprint].
  * @param data The [BytecodeData] this [MethodFingerprintResult] is attached to, to create proxies.
  */
 data class MethodFingerprintResult(
     val method: Method,
     val classDef: ClassDef,
-    val patternScanResult: PatternScanResult?,
+    val scanResult: MethodFingerprintScanResult,
     internal val data: BytecodeData
 ) {
+
+    /**
+     * The result of scanning on the [MethodFingerprint].
+     * @param patternScanResult The result of the pattern scan.
+     * @param stringsScanResult The result of the string scan.
+     */
+    data class MethodFingerprintScanResult(
+        val patternScanResult: PatternScanResult?,
+        val stringsScanResult: StringsScanResult?
+    ) {
+        /**
+         * The result of scanning strings on the [MethodFingerprint].
+         * @param matches The list of strings that were matched.
+         */
+        data class StringsScanResult(val matches: List<StringMatch>){
+            /**
+             * Represents a match for a string at an index.
+             * @param string The string that was matched.
+             * @param index The index of the string.
+             */
+            data class StringMatch(val string: String, val index: Int)
+        }
+
+        /**
+         * The result of a pattern scan.
+         * @param startIndex The start index of the instructions where to which this pattern matches.
+         * @param endIndex The end index of the instructions where to which this pattern matches.
+         * @param warnings A list of warnings considering this [PatternScanResult].
+         */
+        data class PatternScanResult(
+            val startIndex: Int,
+            val endIndex: Int,
+            var warnings: List<Warning>? = null
+        ) {
+            /**
+             * Represents warnings of the pattern scan.
+             * @param correctOpcode The opcode the instruction list has.
+             * @param wrongOpcode The opcode the pattern list of the signature currently has.
+             * @param instructionIndex The index of the opcode relative to the instruction list.
+             * @param patternIndex The index of the opcode relative to the pattern list from the signature.
+             */
+            data class Warning(
+                val correctOpcode: Opcode,
+                val wrongOpcode: Opcode,
+                val instructionIndex: Int,
+                val patternIndex: Int,
+            )
+        }
+    }
+
     /**
      * Returns a mutable clone of [classDef]
      *
      * Please note, this method allocates a [ClassProxy].
      * Use [classDef] where possible.
      */
+    @Suppress("MemberVisibilityCanBePrivate")
     val mutableClass by lazy { data.proxy(classDef).resolve() }
 
     /**
@@ -69,30 +296,4 @@ data class MethodFingerprintResult(
             it.softCompareTo(this.method)
         }
     }
-}
-
-/**
- * The result of a pattern scan.
- * @param startIndex The start index of the instructions where to which this pattern matches.
- * @param endIndex The end index of the instructions where to which this pattern matches.
- * @param warnings A list of warnings considering this [PatternScanResult].
- */
-data class PatternScanResult(
-    val startIndex: Int,
-    val endIndex: Int,
-    var warnings: List<Warning>? = null
-) {
-    /**
-     * Represents warnings of the pattern scan.
-     * @param correctOpcode The opcode the instruction list has.
-     * @param wrongOpcode The opcode the pattern list of the signature currently has.
-     * @param instructionIndex The index of the opcode relative to the instruction list.
-     * @param patternIndex The index of the opcode relative to the pattern list from the signature.
-     */
-    data class Warning(
-        val correctOpcode: Opcode,
-        val wrongOpcode: Opcode,
-        val instructionIndex: Int,
-        val patternIndex: Int,
-    )
 }

src/main/kotlin/app/revanced/patcher/fingerprint/method/utils/MethodFingerprintUtils.kt

@@ -1,158 +0,0 @@
-package app.revanced.patcher.fingerprint.method.utils
-
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyScanThreshold
-import app.revanced.patcher.extensions.parametersEqual
-import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprintResult
-import app.revanced.patcher.fingerprint.method.impl.PatternScanResult
-import org.jf.dexlib2.Opcode
-import org.jf.dexlib2.iface.ClassDef
-import org.jf.dexlib2.iface.Method
-import org.jf.dexlib2.iface.instruction.Instruction
-import org.jf.dexlib2.iface.instruction.ReferenceInstruction
-import org.jf.dexlib2.iface.reference.StringReference
-
-/**
- * Utility class for [MethodFingerprint]
- */
-object MethodFingerprintUtils {
-    /**
-     * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
-     * @param context The classes on which to resolve the [MethodFingerprint].
-     * @param forData The [BytecodeData] to host proxies.
-     * @return True if the resolution was successful, false otherwise.
-     */
-    fun Iterable<MethodFingerprint>.resolve(forData: BytecodeData, context: Iterable<ClassDef>) {
-        for (fingerprint in this) // For each fingerprint
-            classes@ for (classDef in context) // search through all classes for the fingerprint
-                if (fingerprint.resolve(forData, classDef))
-                    break@classes // if the resolution succeeded, continue with the next fingerprint
-    }
-
-    /**
-     * Resolve a [MethodFingerprint] against a [ClassDef].
-     * @param context The class on which to resolve the [MethodFingerprint].
-     * @param forData The [BytecodeData] to host proxies.
-     * @return True if the resolution was successful, false otherwise.
-     */
-    fun MethodFingerprint.resolve(forData: BytecodeData, context: ClassDef): Boolean {
-        for (method in context.methods)
-            if (this.resolve(forData, method, context))
-                return true
-        return false
-    }
-
-    /**
-     * Resolve a [MethodFingerprint] against a [Method].
-     * @param context The context on which to resolve the [MethodFingerprint].
-     * @param classDef The class of the matching [Method].
-     * @param forData The [BytecodeData] to host proxies.
-     * @return True if the resolution was successful, false otherwise.
-     */
-    fun MethodFingerprint.resolve(forData: BytecodeData, context: Method, classDef: ClassDef): Boolean {
-        val methodFingerprint = this
-
-        if (methodFingerprint.returnType != null && !context.returnType.startsWith(methodFingerprint.returnType))
-            return false
-
-        if (methodFingerprint.access != null && methodFingerprint.access != context.accessFlags)
-            return false
-
-
-        if (methodFingerprint.parameters != null && !parametersEqual(
-                methodFingerprint.parameters, // TODO: parseParameters()
-                context.parameterTypes
-            )
-        ) return false
-
-        if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(context))
-            return false
-
-        if (methodFingerprint.strings != null) {
-            val implementation = context.implementation ?: return false
-
-            val stringsList = methodFingerprint.strings.toMutableList()
-
-            implementation.instructions.forEach { instruction ->
-                if (instruction.opcode.ordinal != Opcode.CONST_STRING.ordinal) return@forEach
-
-                val string = ((instruction as ReferenceInstruction).reference as StringReference).string
-                val index = stringsList.indexOfFirst { it == string }
-                if (index != -1) stringsList.removeAt(index)
-            }
-
-            if (stringsList.isNotEmpty()) return false
-        }
-
-        val patternScanResult = if (methodFingerprint.opcodes != null) {
-            context.implementation?.instructions ?: return false
-
-            context.patternScan(methodFingerprint) ?: return false
-        } else null
-
-        methodFingerprint.result = MethodFingerprintResult(context, classDef, patternScanResult, forData)
-
-        return true
-    }
-
-    private fun Method.patternScan(
-        fingerprint: MethodFingerprint
-    ): PatternScanResult? {
-        val instructions = this.implementation!!.instructions
-        val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyScanThreshold
-
-        val pattern = fingerprint.opcodes!!
-        val instructionLength = instructions.count()
-        val patternLength = pattern.count()
-
-        for (index in 0 until instructionLength) {
-            var patternIndex = 0
-            var threshold = fingerprintFuzzyPatternScanThreshold
-
-            while (index + patternIndex < instructionLength) {
-                val originalOpcode = instructions.elementAt(index + patternIndex).opcode
-                val patternOpcode = pattern.elementAt(patternIndex)
-
-                if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
-                    // reaching maximum threshold (0) means,
-                    // the pattern does not match to the current instructions
-                    if (threshold-- == 0) break
-                }
-
-                if (patternIndex < patternLength - 1) {
-                    // if the entire pattern has not been scanned yet
-                    // continue the scan
-                    patternIndex++
-                    continue
-                }
-                // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
-                val result = PatternScanResult(index, index + patternIndex)
-                if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
-                result.warnings = result.createWarnings(pattern, instructions)
-
-                return result
-            }
-        }
-
-        return null
-    }
-}
-
-private fun PatternScanResult.createWarnings(
-    pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
-) = buildList {
-    for ((patternIndex, instructionIndex) in (this@createWarnings.startIndex until this@createWarnings.endIndex).withIndex()) {
-        val originalOpcode = instructions.elementAt(instructionIndex).opcode
-        val patternOpcode = pattern.elementAt(patternIndex)
-
-        if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
-
-        this.add(PatternScanResult.Warning(originalOpcode, patternOpcode, instructionIndex, patternIndex))
-    }
-}
-
-private operator fun ClassDef.component1() = this
-private operator fun ClassDef.component2() = this.methods

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

@@ -27,7 +27,7 @@ abstract class OptionsContainer {
     @Suppress("MemberVisibilityCanBePrivate")
     val options = PatchOptions()
 
-    protected fun option(opt: PatchOption<*>): PatchOption<*> {
+    protected fun <T> option(opt: PatchOption<T>): PatchOption<T> {
         options.register(opt)
         return opt
     }

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

@@ -2,8 +2,8 @@
 
 package app.revanced.patcher.patch
 
-import java.io.File
 import java.nio.file.Path
+import kotlin.io.path.pathString
 import kotlin.reflect.KProperty
 
 class NoSuchOptionException(val option: String) : Exception("No such option: $option")
@@ -17,7 +17,7 @@ object RequirementNotMetException : Exception("null was passed into an option th
  * A registry for an array of [PatchOption]s.
  * @param options An array of [PatchOption]s.
  */
-class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>> {
+class PatchOptions(vararg options: PatchOption<*>) : Iterable<PatchOption<*>> {
     private val register = mutableMapOf<String, PatchOption<*>>()
 
     init {
@@ -35,8 +35,22 @@ class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>
      * Get a [PatchOption] by its key.
      * @param key The key of the [PatchOption].
      */
+    @JvmName("getUntyped")
     operator fun get(key: String) = register[key] ?: throw NoSuchOptionException(key)
 
+    /**
+     * Get a [PatchOption] by its key.
+     * @param key The key of the [PatchOption].
+     */
+    inline operator fun <reified T> get(key: String): PatchOption<T> {
+        val opt = get(key)
+        if (opt.value !is T) throw InvalidTypeException(
+            opt.value?.let { it::class.java.canonicalName } ?: "null",
+            T::class.java.canonicalName
+        )
+        return opt as PatchOption<T>
+    }
+
     /**
      * Set the value of a [PatchOption].
      * @param key The key of the [PatchOption].
@@ -44,7 +58,7 @@ class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>
      * Please note that using the wrong value type results in a runtime error.
      */
     inline operator fun <reified T> set(key: String, value: T) {
-        @Suppress("UNCHECKED_CAST") val opt = get(key) as PatchOption<T>
+        val opt = get<T>(key)
         if (opt.value !is T) throw InvalidTypeException(
             T::class.java.canonicalName,
             opt.value?.let { it::class.java.canonicalName } ?: "null"
@@ -60,7 +74,7 @@ class PatchOptions(vararg val options: PatchOption<*>) : Iterable<PatchOption<*>
         get(key).value = null
     }
 
-    override fun iterator() = options.iterator()
+    override fun iterator() = register.values.iterator()
 }
 
 /**
@@ -101,7 +115,8 @@ sealed class PatchOption<T>(
      * Gets the value of the option.
      * Please note that using the wrong value type results in a runtime error.
      */
-    inline operator fun <reified V> getValue(thisRef: Any?, property: KProperty<*>): V? {
+    @JvmName("getValueTyped")
+    inline operator fun <reified V> getValue(thisRef: Nothing?, property: KProperty<*>): V? {
         if (value !is V?) throw InvalidTypeException(
             V::class.java.canonicalName,
             value?.let { it::class.java.canonicalName } ?: "null"
@@ -109,11 +124,14 @@ sealed class PatchOption<T>(
         return value as? V?
     }
 
+    operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
+
     /**
      * Gets the value of the option.
      * Please note that using the wrong value type results in a runtime error.
      */
-    inline operator fun <reified V> setValue(thisRef: Any?, property: KProperty<*>, new: V) {
+    @JvmName("setValueTyped")
+    inline operator fun <reified V> setValue(thisRef: Nothing?, property: KProperty<*>, new: V) {
         if (value !is V) throw InvalidTypeException(
             V::class.java.canonicalName,
             value?.let { it::class.java.canonicalName } ?: "null"
@@ -121,6 +139,10 @@ sealed class PatchOption<T>(
         value = new as T
     }
 
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, new: T?) {
+        value = new
+    }
+
     /**
      * A [PatchOption] representing a [String].
      * @see PatchOption
@@ -209,34 +231,18 @@ sealed class PatchOption<T>(
     )
 
     /**
-     * A [PatchOption] representing a [Path].
+     * A [PatchOption] representing a [Path], backed by a [String].
+     * The validator passes a [String], if you need a [Path] you will have to convert it yourself.
      * @see PatchOption
      */
-    open class PathOption(
+    class PathOption(
         key: String,
         default: Path?,
         title: String,
         description: String,
         required: Boolean = false,
-        validator: (Path?) -> Boolean = { true }
+        validator: (String?) -> Boolean = { true }
-    ) : PatchOption<Path>(
+    ) : PatchOption<String>(
-        key, default, title, description, required, validator
+        key, default?.pathString, title, description, required, validator
-    )
-
-    /**
-     * A [PathOption] of type [File].
-     * @see PathOption
-     */
-    class FileOption(
-        key: String,
-        default: File?,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (File?) -> Boolean = { true }
-    ) : PathOption(
-        key, default?.toPath(), title, description, required, {
-            validator(it?.toFile())
-        }
     )
 }

src/test/kotlin/app/revanced/patcher/patch/PatchOptionsTest.kt

@@ -3,7 +3,8 @@ package app.revanced.patcher.patch
 import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
-import java.io.File
+import kotlin.io.path.Path
+import kotlin.io.path.pathString
 import kotlin.test.assertNotEquals
 
 internal class PatchOptionsTest {
@@ -36,11 +37,13 @@ internal class PatchOptionsTest {
                 }
 
                 is PatchOption.PathOption -> {
-                    option.value = File("test.txt").toPath()
+                    option.value = Path("test.txt").pathString
                 }
             }
         }
-        val option = options["key1"]
+        val option = options.get<String>("key1")
+        // or: val option: String? by options["key1"]
+        // then you won't need `.value` every time
         println(option.value)
         options["key1"] = "Hello, world!"
         println(option.value)
@@ -60,6 +63,9 @@ internal class PatchOptionsTest {
         // > options["key2"] = null
         // is not possible because Kotlin
         // cannot reify the type "Nothing?".
+        // So we have to do this instead:
+        options["key2"] = null as Any?
+        // This is a cleaner replacement for the above:
         options.nullify("key2")
     }
 
@@ -71,12 +77,19 @@ internal class PatchOptionsTest {
     }
 
     @Test
-    fun `should fail because of invalid value type`() {
+    fun `should fail because of invalid value type when setting an option`() {
         assertThrows<InvalidTypeException> {
             options["key1"] = 123
         }
     }
 
+    @Test
+    fun `should fail because of invalid value type when getting an option`() {
+        assertThrows<InvalidTypeException> {
+            options.get<Int>("key1")
+        }
+    }
+
     @Test
     fun `should fail because of an illegal value`() {
         assertThrows<IllegalValueException> {
@@ -94,7 +107,7 @@ internal class PatchOptionsTest {
     @Test
     fun `should fail because getting a non-initialized option is illegal`() {
         assertThrows<RequirementNotMetException> {
-            println(options["key6"].value)
+            println(options["key5"].value)
         }
     }
 }

src/test/kotlin/app/revanced/patcher/usage/bytecode/ExampleBytecodePatch.kt

@@ -32,8 +32,7 @@ import org.jf.dexlib2.immutable.reference.ImmutableFieldReference
 import org.jf.dexlib2.immutable.reference.ImmutableStringReference
 import org.jf.dexlib2.immutable.value.ImmutableFieldEncodedValue
 import org.jf.dexlib2.util.Preconditions
-import java.io.File
+import kotlin.io.path.Path
-import java.nio.file.Path
 
 @Patch
 @Name("example-bytecode-patch")
@@ -59,7 +58,7 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
         // Let's modify it, so it prints "Hello, ReVanced! Editing bytecode."
         // Get the start index of our opcode pattern.
         // This will be the index of the instruction with the opcode CONST_STRING.
-        val startIndex = result.patternScanResult!!.startIndex
+        val startIndex = result.scanResult.patternScanResult!!.startIndex
 
         implementation.replaceStringAt(startIndex, "Hello, ReVanced! Editing bytecode.")
 
@@ -171,34 +170,34 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
     }
 
     companion object : OptionsContainer() {
-        private var key1: String? by option(
+        private var key1 by option(
             PatchOption.StringOption(
                 "key1", "default", "title", "description", true
             )
         )
-        private var key2: Boolean? by option(
+        private var key2 by option(
             PatchOption.BooleanOption(
                 "key2", true, "title", "description" // required defaults to false
             )
         )
-        private var key3: String? by option(
+        private var key3 by option(
             PatchOption.StringListOption(
                 "key3", "TEST", listOf("TEST", "TEST1", "TEST2"), "title", "description"
             )
         )
-        private var key4: Int? by option(
+        private var key4 by option(
             PatchOption.IntListOption(
                 "key4", 1, listOf(1, 2, 3), "title", "description"
             )
         )
-        private var key5: Path? by option(
+        private var key5 by option(
-            PatchOption.PathOption(
+            PatchOption.StringOption(
-                "key5", File("test.txt").toPath(), "title", "description"
+                "key5", null, "title", "description", true
             )
         )
-        private var key6: String? by option(
+        private var key6 by option(
-            PatchOption.StringOption(
+            PatchOption.PathOption(
-                "key6", null, "title", "description", true
+                "key6", Path("test.txt"), "title", "description", true
             )
         )
     }