override fun resolve(receiverClass: KClass<*>, name: String, parameterValueBinding: ParameterValueBinding): RuntimeFunctionResolver.Resolution {
        receiverClass.memberFunctions.forEach { function ->
            // TODO: `convertBinding` is invoked here with the receiverClass passed as the receiver and non-resolved argument origins; this probably needs a different API shape

        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) =

    }

    @Nullable
    @Override
    public Class<?> matchesProperty(Class<?> receiverClass) {
        Class<?> typeOfProperty = null;
        if (first instanceof PropertyAwareCallInterceptor) {
            typeOfProperty = ((PropertyAwareCallInterceptor) first).matchesProperty(receiverClass);
        }
        if (typeOfProperty == null && second instanceof PropertyAwareCallInterceptor) {

    private
    fun hasDependencyCollectorGetterSignature(receiverClass: KClass<*>, function: KFunction<*>): Boolean {
        return receiverClass.isSubclassOf(Dependencies::class) && with(function) {
            name.startsWith("get") && returnType.classifier == DependencyCollector::class && parameters.size == 1
        }
    }

    private
    fun isDependencyCollectorProperty(receiverClass: KClass<*>, property: KProperty<*>): Boolean {

}


private
class ProjectPropertyAccessorRuntimeResolver : RuntimePropertyResolver {
    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): RuntimePropertyResolver.ReadResolution =
        if (receiverClass.isSubclassOf(Project::class) && name == "projects") {
            RuntimePropertyResolver.ReadResolution.ResolvedRead { receiver -> (receiver as Project).extensions.getByName("projects") }

            .addAnnotation(Override.class)
            .addModifiers(Modifier.PUBLIC)
            .returns(SIGNATURE_AWARE_CALL_INTERCEPTOR_SIGNATURE_MATCH)
            .addParameter(classWildcard, "receiverClass")
            .addParameter(ArrayTypeName.of(classWildcard), "argumentClasses")
            .addParameter(boolean.class, "isStatic")
            .addCode(generateMatchesSignatureCodeFromInterceptorSignatureTree(signatureTree))

        val owner = descriptor.owner

        if (descriptor is IrBasedReceiverParameterDescriptor && owner is IrValueParameter) {
            val receiverClass = (owner.type as? IrSimpleType)?.classifier as? IrClassSymbol
            val receiverClassId = receiverClass?.owner?.classId

            if (receiverClassId != null) {
                if (owner.index >= 0) {

        origin: ObjectOrigin.FunctionInvocationOrigin
    ): DeclarativeRuntimeFunction.InvocationResult {
        val dataFun = origin.function
        val receiverKClass = receiverInstance::class
        return when (val runtimeFunction = functionResolver.resolve(receiverKClass, dataFun.simpleName, origin.parameterBindings)) {
            is RuntimeFunctionResolver.Resolution.Resolved -> {