}

	nimports := 0
	hasGoFiles := false
	for _, f := range list {
		if f.IsDir() {
			n, abort := walkDir(t, filepath.Join(path, f.Name()), endTime)
			nimports += n
			if abort {
				return nimports, true
			}
		} else if strings.HasSuffix(f.Name(), ".go") {
			hasGoFiles = true
		}
	}

	if hasGoFiles {
		doImport(t, path, "")
		nimports++
	}

	return nimports, false
}

Jinseong Jeon <******@****.***> 1701411264 -0800

import java.io.File

fun main() {
    File("foo").writeText("Hello, world!")

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

# This script checks import restrictions. The script looks for a file called
# `.import-restrictions` in each directory, then all imports of the package are
# checked against each "rule" in the file.
# Usage: `hack/verify-import-boss.sh`.

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

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

package a

import (
  _ "a/x/internal/y"
)

-- a/a_test.go --
package a

import (
  _ "a/x/internal/y"
)

-- b/b.go --
// A package with a bad import in test only
package b

-- b/b_test.go --
package b

import (
  _ "a/x/internal/y"
)

-- depends-on-a/depends-on-a.go --
// A package that depends on a package with a bad import
package depends

linters:
  disable-all: true
  enable:
  - goimports
  - gofumpt
  - gci
  fast: false
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:

// MODULE: context

// FILE: context.kt
import java.util.TreeSet

fun test() {
    <caret_context>val x = 0
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
// CODE_FRAGMENT_IMPORT: java.io.File

        when:
        sourceFile << """
    #import "test1"
    #import "test2"
    #import <system1>
    #import <system2>
    #import DEFINED
"""
        then:
        imports == ['"test1"', '"test2"', '<system1>', '<system2>', 'DEFINED'].collect { include(it, true) }

        and:
        noIncludes()
    }

    def "finds mixed import include statement imports"() {

	if runtime.Compiler != "gc" {
		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
	}

	imports := make(map[string]*types.Package)
	fset := token.NewFileSet()
	_, err := Import(fset, imports, "net/http", ".", nil)
	if err != nil {
		t.Fatal(err)
	}

	mutex := imports["sync"].Scope().Lookup("Mutex").(*types.TypeName).Type()
	mset := types.NewMethodSet(types.NewPointer(mutex)) // methods of *sync.Mutex

    - durationcheck
    - gocritic
    - gofumpt
    - goimports
    - gomodguard
    - govet
    - ineffassign
    - misspell
    - revive
    - staticcheck
    - tenv
    - typecheck
    - unconvert
    - unused

issues:
  exclude-use-default: false
  exclude:
    - "empty-block:"
    - "unused-parameter:"
    - "dot-imports:"
    - should have a package comment