): KaConstantValue? {
        val evaluated = evaluate(fir) ?: return null

        val value = evaluated.value
        val psi = evaluated.psi as? KtElement
        return when (evaluated.kind) {
            ConstantValueKind.Byte -> KaConstantValue.KaByteConstantValue(value as Byte, psi)
            ConstantValueKind.Int -> KaConstantValue.KaIntConstantValue(value as Int, psi)

     */
    public fun KtExpression.evaluate(): KaConstantValue? =
        withValidityAssertion { analysisSession.compileTimeConstantProvider.evaluate(this) }

    /**
     * Returns a [KaConstantValue] if the expression evaluates to a value that can be used as an annotation parameter value,
     * e.g. an array of constants, otherwise returns null.
     */

internal fun FirExpression.asKaInitializerValue(builder: KaSymbolByFirBuilder, forAnnotationDefaultValue: Boolean): KaInitializerValue {
    val ktExpression = psi as? KtExpression
    val evaluated = FirCompileTimeConstantEvaluator.evaluateAsKtConstantValue(this)

    return when (evaluated) {
        null -> if (forAnnotationDefaultValue) {
            val annotationConstantValue = FirAnnotationValueConverter.toConstantValue(this, builder)

        then:
        def evaluator = ******@****.***hema(model.settingsSequence, model.projectSequence)
        def settings = evaluator.evaluate("settings.gradle.dcl", file("settings.gradle.dcl").text)
        def project = evaluator.evaluate("build.gradle.dcl", file("build.gradle.dcl").text)

import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
import org.jetbrains.kotlin.types.TypeUtils


internal class KaFe10CompileTimeConstantProvider(
    override val analysisSession: KaFe10Session
) : KaCompileTimeConstantProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun evaluate(expression: KtExpression): KaConstantValue? {

import org.jetbrains.kotlin.analysis.api.components.KaCompileTimeConstantProvider
import org.jetbrains.kotlin.analysis.api.fir.KaFirSession
import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirAnnotationValueConverter
import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator
import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir

                        println("The parameter is `${taskParameter.get()}`")
                    }
                }

                // Expose dsl to the user, the value will be isolated only after settings has been fully evaluated
                extensions.create<my.SettingsPluginDsl>("dsl").let { dsl ->
                    gradle.lifecycle.beforeProject {
                        tasks.register<CustomTask>("test") {

    private val controller: ConfigurationCacheFingerprintController
) : ProjectEvaluator {
    override fun evaluate(project: ProjectInternal, state: ProjectStateInternal) {
        controller.runCollectingFingerprintForProject(project.identityPath) {
            delegate.evaluate(project, state)
        }
    }

class ConfigurationCacheFileTreeIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    @Issue('https://github.com/gradle/gradle/issues/19780')
    def "filter predicates and matching patterns are evaluated lazily"() {
        given:
        buildFile """
            abstract class PrintInputs extends DefaultTask {

                @InputFiles
                abstract ConfigurableFileCollection getInputFiles()

        val constantValue = ConstantExpressionEvaluator.getConstant(initializer, bindingContext)
        if (constantValue != null) {
            val evaluated = constantValue.toConstantValue(propertyDescriptor?.type ?: TypeUtils.NO_EXPECTED_TYPE).toKtConstantValue()
            return KaConstantInitializerValue(evaluated, initializer)
        }
    }

    return KaNonConstantInitializerValue(initializer)
}