* @return The formatted problem location or an empty string if unknown, never {@code null}.
     */
    public static String formatLocation(ModelProblem problem, String projectId) {
        StringBuilder buffer = new StringBuilder(256);

        if (!problem.getModelId().equals(projectId)) {
            buffer.append(problem.getModelId());
            if (!problem.getSource().isEmpty()) {

     */
    @Nullable
    Failure getFailure();

    /**
     * Returns an exception that can be thrown when this problem should result in an error.
     *
     * <p>Not every problem has a useful exception associated with it.</p>
     */
    @Nullable
    Throwable getException();

    /**
     * Returns the stack trace that can be reported to the user about where the problem occurred.
     *

        for (Problem problem : problems) {
            formatter.node(getProblemString(problem));
            problemsService.getInternalReporter().report(problem);
        }
        formatter.endChildren();
        throw new InvalidUserDataException(formatter.toString());
    }

    public static String getProblemString(Problem problem) {
        ProblemDefinition definition = problem.getDefinition();

    private static Set<String> getUniqueErrors(List<? extends Problem> problems) {
        return problems.stream()
            .filter(problem -> !isWarning(problem))
            .map(TypeValidationProblemRenderer::renderMinimalInformationAbout)
            .collect(toImmutableSet());
    }

    private static boolean isWarning(Problem problem) {
        return problem.getDefinition().getSeverity().equals(Severity.WARNING);
    }

import com.google.gson.Gson
import org.gradle.api.problems.Severity
import org.gradle.api.problems.internal.DefaultProblemReporter
import org.gradle.api.problems.internal.DeprecationData
import org.gradle.api.problems.internal.DeprecationDataSpec
import org.gradle.api.problems.internal.DocLink
import org.gradle.api.problems.internal.GeneralData
import org.gradle.api.problems.internal.GeneralDataSpec

    val problem = PropertyProblem(trace, build(message), documentationSection = documentationSection)
    logPropertyProblem("serialize", problem)
}


fun IsolateContext.logPropertyProblem(action: String, problem: PropertyProblem) {
    logger.debug("configuration-cache > failed to {} {} because {}", action, propertyDescriptionFor(problem.trace), problem.message)
    onProblem(problem)
}

    }

    public String format() {
        StringBuilder errorString = new StringBuilder(String.format("Type %s is not a valid %s:", source.getName(), role));
        if (problems.size() == 1 && errorString.length() + problems.get(0).length() < 80) {
            errorString.append(' ');
            errorString.append(problems.get(0));
        } else {
            for (String problem : problems) {

    public static String renderMinimalInformationAbout(Problem problem) {
        return renderMinimalInformationAbout(problem, true);
    }

    public static String renderMinimalInformationAbout(Problem problem, boolean renderDocLink) {
        return renderMinimalInformationAbout(problem, renderDocLink, true);
    }

    public static String renderMinimalInformationAbout(Problem problem, boolean renderDocLink, boolean renderSolutions) {

            appendLine()
            Ordering.from(consoleComparator()).leastOf(uniqueProblems, maxConsoleProblems).forEach { problem ->
                append("- ")
                append(problem.userCodeLocation.capitalized())
                append(": ")
                appendLine(problem.message)
                problem.documentationSection?.let<String, Unit> {

 * limitations under the License.
 */

package org.gradle.api.problems.internal;

public class DefaultProblemProgressDetails implements ProblemProgressDetails {
    private final Problem problem;

    public DefaultProblemProgressDetails(Problem problem) {
        this.problem = problem;
    }

    public Problem getProblem() {
        return problem;
    }