import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.result.BuildableComponentResolveResult;

/**
 * A component metadata resolver which should be used first in chain of resolvers as it will make sure
 * that we never "find" a virtual component, by shortcutting resolution if we find the marker interface
 * for virtual components.
 */

        'project.javaexec'        | 'runWithJavaExec'
        'ExecOperations.javaexec' | 'runWithExecOperations'
        // The test does not work with the JavaExec task because the task resolves the executable prior to starting the process.
        // At the same time, all the cases test the same functionality of the ExecHandle implementation.
        // 'JavaExec task'           | 'run'
    }

 * Additional fields in this interface are not required to reconstitute the serialized graph.
 */
public interface DependencyGraphComponent extends ResolvedGraphComponent {
    /**
     * Returns the meta-data for the component. Resolves if not already resolved.
     *
     * @return null if the meta-data is not available due to some failure.
     */
    @Nullable
    ComponentGraphResolveMetadata getMetadataOrNull();

 * Responsible for resolving a {@link ComponentIdentifier} to a {@link org.gradle.internal.component.model.ComponentGraphResolveState} instance for that component.
 */
public interface ComponentMetaDataResolver {
    /**
     * Resolves the resolution state for a component instance. Failures should be attached to the returned result.
     */

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 {

 */

package org.gradle.internal.resolve.resolver;

import org.gradle.api.internal.artifacts.ResolveContext;
import org.gradle.internal.resolve.result.BuildableComponentResolveResult;

/**
 * Resolves a context to the meta-data for the provided {@link ResolveContext}.
 */
public interface ResolveContextToComponentResolver {
    void resolve(ResolveContext resolveContext, BuildableComponentResolveResult result);

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository.legacy.resolver.conflict;

/**
 * A factory that produces conflict resolvers of various types.
 *
 * @see ConflictResolver
 * @since 3.0
 */
@Deprecated
public interface ConflictResolverFactory {
    // constants --------------------------------------------------------------

     */
    PotentialConflict registerCandidate(CANDIDATE candidate);

    /**
     * Informs whether there is any conflict at present
     */
    boolean hasConflicts();

    /**
     * Resolves next conflict and trigger provided action after the resolution
     */
    void resolveNextConflict(Action<RESULT> resolutionAction);

    /**
     * Indicates if the identifier is a known participant in a conflict

import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertIs


object AssignmentResolverTest {
    @Test
    fun `resolves transitive property`() {
        assignmentTrace(
            schema.resolve(
                """
                val myD = newD("shared")
                val c1 = c(1)
                c1.d = myD

import spock.lang.Issue

class ToolingApiIdeaLocalGroovyCrossVersionSpec extends ToolingApiSpecification {

    @Issue("https://github.com/gradle/gradle/issues/12274")
    @TargetGradleVersion(">=3.4")
    def "resolves localGroovy() as IdeaSingleEntryLibraryDependency for IdeaProject via tooling API"() {
        given: