chore(release): 11.0.2-dev.1 [skip ci]

## [11.0.2-dev.1](https://github.com/revanced/revanced-patcher/compare/v11.0.1...v11.0.2-dev.1) (2023-06-14)

### Bug Fixes

* catch exceptions from closing patches ([d5d6f85](d5d6f85084))
* only close succeeded patches ([b8151eb](b8151ebccb))

CHANGELOG.md

@@ -1,3 +1,11 @@
+## [11.0.2-dev.1](https://github.com/revanced/revanced-patcher/compare/v11.0.1...v11.0.2-dev.1) (2023-06-14)
+
+
+### Bug Fixes
+
+* catch exceptions from closing patches ([d5d6f85](https://github.com/revanced/revanced-patcher/commit/d5d6f85084c03ed9c776632823ca12394a716167))
+* only close succeeded patches ([b8151eb](https://github.com/revanced/revanced-patcher/commit/b8151ebccb5b27dd9e06fa63235cf9baeef1c0ee))
+
 ## [11.0.1](https://github.com/revanced/revanced-patcher/compare/v11.0.0...v11.0.1) (2023-06-12)
 
 

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 11.0.1
+version = 11.0.2-dev.1

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

@@ -23,6 +23,7 @@ import lanchon.multidexlib2.MultiDexIO
 import org.jf.dexlib2.Opcodes
 import org.jf.dexlib2.iface.DexFile
 import org.jf.dexlib2.writer.io.MemoryDataStore
+import java.io.Closeable
 import java.io.File
 import java.io.OutputStream
 import java.nio.file.Files
@@ -350,24 +351,42 @@ class Patcher(private val options: PatcherOptions) {
 
             val executedPatches = LinkedHashMap<String, ExecutedPatch>() // first is name
 
-            try {
-                context.patches.forEach { patch ->
-                    val patchResult = executePatch(patch, executedPatches)
 
-                    val result = if (patchResult.isSuccess()) {
-                        Result.success(patchResult.success()!!)
-                    } else {
-                        Result.failure(patchResult.error()!!)
-                    }
+            context.patches.forEach { patch ->
+                val patchResult = executePatch(patch, executedPatches)
 
-                    yield(patch.patchName to result)
-                    if (stopOnError && patchResult.isError()) return@sequence
-                }
-            } finally {
-                executedPatches.values.reversed().forEach { (patch, _) ->
-                    patch.close()
+                val result = if (patchResult.isSuccess()) {
+                    Result.success(patchResult.success()!!)
+                } else {
+                    Result.failure(patchResult.error()!!)
                 }
+
+                // TODO: This prints before the patch really finishes in case it is a Closeable
+                //  because the Closeable is closed after all patches are executed.
+                yield(patch.patchName to result)
+
+                if (stopOnError && patchResult.isError()) return@sequence
             }
+
+            executedPatches.values
+                .filter(ExecutedPatch::success)
+                .map(ExecutedPatch::patchInstance)
+                .filterIsInstance(Closeable::class.java)
+                .asReversed().forEach {
+                    try {
+                        it.close()
+                    } catch (exception: Exception) {
+                        val patchName = (it as Patch<Context>).javaClass.patchName
+
+                        logger.error("Failed to close '$patchName': ${exception.stackTraceToString()}")
+
+                        yield(patchName to Result.failure(exception))
+
+                        // This is not failsafe. If a patch throws an exception while closing,
+                        // the other patches that depend on it may fail.
+                        if (stopOnError) return@sequence
+                    }
+                }
         }
     }
 

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

@@ -12,7 +12,7 @@ import java.io.Closeable
  * If it implements [Closeable], it will be closed after all patches have been executed.
  * Closing will be done in reverse execution order.
  */
-sealed interface Patch<out T : Context> : Closeable {
+sealed interface Patch<out T : Context> {
     /**
      * The main function of the [Patch] which the patcher will call.
      *
@@ -20,13 +20,6 @@ sealed interface Patch<out T : Context> : Closeable {
      * @return The result of executing the patch.
      */
     fun execute(context: @UnsafeVariance T): PatchResult
-
-    /**
-     * The closing function for this patch.
-     *
-     * This can be treated like popping the patch from the current patch stack.
-     */
-    override fun close() {}
 }
 
 /**