* <p>
     * This order is optimized for both performance and to allow resolvers earlier in the order
     * to mask plugins which would have been found later in the order.
     */
    private void addDefaultResolvers(PluginArtifactRepositories pluginResolveContext, List<PluginResolver> resolvers) {
        resolvers.add(new NoopPluginResolver(pluginRegistry));
        resolvers.add(new CorePluginResolver(documentationRegistry, pluginRegistry));

    }

    private static class ComponentMetaDataResolverChain implements ComponentMetaDataResolver {
        private final List<ComponentMetaDataResolver> resolvers;

        public ComponentMetaDataResolverChain(List<ComponentMetaDataResolver> resolvers) {
            this.resolvers = resolvers;
        }

        @Override

        private static final Lazy<Map<BytecodeInterceptorFilter, ClosureCallInterceptorResolver>> RESOLVERS = Lazy.locking().of(() -> {
            Map<BytecodeInterceptorFilter, ClosureCallInterceptorResolver> resolvers = new EnumMap<>(BytecodeInterceptorFilter.class);
            for (BytecodeInterceptorFilter filter : BytecodeInterceptorFilter.values()) {
                resolvers.put(filter, new ClosureCallInterceptorResolver(filter));
            }

    def visitor = new UnpackingVisitor(context, resolver, TestFiles.taskDependencyFactory(), patternSetFactory)

    def "resolves null"() {
        when:
        visitor.add(null)

        then:
        0 * context._
    }

    def "resolves String"() {
        def file = new File('some-file')

        when:
        visitor.add('path')

        then:

 */
public interface ModuleComponentRepositoryAccess<T> {
    /**
     * Resolves the given dependency to a list of module versions.
     */
    void listModuleVersions(ModuleDependencyMetadata dependency, BuildableModuleVersionListingResolveResult result);

    /**
     * Resolves the metadata for a module component.
     */

 */

package org.gradle.internal.file;

import java.io.File;

/**
 * Resolves some path object to a `File`. May or may not be able to resolve relative paths.
 */
public interface PathToFileResolver {
    /**
     * Resolves the given path to a file.
     */
    File resolve(Object path);

    /**
     * Returns a resolver that resolves paths relative to the given base dir.
     */

import org.apache.maven.api.annotations.Nonnull;

/**
 * Resolves artifact meta/pseudo versions.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface VersionResolver extends Service {

    /**
     * Resolves an artifact's meta version (if any) to a concrete version. For example, resolves "1.0-SNAPSHOT"
     * to "1.0-20090208.132618-23" or "RELEASE"/"LATEST" to "2.0".
     *

import java.util.Collection;

public interface ResolverProviderFactory {
    /**
     * Create any applicable resolvers and add to the given collection.
     */
    void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry);

        if (it.isLowerCase()) it.uppercaseChar() else it
    }
}


class CompositePropertyResolver(private val resolvers: List<RuntimePropertyResolver>) : RuntimePropertyResolver {
    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution {
        resolvers.forEach {
            val resolution = it.resolvePropertyRead(receiverClass, name)
            if (resolution !is UnresolvedRead)

 *             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}.