const _ = unsafe.Offsetof(struct{ x int64 }{}.x)
`
	info := types2.Info{Types: make(map[syntax.Expr]types2.TypeAndValue)}
	conf := types2.Config{
		Importer: defaultImporter(),
		Sizes:    &types2.StdSizes{WordSize: 8, MaxAlign: 8},
	}
	mustTypecheck(src, &conf, &info)
	for _, tv := range info.Types {
		_ = conf.Sizes.Sizeof(tv.Type)
		_ = conf.Sizes.Alignof(tv.Type)
	}
}

// go.dev/issue/53884.

		return x
	}
	return fib(x-1) - fib(x-2)
}`
	// Type-check the package.
	// We create an empty map for each kind of input
	// we're interested in, and Check populates them.
	info := types2.Info{
		Types: make(map[syntax.Expr]types2.TypeAndValue),
		Defs:  make(map[*syntax.Name]types2.Object),
		Uses:  make(map[*syntax.Name]types2.Object),
	}
	pkg := mustTypecheck(input, nil, &info)

	gcimporter "cmd/compile/internal/importer"
	"cmd/compile/internal/types2"
	"io"
)

func defaultImporter() types2.Importer {
	return &gcimports{
		packages: make(map[string]*types2.Package),
	}
}

type gcimports struct {
	packages map[string]*types2.Package
	lookup   func(path string) (io.ReadCloser, error)
}

func (m *gcimports) Import(path string) (*types2.Package, error) {

        types == [Parent, Child] as Set

        def types2 = inspector.getReachableTypes(Child)
        types2 == types
    }

    def "inspects cyclic generic types"() {
        expect:
        def types = inspector.getReachableTypes(GenericChild)
        types == [GenericItem1, GenericItem2, GenericChild] as Set

        def types2 = inspector.getReachableTypes(GenericChild)
        types2.is(types)
    }

	pkg.Scope().Insert(obj)

	// func panicrangestate()
	obj = types2.NewFunc(nopos, pkg, "panicrangestate", types2.NewSignatureType(nil, nil, nil, types2.NewTuple(types2.NewParam(nopos, pkg, "state", intType)), nil, false))
	pkg.Scope().Insert(obj)

	return pkg
}()

		"issue22200.go",  // types2 does not have constraints on stack size
		"issue22200b.go", // types2 does not have constraints on stack size
		"issue25507.go",  // types2 does not have constraints on stack size
		"issue20780.go",  // types2 does not have constraints on stack size
		"issue42058a.go", // types2 does not have constraints on channel element size

	_ = func(i int) int {
		// typecheck reports at column 14 ('+'), but types2 reports at
		// column 10 ('C').
		// TODO(mdempsky): Investigate why, and see if types2 can be
		// updated to match typecheck behavior.
		return C.i + 1 // ERROR HERE: \b(10|14)\b
	}
	_ = func(i int) {
		// typecheck reports at column 7 ('('), but types2 reports at
		// column 8 ('i'). The types2 position is more correct, but

package syntax

import "go/constant"

// A Type represents a type of Go.
// All types implement the Type interface.
// (This type originally lived in types2. We moved it here
// so we could depend on it from other packages without
// introducing an import cycle.)
type Type interface {
	// Underlying returns the underlying type of a type.
	// Underlying types are never Named, TypeParam, or Alias types.
	//

	srcDir = "/src/cmd/compile/internal/types2/"
	dstDir = "/src/go/types/"
)

// TestGenerate verifies that generated files in go/types match their types2
// counterpart. If -write is set, this test actually writes the expected
// content to go/types; otherwise, it just compares with the existing content.
func TestGenerate(t *testing.T) {
	// If filesToWrite is set, write the generated content to disk.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types2

import "cmd/compile/internal/syntax"

// A Type represents a type of Go.
// All types implement the Type interface.