private final boolean transitive;
    private final String revConstraint;
    private final Set<DependencyArtifact> artifacts;
    private final Set<ExcludeRule> excludeRules;

    public DefaultIvyDependency(
        String organisation,
        String module,
        String revision,
        String confMapping,
        boolean transitive,
        @Nullable String revConstraint,
        Set<DependencyArtifact> artifacts,

    }

    public static ModuleRevisionId createModuleRevisionId(String org, String name, String branch, String revConstraint, Map<String, String> extraAttributes, boolean replaceNullBranchWithDefault) {
        synchronized (MODULE_ID_LOCK) {
            return ModuleRevisionId.newInstance(org, name, branch, revConstraint, extraAttributes, replaceNullBranchWithDefault);
        }
    }

     * is used in preference to the {@code rev} attribute. When disabled (the default), the {@code rev} attribute is always used.
     */
    boolean isDynamicMode();

    /**
     * Specifies whether dynamic resolve mode should be used for Ivy modules. When enabled, the {@code revConstraint} attribute for each dependency declaration

 */
public interface ConfiguredModuleComponentRepository extends ModuleComponentRepository<ModuleComponentResolveMetadata> {

    /**
     * Should the 'dynamic resolve mode' be used for this (Ivy) repository, where the 'revConstraint'
     * attribute is used for versions instead of the 'rev' attribute.
     */
    boolean isDynamicResolveMode();

    /**

import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;

/**
 * A ModuleComponentRepository that provides the 'dynamic resolve mode' for an Ivy repository, where the 'revConstraint'
 * attribute is used for versions instead of the 'rev' attribute.
 */
class IvyDynamicResolveModuleComponentRepository extends BaseModuleComponentRepository<ModuleComponentGraphResolveState> {

            ResolvedCoordinates coordinates = resolveDependency(dependency);

            String revConstraint = null;
            if (!(dependency instanceof ProjectDependency) &&
                dependency.getVersion() != null &&
                isDynamicVersion(dependency.getVersion())
            ) {
                revConstraint = dependency.getVersion();
            }

            return new DefaultIvyDependency(

    IvyModule withoutExtraChecksums();

    IvyModule withExtraChecksums();

    /**
     * Attributes:
     *  organisation
     *  module
     *  revision
     *  revConstraint
     *  conf
     *  exclusions - list of maps: [[group: ?, module: ?], ...]
     */
    IvyModule dependsOn(Map<String, ?> attributes);

    IvyModule dependsOn(Module target);

            def ivyDependency = new IvyDescriptorDependency(
                    org: dep.@org,
                    module: dep.@name,
                    revision: dep.@rev,
                    revisionConstraint: dep.@revConstraint,
                    confs: [dep.@conf],
                    transitive: dep.@transitive
            )

            dep.exclude.each { exclude ->

            String revConstraint = substitute(attributes.getValue("revConstraint"));

            Map<String, String> extraAttributes = getExtraAttributes(attributes, DEPENDENCY_REGULAR_ATTRIBUTES);

            ModuleRevisionId revId = createModuleRevisionId(org, name, branch, rev, extraAttributes);
            ModuleRevisionId dynamicId;
            if ((revConstraint == null) && (branchConstraint == null)) {

        def classifier = dep.classifier
        def depAttrs = [org: dep.organisation, name: dep.module, rev: dep.revision, conf: conf]
        if (dep.revConstraint) {
            depAttrs.revConstraint = dep.revConstraint
        }
        builder.dependency(depAttrs) {
            if (dep.exclusions) {
                for (exc in dep.exclusions) {
                    def excludeAttrs = [:]