chore(release): 6.4.1 [skip ci]

## [6.4.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1) (2023-01-15)

### Bug Fixes

* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](dd7dd38357))

.github/workflows/pull_request.yml

@@ -7,10 +7,11 @@ on:
   workflow_dispatch:
 
 env:
-  MESSAGE: merge branch \`${{ github.head_ref || github.ref_name }}\` to \`main\`
+  MESSAGE: merge branch `${{ github.head_ref || github.ref_name }}` to `main`
 
 jobs:
   pull-request:
+    name: Open pull request
     runs-on: ubuntu-latest
     steps:
       - name: Checkout

.github/workflows/release.yml

@@ -1,4 +1,5 @@
 name: Release
+
 on:
   workflow_dispatch:
   push:
@@ -9,6 +10,7 @@ on:
     branches:
       - main
       - dev
+
 jobs:
   release:
     name: Release
@@ -17,6 +19,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
         with:
+          # Make sure the release step uses its own credentials:
+          # https://github.com/cycjimmy/semantic-release-action#private-packages
+          persist-credentials: false
           fetch-depth: 0
       - name: Setup JDK
         uses: actions/setup-java@v3
@@ -30,8 +35,8 @@ jobs:
           node-version: "latest"
           cache: 'npm'
       - name: Setup semantic-release
-        run: npm install semantic-release @saithodev/semantic-release-backmerge @semantic-release/git @semantic-release/changelog gradle-semantic-release-plugin -D
+        run: npm install semantic-release@19.0.5 @saithodev/semantic-release-backmerge @semantic-release/git @semantic-release/changelog gradle-semantic-release-plugin@1.7.4 -D
       - name: Release
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
         run: npx semantic-release

.releaserc

@@ -27,6 +27,11 @@
         clearWorkspace: true
       }
     ],
-    "@semantic-release/github"
+    [
+        "@semantic-release/github",
+        {
+            successComment: false
+        }
+    ]
   ]
 }

CHANGELOG.md

@@ -1,3 +1,43 @@
+## [6.4.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1) (2023-01-15)
+
+
+### Bug Fixes
+
+* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](https://github.com/revanced/revanced-patcher/commit/dd7dd383577dcfc95e97f77b446a89b41b589dc0))
+
+## [6.4.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1) (2023-01-15)
+
+
+### Bug Fixes
+
+* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](https://github.com/revanced/revanced-patcher/commit/dd7dd383577dcfc95e97f77b446a89b41b589dc0))
+
+## [6.4.1-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1-dev.1) (2023-01-15)
+
+
+### Bug Fixes
+
+* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](https://github.com/revanced/revanced-patcher/commit/dd7dd383577dcfc95e97f77b446a89b41b589dc0))
+
+# [6.4.0](https://github.com/revanced/revanced-patcher/compare/v6.3.2...v6.4.0) (2023-01-02)
+
+
+### Features
+
+* add missing setter to `MutableMethod` ([8f3ecc3](https://github.com/revanced/revanced-patcher/commit/8f3ecc318c39f0270aff53efdee7a1c8d82af421))
+* do not fix methods or methods in class merger ([4102f43](https://github.com/revanced/revanced-patcher/commit/4102f43b8a9473fd0ee96c5d4fb8f6e9b4e30e70))
+* fix method and field access when merging classes ([5c09ef7](https://github.com/revanced/revanced-patcher/commit/5c09ef7837f9b731e137b66c19da77f63c007595))
+* make `aaptPath` nullable ([#146](https://github.com/revanced/revanced-patcher/issues/146)) ([9f0a09a](https://github.com/revanced/revanced-patcher/commit/9f0a09a7569fd5dd78afa27cb66a73d1662edc69))
+
+# [6.4.0-dev.2](https://github.com/revanced/revanced-patcher/compare/v6.4.0-dev.1...v6.4.0-dev.2) (2023-01-02)
+
+
+### Features
+
+* add missing setter to `MutableMethod` ([8f3ecc3](https://github.com/revanced/revanced-patcher/commit/8f3ecc318c39f0270aff53efdee7a1c8d82af421))
+* do not fix methods or methods in class merger ([4102f43](https://github.com/revanced/revanced-patcher/commit/4102f43b8a9473fd0ee96c5d4fb8f6e9b4e30e70))
+* fix method and field access when merging classes ([5c09ef7](https://github.com/revanced/revanced-patcher/commit/5c09ef7837f9b731e137b66c19da77f63c007595))
+
 # [6.4.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.3.2...v6.4.0-dev.1) (2022-12-20)
 
 

build.gradle.kts

@@ -23,7 +23,7 @@ repositories {
 dependencies {
     implementation("xpp3:xpp3:1.1.4c")
     implementation("org.smali:smali:2.5.2")
-    implementation("app.revanced:multidexlib2:2.5.2.r2")
+    implementation("app.revanced:multidexlib2:2.5.3-8649b642")
     implementation("org.apktool:apktool-lib:2.9.0-SNAPSHOT")
 
     implementation(kotlin("reflect"))

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 6.4.0-dev.1
+version = 6.4.1

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

@@ -7,12 +7,8 @@ import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.extensions.nullOutputStream
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolve
 import app.revanced.patcher.patch.*
-import app.revanced.patcher.util.TypeUtil.traverseClassHierarchy
+import app.revanced.patcher.util.ClassMerger.merge
 import app.revanced.patcher.util.VersionReader
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import brut.androlib.Androlib
 import brut.androlib.meta.UsesFramework
 import brut.androlib.options.BuildOptions
@@ -26,11 +22,8 @@ import brut.directory.ExtFile
 import lanchon.multidexlib2.BasicDexFileNamer
 import lanchon.multidexlib2.DexIO
 import lanchon.multidexlib2.MultiDexIO
-import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Opcodes
-import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.DexFile
-import org.jf.dexlib2.util.MethodUtil
 import org.jf.dexlib2.writer.io.MemoryDataStore
 import java.io.File
 import java.nio.file.Files
@@ -89,100 +82,16 @@ class Patcher(private val options: PatcherOptions) {
                     if (result == null) {
                         logger.trace("Merging type $type")
                         classes.add(classDef)
-                    } else {
+                        continue
-                        val (existingClass, existingClassIndex) = result
+                    }
 
-                        logger.trace("Type $type exists. Adding missing methods and fields.")
+                    val (existingClass, existingClassIndex) = result
 
-                        /**
+                    logger.trace("Type $type exists. Adding missing methods and fields.")
-                         * Add missing fields and methods from [from].
-                         *
-                         * @param from The class to add methods and fields from.
-                         */
-                        fun ClassDef.addMissingFrom(from: ClassDef) {
-                            var changed = false
-                            fun <T> ClassDef.transformClass(transform: (MutableClass) -> T): T {
-                                fun toMutableClass() =
-                                    if (this@transformClass is MutableClass) this else this.toMutable()
-                                return transform(toMutableClass())
-                            }
 
-                            /**
+                    existingClass.merge(classDef, context, logger).let { mergedClass ->
-                             * Check if the [AccessFlags.PUBLIC] flag is set.
+                        if (mergedClass !== existingClass) // referential equality check
-                             *
+                            classes[existingClassIndex] = mergedClass
-                             * @return True, if the flag is set.
-                             */
-                            fun Int.isPublic() = AccessFlags.PUBLIC.isSet(this)
-
-                            /**
-                             * Make a class and its super class public recursively.
-                             */
-                            fun MutableClass.publicize() {
-                                context.bytecodeContext.traverseClassHierarchy(this) {
-                                    if (accessFlags.isPublic()) return@traverseClassHierarchy
-
-                                    accessFlags = accessFlags.or(AccessFlags.PUBLIC.value)
-                                }
-                            }
-
-                            /**
-                             * Add missing methods to the class, considering to publicise the [ClassDef] if necessary.
-                             */
-                            fun ClassDef.addMissingMethods(): ClassDef {
-                                fun getMissingMethods() = from.methods.filterNot {
-                                    this@addMissingMethods.methods.any { original ->
-                                        MethodUtil.methodSignaturesMatch(original, it)
-                                    }
-                                }
-
-                                return getMissingMethods()
-                                    .apply {
-                                        if (isEmpty()) return@addMissingMethods this@addMissingMethods else changed =
-                                            true
-                                    }
-                                    .map { it.toMutable() }
-                                    .let { missingMethods ->
-                                        this@addMissingMethods.transformClass { classDef ->
-                                            classDef.apply {
-                                                // make sure the class is public, if the class contains public methods
-                                                if (missingMethods.any { it.accessFlags.isPublic() })
-                                                    classDef.publicize()
-
-                                                methods.addAll(missingMethods)
-                                            }
-                                        }
-                                    }
-                            }
-
-                            /**
-                             * Add missing fields to the class, considering to publicise the [ClassDef] if necessary.
-                             */
-                            fun ClassDef.addMissingFields(): ClassDef {
-                                fun getMissingFields() = from.fields.filterNot {
-                                    this@addMissingFields.fields.any { original -> original.name == it.name }
-                                }
-
-                                return getMissingFields()
-                                    .apply {
-                                        if (isEmpty()) return@addMissingFields this@addMissingFields else changed = true
-                                    }
-                                    .map { it.toMutable() }
-                                    .let { missingFields ->
-                                        this@addMissingFields.transformClass { classDef ->
-                                            // make sure the class is public, if the class contains public fields
-                                            if (missingFields.any { it.accessFlags.isPublic() })
-                                                classDef.publicize()
-
-                                            classDef.apply { fields.addAll(missingFields) }
-                                        }
-                                    }
-                            }
-
-                            classes[existingClassIndex] = addMissingMethods().addMissingFields()
-                                .apply { if (!changed) return }
-                        }
-
-                        existingClass.addMissingFrom(classDef)
                     }
                 }
             }

src/main/kotlin/app/revanced/patcher/util/ClassMerger.kt

@@ -0,0 +1,214 @@
+package app.revanced.patcher.util
+
+import app.revanced.patcher.PatcherContext
+import app.revanced.patcher.extensions.or
+import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.util.ClassMerger.Utils.asMutableClass
+import app.revanced.patcher.util.ClassMerger.Utils.filterAny
+import app.revanced.patcher.util.ClassMerger.Utils.filterNotAny
+import app.revanced.patcher.util.ClassMerger.Utils.isPublic
+import app.revanced.patcher.util.ClassMerger.Utils.toPublic
+import app.revanced.patcher.util.TypeUtil.traverseClassHierarchy
+import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
+import app.revanced.patcher.util.proxy.mutableTypes.MutableClass.Companion.toMutable
+import app.revanced.patcher.util.proxy.mutableTypes.MutableField
+import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
+import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
+import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
+import org.jf.dexlib2.AccessFlags
+import org.jf.dexlib2.iface.ClassDef
+import org.jf.dexlib2.util.MethodUtil
+import kotlin.reflect.KFunction2
+
+/**
+ * Experimental class to merge a [ClassDef] with another.
+ * Note: This will not consider method implementations or if the class is missing a superclass or interfaces.
+ */
+internal object ClassMerger {
+    /**
+     * Merge a class with [otherClass].
+     *
+     * @param otherClass The class to merge with
+     * @param context The context to traverse the class hierarchy in.
+     * @param logger A logger.
+     */
+    fun ClassDef.merge(otherClass: ClassDef, context: PatcherContext, logger: Logger? = null) = this
+        //.fixFieldAccess(otherClass, logger)
+        //.fixMethodAccess(otherClass, logger)
+        .addMissingFields(otherClass, logger)
+        .addMissingMethods(otherClass, logger)
+        .publicize(otherClass, context, logger)
+
+    /**
+     * Add methods which are missing but existing in [fromClass].
+     *
+     * @param fromClass The class to add missing methods from.
+     * @param logger A logger.
+     */
+    private fun ClassDef.addMissingMethods(fromClass: ClassDef, logger: Logger? = null): ClassDef {
+        val missingMethods = fromClass.methods.let { fromMethods ->
+            methods.filterNot { method ->
+                fromMethods.any { fromMethod ->
+                    MethodUtil.methodSignaturesMatch(fromMethod, method)
+                }
+            }
+        }
+
+        if (missingMethods.isEmpty()) return this
+
+        logger?.trace("Found ${missingMethods.size} missing methods")
+
+        return asMutableClass().apply {
+            methods.addAll(missingMethods.map { it.toMutable() })
+        }
+    }
+
+    /**
+     * Add fields which are missing but existing in [fromClass].
+     *
+     * @param fromClass The class to add missing fields from.
+     * @param logger A logger.
+     */
+    private fun ClassDef.addMissingFields(fromClass: ClassDef, logger: Logger? = null): ClassDef {
+        val missingFields = fields.filterNotAny(fromClass.fields) { field, fromField ->
+            fromField.name == field.name
+        }
+
+        if (missingFields.isEmpty()) return this
+
+        logger?.trace("Found ${missingFields.size} missing fields")
+
+        return asMutableClass().apply {
+            fields.addAll(missingFields.map { it.toMutable() })
+        }
+    }
+
+    /**
+     * Make a class and its super class public recursively.
+     * @param reference The class to check the [AccessFlags] of.
+     * @param context The context to traverse the class hierarchy in.
+     * @param logger A logger.
+     */
+    private fun ClassDef.publicize(reference: ClassDef, context: PatcherContext, logger: Logger? = null) =
+        if (reference.accessFlags.isPublic() && !accessFlags.isPublic())
+            this.asMutableClass().apply {
+                context.bytecodeContext.traverseClassHierarchy(this) {
+                    if (accessFlags.isPublic()) return@traverseClassHierarchy
+
+                    logger?.trace("Publicizing ${this.type}")
+
+                    accessFlags = accessFlags.toPublic()
+                }
+            }
+        else this
+
+    /**
+     * Publicize fields if they are public in [reference].
+     *
+     * @param reference The class to check the [AccessFlags] of the fields in.
+     * @param logger A logger.
+     */
+    private fun ClassDef.fixFieldAccess(reference: ClassDef, logger: Logger? = null): ClassDef {
+        val brokenFields = fields.filterAny(reference.fields) { field, referenceField ->
+            if (field.name != referenceField.name) return@filterAny false
+
+            referenceField.accessFlags.isPublic() && !field.accessFlags.isPublic()
+        }
+
+        if (brokenFields.isEmpty()) return this
+
+        logger?.trace("Found ${brokenFields.size} broken fields")
+
+        /**
+         * Make a field public.
+         */
+        fun MutableField.publicize() {
+            accessFlags = accessFlags.toPublic()
+        }
+
+        return asMutableClass().apply {
+            fields.filter { brokenFields.contains(it) }.forEach(MutableField::publicize)
+        }
+    }
+
+    /**
+     * Publicize methods if they are public in [reference].
+     *
+     * @param reference The class to check the [AccessFlags] of the methods in.
+     * @param logger A logger.
+     */
+    private fun ClassDef.fixMethodAccess(reference: ClassDef, logger: Logger? = null): ClassDef {
+        val brokenMethods = methods.filterAny(reference.methods) { method, referenceMethod ->
+            if (!MethodUtil.methodSignaturesMatch(method, referenceMethod)) return@filterAny false
+
+            referenceMethod.accessFlags.isPublic() && !method.accessFlags.isPublic()
+        }
+
+        if (brokenMethods.isEmpty()) return this
+
+        logger?.trace("Found ${brokenMethods.size} methods")
+
+        /**
+         * Make a method public.
+         */
+        fun MutableMethod.publicize() {
+            accessFlags = accessFlags.toPublic()
+        }
+
+        return asMutableClass().apply {
+            methods.filter { brokenMethods.contains(it) }.forEach(MutableMethod::publicize)
+        }
+    }
+
+    private object Utils {
+        fun ClassDef.asMutableClass() = if (this is MutableClass) this else this.toMutable()
+
+        /**
+         * Check if the [AccessFlags.PUBLIC] flag is set.
+         *
+         * @return True, if the flag is set.
+         */
+        fun Int.isPublic() = AccessFlags.PUBLIC.isSet(this)
+
+        /**
+         * Make [AccessFlags] public.
+         *
+         * @return The new [AccessFlags].
+         */
+        fun Int.toPublic() = this.or(AccessFlags.PUBLIC).and(AccessFlags.PRIVATE.value.inv())
+
+        /**
+         * Filter [this] on [needles] matching the given [predicate].
+         *
+         * @param this The hay to filter for [needles].
+         * @param needles The needles to filter [this] with.
+         * @param predicate The filter.
+         * @return The [this] filtered on [needles] matching the given [predicate].
+         */
+        fun <HayType, NeedleType> Iterable<HayType>.filterAny(
+            needles: Iterable<NeedleType>, predicate: (HayType, NeedleType) -> Boolean
+        ) = Iterable<HayType>::filter.any(this, needles, predicate)
+
+        /**
+         * Filter [this] on [needles] not matching the given [predicate].
+         *
+         * @param this The hay to filter for [needles].
+         * @param needles The needles to filter [this] with.
+         * @param predicate The filter.
+         * @return The [this] filtered on [needles] not matching the given [predicate].
+         */
+        fun <HayType, NeedleType> Iterable<HayType>.filterNotAny(
+            needles: Iterable<NeedleType>, predicate: (HayType, NeedleType) -> Boolean
+        ) = Iterable<HayType>::filterNot.any(this, needles, predicate)
+
+        fun <HayType, NeedleType> KFunction2<Iterable<HayType>, (HayType) -> Boolean, List<HayType>>.any(
+            haystack: Iterable<HayType>,
+            needles: Iterable<NeedleType>,
+            predicate: (HayType, NeedleType) -> Boolean
+        ) = this(haystack) { hay ->
+            needles.any { needle ->
+                predicate(hay, needle)
+            }
+        }
+    }
+}

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

@@ -20,6 +20,22 @@ class MutableMethod(method: Method) : Method, BaseMethodReference() {
     private val _parameterTypes by lazy { method.parameterTypes.toMutableList() }
     private val _hiddenApiRestrictions by lazy { method.hiddenApiRestrictions }
 
+    fun setDefiningClass(definingClass: String) {
+        this.definingClass = definingClass
+    }
+
+    fun setName(name: String) {
+        this.name = name
+    }
+
+    fun setAccessFlags(accessFlags: Int) {
+        this.accessFlags = accessFlags
+    }
+
+    fun setReturnType(returnType: String) {
+        this.returnType = returnType
+    }
+
     override fun getDefiningClass(): String {
         return definingClass
     }