1 -> {
            val resolution = overloads.single()
            doProduceAndHandleFunctionResult(resolution, argResolutions.value, functionCall, resolution.receiver)
        }

        else -> {
            errorCollector.collect(ResolutionError(functionCall, ErrorReason.AmbiguousFunctions(overloads)))
            null
        }
    }

    // TODO: check the resolution order with the Kotlin spec
    private

[[sub:terminology_resolution_rule]]
== Resolution rule

A resolution rule influences the behavior of how a <<#sub:terminology_dependency,dependency>> is resolved directly.
Resolution rules are defined as part of the build logic.
For more information, see the section on <<resolution_rules.adoc#resolution_rules,customizing resolution of a dependency directly>>.

[[sub:terminology_transitive_dependency]]

import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactRequest;
import org.eclipse.aether.resolution.ArtifactResolutionException;
import org.eclipse.aether.resolution.VersionRangeRequest;
import org.eclipse.aether.resolution.VersionRangeResolutionException;
import org.eclipse.aether.resolution.VersionRangeResult;

/**

import spock.lang.Issue

/**
 * Common location for resolution tests that are related to user-reported issues.
 *
 * Once these issues are resolved, we should make sure to  move these tests to a
 * file more appropriate for the feature they are testing.
 */
class ResolutionIssuesIntegrationTest extends AbstractIntegrationSpec {

    @NotYetImplemented
    def "resolution hits isConstraint assertion"() {

		DefaultAddress: constants.UnspecifiedIP,
		Ports: model.PortList{&model.Port{
			Name:     "tcp-port",
			Port:     9000,
			Protocol: protocol.TCP,
		}},
		Resolution: model.Passthrough,
		Attributes: model.ServiceAttributes{
			Name:            "headless-svc",
			Namespace:       "testns",
			ServiceRegistry: provider.Kubernetes,
		},
	}

import org.eclipse.aether.repository.WorkspaceReader;
import org.eclipse.aether.resolution.MetadataRequest;
import org.eclipse.aether.resolution.MetadataResult;
import org.eclipse.aether.resolution.VersionRangeRequest;
import org.eclipse.aether.resolution.VersionRangeResolutionException;
import org.eclipse.aether.resolution.VersionRangeResult;
import org.eclipse.aether.spi.synccontext.SyncContextFactory;

                ((ResolutionProvider) failure).getResolutions().forEach(resolution -> {
                    if (!resolution.startsWith(ResolutionFailureHandler.DEFAULT_MESSAGE_PREFIX) && uniqueResolutions.add(resolution)) {
                        formatter.node(resolution);
                    }
                });
            }

            if (alreadyReportedErrors.contains(cause)) {

May be followed by a `because` text.

| By conflict resolution : between versions <version>
| The dependency appeared multiple times, with different version requests.
This resulted in <<dependency_resolution#sec:version-conflict, conflict resolution>> to select the most appropriate version.

| By constraint

    /**
     * An immutable data class that holds information about a single variant which was a candidate for matching during resolution.
     *
     * This includes classifying its attributes into lists of compatible, incompatible, and absent attributes.  Each candidate
     * is assessed within the context of a resolution, but must not reference the assessor

            root(":", ":test:") {
                module("org:first-level:1.0")
                module("org:foo:1.0")
            }
        }
    }

    void "dependency constraint is not included in resolution without a hard dependency"() {
        given:
        def available = featureAvailable()
        repository {
            'org:foo:1.0'()
            'org:first-level:1.0' {
                constraint 'org:foo:1.0'