the module root (defined by the presence of a go.mod file).  These files
contain rules which are evaluated against each dependency of the package in
question.

Evaluation starts with the rules file closest to the package.  If that file
makes a determination to allow or forbid the import, evaluation is done.  If
the import does not match any rule, the next-closest rules file is consulted,
and so forth.  If the rules files are exhausted and no determination has been

// run

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test evaluation order.

package main

var calledf int

func f() int {
	calledf++
	return 0
}

func g() int {
	return calledf
}

var xy string

//go:noinline
func x() bool {
	xy += "x"
	return false
}

//go:noinline

 */

package org.gradle.kotlin.dsl.execution

import java.util.*


enum class EvalOption {
    IgnoreErrors,
    SkipBody
}


typealias EvalOptions = EnumSet<EvalOption>


internal
val defaultEvalOptions: EvalOptions =

  // encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation.
  optional bool incomplete = 3;

  // EvaluationError can appear in combination with Rules. It indicates an error occurred during
  // rule evaluation, such as an authorizer that doesn't support rule evaluation, and that
  // ResourceRules and/or NonResourceRules may be incomplete.
  // +optional

  // encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation.
  optional bool incomplete = 3;

  // EvaluationError can appear in combination with Rules. It indicates an error occurred during
  // rule evaluation, such as an authorizer that doesn't support rule evaluation, and that
  // ResourceRules and/or NonResourceRules may be incomplete.
  // +optional

	// encountered when an authorizer, such as an external authorizer, doesn't support rules evaluation.
	Incomplete bool
	// EvaluationError can appear in combination with Rules. It indicates an error occurred during
	// rule evaluation, such as an authorizer that doesn't support rule evaluation, and that
	// ResourceRules and/or NonResourceRules may be incomplete.
	EvaluationError string
}

        failure.assertHasFileName("Build file '$buildFile.path'")
        failure.assertHasLineNumber(lines + 10)
        failure.assertHasCause("There was an error while evaluating a component selection rule for org.utils:api:1.2.")
        failure.assertHasCause("Could not find method foo()")
    }

    @Requires(UnitTestPreconditions.IsGroovy4)

// run

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 8336. Order of evaluation of receive channels in select.

package main

type X struct {
	c chan int
}

func main() {
	defer func() {
		recover()
	}()
	var x *X
	select {
	case <-x.c: // should fault and panic before foo is called

        verify(dependencies).add(eq("classpath"), eq(notation))
        verify(dependencies).addProvider(eq("classpath"), eq(notation), any<Action<ExternalModuleDependency>>())
        // Because it's a Provider, this isn't called until evaluation
        verify(dependency, never()).exclude(mapOf("module" to "com.google.guava"))
    }

    @Test
    fun `can use a provider convertible for the dependency declaration`() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.evaluator.features

import org.gradle.declarative.dsl.evaluation.InterpretationStepFeature
import org.gradle.internal.declarativedsl.analysis.ResolutionResult


interface ResolutionResultHandler : InterpretationStepFeatureHandler<InterpretationStepFeature.ResolutionResultPostprocessing> {