/**
 * Holds the resolution state for an external component.
 */
public interface ExternalComponentGraphResolveState extends ComponentGraphResolveState {

    /**
     * @deprecated Try to avoid using this. This method exposes legacy stateful metadata. Usages should be
     * replaced by using the stateful types like {@link ComponentGraphResolveState} and
     * {@link org.gradle.internal.component.model.ComponentArtifactResolveState}.
     */

		if len(check.pkgPathMap[pkg.name]) > 1 {
			return strconv.Quote(pkg.path)
		}
		return pkg.name
	}
	return ""
}

// markImports recursively walks pkg and its imports, to record unique import
// paths in pkgPathMap.
func (check *Checker) markImports(pkg *Package) {
	if check.seenPkgMap[pkg] {
		return
	}
	check.seenPkgMap[pkg] = true

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package importdecl0

import ()

import (
	// we can have multiple blank imports (was bug)
	_ "math"
	_ "net/rpc"
	init /* ERROR "cannot import package as init" */ "fmt"
	// reflect defines a type "flag" which shows up in the gc export data
	"reflect"
	. /* ERROR "imported and not used" */ "reflect"

// SortImports sorts runs of consecutive import lines in import blocks in f.
// It also removes duplicate imports when it is possible to do so without data loss.
func SortImports(fset *token.FileSet, f *File) {
	for _, d := range f.Decls {
		d, ok := d.(*GenDecl)
		if !ok || d.Tok != token.IMPORT {
			// Not an import declaration, so we're done.
			// Imports are always first.
			break
		}

		if !d.Lparen.IsValid() {

        given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        testDirectory.file(file) << """
            ${snippets.imports}
            ${snippets.body}
        """

        when:
        configurationCacheFails(":help")

        then:
        failure.assertOutputContains("Hello")

 * excessive class loading on startup.
 *
 * The [KaCachedService] annotation itself is currently not enforced by any checkers or inspections, but it serves as an anchor for
 * documentation and improves discoverability of cached services.
 */
@Target(allowedTargets = [AnnotationTarget.PROPERTY, AnnotationTarget.FIELD])

                    .contextualLabel("is registered as a software type plugin, but it exposes multiple software types")
                    .severity(Severity.ERROR)

}

public typealias KtImportOptimizer = KaImportOptimizer

public interface KaImportOptimizerMixIn : KaSessionMixIn {

    /**
     * Takes [file] and inspects its imports and their usages,
     * so they can be optimized based on the resulting [KaImportOptimizerResult].
     *
     * Does **not** change the file.
     */

        lookupNamedValueInScopes(propertyAccess, onLocalValue, onProperty)

        if (propertyAccess.name in imports) {
            schema.externalObjectsByFqName[imports[propertyAccess.name]]?.let { external ->
                onExternal(ObjectOrigin.External(external, propertyAccess))
            }
        }
    }

    private

 * graph being resolved.
 *
 * <p>Resolution happens in multiple steps. The first step is to calculate the dependency graph, which involves selecting component instances and one or more variants of each instance.
 * This type exposes only the information and operations required to do this. In particular, it does not expose any information about artifacts unless this is actually required for graph resolution,