}

        when: 'the build and settings files contain errors'
        def settingsWithErrors = evaluator.evaluate("settings.gradle.dcl", file("settings.gradle.dcl").text.replace("id", "unresolvedId"))
        def projectWithErrors = evaluator.evaluate("build.gradle.dcl", file("build.gradle.dcl").text + "\nunresolvedToTestErrorHandling()")

	}
}

// unresolvedName parses:
//
//	<unresolved-name> ::= [gs] <base-unresolved-name>
//	                  ::= sr <unresolved-type> <base-unresolved-name>
//	                  ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
//	                  ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
func (st *state) unresolvedName() AST {

     * from any repository but are present among the set of specified projects will not cause an exception. Instead,
     * those unresolved artifacts will be returned in the result set, allowing the caller to take special care of
     * artifacts that haven't been build yet.
     *

        "language feature" | "@A dependencies { }" | "3:13: unsupported language feature: AnnotationUsage"
        "semantic"         | "x = 1"               | "3:13: unresolved reference 'x'"
    }

    def 'reports illegal order of settings blocks on #order'() {
        given:
        file("settings.gradle.dcl") << content

        when:
        def failure = fails(":projects")

        assert componentResult instanceof $expectedComponentResult.name
"""
    }

    private String createUnresolvedComponentResultVerificationCode() {
        """
        // Check unresolved component result
        UnresolvedComponentResult unresolvedComponentResult = (UnresolvedComponentResult)componentResult
        assert unresolvedComponentResult.failure instanceof ${expectedException.getClass().name}

            }
            ?.value?.let(RuntimeFunctionResolver.Resolution::Resolved)
            ?: RuntimeFunctionResolver.Resolution.Unresolved
    }

    /**
     * Gradle decoration does not generate correct Kotlin metadata for decorated Kotlin types.

        classpath.sourceCollections.size() == 1
        with(classpath.sourceCollections[0]) {
            it instanceof Configuration
            state == Configuration.State.UNRESOLVED
            dependencies.size() == expectedDependencies.size()
            expectedDependencies.each { expectedJar ->
                assert dependencies.any {

    Configuration resolutionStrategy(Action<? super ResolutionStrategy> action);

    /**
     * The states a configuration can be into. A configuration is only mutable as long as it is
     * in the unresolved state.
     */
    enum State { UNRESOLVED, RESOLVED, RESOLVED_WITH_FAILURES }

    /**
     * Returns the state of the configuration.
     *

        }
    }

    // TODO: Dependency locking failures should be attached to the resolution result just like
    // dependency verification failures are. Dependency locking failures are not unresolved dependencies
    // and should not be modeled as one.
    public void addDependencyLockingFailures(long rootId, Set<UnresolvedDependency> extraFailures) {
        DefaultResolvedComponentResult root = components.get(rootId);

	//     52  .  Scope: *ast.Scope {
	//     53  .  .  Objects: map[string]*ast.Object (len = 1) {
	//     54  .  .  .  "main": *(obj @ 11)
	//     55  .  .  }
	//     56  .  }
	//     57  .  Unresolved: []*ast.Ident (len = 1) {
	//     58  .  .  0: *(obj @ 29)
	//     59  .  }
	//     60  .  GoVersion: ""
	//     61  }
}

func ExamplePreorder() {
	src := `
package p

func f(x, y int) {