Fix Declarative DSL runtime setting properties in Kotlin types

If Kotlin reflection cannot find the property or the setter method,
try to look up the setter via Java reflection.

Also, refactor some code around `DeclarativeRuntimeProperty`.

platforms/core-configuration/declarative-dsl-core/src/main/kotlin/org/gradle/internal/declarativedsl/mappingToJvm/DeclarativeReflectionToObjectConverter.kt

@@ -168,8 +168,8 @@ class DeclarativeReflectionToObjectConverter(
             ?: error("tried to access a property ${dataProperty.name} on a null receiver")
         val receiverKClass = receiverInstance::class
         return when (val property = propertyResolver.resolvePropertyRead(receiverKClass, dataProperty.name)) {
-            is RuntimePropertyResolver.Resolution.Resolved -> property.property.getValue(receiverInstance)
-            else -> error("cannot get property ${dataProperty.name} from the receiver class $receiverKClass")
+            is RuntimePropertyResolver.ReadResolution.ResolvedRead -> property.getter.getValue(receiverInstance)
+            RuntimePropertyResolver.ReadResolution.UnresolvedRead -> error("cannot get property ${dataProperty.name} from the receiver class $receiverKClass")
         }
     }
 
@@ -179,8 +179,8 @@ class DeclarativeReflectionToObjectConverter(
             ?: error("tried to access a property ${dataProperty.name} on a null receiver")
         val receiverKClass = receiverInstance::class
         when (val property = propertyResolver.resolvePropertyWrite(receiverKClass, dataProperty.name)) {
-            is RuntimePropertyResolver.Resolution.Resolved -> property.property.setValue(receiverInstance, value)
-            RuntimePropertyResolver.Resolution.Unresolved -> error("cannot set property ${dataProperty.name} in the receiver class $receiverKClass")
+            is RuntimePropertyResolver.WriteResolution.ResolvedWrite -> property.setter.setValue(receiverInstance, value)
+            RuntimePropertyResolver.WriteResolution.UnresolvedWrite -> error("cannot set property ${dataProperty.name} in the receiver class $receiverKClass")
         }
     }
 }

platforms/core-configuration/declarative-dsl-core/src/main/kotlin/org/gradle/internal/declarativedsl/mappingToJvm/DeclarativeRuntimeProperty.kt

@@ -17,7 +17,11 @@
 package org.gradle.internal.declarativedsl.mappingToJvm
 
 
-interface DeclarativeRuntimeProperty {
+fun interface DeclarativeRuntimePropertyGetter {
     fun getValue(receiver: Any): Any?
+}
+
+
+fun interface DeclarativeRuntimePropertySetter {
     fun setValue(receiver: Any, value: Any?)
 }

platforms/core-configuration/declarative-dsl-core/src/main/kotlin/org/gradle/internal/declarativedsl/mappingToJvm/RuntimePropertyResolver.kt

@@ -16,55 +16,86 @@
 
 package org.gradle.internal.declarativedsl.mappingToJvm
 
-import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.Resolution.Resolved
-import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.Resolution.Unresolved
+import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.ReadResolution
+import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.ReadResolution.ResolvedRead
+import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.ReadResolution.UnresolvedRead
+import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.WriteResolution
+import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.WriteResolution.ResolvedWrite
+import org.gradle.internal.declarativedsl.mappingToJvm.RuntimePropertyResolver.WriteResolution.UnresolvedWrite
+import java.lang.reflect.Modifier
 import kotlin.reflect.KClass
 import kotlin.reflect.KMutableProperty
+import kotlin.reflect.KProperty
 import kotlin.reflect.KVisibility
 import kotlin.reflect.full.memberFunctions
 import kotlin.reflect.full.memberProperties
 
 
 interface RuntimePropertyResolver {
-    fun resolvePropertyRead(receiverClass: KClass<*>, name: String): Resolution
-    fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): Resolution
+    fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution
+    fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): WriteResolution
 
