public ArtifactCoordinates getArtifactCoordinates() {
                return artifactCoordinates;
            }

            @Nullable
            @Override
            public List<RemoteRepository> getRepositories() {
                return repositories;
            }

            @Nonnull
            @Override
            public Nature getNature() {
                return nature;
            }

                        "dependencyManagement.dependencies.dependency.",
                        EMPTY,
                        request);
            }

            validateRawRepositories(problems, m.getRepositories(), "repositories.repository.", EMPTY, request);

            validateRawRepositories(
                    problems, m.getPluginRepositories(), "pluginRepositories.pluginRepository.", EMPTY, request);

        LinkedHashMap<String, Repository> remotePluginRepositories = new LinkedHashMap<>();

        // settings/repositories
        for (Repository remoteRepository : settings.getRepositories()) {
            remoteRepositories.put(remoteRepository.getId(), remoteRepository);
        }
        for (Repository pluginRepository : settings.getPluginRepositories()) {

            try {
                remoteRepositories = projectBuildingHelper.createArtifactRepositories(
                        project.getModel().getRepositories(), remoteRepositories, request);
            } catch (Exception e) {
                result.getProblemCollector()
                        .reportProblem(new org.apache.maven.impl.model.DefaultModelProblem(

        List<ArtifactRepository> pomRepositories = new ArrayList<>();
        for (Repository modelRepository : model.getRepositories()) {
            try {
                pomRepositories.add(MavenRepositorySystem.buildArtifactRepository(modelRepository));
            } catch (InvalidRepositoryException e) {
                // cannot use this then

            }

            @Override
            public Version getTargetVersion() {
                return targetVersion;
            }

            @Override
            public List<RemoteRepository> getRepositories() {
                return repositories;
            }

            @Override
            public boolean equals(Object o) {
                return o instanceof DefaultDependencyResolverRequest that

                for (Dependency dependency : modelBase.getDependencies()) {
                    visit(dependency);
                }
                for (Repository repository : modelBase.getRepositories()) {
                    visit(repository);
                }
                for (Repository repository : modelBase.getPluginRepositories()) {
                    visit(repository);
                }

        this.parentArtifact = parentArtifact;
    }

    public Artifact getParentArtifact() {
        return parentArtifact;
    }

    public List<Repository> getRepositories() {
        return getModel().getRepositories();
    }

    // ----------------------------------------------------------------------
    // Plugins
    // ----------------------------------------------------------------------

    }

    protected void mergeModelBase_Repositories(
            ModelBase target, ModelBase source, boolean sourceDominant, Map<Object, Object> context) {
        target.setRepositories(
                merge(target.getRepositories(), source.getRepositories(), sourceDominant, new RepositoryKeyComputer()));
    }

    protected void mergeModelBase_PluginRepositories(

            boolean replaceRepositories) {
        if (modelResolver == null) {
            return;
        }

        problems.setSource(model);

        List<Repository> repositories = model.getRepositories();

        for (Repository repository : repositories) {
            try {
                modelResolver.addRepository(repository, replaceRepositories);
            } catch (InvalidRepositoryException e) {