# Test that pgo properly splits off the Imports field so that list doesn't alias
# the non-pgo variant's slice when it modifies the pgo variant's Imports field to
# add the [.ForMain] suffix.

go list -f 'ImportPath: "{{.ImportPath}}", Imports: "{{.Imports}}", ImportMap: "{{.ImportMap}}"' m/a m/b
cmp stdout want

-- want --
ImportPath: "m/a", Imports: "[m/b [m/a]]", ImportMap: "map[m/b:m/b [m/a]]"
ImportPath: "m/b", Imports: "[m/c]", ImportMap: "map[]"

import spock.lang.Issue

class TaskDependencyInferenceIntegrationTest extends AbstractIntegrationSpec implements TasksWithInputsAndOutputs {
    def "dependency declared using task provider implies dependency on task"() {
        buildFile << """
            // verify that eager and lazy providers work
            def providerA = tasks.register("a")
            tasks.create("b")

        _ * classMetaData.imports >> ['org.gradle.SomeClass']
    }

    def resolvesUnqualifiedNameToImportedPackage() {
        when:
        def name = typeNameResolver.resolve('SomeClass', classMetaData)

        then:
        name == 'org.gradle.SomeClass'
        _ * classMetaData.innerClassNames >> []
        _ * classMetaData.imports >> ['org.gradle.*']

type ptrTest struct {
	name      string   // for reporting
	c         string   // the cgo comment
	c1        string   // cgo comment forced into non-export cgo file
	imports   []string // a list of imports
	support   string   // supporting functions
	body      string   // the body of the main function
	extra     []extra  // extra files
	fail      bool     // whether the test should fail

        given:
        buildFile << """
        ${imports()}
        ${captureAndAssert()}
        """

        expect:
        buildSucceeds()

    }

    def "should capture basic data via when the daemon is running in continuous mode"() {
        given:
        buildFile << """
        ${imports()}
        ${captureAndAssert()}
        """

        expect:

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

# Package org.gradle.kotlin.dsl

The `org.gradle.kotlin.dsl` package contains the Gradle Kotlin DSL public API.

# cannot be resolved.

! go get
stderr '^go: example.com/m imports\n\texample.com/badimport imports\n\texample.net/oops: cannot find module providing package example.net/oops$'
cmp go.mod.orig go.mod

cd importsyntax


# A syntax error in a dependency prevents the compiler from needing that
# dependency's imports, so 'go get' should not report an error when those
# imports cannot be resolved: it has all of the dependencies that the compiler

====

[[script-default-imports]]
== Default imports

To make build scripts more concise, Gradle automatically adds a set of import statements to scripts.

As a result, instead of writing `throw new org.gradle.api.tasks.StopExecutionException()`, you can write `throw new StopExecutionException()` instead.

Gradle implicitly adds the following imports to each script:

.Gradle default imports

// An Importer resolves import paths to Packages. The imports map records
// packages already known, indexed by package path.
// An importer must determine the canonical package path and check imports
// to see if it is already present in the map. If so, the Importer can return
// the map entry. Otherwise, the importer must load the package data for the
// given path into a new *Package, record it in imports map, and return the
// package.