-    sealed interface Resolution {
-        data class Resolved(val property: DeclarativeRuntimeProperty) : Resolution
-        data object Unresolved : Resolution
+    sealed interface ReadResolution {
+        data class ResolvedRead(val getter: DeclarativeRuntimePropertyGetter) : ReadResolution
+        data object UnresolvedRead : ReadResolution
+    }
+
+    sealed interface WriteResolution {
+        data class ResolvedWrite(val setter: DeclarativeRuntimePropertySetter) : WriteResolution
+        data object UnresolvedWrite : WriteResolution
     }
 }
 
 
 object ReflectionRuntimePropertyResolver : RuntimePropertyResolver {
-    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): RuntimePropertyResolver.Resolution {
-        val callable = receiverClass.memberProperties.find { it.name == name && it.visibility == KVisibility.PUBLIC }
-            ?: receiverClass.memberFunctions.find { it.name == getterName(name) && it.parameters.size == 1 && it.visibility == KVisibility.PUBLIC }
-
-        return when (callable) {
-            null -> Unresolved
-            else -> Resolved(object : DeclarativeRuntimeProperty {
-                override fun getValue(receiver: Any): Any? = callable.call(receiver)
-                override fun setValue(receiver: Any, value: Any?) = throw UnsupportedOperationException()
-            })
-        }
+    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution {
+        val getter = findKotlinProperty(receiverClass, name)?.let(::kotlinPropertyGetter)
+            ?: findKotlinFunctionGetter(receiverClass, name)
+            ?: findJavaGetter(receiverClass, name)
+
+        return getter?.let(::ResolvedRead) ?: UnresolvedRead
     }
 
-    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): RuntimePropertyResolver.Resolution {
-        val setter = (receiverClass.memberProperties.find { it.name == name && it.visibility == KVisibility.PUBLIC } as? KMutableProperty<*>)?.setter
-            ?: receiverClass.memberFunctions.find { it.name == setterName(name) && it.visibility == KVisibility.PUBLIC }
-
-        return when (setter) {
-            null -> Unresolved
-            else -> Resolved(object : DeclarativeRuntimeProperty {
-                override fun getValue(receiver: Any): Any = throw UnsupportedOperationException()
-                override fun setValue(receiver: Any, value: Any?) {
-                    setter.call(receiver, value)
-                }
-            })
-        }
+    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): WriteResolution {
+        val setter = (findKotlinProperty(receiverClass, name) as? KMutableProperty<*>)?.let(::kotlinPropertySetter)
+            ?: findKotlinFunctionSetter(receiverClass, name)
+            ?: findJavaSetter(receiverClass, name)
+
+        return setter?.let(::ResolvedWrite) ?: UnresolvedWrite
     }
 
+    private
+    fun findKotlinProperty(receiverClass: KClass<*>, name: String) =
+        receiverClass.memberProperties.find { it.name == name && it.visibility == KVisibility.PUBLIC }
+
+    private
+    fun kotlinPropertyGetter(property: KProperty<*>) =
+        DeclarativeRuntimePropertyGetter { property.call(it) }
+
+    private
+    fun kotlinPropertySetter(property: KMutableProperty<*>) =
+        DeclarativeRuntimePropertySetter { receiver, value -> property.setter.call(receiver, value) }
+
+    private
+    fun findKotlinFunctionGetter(receiverClass: KClass<*>, name: String) =
+        receiverClass.memberFunctions.find { it.name == getterName(name) && it.parameters.size == 1 && it.visibility == KVisibility.PUBLIC }
+            ?.let { property -> DeclarativeRuntimePropertyGetter { property.call(it) } }
+
+    private
+    fun findKotlinFunctionSetter(receiverClass: KClass<*>, name: String) =
+        receiverClass.memberFunctions.find { it.name == setterName(name) && it.visibility == KVisibility.PUBLIC }
+            ?.let { function -> DeclarativeRuntimePropertySetter { receiver: Any, value: Any? -> function.call(receiver, value) } }
+
+    private
+    fun findJavaGetter(receiverClass: KClass<*>, name: String) =
+        receiverClass.java.methods.find { it.name == getterName(name) && it.parameters.isEmpty() && it.modifiers.and(Modifier.PUBLIC) != 0 }
+            ?.let { method -> DeclarativeRuntimePropertyGetter { method.invoke(it) } }
+
+    private
+    fun findJavaSetter(receiverClass: KClass<*>, name: String) =
+        receiverClass.java.methods.find { it.name == setterName(name) && it.parameters.size == 1 && it.modifiers.and(Modifier.PUBLIC) != 0 }
+            ?.let { method -> DeclarativeRuntimePropertySetter { receiver: Any, value: Any? -> method.invoke(receiver, value) } }
+
     private
     fun getterName(propertyName: String) = "get" + capitalize(propertyName)
 
@@ -79,21 +110,21 @@ object ReflectionRuntimePropertyResolver : RuntimePropertyResolver {
 
 
 class CompositePropertyResolver(private val resolvers: List<RuntimePropertyResolver>) : RuntimePropertyResolver {
-    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): RuntimePropertyResolver.Resolution {
+    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution {
         resolvers.forEach {
             val resolution = it.resolvePropertyRead(receiverClass, name)
-            if (resolution is Resolved)
+            if (resolution !is UnresolvedRead)
                 return resolution
         }
-        return Unresolved
+        return UnresolvedRead
     }
 
-    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): RuntimePropertyResolver.Resolution {
+    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): WriteResolution {
         resolvers.forEach {
             val resolution = it.resolvePropertyWrite(receiverClass, name)
-            if (resolution is Resolved)
+            if (resolution !is UnresolvedWrite)
                 return resolution
         }
-        return Unresolved
+        return UnresolvedWrite
     }
 }