)

    fun isIgnoredStartParameterProperty(key: String): Boolean =
        ignoredStartParameterProperties.contains(key)


    fun canReadSystemProperty(from: String): Boolean =
        withWorkaroundsFor("systemProps") {
            isBuildScanPlugin(from)
        }

    fun canReadEnvironmentVariable(from: String): Boolean =
        withWorkaroundsFor("envVars") {
            isBuildScanPlugin(from)

internal
fun KotlinClassMetadata.hasKotlinFlag(memberType: MemberType, jvmSignature: String, flag: Flag): Boolean =
    hasKotlinFlags(memberType, jvmSignature) { flags ->
        flag(flags)
    }


private
fun KotlinClassMetadata.hasKotlinFlags(memberType: MemberType, jvmSignature: String, predicate: (Flags) -> Boolean): Boolean =
    when (this) {

    fun isKotlinInternal(ctMember: CtMember): Boolean =
        if (Modifier.isPrivate(ctMember.modifiers)) false
        else hasKotlinFlag(ctMember, Flag.IS_INTERNAL)

    fun isKotlinOperatorFunction(ctMethod: CtMethod): Boolean =
        hasKotlinFlag(ctMethod, Flag.Function.IS_OPERATOR)

    fun isKotlinInfixFunction(ctMethod: CtMethod): Boolean =
        hasKotlinFlag(ctMethod, Flag.Function.IS_INFIX)

    val type: PerformanceTestType
    val os: Os
    val arch: Arch
    val withoutDependencies: Boolean

    fun asConfigurationId(model: CIBuildModel, bucket: String): String
    fun channel(): String
}

interface PerformanceTestProjectSpec {
    val type: PerformanceTestType
    val failsStage: Boolean

    fun asConfigurationId(model: CIBuildModel): String
    fun asName(): String
    fun channel(): String
}

    allMethods().firstAccessibleMatchingMethodOrNull(predicate)


internal
fun Iterable<Method>.firstAccessibleMatchingMethodOrNull(predicate: Method.() -> Boolean): Method? =
    find(predicate)?.apply { isAccessible = true }


internal
fun Class<*>.firstMatchingMethodOrNull(predicate: Method.() -> Boolean): Method? =
    allMethods().find(predicate)

        delegate.addLater(provider)

    override fun containsAll(elements: Collection<T>): Boolean =
        delegate.containsAll(elements)

    override fun isEmpty(): Boolean =
        delegate.isEmpty()

    override fun remove(element: T): Boolean =
        delegate.remove(element)

    override fun getAsMap(): SortedMap<String, T> =
        delegate.asMap

            interface Required : ConfigureBlockRequirement

            val allows: Boolean
                get() = this !is NotAllowed

            val requires: Boolean
                get() = this is Required

            fun isValidIfLambdaIsPresent(isPresent: Boolean): Boolean = when {
                isPresent -> allows
                else -> !requires
            }
        }
    }

    @get:Restricted
    var version: String = ""

    @get:HasDefaultValue
    var apply: Boolean = false

    @Builder
    infix fun version(value: String): PluginDefinition =
        apply { version = value }

    @Builder
    infix fun apply(value: Boolean): PluginDefinition =
        apply { apply = value }

    writer: ClassWriter,
    val useLowPriorityInOverloadResolution: Boolean
) : ClassVisitor(ASM_LEVEL, writer)


internal
typealias MetadataWriter = MetadataFragmentScope.() -> Unit


internal
data class MetadataFragmentScope(
    val signature: JvmMethodSignature,
    val kmPackage: KmPackage,
    val useLowPriorityInOverloadResolution: Boolean
)


internal

    val isLoaded: Boolean

    // This is a temporary method to allow migration from a root build scoped cache to a build tree scoped cache
    fun attachRootBuild(host: DefaultConfigurationCache.Host)

    class WorkGraphResult(val graph: BuildTreeWorkGraph.FinalizedGraph, val wasLoadedFromCache: Boolean, val entryDiscarded: Boolean)