Extract Invokable helper for backward compat (#2074)

ZacSweers · web-flow · commit 5e390e1a2eff · 2026-01-28T15:31:21.000-05:00
diff --git a/moshi-kotlin/src/main/java/com/squareup/moshi/kotlin/reflect/Invokable.kt b/moshi-kotlin/src/main/java/com/squareup/moshi/kotlin/reflect/Invokable.kt
@@ -0,0 +1,80 @@
+package com.squareup.moshi.kotlin.reflect
+
+import com.squareup.moshi.internal.DEFAULT_CONSTRUCTOR_MARKER
+import java.lang.reflect.Constructor
+import java.lang.reflect.Method
+
+private val DEFAULT_CONSTRUCTOR_SIGNATURE by
+  lazy(LazyThreadSafetyMode.NONE) { DEFAULT_CONSTRUCTOR_MARKER!!.descriptor }
+
+/**
+ * A thin wrapper over [Constructor] and [Method] to avoid using [java.lang.reflect.Executable],
+ * which is not available on Android until API 26.
+ */
+internal sealed interface Invokable {
+  val parameterTypes: Array<Class<*>>
+  val parameterAnnotations: Array<Array<Annotation>>
+  val jvmMethodSignature: String
+
+  fun setAccessible()
+
+  fun defaultsSignature(): String
+
+  @JvmInline
+  value class InvokableConstructor(val constructor: Constructor<*>) : Invokable {
+    override val parameterTypes: Array<Class<*>>
+      get() = constructor.parameterTypes
+
+    override val parameterAnnotations: Array<Array<Annotation>>
+      get() = constructor.parameterAnnotations
+
+    override val jvmMethodSignature: String
+      get() = constructor.jvmMethodSignature
+
+    override fun setAccessible() {
+      constructor.isAccessible = true
+    }
+
+    override fun defaultsSignature(): String {
+      val rawPrefix = jvmMethodSignature.removeSuffix("V").removeSuffix(")")
+      return buildDefaultsSignature(rawPrefix, parameterTypes.size, "V")
+    }
+  }
+
+  @JvmInline
+  value class InvokableMethod(val method: Method) : Invokable {
+    override val parameterTypes: Array<Class<*>>
+      get() = method.parameterTypes
+
+    override val parameterAnnotations: Array<Array<Annotation>>
+      get() = method.parameterAnnotations
+
+    override val jvmMethodSignature: String
+      get() = method.jvmMethodSignature
+
+    override fun setAccessible() {
+      method.isAccessible = true
+    }
+
+    override fun defaultsSignature(): String {
+      val suffixDescriptor = method.returnType.descriptor
+      val rawPrefix = jvmMethodSignature.removeSuffix(suffixDescriptor).removeSuffix(")")
+      // Need to add $default to the end of the method name
+      val (name, rest) = rawPrefix.split("(", limit = 2)
+      // ktlint doesn't support multi-dollar prefixes
+      @Suppress("CanConvertToMultiDollarString") val prefix = "$name\$default($rest"
+      return buildDefaultsSignature(prefix, parameterTypes.size, suffixDescriptor)
+    }
+  }
+}
+
+private fun buildDefaultsSignature(prefix: String, parameterCount: Int, suffix: String): String {
+  val maskParamsToAdd = (parameterCount + 31) / 32
+  return buildString {
+    append(prefix)
+    repeat(maskParamsToAdd) { append("I") }
+    append(DEFAULT_CONSTRUCTOR_SIGNATURE)
+    append(')')
+    append(suffix)
+  }
+}
diff --git a/moshi-kotlin/src/main/java/com/squareup/moshi/kotlin/reflect/JvmDescriptors.kt b/moshi-kotlin/src/main/java/com/squareup/moshi/kotlin/reflect/JvmDescriptors.kt
@@ -16,7 +16,6 @@
 package com.squareup.moshi.kotlin.reflect
 
 import java.lang.reflect.Constructor
-import java.lang.reflect.Executable
 import java.lang.reflect.Method
 import kotlin.metadata.jvm.JvmMethodSignature
 
@@ -156,25 +155,28 @@ internal fun JvmMethodSignature.decodeParameterTypes(): List<Class<*>> {
 }
 
 /**
- * Returns the JVM signature in the form "<init>$MethodDescriptor", for example:
- * `"<init>(Ljava/lang/Object;)V")`.
+ * Returns the JVM signature in the form "name$MethodDescriptor", for example:
+ * `"<init>(Ljava/lang/Object;)V"` or `"foo(Ljava/lang/Object;)V"`.
  *
  * Useful for comparing with [JvmMethodSignature].
  *
  * @see <a href="https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3">JVM
  *   specification, section 4.3</a>
  */
-internal val Executable.jvmMethodSignature: String
-  get() = buildString {
-    when (this@jvmMethodSignature) {
-      is Constructor<*> -> append("<init>")
-      is Method -> append(name)
-    }
-    parameterTypes.joinTo(buffer = this, separator = "", prefix = "(", postfix = ")") {
-      it.descriptor
-    }
-    when (this@jvmMethodSignature) {
-      is Constructor<*> -> append("V")
-      is Method -> append(returnType.descriptor)
-    }
+private fun jvmMethodSignature(
+  name: String,
+  parameterTypes: Array<Class<*>>,
+  returnDescriptor: String,
+): String = buildString {
+  append(name)
+  parameterTypes.joinTo(buffer = this, separator = "", prefix = "(", postfix = ")") {
+    it.descriptor
   }
+  append(returnDescriptor)
+}
+
+internal val Constructor<*>.jvmMethodSignature: String
+  get() = jvmMethodSignature("<init>", parameterTypes, "V")
+
+internal val Method.jvmMethodSignature: String
+  get() = jvmMethodSignature(name, parameterTypes, returnType.descriptor)
diff --git a/moshi-kotlin/src/main/java/com/squareup/moshi/kotlin/reflect/KmExecutable.kt b/moshi-kotlin/src/main/java/com/squareup/moshi/kotlin/reflect/KmExecutable.kt
@@ -1,8 +1,6 @@
 package com.squareup.moshi.kotlin.reflect
 
-import com.squareup.moshi.internal.DEFAULT_CONSTRUCTOR_MARKER
 import java.lang.reflect.Constructor
-import java.lang.reflect.Executable
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
 import kotlin.metadata.KmClass
@@ -12,14 +10,11 @@ import kotlin.metadata.isValue
 import kotlin.metadata.jvm.KotlinClassMetadata
 import kotlin.metadata.jvm.signature
 
-private val DEFAULT_CONSTRUCTOR_SIGNATURE by
-  lazy(LazyThreadSafetyMode.NONE) { DEFAULT_CONSTRUCTOR_MARKER!!.descriptor }
-
 /**
  * Simple facade over KM constructor-ish types, which could be a constructor or a static creator
  * method (value classes).
  */
-internal sealed class KmExecutable<T : Executable> {
+internal sealed class KmExecutable<T : Any> {
   abstract val parameters: List<KtParameter>
   abstract val isDefault: Boolean
   abstract val needsDefaultMarker: Boolean
@@ -72,56 +67,25 @@ internal sealed class KmExecutable<T : Executable> {
       return boxImplMethod to unboxImplMethod
     }
 
-    private fun Executable.defaultsSignature(): String {
-      val suffixDescriptor =
-        when (this) {
-          is Constructor<*> -> "V"
-          is Method -> returnType.descriptor
-        }
-      val rawPrefix = jvmMethodSignature.removeSuffix(suffixDescriptor).removeSuffix(")")
-      val prefix =
-        when (this) {
-          is Constructor<*> -> {
-            rawPrefix
-          }
-
-          is Method -> {
-            // Need to add $default to the end of the method name
-            val (name, rest) = rawPrefix.split("(", limit = 2)
-            // ktlint doesn't support multi-dollar prefixes
-            @Suppress("CanConvertToMultiDollarString") "$name\$default($rest"
-          }
-        }
-      val parameterCount = parameterTypes.size
-      val maskParamsToAdd = (parameterCount + 31) / 32
-      val defaultConstructorSignature = buildString {
-        append(prefix)
-        repeat(maskParamsToAdd) { append("I") }
-        append(DEFAULT_CONSTRUCTOR_SIGNATURE)
-        append(')')
-        append(suffixDescriptor)
-      }
-      return defaultConstructorSignature
-    }
-
     operator fun invoke(rawType: Class<*>, kmClass: KmClass): KmExecutable<*>? {
       // If this is a value class, the "constructor" will actually be a static creator function
-      val constructorsBySignature =
+      val constructorsBySignature: Map<String, Invokable> =
         if (kmClass.isValue) {
           // kmConstructorSignature is something like constructor-impl(I)I
           // Need to look up the matching static function
           rawType.declaredMethods
             .filter { Modifier.isStatic(it.modifiers) }
-            .associateBy { it.jvmMethodSignature }
+            .associateBy({ it.jvmMethodSignature }, { Invokable.InvokableMethod(it) })
         } else {
-          rawType.declaredConstructors.associateBy { it.jvmMethodSignature }
+          rawType.declaredConstructors.associateBy(
+            { it.jvmMethodSignature },
+            { Invokable.InvokableConstructor(it) },
+          )
         }
       val kmConstructor = kmClass.constructors.find { !it.isSecondary } ?: return null
       val kmConstructorSignature = kmConstructor.signature?.toString() ?: return null
       val jvmConstructor = constructorsBySignature[kmConstructorSignature] ?: return null
 
-      val parameterAnnotations = jvmConstructor.parameterAnnotations
-      val parameterTypes = jvmConstructor.parameterTypes
       val parameters =
         kmConstructor.valueParameters.withIndex().map { (index, kmParam) ->
           // Check if this parameter's type is a value class
@@ -130,41 +94,45 @@ internal sealed class KmExecutable<T : Executable> {
           KtParameter(
             kmParam,
             index,
-            parameterTypes[index],
-            parameterAnnotations[index].toList(),
+            jvmConstructor.parameterTypes[index],
+            jvmConstructor.parameterAnnotations[index].toList(),
             parameterValueClassBoxer,
             parameterValueClassUnboxer,
           )
         }
       val anyOptional = parameters.any { it.declaresDefaultValue }
       val actualConstructor =
         if (anyOptional) {
-          val defaultsSignature = jvmConstructor.defaultsSignature()
-          constructorsBySignature[defaultsSignature] ?: return null
+          constructorsBySignature[jvmConstructor.defaultsSignature()] ?: return null
         } else {
           jvmConstructor
         }
 
-      actualConstructor.isAccessible = true
+      actualConstructor.setAccessible()
 
       return if (kmClass.isValue) {
         // Things get quirky here. KM will return the primary constructor for the value class
         // as a constructor-impl static function, BUT this function always only returns the
-        // underlying
-        // type. What we want is the boxed type, so we need to be able to invoke the constructor and
-        // then be able to pass it on to the box-impl function to get the full instance.
-        // We can't just skip ahead and use only the box-impl function because the constructor is
-        // the only one that handles default values
-
-        val boxImpl = constructorsBySignature.entries.first { it.key.startsWith("box-impl") }.value
+        // underlying type. What we want is the boxed type, so we need to be able to invoke the
+        // constructor and then be able to pass it on to the box-impl function to get the full
+        // instance. We can't just skip ahead and use only the box-impl function because the
+        // constructor is the only one that handles default values
+
+        val boxImpl =
+          constructorsBySignature.entries.first { it.key.startsWith("box-impl") }.value
+            as Invokable.InvokableMethod
         KmExecutableFunction(
-          actualConstructor as Method,
+          (actualConstructor as Invokable.InvokableMethod).method,
           parameters,
           anyOptional,
-          boxImpl as Method,
+          boxImpl.method,
         )
       } else {
-        KmExecutableConstructor(actualConstructor as Constructor<*>, parameters, anyOptional)
+        KmExecutableConstructor(
+          (actualConstructor as Invokable.InvokableConstructor).constructor,
+          parameters,
+          anyOptional,
+        )
       }
     }
   }
