import java.util.Set;

public interface WorkDependencyResolver<T> {
    /**
     * Resolves dependencies to a specific type.
     *
     * @return {@code true} if this resolver could resolve the given node, {@code false} otherwise.
     */
    boolean resolve(Task task, Object node, Action<? super T> resolveAction);

    /**
     * Resolves dependencies to {@link Task} objects.
     */

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.plugin.prefix;

/**
 * Resolves a plugin prefix.
 *
 * @since 3.0
 */
public interface PluginPrefixResolver {

    /**
     * Resolves the plugin prefix for the specified request.
     *
     * @param request The request that holds the details about the plugin and the repositories to consult, must not be

        then:
        test(result)

        where:
        logLevel | test
        "warn"   | { ExecutionResult r -> r.assertOutputContains("Some toolchain resolvers had internal failures: failsOnResolve (Ooops!). " +

import org.gradle.integtests.tooling.r33.FetchIdeaProject

@TargetGradleVersion(">=5.0")
class ProjectStateLockingCrossVersionTest extends ToolingApiSpecification {
    def "does not emit deprecation warnings when idea model builder resolves a configuration"() {
        singleProjectBuildInRootFolder("root") {
            buildFile << """
                apply plugin: 'java'
            """
        }

        when:
        withConnection {

        resolver
    }

    private void mockRegistry(JavaToolchainResolver... resolvers) {
        def repositories = IntStream.range(0, resolvers.length)
            .mapToObj { i -> mockRepository("resolver" + i, resolvers[i]) }
            .collect(Collectors.toList())

        registry.requestedRepositories() >> repositories
    }

        module.publish()
    }

    def initBuild(MavenRepository repo) {
        buildFile.text = """
repositories {
    maven { url '$repo.uri' }
}
"""
    }

    def "resolves and caches source artifacts"() {
        fixture.requestingSource()
                .expectSourceArtifact("sources")
                .prepare()

        when:
        module.pom.expectGet()

limitations under the License.
*/

package common

import (
	"github.com/google/cel-go/common/types"
	"github.com/google/cel-go/common/types/ref"
)

// TypeResolver resolves a type by a given name.
type TypeResolver interface {
	// Resolve resolves the type by its name, starting with "Object" as its root.
	// The type that the name refers to must be an object.

     *
     * <p>The collection is live and resolves the files on each query.
     *
     * <p>The collection fails to resolve if it contains providers which are not present.
     */
    FileCollectionInternal resolving(String displayName, Object sources);

    /**
     * Creates a {@link FileCollection} with the given files as content.
     *
     * <p>The collection is live and resolves the files on each query.
     *

    }
}


class CompositeFunctionResolver(private val resolvers: List<RuntimeFunctionResolver>) : RuntimeFunctionResolver {
    override fun resolve(receiverClass: KClass<*>, name: String, parameterValueBinding: ParameterValueBinding): RuntimeFunctionResolver.Resolution {
        resolvers.forEach {
            val resolution = it.resolve(receiverClass, name, parameterValueBinding)

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.project;

/**
 * Resolves the transitive dependencies of a project.
 *
 */
public interface ProjectDependenciesResolver {

    /**
     * Resolves the transitive dependencies of a project.
     *
     * @param request The resolution request holding the parameters, must not be {@code null}.