*             but should have been.
 *
 */
@Deprecated
public interface ProjectDependenciesResolver {

    /**
     * Resolves the transitive dependencies of the specified project.
     *
     * @param project         The project whose dependencies should be resolved, must not be {@code null}.

import java.nio.file.Path;

import org.apache.maven.model.Model;
import org.apache.maven.model.building.ModelBuildingRequest;

/**
 * Resolves relative paths of a model against a specific base directory.
 *
 */
public interface ModelPathTranslator {

    /**
     * Resolves the well-known paths of the specified model against the given base directory. Paths within plugin
     * configuration are not processed.
     *

 * under the License.
 */
package org.apache.maven.model.path;

import java.io.File;
import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the

    def patternSetFactory = Mock(Factory)
    def fileCollection = new ProviderBackedFileCollection(provider, resolver, taskDependencyFactory, patternSetFactory, ProviderResolutionStrategy.REQUIRE_PRESENT)

    def "resolves task dependencies for provider with known producer"() {
        def task = Stub(Task)

        when:
        def dependencies = fileCollection.buildDependencies

        then:
        0 * _

        when:

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

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
    }

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.

    }
}


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)