}
        }

        if (hasErrors(problems)) {
            throw new SettingsBuilderException("Error building settings", problems);
        }

        return new DefaultSettingsBuilderResult(effective, problems);
    }

    private boolean hasErrors(List<BuilderProblem> problems) {
        if (problems != null) {

        // When
        Result<ProjectDependencyGraph> result = graphBuilder.build(session);

        // Then
        if (parameterExpectedResult instanceof SelectedProjectsResult) {
            assertThat(result.hasErrors())
                    .withFailMessage("Expected result not to have errors")
                    .isFalse();
            List<String> expectedProjectNames = ((SelectedProjectsResult) parameterExpectedResult).projectNames;

        }

        eventCatapult.fire(ExecutionEvent.Type.ProjectDiscoveryStarted, session, null);

        Result<? extends ProjectDependencyGraph> graphResult = buildGraph(session);

        if (graphResult.hasErrors()) {
            return addExceptionToResult(
                    result, graphResult.getProblems().iterator().next().getException());
        }

        try {

            severities.add(problem.getSeverity());
        }
    }

    public boolean hasFatalErrors() {
        return severities.contains(ModelProblem.Severity.FATAL);
    }

    public boolean hasErrors() {
        return severities.contains(ModelProblem.Severity.ERROR) || severities.contains(ModelProblem.Severity.FATAL);
    }

    @Override
    public List<ModelProblem> getProblems() {
        return problems;

            severities.add(problem.getSeverity());
        }
    }

    public boolean hasFatalErrors() {
        return severities.contains(ModelProblem.Severity.FATAL);
    }

    public boolean hasErrors() {
        return severities.contains(ModelProblem.Severity.ERROR) || severities.contains(ModelProblem.Severity.FATAL);
    }

    @Override
    public List<ModelProblem> getProblems() {
        return problems;

    private val pathTranslation: (String) -> String,
) : MessageCollector {

    val errors = arrayListOf<ScriptCompilationError>()

    override fun hasErrors() = errors.isNotEmpty()

    override fun clear() = errors.clear()

    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {

        fun msg() =

        return definingCategory
            .severity(ERROR);
    }

    private void assertNoParseErrors(TomlParseResult result) {
        if (result.hasErrors()) {
            List<TomlParseError> errors = result.errors();
            reportErrors(errors);

            TreeFormatter formatter = new TreeFormatter();
            formatter.node(INVALID_TOML_CATALOG_DEFINITION);

                && (version == null || message.contains(version));
    }

    protected boolean hasModelErrors(ModelProblemCollector problems) {
        return problems.hasErrors();
    }

    protected boolean hasFatalErrors(ModelProblemCollector problems) {
        return problems.hasFatalErrors();
    }

    ModelProcessor getModelProcessor() {

    }

    protected boolean hasModelErrors(ModelProblemCollectorExt problems) {
        if (problems instanceof DefaultModelProblemCollector) {
            return ((DefaultModelProblemCollector) problems).hasErrors();
        } else {
            // the default execution path only knows the DefaultModelProblemCollector,
            // only reason it's not in signature is because it's package private

            hasError = false;
        } else {
            hasError = true;
            errors.forEach(this.errors::add);
        }
    }

    public int getNumberOfSuggestDocs() {
        return numberOfSuggestDocs;
    }

    public int getNumberOfInputDocs() {
        return numberOfInputDocs;
    }

    public boolean hasError() {
        return hasError;
    }