import org.gradle.internal.service.scopes.ServiceScope;

import java.util.Collection;

@ServiceScope(Scope.Build.class)
public interface PluginResolverContributor {
    void collectResolversInto(Collection<PluginResolver> resolvers);

agentsRuntimeClasspath.description = "Resolves to all Jars that need to be added as agents"
val gradleScriptPath by startScriptResolver(":gradle-cli-main")
gradleScriptPath.description = "Resolves to the Gradle start scripts (bin/*) - automatically adds dependency to the :launcher project"
val sourcesPath by sourcesResolver(listOf(coreRuntimeOnly, pluginsRuntimeOnly))

 * changed or deleted without prior notice.
 *
 * @since 3.0
 */
public interface PluginDependenciesResolver {

    /**
     * Resolves the main artifact of the specified plugin.
     *
     * @param plugin The plugin for which to resolve the main artifact, must not be {@code null}.

	// resource instance is suitable. The language is as defined in
	// https://kubernetes.io/docs/reference/using-api/cel/
	//
	// In addition, for each type NamedResourcesin AttributeValue there is a map that
	// resolves to the corresponding value of the instance under evaluation.
	// For example:
	//
	//    attributes.quantity["a"].isGreaterThan(quantity("0")) &&
	//    attributes.stringslice["b"].isSorted()
	Selector string
}

                        new File("$userHomeDir/caches/$it").deleteDir()
                    }
                }
            }
        }
    }

    def "resolves dependencies from external repository"() {
        startServer()

        given:
        runner.tasksToRun = ['resolveDependencies']

        e.message == "Cannot locate tasks that match ':pr:task' as project 'pr' is ambiguous in <root project>. Candidates are: 'proj', 'proj1', 'proj2', 'proj3'."
    }

    def "lazily resolves an exclude name to tasks in the target build"() {
        when:
        def filter = selector.resolveExcludedTaskName(target, "task")

        then:
        filter.build == target

        and:

                .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +
                    "Some toolchain resolvers had provisioning failures: custom (Unable to download toolchain matching the requirements " +
                    "({languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific}) from '$archiveUri', " +

*/

package unstructured

import (
	"strings"

	"k8s.io/apiserver/pkg/cel/mutation/common"
)

const object = common.RootTypeReferenceName

type TypeResolver struct {
}

// Resolve resolves the TypeRef for the given type name
// that starts with "Object".
// This is the unstructured version, which means the
// returned TypeRef does not refer to the schema.

            this.workingDirResolver = workingDirResolver;
        }

        @Override
        public void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry) {
            if (vcsResolver.hasRules()) {
                resolvers.add(new VcsDependencyResolver(
                    localComponentRegistry, vcsResolver, versionControlSystemFactory,

package org.gradle.execution.plan;

import org.gradle.api.Action;
import org.gradle.api.Task;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Resolves dependencies to {@link TaskNode} objects. Uses the same logic as {@link #TASK_AS_TASK}.
 */
@ServiceScope(Scope.Build.class)
public class TaskNodeDependencyResolver implements DependencyResolver {