runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/dependencyBetweenBinaryLibraries.kt");
  }

  @Test
  @TestMetadata("imports.kt")
  public void testImports() {
    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/imports.kt");
  }

  @Test
  @TestMetadata("internalUsage.kt")
  public void testInternalUsage() {

		f, err := fsys.Open(filepath.Join(dir, info.Name()))
		if err != nil {
			base.Fatal(err)
		}
		defer f.Close()

		content, err := imports.ReadImports(f, false, nil)
		if err == nil && !imports.ShouldBuild(content, imports.AnyTags()) {
			// The file is explicitly tagged "ignore", so it can't affect the build.
			// Leave it out.
			return false
		}
		return true
	}

	var ret []types.Object
	// Search through the imports to see if any of them define name.
	// It's hard to tell in general which package is being tested, so
	// for the purposes of the analysis, allow the object to appear
	// in any of the imports. This guarantees there are no false positives
	// because the example needs to use the object so it must be defined
	// in the package or one if its imports. On the other hand, false

		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")

    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/dependencyBetweenBinaryLibraries.kt");
  }

  @Test
  @TestMetadata("imports.kt")
  public void testImports() {
    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/imports.kt");
  }

  @Test
  @TestMetadata("internalUsage.kt")
  public void testInternalUsage() {

}

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.
     */

package org.gradle.kotlin.dsl.support

import org.gradle.configuration.ImportsReader
import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope


/**
 * Holds the list of imports implicitly added to every Kotlin build script.
 */
@ServiceScope(Scope.Global::class)
class ImplicitImports internal constructor(
    @Transient
    private val importsReader: ImportsReader
) {