* 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,

            }
        }
    }

    private static Snippets newSnippets(String body, String imports) {
        return new Snippets() {
            @Override
            String getBody() {
                return body
            }

            @Override
            String getImports() {
                return imports
            }
        }
    }

    static PrintProcessOutput processBuilder() {

        given:
        def snippets = ExternalProcessFixture.processBuilder().groovy.newSnippets(new ExternalProcessFixture(testDirectory))

        buildFile """
            ${snippets.imports}
            ${snippets.body}
        """

        when:
        configurationCacheFails ":help"

        then:
        problems.assertFailureHasProblems(failure) {

        project.projectDependencies[0].classpathAttributes.find { it.name == 'without_test_code' }.value == "true"
    }

    def "project dependency pointing to test fixture project exposes test sources"() {
        setup:
        settingsFile << "include 'a', 'b'"
        file('a/build.gradle') << """
            plugins {
                id 'java-library'
                id 'java-test-fixtures'

accessed in disjoint regions of a function, which reduces stack usage
for Go applications.

<!-- https://go.dev/cl/577935 -->
For 386 and amd64, the compiler will use information from PGO to align certain
hot blocks in loops.  This improves performance an additional 1-1.5% at
a cost of an additional 0.1% text and binary size.  This is currently only implemented
on 386 and amd64 because it has not shown an improvement on other platforms.

		if pkg == nil {
			t.Errorf("for %s importer, type-checking failed to return a package", compiler)
			continue
		}

		imports := pkg.Imports()
		if len(imports) != 1 {
			t.Errorf("for %s importer, got %d imports, want 1", compiler, len(imports))
			continue
		}
		imp := imports[0]
		if imp.Name() != "foo" {
			t.Errorf(`for %s importer, got %q, want "foo"`, compiler, imp.Name())
			continue
		}