}

	// import go/internal/gcimporter which imports go/types partially
	fset := token.NewFileSet()
	imports := make(map[string]*types.Package)
	_, err := Import(fset, imports, "go/internal/gcimporter", ".", nil)
	if err != nil {
		t.Fatal(err)
	}

	// look for go/types package
	var goTypesPkg *types.Package
	for path, pkg := range imports {
		if path == "go/types" {
			goTypesPkg = pkg
			break

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Export guts for testing.
// Since testing imports os and os imports internal/poll,
// the internal/poll tests can not be in package poll.

package poll

var Consume = consume

type XFDMutex struct {
	fdMutex
}

func (mu *XFDMutex) Incref() bool {
	return mu.incref()
}

	Run(stop <-chan struct{})
}

// DelayedFilter exposes an interface for a filter create delayed informers, which start
// once the underlying resource is available. See kclient.NewDelayedInformer.
type DelayedFilter interface {
	HasSynced() bool
	KnownOrCallback(f func(stop <-chan struct{})) bool
}

// WriteAPI exposes a generic API for a client go type for write operations.

			continue
		}
		if bytes.Contains(info.header, buildIgnore) {
			continue
		}
		for _, imp := range info.imports {
			path := imp.path
			if !haveImport[path] {
				haveImport[path] = true
				imports = append(imports, path)
			}
		}
	}
	slices.Sort(imports)
	return imports, nil
}

// depsPolicy returns a map m such that m[p][d] == true when p can import d.

                if (childPackageName != ownPackageName) {
                    imports += imports == '' ? '\n        ' : ''
                    imports += "import ${childPackageName}.Production${childNumber};\n        "
                }
            } else {
                propertyType = "String"
            }

# See the License for the specific language governing permissions and
# limitations under the License.

# This script verifies that all the imports have our preferred alias(es). The
# preferred aliases for imports are listed in `hack/.import-aliases`.
# Usage: `hack/verify-import-aliases.sh`.

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..

linters-settings:
  gci:
    sections:
      - standard # Captures all standard packages if they do not match another section.
      - default # Contains all imports that could not be matched to another section type.
      - prefix(istio.io/) # Groups all imports with the specified Prefix.
  goimports:
    # put imports beginning with prefix after 3rd-party packages;
    # it's a comma-separated list of prefixes
    local-prefixes: istio.io/
issues:

import "" // ERROR "invalid import path (empty string)"
import
var /* ERROR "missing import path" */ _ int
import .; // ERROR "missing import path"
import 'x' // ERROR "import path must be a string"
var _ int
import /* ERROR "imports must appear before other declarations" */ _ "math"

// Don't repeat previous error for each immediately following import ...
import ()
import (.) // ERROR "missing import path"
import (
	"fmt"
	.

# The import graph used in this test looks like:
#
# m --- x
#       |
#       x_test --- y
#
# The module dependency graph of m is initially empty.
# Modules x and y look like:
#
# x.1 (provides package x that imports y, but does not depend on module y)
#
# x.2-pre (no dependencies, but does not provide package x)
#
# y.1 (no dependencies, but provides package y)
#
# y.2 --- x.2-pre (provides package y)
#
#

            Component(providerAccessors, "Accessors", "Collects Project Schema, generates Accessors source and bytecode")
            Component(providerImports, "Implicit Imports", "Includes Gradle's default imports")


            Rel_Neighbor(providerFactory, providerExecution, "Delegates to")
            Rel(providerExecution, providerScriptTemplates, "Uses", "script API for compilation")