chore(release): 2.6.0 [skip ci]

# [2.6.0](https://github.com/revanced/revanced-patcher/compare/v2.5.2...v2.6.0) (2022-07-31)

### Features

* add Patch#dependsOn extension ([523f67b](523f67b238))
* Soft Dependencies for Patches ([8c12f8d](8c12f8d488))

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -0,0 +1,60 @@
+name: 🐞 Bug report
+description: Report a very clearly broken issue.
+title: 'bug: <title>'
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # ReVanced bug report
+
+        Important to note that your issue may have already been reported before. Please check for existing issues [here](https://github.com/revanced/revanced-patcher/labels/bug).
+
+  - type: dropdown
+    attributes:
+      label: Type
+      options:
+        - Crash
+        - Cosmetic
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Bug description
+      description: How did you find the bug? Any additional details that might help?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: Add the steps to reproduce this bug including your environment.
+      placeholder: Step 1. Download some files. Step 2. ...
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Screenshots or videos
+      description: Add screenshots or videos that show the bug here.
+      placeholder: Drag and drop the screenshots/videos into this box.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Solution
+      description: If applicable, add a possible solution.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add additional context here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 📃 Documentation
+    url: https://github.com/revanced/revanced-documentation/
+    about: Don't know how or where to start? Check out our documentation!
+  - name: 🗨 Discussions
+    url: https://github.com/revanced/revanced-suggestions/discussions
+    about: Got something you think should change or be added? Search for or start a new discussion!

.github/ISSUE_TEMPLATE/feature-issue.yml

@@ -0,0 +1,46 @@
+name: ⭐ Feature request
+description: Create a detailed feature request.
+title: 'feat: <title>'
+labels: [feature-request]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # ReVanced feature request
+        
+        Do not submit requests for patches here. Please submit them [here](https://github.com/orgs/revanced/discussions/categories/patches) instead.
+        Important to note that your feature request may have already been made before. Please check for existing feature requests [here](https://github.com/revanced/revanced-patcher/labels/feature-request).
+
+  - type: dropdown
+    attributes:
+      label: Type
+      options:
+        - Functionality
+        - Cosmetic
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Issue
+      description: What is the current problem. Why does it require a feature request?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Feature
+      description: Describe your feature in detail. How does it solve the issue?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Motivation
+      description: Why should your feature should be considered?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add additional context here.
+    validations:
+      required: false

CHANGELOG.md

@@ -1,3 +1,68 @@
+# [2.6.0](https://github.com/revanced/revanced-patcher/compare/v2.5.2...v2.6.0) (2022-07-31)
+
+
+### Features
+
+* add Patch#dependsOn extension ([523f67b](https://github.com/revanced/revanced-patcher/commit/523f67b238646caaa9b7676a0e238ce82adbdda4))
+* Soft Dependencies for Patches ([8c12f8d](https://github.com/revanced/revanced-patcher/commit/8c12f8d488f939cc932e826aad0b20876ae165b7))
+
+## [2.5.2](https://github.com/revanced/revanced-patcher/compare/v2.5.1...v2.5.2) (2022-07-24)
+
+## [2.5.1](https://github.com/revanced/revanced-patcher/compare/v2.5.0...v2.5.1) (2022-07-17)
+
+
+### Bug Fixes
+
+* close stream when closing `DomFileEditor` ([77604d4](https://github.com/revanced/revanced-patcher/commit/77604d40785847b775155c0e75b663a3c7336aa3))
+
+# [2.5.0](https://github.com/revanced/revanced-patcher/compare/v2.4.0...v2.5.0) (2022-07-11)
+
+
+### Bug Fixes
+
+* missing additional items [skip ci] ([0ebab8b](https://github.com/revanced/revanced-patcher/commit/0ebab8bf598d993df6e340651205cba48f1ef725))
+
+
+### Features
+
+* feature request issue template ([1b39278](https://github.com/revanced/revanced-patcher/commit/1b39278b24ba2f964d93bd8ad2e28472ee036d90))
+* issue templates [skip ci] ([112bc99](https://github.com/revanced/revanced-patcher/commit/112bc998f4761a647cb9eab7454e35264fa96fd9))
+
+# [2.4.0](https://github.com/revanced/revanced-patcher/compare/v2.3.1...v2.4.0) (2022-07-09)
+
+
+### Features
+
+* Improve Smali Compiler ([6bfe571](https://github.com/revanced/revanced-patcher/commit/6bfe5716c38181bbe9476b5c6ad29526edb4e022))
+
+## [2.3.1](https://github.com/revanced/revanced-patcher/compare/v2.3.0...v2.3.1) (2022-07-07)
+
+
+### Bug Fixes
+
+* handle null properly ([#64](https://github.com/revanced/revanced-patcher/issues/64)) ([482af78](https://github.com/revanced/revanced-patcher/commit/482af78f2ba23b8003fc9961df5fde54d7295d5c))
+
+# [2.3.0](https://github.com/revanced/revanced-patcher/compare/v2.2.2...v2.3.0) (2022-07-05)
+
+
+### Features
+
+* nullability for `BytecodePatch` constructor ([#59](https://github.com/revanced/revanced-patcher/issues/59)) ([4ea030d](https://github.com/revanced/revanced-patcher/commit/4ea030d0a03f736bbecbd491317ba2167b18fe94))
+
+## [2.2.2](https://github.com/revanced/revanced-patcher/compare/v2.2.1...v2.2.2) (2022-07-04)
+
+
+### Bug Fixes
+
+* `MethodWalker` not accounting for all reference instructions ([48068cb](https://github.com/revanced/revanced-patcher/commit/48068cb3d79e283ff1cad9f3f78dc1d0fcd14f83))
+
+## [2.2.1](https://github.com/revanced/revanced-patcher/compare/v2.2.0...v2.2.1) (2022-07-03)
+
+
+### Bug Fixes
+
+* more useful error message ([4b2e323](https://github.com/revanced/revanced-patcher/commit/4b2e3230ec74fa3a57ae86067e5cb7cecbe45013))
+
 # [2.2.0](https://github.com/revanced/revanced-patcher/compare/v2.1.2...v2.2.0) (2022-07-02)
 
 

README.md

@@ -1 +1,2 @@
 # Patcher
+Patcher framework used in the ReVanced project.

build.gradle.kts

@@ -24,7 +24,7 @@ dependencies {
     implementation("xpp3:xpp3:1.1.4c")
     implementation("org.smali:smali:2.5.2")
     implementation("app.revanced:multidexlib2:2.5.2.r2")
-    implementation("org.apktool:apktool-lib:2.6.9-SNAPSHOT")
+    implementation("org.apktool:apktool-lib:2.7.0-SNAPSHOT")
 
     testImplementation(kotlin("test"))
 }

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 2.2.0
+version = 2.6.0

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

@@ -11,6 +11,7 @@ import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchResult
 import app.revanced.patcher.patch.PatchResultError
 import app.revanced.patcher.patch.PatchResultSuccess
+import app.revanced.patcher.patch.annotations.DependencyType
 import app.revanced.patcher.patch.impl.BytecodePatch
 import app.revanced.patcher.patch.impl.ResourcePatch
 import app.revanced.patcher.util.ListBackedSet
@@ -226,7 +227,7 @@ class Patcher(private val options: PatcherOptions) {
         return PatcherResult(
             dexFiles.map {
                 app.revanced.patcher.util.dex.DexFile(it.key, it.value.readAt(0))
-            }, metaInfo.doNotCompress.toList(), resourceFile
+            }, metaInfo.doNotCompress?.toList(), resourceFile
         )
     }
 
@@ -261,15 +262,19 @@ class Patcher(private val options: PatcherOptions) {
         }
 
         // recursively apply all dependency patches
-        patch.dependencies?.forEach {
+        patch.dependencies.forEach {
-            val patchDependency = it.java
+            val dependency = it.patch.java
-
+            if ( // soft dependencies must be included manually.
-            val result = applyPatch(patchDependency, appliedPatches)
+                it.type == DependencyType.SOFT && !data.patches.any { p ->
+                    p.patchName == dependency.patchName
+                }
+            ) return@forEach
 
+            val result = applyPatch(dependency, appliedPatches)
             if (result.isSuccess()) return@forEach
 
-            val errorMessage = result.error()!!.message
+            val errorMessage = result.error()!!.cause
-            return PatchResultError("'$patchName' depends on '${patchDependency.patchName}' but the following error was raised: $errorMessage")
+            return PatchResultError("'$patchName' depends on '${dependency.patchName}' but the following error was raised: $errorMessage")
         }
 
         val patchInstance = patch.getDeclaredConstructor().newInstance()
@@ -285,7 +290,7 @@ class Patcher(private val options: PatcherOptions) {
             data.resourceData
         } else {
             val bytecodeData = data.bytecodeData
-            (patchInstance as BytecodePatch).fingerprints.resolve(bytecodeData, bytecodeData.classes.internalClasses)
+            (patchInstance as BytecodePatch).fingerprints?.resolve(bytecodeData, bytecodeData.classes.internalClasses)
             bytecodeData
         }
 

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

@@ -26,17 +26,24 @@ class ResourceData(private val resourceCacheDirectory: File) : Data, Iterable<Fi
     }
 }
 
-class DomFileEditor internal constructor(inputStream: InputStream, private val outputStream: Lazy<OutputStream>) : Closeable {
+class DomFileEditor internal constructor(
+    private val inputStream: InputStream,
+    private val outputStream: Lazy<OutputStream>,
+) : Closeable {
+    val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
+        .also(Document::normalize)
 
     // lazily open an output stream
     // this is required because when constructing a DomFileEditor the output stream is created along with the input stream, which is not allowed
     // the workaround is to lazily create the output stream. This way it would be used after the input stream is closed, which happens in the constructor
     constructor(file: File) : this(file.inputStream(), lazy { file.outputStream() })
 
-    val file: Document =
+    override fun close() {
-        DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream).also(Document::normalize)
+        val result = StreamResult(outputStream.value)
+        TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
 
-    override fun close() =
+        inputStream.close()
-        TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), StreamResult(outputStream.value))
+        outputStream.value.close()
+    }
 
 }

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

@@ -7,6 +7,9 @@ import app.revanced.patcher.annotation.Version
 import app.revanced.patcher.data.Data
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.annotations.Dependencies
+import app.revanced.patcher.patch.annotations.DependencyType
+import app.revanced.patcher.patch.annotations.DependsOn
 import kotlin.reflect.KClass
 
 /**
@@ -35,14 +38,26 @@ private fun <T : Annotation> Class<*>.findAnnotationRecursively(
     return null
 }
 
+private typealias PatchClass = Class<out Patch<Data>>
+
 object PatchExtensions {
-    val Class<out Patch<Data>>.patchName: String
+    val PatchClass.patchName: String get() = recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
-        get() = recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
+    val PatchClass.version get() = recursiveAnnotation(Version::class)?.version
-    val Class<out Patch<Data>>.version get() = recursiveAnnotation(Version::class)?.version
+    val PatchClass.include get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Patch::class)!!.include
-    val Class<out Patch<Data>>.include get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Patch::class)!!.include
+    val PatchClass.description get() = recursiveAnnotation(Description::class)?.description
-    val Class<out Patch<Data>>.description get() = recursiveAnnotation(Description::class)?.description
+    val PatchClass.dependencies get() = buildList {
-    val Class<out Patch<Data>>.dependencies get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Dependencies::class)?.dependencies
+        recursiveAnnotation(DependsOn::class)?.let { add(PatchDependency(it.value, it.type)) }
-    val Class<out Patch<Data>>.compatiblePackages get() = recursiveAnnotation(Compatibility::class)?.compatiblePackages
+        recursiveAnnotation(Dependencies::class)?.dependencies?.forEach { add(PatchDependency(it, DependencyType.HARD)) }
+    }.toTypedArray()
+    val PatchClass.compatiblePackages get() = recursiveAnnotation(Compatibility::class)?.compatiblePackages
+
+    @JvmStatic
+    fun PatchClass.dependsOn(patch: PatchClass): Boolean {
+        if (this.patchName == patch.patchName) throw IllegalArgumentException("thisval and patch may not be the same")
+        return this.dependencies.any { it.patch.java.patchName == this@dependsOn.patchName }
+    }
+
+    class PatchDependency internal constructor(val patch: KClass<out Patch<Data>>, val type: DependencyType = DependencyType.HARD)
 }
 
 object MethodFingerprintExtensions {

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

@@ -2,12 +2,17 @@ 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.ExternalLabel
 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.BuilderOffsetInstruction
+import org.jf.dexlib2.builder.Label
 import org.jf.dexlib2.builder.MutableMethodImplementation
+import org.jf.dexlib2.builder.instruction.*
 import org.jf.dexlib2.iface.Method
+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
@@ -23,6 +28,12 @@ fun MutableMethodImplementation.addInstructions(index: Int, instructions: List<B
     }
 }
 
+fun MutableMethodImplementation.addInstructions(instructions: List<BuilderInstruction>) {
+    for (instruction in instructions) {
+        this.addInstruction(instruction)
+    }
+}
+
 fun MutableMethodImplementation.replaceInstructions(index: Int, instructions: List<BuilderInstruction>) {
     for (i in instructions.lastIndex downTo 0) {
         this.replaceInstruction(index + i, instructions[i])
@@ -40,11 +51,11 @@ fun MutableMethodImplementation.removeInstructions(index: Int, count: Int) {
  * @param otherMethod The method to compare against.
  * @return True if the methods match given the conditions.
  */
-fun Method.softCompareTo(
+fun Method.softCompareTo(otherMethod: MethodReference): Boolean {
-    otherMethod: MethodReference
+    if (MethodUtil.isConstructor(this) && !parametersEqual(
-): Boolean {
+            this.parameterTypes, otherMethod.parameterTypes
-    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
+        )
-        return false
+    ) return false
     return this.name == otherMethod.name
 }
 
@@ -54,9 +65,7 @@ fun Method.softCompareTo(
  * 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(
+internal fun Method.clone(registerCount: Int = 0): ImmutableMethod {
-    registerCount: Int = 0,
-): ImmutableMethod {
     val clonedImplementation = implementation?.let {
         ImmutableMethodImplementation(
             it.registerCount + registerCount,
@@ -66,14 +75,7 @@ internal fun Method.clone(
         )
     }
     return ImmutableMethod(
-        returnType,
+        returnType, name, parameters, returnType, accessFlags, annotations, hiddenApiRestrictions, clonedImplementation
-        name,
-        parameters,
-        returnType,
-        accessFlags,
-        annotations,
-        hiddenApiRestrictions,
-        clonedImplementation
     )
 }
 
@@ -104,16 +106,89 @@ fun MutableMethod.replaceInstruction(index: Int, instruction: String) =
  * Remove a smali instruction within the method.
  * @param index The index to delete the instruction at.
  */
-fun MutableMethod.removeInstruction(index: Int) =
+fun MutableMethod.removeInstruction(index: Int) = this.implementation!!.removeInstruction(index)
-    this.implementation!!.removeInstruction(index)
+
+/**
+ * Create a label for the instruction at given index in the method's implementation.
+ * @param index The index to create the label for the instruction at.
+ * @return The label.
+ */
+fun MutableMethod.label(index: Int) = this.implementation!!.newLabelForIndex(index)
+
+/**
+ * Get the instruction at given index in the method's implementation.
+ * @param index The index to get the instruction at.
+ * @return The instruction.
+ */
+fun MutableMethod.instruction(index: Int): BuilderInstruction = this.implementation!!.instructions[index]
 
 /**
  * Add smali instructions to the method.
  * @param index The index to insert the instructions at.
+ * @param smali The smali instructions to add.
+ * @param externalLabels A list of [ExternalLabel] representing a list of labels for instructions which are not in the method to compile.
+ */
+
+fun MutableMethod.addInstructions(index: Int, smali: String, externalLabels: List<ExternalLabel> = emptyList()) {
+    // Create reference dummy instructions for the instructions.
+    val nopedSmali = StringBuilder(smali).also { builder ->
+        externalLabels.forEach { (name, _) ->
+            builder.append("\n:$name\nnop")
+        }
+    }.toString()
+
+    // Compile the instructions with the dummy labels
+    val compiledInstructions = nopedSmali.toInstructions(this)
+
+    // Add the compiled list of instructions to the method.
+    val methodImplementation = this.implementation!!
+    methodImplementation.addInstructions(index, compiledInstructions)
+
+    val methodInstructions = methodImplementation.instructions
+    methodInstructions.subList(index, index + compiledInstructions.size)
+        .forEachIndexed { compiledInstructionIndex, compiledInstruction ->
+            // If the compiled instruction is not an offset instruction, skip it.
+            if (compiledInstruction !is BuilderOffsetInstruction) return@forEachIndexed
+
+            /**
+             * Creates a new label for the instruction and replaces it with the label of the [compiledInstruction] at [compiledInstructionIndex].
+             */
+            fun Instruction.makeNewLabel() {
+                // Create the final label.
+                val label = methodImplementation.newLabelForIndex(methodInstructions.indexOf(this))
+                // Create the final instruction with the new label.
+                val newInstruction = replaceOffset(
+                    compiledInstruction, label
+                )
+                // Replace the instruction pointing to the dummy label with the new instruction pointing to the real instruction.
+                methodImplementation.replaceInstruction(index + compiledInstructionIndex, newInstruction)
+            }
+
+            // If the compiled instruction targets its own instruction,
+            // which means it points to some of its own, simply an offset has to be applied.
+            val labelIndex = compiledInstruction.target.location.index
+            if (labelIndex < compiledInstructions.size - externalLabels.size) {
+                // Get the targets index (insertion index + the index of the dummy instruction).
+                methodInstructions[index + labelIndex].makeNewLabel()
+                return@forEachIndexed
+            }
+
+            // Since the compiled instruction points to a dummy instruction,
+            // we can find the real instruction which it was created for by calculation.
+
+            // Get the index of the instruction in the externalLabels list which the dummy instruction was created for.
+            // this line works because we created the dummy instructions in the same order as the externalLabels list.
+            val (_, instruction) = externalLabels[(compiledInstructions.size - 1) - labelIndex]
+            instruction.makeNewLabel()
+        }
+}
+
+/**
+ * Add smali instructions to the end of the method.
  * @param instructions The smali instructions to add.
  */
-fun MutableMethod.addInstructions(index: Int, instructions: String) =
+fun MutableMethod.addInstructions(instructions: String, labels: List<ExternalLabel> = emptyList()) =
-    this.implementation!!.addInstructions(index, instructions.toInstructions(this))
+    this.addInstructions(this.implementation!!.instructions.size, instructions, labels)
 
 /**
  * Replace smali instructions within the method.
@@ -128,8 +203,21 @@ fun MutableMethod.replaceInstructions(index: Int, instructions: String) =
  * @param index The index to remove the instructions at.
  * @param count The amount of instructions to remove.
  */
-fun MutableMethod.removeInstructions(index: Int, count: Int) =
+fun MutableMethod.removeInstructions(index: Int, count: Int) = this.implementation!!.removeInstructions(index, count)
-    this.implementation!!.removeInstructions(index, count)
+
+private fun replaceOffset(
+    i: BuilderOffsetInstruction, label: Label
+): BuilderOffsetInstruction {
+    return when (i) {
+        is BuilderInstruction10t -> BuilderInstruction10t(i.opcode, label)
+        is BuilderInstruction20t -> BuilderInstruction20t(i.opcode, label)
+        is BuilderInstruction21t -> BuilderInstruction21t(i.opcode, i.registerA, label)
+        is BuilderInstruction22t -> BuilderInstruction22t(i.opcode, i.registerA, i.registerB, label)
+        is BuilderInstruction30t -> BuilderInstruction30t(i.opcode, label)
+        is BuilderInstruction31t -> BuilderInstruction31t(i.opcode, i.registerA, label)
+        else -> throw IllegalStateException("A non-offset instruction was given, this should never happen!")
+    }
+}
 
 /**
  * Clones the method.
@@ -137,14 +225,11 @@ fun MutableMethod.removeInstructions(index: Int, count: Int) =
  * This may be a positive or negative number.
  * @return The **mutable** cloned method. Call [clone] to get an **immutable** copy.
  */
-internal fun Method.cloneMutable(
+internal fun Method.cloneMutable(registerCount: Int = 0) = clone(registerCount).toMutable()
-    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>,
+    parameters1: Iterable<CharSequence>, parameters2: Iterable<CharSequence>
-    parameters2: Iterable<CharSequence>
 ): Boolean {
     return parameters1.count() == parameters2.count() && parameters1.all { parameter ->
         parameters2.any {
@@ -155,10 +240,9 @@ internal fun parametersEqual(
     }
 }
 
-internal val nullOutputStream: OutputStream =
+internal val nullOutputStream = object : OutputStream() {
-    object : OutputStream() {
+    override fun write(b: Int) {}
-        override fun write(b: Int) {}
+}
-    }
 
 /**
  * Should be used to parse a list of parameters represented by their first letter,

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

@@ -19,6 +19,24 @@ annotation class Patch(val include: Boolean = true)
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @MustBeDocumented
+@Deprecated(
+    "Does not support new parameter 'type'",
+    ReplaceWith("DependsOn")
+)
 annotation class Dependencies(
     val dependencies: Array<KClass<out Patch<Data>>> = []
-)
+)
+
+/**
+ * Annotation for dependencies of [Patch]es .
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+@Repeatable
+annotation class DependsOn(
+    val value: KClass<out Patch<Data>>,
+    val type: DependencyType = DependencyType.HARD
+)
+
+enum class DependencyType { HARD, SOFT }

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

@@ -9,5 +9,5 @@ import app.revanced.patcher.patch.Patch
  * @param fingerprints A list of [MethodFingerprint] this patch relies on.
  */
 abstract class BytecodePatch(
-    internal val fingerprints: Iterable<MethodFingerprint>
+    internal val fingerprints: Iterable<MethodFingerprint>? = null
-) : Patch<BytecodeData>()
+) : Patch<BytecodeData>()

src/main/kotlin/app/revanced/patcher/util/method/MethodWalker.kt

@@ -4,11 +4,9 @@ import app.revanced.patcher.data.impl.BytecodeData
 import app.revanced.patcher.data.impl.MethodNotFoundException
 import app.revanced.patcher.extensions.softCompareTo
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import org.jf.dexlib2.Format
 import org.jf.dexlib2.iface.Method
-import org.jf.dexlib2.iface.instruction.formats.Instruction35c
+import org.jf.dexlib2.iface.instruction.ReferenceInstruction
 import org.jf.dexlib2.iface.reference.MethodReference
-import org.jf.dexlib2.util.Preconditions
 
 /**
  * Find a method from another method via instruction offsets.
@@ -37,9 +35,7 @@ class MethodWalker internal constructor(
         currentMethod.implementation?.instructions?.let { instructions ->
             val instruction = instructions.elementAt(offset)
 
-            Preconditions.checkFormat(instruction.opcode, Format.Format35c)
+            val newMethod = (instruction as ReferenceInstruction).reference as MethodReference
-
-            val newMethod = (instruction as Instruction35c).reference as MethodReference
             val proxy = bytecodeData.findClass(newMethod.definingClass)!!
 
             val methods = if (walkMutable) proxy.resolve().methods else proxy.immutableClass.methods

src/main/kotlin/app/revanced/patcher/util/smali/ExternalLabel.kt

@@ -0,0 +1,10 @@
+package app.revanced.patcher.util.smali
+
+import org.jf.dexlib2.iface.instruction.Instruction
+
+/**
+ * A class that represents a label for an instruction.
+ * @param name The label name.
+ * @param instruction The instruction that this label is for.
+ */
+data class ExternalLabel(internal val name: String, internal val instruction: Instruction)

src/main/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompiler.kt

@@ -1,12 +1,12 @@
 package app.revanced.patcher.util.smali
 
+import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import org.antlr.runtime.CommonTokenStream
 import org.antlr.runtime.TokenSource
 import org.antlr.runtime.tree.CommonTreeNodeStream
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Opcodes
 import org.jf.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.iface.Method
 import org.jf.dexlib2.writer.builder.DexBuilder
 import org.jf.smali.LexerErrorInterface
 import org.jf.smali.smaliFlexLexer
@@ -27,18 +27,19 @@ class InlineSmaliCompiler {
     companion object {
         /**
          * Compiles a string of Smali code to a list of instructions.
-         * p0, p1 etc. will only work correctly if the parameters and registers are passed.
+         * Special registers (such as p0, p1) will only work correctly
-         * Do not cross the boundaries of the control flow (if-nez insn, etc),
+         * if the parameters and registers of the method are passed.
-         * as that will result in exceptions since the labels cannot be calculated.
-         * Do not create dummy labels to fix the issue, since the code addresses will
-         * be messed up and results in broken Dalvik bytecode.
-         * FIXME: Fix the above issue. When this is fixed, add the proper conversions in [InstructionConverter].
          */
         fun compile(
             instructions: String, parameters: String, registers: Int, forStaticMethod: Boolean
         ): List<BuilderInstruction> {
-            val input =
+            val input = METHOD_TEMPLATE.format(
-                METHOD_TEMPLATE.format(if (forStaticMethod) "static" else "", parameters, registers, instructions)
+                if (forStaticMethod) {
+                    "static"
+                } else {
+                    ""
+                }, parameters, registers, instructions
+            )
             val reader = InputStreamReader(input.byteInputStream())
             val lexer: LexerErrorInterface = smaliFlexLexer(reader, 15)
             val tokens = CommonTokenStream(lexer as TokenSource)
@@ -54,25 +55,30 @@ class InlineSmaliCompiler {
             val dexGen = smaliTreeWalker(treeStream)
             dexGen.setDexBuilder(DexBuilder(Opcodes.getDefault()))
             val classDef = dexGen.smali_file()
-            return classDef.methods.first().implementation!!.instructions.map { it.toBuilderInstruction() }
+            return classDef.methods.first().implementation!!.instructions.map { it as BuilderInstruction }
         }
     }
 }
 
 /**
  * Compile lines of Smali code to a list of instructions.
- * @param templateMethod The method to compile the instructions against.
+ *
+ * Note: Adding compiled instructions to an existing method with
+ * offset instructions WITHOUT specifying a parent method will not work.
+ * @param method The method to compile the instructions against.
  * @returns A list of instructions.
  */
-fun String.toInstructions(templateMethod: Method? = null) = InlineSmaliCompiler.compile(this,
+fun String.toInstructions(method: MutableMethod? = null): List<BuilderInstruction> {
-    templateMethod?.parameters?.joinToString("") { it } ?: "",
+    return InlineSmaliCompiler.compile(this,
-    templateMethod?.implementation?.registerCount ?: 1,
+        method?.parameters?.joinToString("") { it } ?: "",
-    templateMethod?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true
+        method?.implementation?.registerCount ?: 1,
-)
+        method?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true
+    )
+}
 
 /**
  * Compile a line of Smali code to an instruction.
  * @param templateMethod The method to compile the instructions against.
  * @return The instruction.
  */
-fun String.toInstruction(templateMethod: Method? = null) = this.toInstructions(templateMethod).first()
+fun String.toInstruction(templateMethod: MutableMethod? = null) = this.toInstructions(templateMethod).first()

src/test/kotlin/app/revanced/patcher/usage/PatcherTest.kt

@@ -1,46 +0,0 @@
-package app.revanced.patcher.usage
-
-import org.junit.jupiter.api.Test
-
-internal class PatcherTest {
-    @Test
-    fun testPatcher() {
-        return // FIXME: create a proper resource to pass this test
-        /**
-        val patcher = Patcher(
-        File(PatcherTest::class.java.getResource("/example.apk")!!.toURI()),
-        "exampleCacheDirectory",
-        patchResources = true
-        )
-
-        patcher.addPatches(listOf(ExampleBytecodePatch(), ExampleResourcePatch()))
-
-        for (signature in patcher.resolveSignatures()) {
-        if (!signature.resolved) {
-        throw Exception("Signature ${signature.metadata.name} was not resolved!")
-        }
-        val patternScanMethod = signature.metadata.patternScanMethod
-        if (patternScanMethod is PatternScanMethod.Fuzzy) {
-        val warnings = patternScanMethod.warnings
-        if (warnings != null) {
-        println("Signature ${signature.metadata.name} had ${warnings.size} warnings!")
-        for (warning in warnings) {
-        println(warning.toString())
-        }
-        } else {
-        println("Signature ${signature.metadata.name} used the fuzzy resolver, but the warnings list is null!")
-        }
-        }
-        }
-        for ((metadata, result) in patcher.applyPatches()) {
-        if (result.isFailure) {
-        throw Exception("Patch ${metadata.shortName} failed", result.exceptionOrNull()!!)
-        } else {
-        println("Patch ${metadata.shortName} applied successfully!")
-        }
-        }
-        val out = patcher.save()
-        assertTrue(out.isNotEmpty(), "Expected the output of Patcher#save() to not be empty.")
-         */
-    }
-}

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

@@ -1,4 +1,4 @@
-package app.revanced.patcher.usage.bytecode.annotation
+package app.revanced.patcher.usage.bytecode
 
 import app.revanced.patcher.annotation.Compatibility
 import app.revanced.patcher.annotation.Package

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

@@ -1,4 +1,4 @@
-package app.revanced.patcher.usage.bytecode.patch
+package app.revanced.patcher.usage.bytecode
 
 import app.revanced.patcher.annotation.Description
 import app.revanced.patcher.annotation.Name
@@ -6,15 +6,16 @@ import app.revanced.patcher.annotation.Version
 import app.revanced.patcher.data.impl.BytecodeData
 import app.revanced.patcher.extensions.addInstructions
 import app.revanced.patcher.extensions.or
+import app.revanced.patcher.extensions.replaceInstruction
 import app.revanced.patcher.patch.PatchResult
 import app.revanced.patcher.patch.PatchResultSuccess
+import app.revanced.patcher.patch.annotations.DependencyType
+import app.revanced.patcher.patch.annotations.DependsOn
 import app.revanced.patcher.patch.annotations.Patch
 import app.revanced.patcher.patch.impl.BytecodePatch
-import app.revanced.patcher.usage.bytecode.fingerprints.ExampleFingerprint
 import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
 import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import app.revanced.patcher.util.smali.toInstruction
 import com.google.common.collect.ImmutableList
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Format
@@ -36,6 +37,7 @@ import org.jf.dexlib2.util.Preconditions
 @Description("Example demonstration of a bytecode patch.")
 @ExampleResourceCompatibility
 @Version("0.0.1")
+@DependsOn(ExampleBytecodePatch::class, DependencyType.SOFT)
 class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
     // This function will be executed by the patcher.
     // You can treat it as a constructor
@@ -107,22 +109,21 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
         )
 
         // store the fields initial value into the first virtual register
-        implementation.replaceInstruction(
+        method.replaceInstruction(0, "sget-object v0, LTestClass;->dummyField:Ljava/io/PrintStream;")
-            0,
-            "sget-object v0, LTestClass;->dummyField:Ljava/io/PrintStream;".toInstruction()
-        )
 
         // Now let's create a new call to our method and print the return value!
         // You can also use the smali compiler to create instructions.
         // For this sake of example I reuse the TestClass field dummyField inside the virtual register 0.
         //
         // Control flow instructions are not supported as of now.
-        val instructions = """
+        method.addInstructions(
-                        invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
+            startIndex + 2,
-                        move-result-object v1
+            """
-                        invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+                invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
-                    """
+                move-result-object v1
-        method.addInstructions(startIndex + 2, instructions)
+                invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+                """
+        )
 
         // Finally, tell the patcher that this patch was a success.
         // You can also return PatchResultError with a message.

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

@@ -1,4 +1,4 @@
-package app.revanced.patcher.usage.bytecode.fingerprints
+package app.revanced.patcher.usage.bytecode
 
 import app.revanced.patcher.annotation.Name
 import app.revanced.patcher.annotation.Version
@@ -6,7 +6,7 @@ import app.revanced.patcher.extensions.or
 import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
 import app.revanced.patcher.fingerprint.method.annotation.MatchingMethod
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.usage.bytecode.annotation.ExampleBytecodeCompatibility
+import app.revanced.patcher.usage.bytecode.ExampleBytecodeCompatibility
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Opcode
 

src/test/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompilerTest.kt

@@ -0,0 +1,104 @@
+package app.revanced.patcher.util.smali
+
+import app.revanced.patcher.extensions.addInstructions
+import app.revanced.patcher.extensions.instruction
+import app.revanced.patcher.extensions.label
+import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
+import org.jf.dexlib2.AccessFlags
+import org.jf.dexlib2.Opcode
+import org.jf.dexlib2.builder.BuilderInstruction
+import org.jf.dexlib2.builder.MutableMethodImplementation
+import org.jf.dexlib2.builder.instruction.BuilderInstruction21c
+import org.jf.dexlib2.builder.instruction.BuilderInstruction21t
+import org.jf.dexlib2.immutable.ImmutableMethod
+import org.jf.dexlib2.immutable.reference.ImmutableStringReference
+import java.util.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+internal class InlineSmaliCompilerTest {
+    @Test
+    fun `compiler should output valid instruction`() {
+        val want = BuilderInstruction21c(Opcode.CONST_STRING, 0, ImmutableStringReference("Test")) as BuilderInstruction
+        val have = "const-string v0, \"Test\"".toInstruction()
+        instructionEquals(want, have)
+    }
+
+    @Test
+    fun `compiler should support branching with own branches`() {
+        val method = createMethod()
+        val insnAmount = 8
+        val insnIndex = insnAmount - 2
+        val targetIndex = insnIndex - 1
+
+        method.addInstructions(arrayOfNulls<String>(insnAmount).also {
+            Arrays.fill(it, "const/4 v0, 0x0")
+        }.joinToString("\n"))
+        method.addInstructions(
+            targetIndex,
+            """
+                :test
+                const/4 v0, 0x1
+                if-eqz v0, :test
+            """
+        )
+
+        val insn = method.instruction(insnIndex) as BuilderInstruction21t
+        assertEquals(targetIndex, insn.target.location.index)
+    }
+
+    @Test
+    fun `compiler should support branching to outside branches`() {
+        val method = createMethod()
+        val insnIndex = 3
+        val labelIndex = 1
+
+        method.addInstructions(
+            """
+                const/4 v0, 0x1
+                const/4 v0, 0x0
+            """
+        )
+
+        assertEquals(labelIndex, method.label(labelIndex).location.index)
+
+        method.addInstructions(
+            """
+                const/4 v0, 0x1
+                if-eqz v0, :test
+                return-void
+            """, listOf(
+                ExternalLabel("test",method.instruction(1))
+            )
+        )
+
+        val insn = method.instruction(insnIndex) as BuilderInstruction21t
+        assertTrue(insn.target.isPlaced, "Label was not placed")
+        assertEquals(labelIndex, insn.target.location.index)
+    }
+
+    companion object {
+        private fun createMethod(
+            name: String = "dummy",
+            returnType: String = "V",
+            accessFlags: Int = AccessFlags.STATIC.value,
+            registerCount: Int = 1,
+        ) = ImmutableMethod(
+            "Ldummy;",
+            name,
+            emptyList(), // parameters
+            returnType,
+            accessFlags,
+            emptySet(),
+            emptySet(),
+            MutableMethodImplementation(registerCount)
+        ).toMutable()
+
+        private fun instructionEquals(want: BuilderInstruction, have: BuilderInstruction) {
+            assertEquals(want.opcode, have.opcode)
+            assertEquals(want.format, have.format)
+            assertEquals(want.codeUnits, have.codeUnits)
+        }
+    }
+}