companion object {
        val none = object : PropertyExtractor {
            override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> = emptyList()
        }
    }
}


class CompositePropertyExtractor(internal val extractors: Iterable<PropertyExtractor>) : PropertyExtractor {

) : TypeDiscovery {
    /**
     * Collect everything that potentially looks like types configured by the lambdas.
     * TODO: this may be excessive
     */
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        kClass.memberFunctions
            .filter { memberFilter.shouldIncludeMember(it) }

private
class GradlePropertyApiPropertyExtractor(
    private val includeMemberFilter: MemberFilter
) : PropertyExtractor {
    override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> =
        propertiesFromGettersOf(kClass, propertyNamePredicate) + memberPropertiesOf(kClass, propertyNamePredicate)

    private

        )
    )
}


private
fun softwareTypeConfiguringFunctions(typeToExtend: KClass<*>, softwareTypeImplementations: Iterable<SoftwareTypeInfo<*>>): FunctionExtractor = object : FunctionExtractor {
    override fun memberFunctions(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<SchemaMemberFunction> =
        if (kClass == typeToExtend) softwareTypeImplementations.map(SoftwareTypeInfo<*>::schemaFunction) else emptyList()

sealed interface DocumentResolution {
    sealed interface SuccessfulResolution : DocumentResolution
    sealed interface UnsuccessfulResolution : DocumentResolution {
        val reasons: Iterable<ResolutionFailureReason>
    }

    sealed interface DocumentNodeResolution : DocumentResolution

    sealed interface PropertyResolution : DocumentNodeResolution {

}


private
class TypesafeProjectAccessorTypeDiscovery : TypeDiscovery {
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> {
        return if (kClass.isGeneratedAccessors()) {
            allClassesReachableFromGetters(kClass).flatMapTo(mutableSetOf(), ::allSupertypes)
        } else {
            emptyList()
        }

    val writeOnlyPropertyContributor = object : PropertyExtractor {
        override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> {
            return if (kClass == MyReceiver::class) {
                listOf(
                    CollectedPropertyInformation(
                        "z",

 * limitations under the License.
 */

package org.gradle.declarative.dsl.evaluation

import java.io.Serializable


interface InterpretationSequence : Serializable {
    val steps: Iterable<InterpretationSequenceStep>

import org.gradle.internal.declarativedsl.objectGraph.AssignmentTrace


interface StepContext


data class AnalysisStepContext(
    val supportedDocumentChecks: Iterable<DocumentCheck>,
    val supportedResolutionResultHandlers: Iterable<ResolutionResultHandler>
) : StepContext


data class AnalysisStepResult(
    val evaluationSchema: EvaluationSchema,
    val languageTreeResult: LanguageTreeResult,

    cause: Throwable? = null
) : ConfigurationCacheThrowable, Exception(error, cause)


@Contextual
sealed class ConfigurationCacheException protected constructor(
    message: () -> String,
    causes: Iterable<Throwable>
) : DefaultMultiCauseException(message, causes), ConfigurationCacheThrowable


open class ConfigurationCacheProblemsException : ConfigurationCacheException {

    protected
    object Documentation {