}

        /*
         * Remembers the unresolved dependency for later logging and also adds a fake
         * file dependency, with the file path pointing to the attempted component selector.
         * This shows up in the IDE as a red flag in the dependencies view. That's not the best
         * usability and it also muddies the API contract, because we disguise an unresolved

    Set<? extends RenderableDependency> getChildren();
    List<Section> getExtraDetails();

    enum ResolutionState {
        FAILED,
        RESOLVED,
        RESOLVED_CONSTRAINT,
        UNRESOLVED
    }

        assert classpath.sourceCollections.size() == 1
        with(classpath.sourceCollections[0]) {
            assert it instanceof Configuration
            assert it.state == Configuration.State.UNRESOLVED
            assert it.dependencies.size() == 3
            assert it.dependencies.any { d ->
                d.group == "org.scala-lang" &&
                    d.name == "scala-compiler" &&

        @Override
        public void visitIdentifier(Expression value) {
            results.unresolved();
        }

        @Override
        public void visitTokens(Expression tokens) {
            results.unresolved();
        }

        @Override
        public void visitUnresolved() {
            results.unresolved();
        }
    }

import static org.gradle.api.internal.artifacts.result.ResolutionResultDataBuilder.newVariant

class DefaultResolutionResultTest extends Specification {

    def "provides all modules and dependencies including unresolved"() {
        given:
        def dep1 = newDependency('dep1')
        def dep2 = newDependency('dep2')

        def root = newModule('root').addDependency(dep1).addDependency(dep2)

                }
                break;
            case RESOLVED_CONSTRAINT:
                output.withStyle(Info).text(" (c)");
                break;
            case UNRESOLVED:
                output.withStyle(Info).text(" (n)");
                break;
        }
    }

# It doesn't make sense to 'go get' a path in the standard library,
# since the standard library necessarily can't have unresolved imports.
#
# TODO(#30241): Maybe that won't always be the case?
#
# For that case, we emit a "malformed module path" error message,
# which isn't ideal either.

    override val fe10Type: ErrorType,
    override val analysisContext: Fe10AnalysisContext
) : KaErrorType, KaFe10Type {
    init {
        check(!fe10Type.kind.isUnresolved) {
            "Expected unresolved ErrorType but ${fe10Type.kind} found for $fe10Type"
        }
    }

    @KaAnalysisNonPublicApi
    override val presentableText: String?
        get() = withValidityAssertion {
            when (fe10Type.kind) {

# https://golang.org/issue/45979: after 'go get' on a package,
# that package should be importable without error.


# We start out with an unresolved dependency.
# 'go list' suggests that we run 'go get' on that dependency.

! go list -deps .
stderr '^m.go:3:8: no required module provides package rsc\.io/quote; to add it:\n\tgo get rsc.io/quote$'


# When we run the suggested 'go get' command, the new dependency can be used
# immediately.
#

			ident.Obj = obj
			return
		}
	}
	// all local scopes are known, so any unresolved identifier
	// must be found either in the file scope, package scope
	// (perhaps in another file), or universe scope --- collect
	// them so that they can be resolved later
	ident.Obj = unresolved
	p.unresolved = append(p.unresolved, ident)
}

// ----------------------------------------------------------------------------