return ModuleRevisionId.newInstance(org, name, branch, revConstraint, extraAttributes, replaceNullBranchWithDefault);
        }
    }

    public static ModuleId createModuleId(String org, String name) {
        synchronized (MODULE_ID_LOCK) {
            return ModuleId.newInstance(org, name);
        }
    }

        return DefaultExcludeAllOf.of(ImmutableSet.copyOf(specs));
    }

    @Override
    public ExcludeSpec ivyPatternExclude(ModuleIdentifier moduleId, IvyArtifactName artifact, String matcher) {
        return DefaultIvyPatternMatcherExcludeRuleSpec.of(moduleId, artifact, matcher);
    }

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {

            return null;
        }

        @Override
        public boolean participatesInReplacements(ModuleIdentifier moduleId) {
            return false;
        }
    };

    @Nullable Replacement getReplacementFor(ModuleIdentifier sourceModule);

    boolean participatesInReplacements(ModuleIdentifier moduleId);

    class Replacement {
        private final ModuleIdentifier target;
        private final String reason;

            Set<ModuleIdentifier> items = ids.getModuleIds().stream().filter(id -> !id.getName().equals(leftModule)).collect(Collectors.toSet());
            if (items.size() == 1) {
                return factory.anyOf(left, factory.moduleId(items.iterator().next()));
            }
            if (items.isEmpty()) {
                return left;
            }
            if (items.size() != ids.getModuleIds().size()) {

            ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) artifact.getId().getComponentIdentifier();
            IdeExtendedRepoFileDependency ideRepoFileDependency = new IdeExtendedRepoFileDependency();
            ideRepoFileDependency.setId(DefaultModuleVersionIdentifier.newId(moduleId.getModuleIdentifier(), moduleId.getVersion()));
            externalDependencies.add(ideRepoFileDependency);

            if (componentId instanceof ModuleComponentIdentifier) {
                ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) componentId;
                resolvedComponentVersions.put(moduleId.getModuleIdentifier(), moduleId.getVersion());
            }

        }, Actions.doNothing(), new HashSet<>());

        return resolvedComponentVersions;
    }

  }
  auto module_out = std::move(module_or_status).value();

  // We cannot replace the module in a ModulePass. So we simply copy the
  // operation list from module_out to module_in.
  auto& module_in_ops = module_in.getBody()->getOperations();
  module_in_ops.clear();
  module_in_ops.splice(module_in_ops.end(),
                       module_out->getBody()->getOperations());
}

        MutableIvyModuleResolveMetadata metadata = parseIvyFile(publication);
        ModuleVersionIdentifier moduleId = metadata.getModuleVersionId();
        organisation.matches(moduleId.getGroup());
        moduleName.matches(moduleId.getName());
        revision.matches(moduleId.getVersion());

        field(publication, "branch", metadata.getBranch())
                .optionalNotEmpty()

        return replacements.get(sourceModule);
    }

    @Override
    public boolean participatesInReplacements(ModuleIdentifier moduleId) {
        return targets.contains(moduleId) || replacements.containsKey(moduleId);
    }

    private static void detectCycles(Map<ModuleIdentifier, Replacement> replacements, ModuleIdentifier source, ModuleIdentifier target) {
        if (source.equals(target)) {

        }

        @Override
        public void onChangingModuleResolve(ModuleComponentIdentifier moduleId, Expiry expiry) {
        }
    };

    /**
     * Called when a dynamic version is selected using the set of candidate versions queried from a repository.
     */