// into their respective scopes. It also performs imports and associates
// methods with receiver base type names.
func (check *Checker) collectObjects() {
	pkg := check.pkg

	// pkgImports is the set of packages already imported by any package file seen
	// so far. Used to avoid duplicate entries in pkg.imports. Allocate and populate
	// it (pkg.imports may not be empty if we are checking test files incrementally).

// into their respective scopes. It also performs imports and associates
// methods with receiver base type names.
func (check *Checker) collectObjects() {
	pkg := check.pkg

	// pkgImports is the set of packages already imported by any package file seen
	// so far. Used to avoid duplicate entries in pkg.imports. Allocate and populate
	// it (pkg.imports may not be empty if we are checking test files incrementally).

env GO111MODULE=off

# go list -find should not report imports

go list -f {{.Incomplete}} x/y/z...  # should probably exit non-zero but never has
stdout true
go list -find -f '{{.Incomplete}} {{.Imports}}' x/y/z...
stdout '^false \[\]'

# go list -find -compiled should use cached sources the second time it's run.
# It might not find the same cached sources as "go build", but the sources

public class ProjectHierarchyUtils {
    /**
     * Gets the collection of the direct child projects from {@code thisProject}.
     * This method is safe to use in the Gradle internal code, as it does not impose the contracts
     * specific to the project public API.
     *
     * @param thisProject the project to get the children from. Expected to be {@link ProjectInternal}.
     * @return the collection of the child projects

		to   string
	}

	adj := make(map[edge]bool)
	imports := make(map[string]struct{})
	for from, tos := range in {
		for _, to := range tos {
			adj[edge{from, to}] = true
			imports[to] = struct{}{}
		}
	}

	// Warshal's algorithm
	for k := range in {
		for i := range in {
			if !adj[edge{i, k}] {
				continue
			}
			for j := range imports {
				if adj[edge{i, j}] {
					continue
				}

import (
	"cmd/internal/goobj"
	"cmd/internal/src"
)

// AddImport adds a package to the list of imported packages.
func (ctxt *Link) AddImport(pkg string, fingerprint goobj.FingerprintType) {
	ctxt.Imports = append(ctxt.Imports, goobj.ImportedPkg{Pkg: pkg, Fingerprint: fingerprint})
}

// getFileIndexAndLine returns the relative file index (local to the CU), and
// the relative line number for a position (i.e., as adjusted by a //line

[!compiler:gc] skip

# 'go list' should report imports from _test.go in the TestImports field.
go list -f '{{.TestImports}}'
stdout net/http # from .TestImports

# 'go list' should report standard-vendored packages by path.
go list -f '{{.Dir}}' vendor/golang.org/x/net/http2/hpack
stdout $GOROOT[/\\]src[/\\]vendor

# 'go list -test' should report vendored transitive dependencies of _test.go

# does not privilege roots above other dependencies).
#
# However, the overall build list is identical for both versions.

cp go.mod go.mod.orig

! go mod tidy

private
val isTopLevelPluginManagementBlock = isTopLevelElement.implies(isPluginManagementCall)


private
val ignoreTopLevelPluginsPluginManagementAndConventions = isTopLevelElement.implies(
    isPluginManagementCall.not()
        .and(isTopLevelPluginsBlock.not())
        .and(isConventionsConfiguringCall.not())

 * <p>
 * For example, the implementation of such an API might add validations checking third-party
 * plugins or build scripts for compliance with some limitations imposed by Gradle. In the internal
 * code, one does not expect such limitations.
 * <p>
 * This annotations should only be applied to Gradle public API declarations.
 *
 * @see AllowUsingApiForExternalUse
 */