void loadGradlePropertiesFrom(File settingsDir, boolean setSystemProperties);

    /**
     * Unloads the properties so the next call to {@link #loadGradlePropertiesFrom(File, boolean)} would reload them and
     * re-evaluate any property defining system properties and environment variables.
     */
    void unloadGradleProperties();

	// DepAllowed means the dependency was explicitly allowed by a rule.
	DepAllowed
	// DepAllowed means the dependency did not match any rule.
	DepUnknown
)

// Evaluate considers this rule and decides if this dependency is allowed.
func (r Rule) Evaluate(imp string) Disposition {
	// To pass, an import muct be allowed and not forbidden.
	// Check forbidden first.
	for _, forbidden := range r.ForbiddenPrefixes {

        supportedResolutionResultHandlers = listOf(ConventionDefinitionCollector(conventionStorage), ConventionApplicationHandler(conventionStorage))
    )

    fun evaluate(
        scriptFileName: String,
        scriptSource: String
    ): AnalysisSequenceResult {
        val scriptContext = scriptContextFromFileName(scriptFileName)

 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

package org.jetbrains.kotlin.analysis.api.fir.evaluate

import org.jetbrains.kotlin.analysis.api.KaSession
import org.jetbrains.kotlin.analysis.api.annotations.*
import org.jetbrains.kotlin.analysis.api.base.KaConstantValue

					},
				},
			},
			messageEvaluations: []cel.EvaluationResult{
				{
					EvalResult: celtypes.String("evaluated message"),
				},
			},
			policyDecision: []PolicyDecision{
				{
					Action:  ActionDeny,
					Message: "evaluated message",
					Reason:  forbiddenReason,
				},
			},
		},
		{
			name: "messageExpression for multiple validations",

import org.jetbrains.kotlin.analysis.api.annotations.KaAnnotationList
import org.jetbrains.kotlin.analysis.api.fir.KaSymbolByFirBuilder
import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirAnnotationValueConverter
import org.jetbrains.kotlin.analysis.api.fir.toKaAnnotation
import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KaEmptyAnnotationList

                        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") {

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

    "must have compile-time constant inputs and outputs.\n\n"
    "XLA compilation requires that operator arguments that represent shapes or "
    "dimensions be evaluated to concrete values at compile time.  This error "
    "means that a shape or dimension argument could not be evaluated at "
    "compile time, usually because the value of the argument depends on a "
    "parameter to the computation, on a variable, or on a stateful operation "

    }

    @Override
    Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override
            void evaluate() throws Throwable {
                try {
                    base.evaluate()
                } finally {
                    cleanUpIsolatedDaemonsAndServices()
                }
            }
        }
    }