-- go.mod --
module m

go 1.16
-- pkg1/a.go --
package pkg1

import "fmt"

func F() {
	fmt.Println("pkg1")
}
-- pkg2/a.go --
package pkg2

import "fmt"

func F() {
	fmt.Println("pkg2")
}
-- pkg2/a_test.go --
package pkg2
-- pkg3/a.go --
package pkg3

import "fmt"

func F() {
	fmt.Println("pkg3")
}
-- pkg3/a_test.go --

// Copyright 2015 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.

// Package comment.
package pkg

import "io"

// Constants

// Comment about exported constant.
const ExportedConstant = 1

// Comment about internal constant.
const internalConstant = 2

// Comment about block of constants.
const (
	// Comment before ConstOne.

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

# This script verifies whether codes follow golang convention.
# Usage: `hack/verify-pkg-names.sh`.

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

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
source "${KUBE_ROOT}/hack/lib/init.sh"

cd "${KUBE_ROOT}"

go test -c -o $devnull ./...

rm pkg1.test$GOEXE
rm pkg2.test$GOEXE
go test -o . ./pkg/...
exists -exec pkg1.test$GOEXE
exists -exec pkg2.test$GOEXE

-- go.mod --
module example

-- pkg/pkg1/pkg1_test.go --
package pkg1

-- pkg/pkg2/pkg2_test.go --
package pkg2

-- anotherpkg/pkg1/pkg1_test.go --

func TestInstantiateNonEquality(t *testing.T) {
	const src = "package p; type T[P any] int"
	pkg1 := mustTypecheck(src, nil, nil)
	pkg2 := mustTypecheck(src, nil, nil)
	// We consider T1 and T2 to be distinct types, so their instances should not
	// be deduplicated by the context.
	T1 := pkg1.Scope().Lookup("T").Type().(*Named)
	T2 := pkg2.Scope().Lookup("T").Type().(*Named)
	ctxt := NewContext()

func TestInstantiateNonEquality(t *testing.T) {
	const src = "package p; type T[P any] int"
	pkg1 := mustTypecheck(src, nil, nil)
	pkg2 := mustTypecheck(src, nil, nil)
	// We consider T1 and T2 to be distinct types, so their instances should not
	// be deduplicated by the context.
	T1 := pkg1.Scope().Lookup("T").Type().(*Named)
	T2 := pkg2.Scope().Lookup("T").Type().(*Named)
	ctxt := NewContext()

// license that can be found in the LICENSE file.

package main

import (
	"./pkg1"
	"./pkg2"
)

func main() {
	if pkg1.T != pkg2.T {
		panic("pkg1.T != pkg2.T")
	}
	if pkg1.U != pkg2.U {
		panic("pkg1.U != pkg2.U")
	}
	if pkg1.V != pkg2.V {
		panic("pkg1.V != pkg2.V")
	}
	if pkg1.W != pkg2.W {
		panic("pkg1.W != pkg2.W")
	}

module exmod

-- cmd/c1/main.go --
package main

func main() {}

-- cmd/c2/main.go --
package main

func main() {}

-- pkg1/pkg1.go --
package pkg1

-- pkg2/pkg2.go --
package pkg2

-- exec.go --
package main

func main() {}

-- c1$GOEXE/keep.txt --

	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args)
	w := 0
	for _, pkg := range pkgs {
		if pkg.Error != nil {
			base.Errorf("%v", pkg.Error)
			continue
		}
		pkgs[w] = pkg
		w++
	}
	pkgs = pkgs[:w]

	printed := false
	for _, pkg := range pkgs {
		if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
			if !printed {

}

func TestInverse(t *testing.T) {
	pkgs, err := loadPkgs("./testdata/inverse/...")
	if err != nil {
		t.Fatalf("unexpected failure: %v", err)
	}
	if len(pkgs) != 10 {
		t.Fatalf("expected 10 pkg results, got %d", len(pkgs))
	}

	boss := newBoss(pkgs)

	var errs []error
	for _, pkg := range pkgs {
		errs = append(errs, boss.Verify(pkg)...)
	}

	expect := []string{