return details;
    }

    @Override
    public List<Location> getLocations() {
        return locations;
    }

    @Override
    public List<Solution> getSolutions() {
        return solutions;
    }

    @Nullable
    @Override
    public FailureContainer getFailure() {
        return failure;
    }

    @Override
    public AdditionalData getAdditionalData() {

        });
        if (renderSolutions) {
            List<String> allSolutions = new ArrayList<>(problem.getSolutions().size() + problem.getSolutions().size());
            allSolutions.addAll(problem.getSolutions());
            renderSolutions(formatter, allSolutions);
        }
        if (renderDocLink) {

     *
     * @return the locations
     * @since 8.8
     */
    List<Location> getLocations();

    /**
     * Returns the list of solutions.
     *
     * @return the solutions
     * @since 8.8
     */
    List<Solution> getSolutions();

    /**
     * Returns the failure associated with this problem.
     *
     * @return the failure
     * @since 8.8
     */
    @Nullable

		fi, err := fsys.Stat(path)
		return err == nil && fi.IsDir()
	})
}

// ResolveImportPath returns the true meaning of path when it appears in parent.
// There are two different resolutions applied.
// First, there is Go 1.5 vendoring (golang.org/s/go15vendor).
// If vendor expansion doesn't trigger, then the path is also subject to
// Go 1.11 module legacy conversion (golang.org/issue/25069).

        return this;
    }


    @Override
    public InternalProblemBuilder solution(@Nullable String solution) {
        if (this.solutions == null) {
            this.solutions = new ArrayList<String>();
        }
        this.solutions.add(solution);
        return this;
    }

    @Override
    @SuppressWarnings("unchecked")

    }

    private static List<Solution> toSolutions(List<InternalSolution> solutions) {
        List<Solution> result = new ArrayList<>(solutions.size());
        for (InternalSolution solution : solutions) {
            result.add(new DefaultSolution(solution.getSolution()));
        }
        return result;
    }

    @Override
    String getContextualLabel() {
       contextualLabel
    }

    @Override
    String getDetails() {
       details
    }

    @Override
    List<String> getSolutions() {
        solutions
    }

    @Override
    List<ProblemLocation> getLocations() {
        locations
    }

    <T extends ProblemLocation> T getSingleLocation(Class<T> locationType) {

import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundArrayAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundVariableAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaDelegatedConstructorCall
import org.jetbrains.kotlin.analysis.api.resolution.KaErrorCallInfo

import org.gradle.internal.component.resolution.failure.describer.IncompatibleArtifactVariantsFailureDescriber;
import org.gradle.internal.component.resolution.failure.describer.IncompatibleGraphVariantsFailureDescriber;
import org.gradle.internal.component.resolution.failure.describer.IncompatibleRequestedConfigurationFailureDescriber;

/**
 * An internal lazy reference to a graph resolution. Provides access to the inputs and
 * outputs of a graph resolution.
 */
public interface ResolutionAccess {

    /**
     * Get the owner of the resolution.
     */
    ResolutionHost getHost();

    /**
     * Get the request attributes for this resolution. Calling this method will lock-in the