// Path is the file path into which the generator will emit the code for this
	// variant.
	Path string

	// Package is the package this code will be emitted into.
	Package string

	// Imports is the imports needed for this package.
	Imports string

	// FuncSuffix is appended to all function names in this variant's code. All
	// suffixes should be unique within a package.
	FuncSuffix string

	imports := make(map[string]*Object)

	// complete file scopes with imports and resolve identifiers
	for _, file := range files {
		// ignore file if it belongs to a different package
		// (error has already been reported)
		if file.Name.Name != pkgName {
			continue
		}

		// build file scope by processing all imports
		importErrors := false

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/imports/importAliases"), Pattern.compile("^(.+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("classAlias.kt")
  public void testClassAlias() {
    runTest("analysis/analysis-api/testData/imports/importAliases/classAlias.kt");
  }

  @Test
  @TestMetadata("classAliasWithCompanionObject.kt")

! stderr 'package nonexist is not in std'
stderr '^go: issue27063 imports\n\tnonexist.example.com: cannot find module providing package nonexist.example.com'
stderr '^go: issue27063 imports\n\tissue27063/other imports\n\tother.example.com/nonexist: cannot find module providing package other.example.com/nonexist'

! go mod vendor
! stderr 'package nonexist is not in std'

        )
    }

    @Test
    fun `collects basic imports`() {
        val imports = listOf(
            importOf("a", "b", "C"),
            importOf("a", "b", "c", "d")
        )
        val analysisContext = testContext()
        val result = defaultCodeResolver().collectImports(imports, analysisContext)

        assertEquals(
            mapOf(

# when they are excluded by build constraints.

# Linux and cgo files should be included when building in that configuration.
env GOOS=linux
env GOARCH=amd64
env CGO_ENABLED=1
go list -f '{{range .GoFiles}}{{.}} {{end}}'
stdout '^cgotag.go empty.go suffix_linux.go tag.go $'
go list -f '{{range .CgoFiles}}{{.}} {{end}}'
stdout '^cgoimport.go $'
go list -f '{{range .Imports}}{{.}} {{end}}'

// If pkg uses cgo and the FakeImportC configuration option
// was enabled, the imports list may contain a fake "C" package.
func (pkg *Package) Imports() []*Package { return pkg.imports }

// SetImports sets the list of explicitly imported packages to list.
// It is the caller's responsibility to make sure list elements are unique.
func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }

func (pkg *Package) String() string {

    String testSuiteName
    String methodName
    String assertion
    String[] imports
    String[] importsTestable

    SwiftXCTestWithDepAndCustomXCTestSuite(
        String projectName,
        String classToTest,
        String assertion,
        String[] imports,
        String[] importsTestable
    ) {
        super(projectName)
        this.testSuiteName = classToTest + "Test"

			pmain.Internal.Imports = append(pmain.Internal.Imports, ptest)
			pmain.Imports = append(pmain.Imports, ptest.ImportPath)
			t.ImportTest = true
		}
		if pxtest != nil {
			pmain.Internal.Imports = append(pmain.Internal.Imports, pxtest)
			pmain.Imports = append(pmain.Imports, pxtest.ImportPath)
			t.ImportXtest = true
		}

		// Sort and dedup pmain.Imports.
		// Only matters for go list -test output.

    builder: KaSymbolByFirBuilder,
) : KaFirBasedScope<FirAbstractSimpleImportingScope>(firScope, builder) {

    private val imports: List<NonStarImport> by cached {
        buildList {
            firScope.simpleImports.values.forEach { imports ->
                imports.forEach { import ->
                    val importedClassId = import.importedName?.let { importedName ->
                        val importedClassId =