// If v's kind is Pointer, the pointer element type must have kind Array.
// Otherwise v's kind must be Int, Int8, Int16, Int32, Int64,
// Uint, Uint8, Uint16, Uint32, Uint64, Uintptr,
// Array, Chan, Map, Slice, or String.
func (v Value) Seq() iter.Seq[Value] {
	if canRangeFunc(v.typ()) {
		return func(yield func(Value) bool) {
			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {

	// The number of levels in the radix tree.
	summaryLevels = 4

	// Constants for testing.
	pageAlloc32Bit = 1
	pageAlloc64Bit = 0

	// Number of bits needed to represent all indices into the L1 of the
	// chunks map.
	//
	// See (*pageAlloc).chunks for more details. Update the documentation
	// there should this number change.
	pallocChunksL1Bits = 0
)

// See comment in mpagealloc_64bit.go.
var levelBits = [summaryLevels]uint{

	_ = s /* ERROR "< not defined" */ < s
}

func maps() {
	// basics
	var m map[string]int
	_ = m == nil
	_ = m != nil
	_ = m /* ERROR "< not defined" */ < nil

	// maps are not otherwise comparable
	_ = m /* ERROR "map can only be compared to nil" */ == m
	_ = m /* ERROR "< not defined" */ < m
}

func funcs() {
	// basics
	var f func(int) float32

			pass:     pass,
			hasBreak: make(map[ast.Stmt]bool),
			hasGoto:  make(map[string]bool),
			labels:   make(map[string]ast.Stmt),
		}
		d.findLabels(body)
		d.reachable = true
		d.findDead(body)
	})
	return nil, nil
}

type deadState struct {
	pass        *analysis.Pass
	hasBreak    map[ast.Stmt]bool
	hasGoto     map[string]bool
	labels      map[string]ast.Stmt
	breakTarget ast.Stmt

// must not be nil.
//
// If the directory couldn't be read, a nil map and the respective error are
// returned. If a parse error occurred, a non-nil but incomplete map and the
// first error encountered are returned.
func ParseDir(fset *token.FileSet, path string, filter func(fs.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error) {
	list, err := os.ReadDir(path)
	if err != nil {
		return nil, err

package p

func _[T bool](ch chan T) {
	var _, _ T = <-ch
}

// offending code snippets from issue

func _[T ~bool](ch <-chan T) {
	var x, ok T = <-ch
	println(x, ok)
}

func _[T ~bool](m map[int]T) {
	var x, ok T = m[0]
	println(x, ok)

			want: &nssConf{
				sources: map[string][]nssSource{
					"foo": {{source: "a"}, {source: "b"}},
				},
			},
		},
		{
			name: "comment1",
			in:   "   foo:a    b#c\n",
			want: &nssConf{
				sources: map[string][]nssSource{
					"foo": {{source: "a"}, {source: "b"}},
				},
			},
		},
		{
			name: "comment2",
			in:   "   foo:a    b #c \n",
			want: &nssConf{
				sources: map[string][]nssSource{

// "blocked" argument is equal to blocked.
func filterBlocked(blocked string) eventFilterFn {
	return func(e *format.Event, _ *format.Data) bool {
		m, ok := e.Arg.(map[string]any)
		if !ok {
			return false
		}
		return m["blocked"] == blocked
	}
}

// filterStackRootFunc returns an event filter that returns true if the function

package p

type T /* ERROR unexpected newline */

type Map map[int] /* ERROR unexpected newline */

// Examples from go.dev/issue/23434:

func g() {
	m := make(map[string] /* ERROR unexpected ! */ !)
	for {
		x := 1
		print(x)
	}
}

func f() {
	m := make(map[string] /* ERROR unexpected \) */ )
	for {
		x := 1
		print(x)
	}

package test

// passFlagToTest contains the flags that should be forwarded to
// the test binary with the prefix "test.".
var passFlagToTest = map[string]bool {
{{- range .testFlags}}
	"{{.}}": true,
{{- end }}
}

var passAnalyzersToVet = map[string]bool {
{{- range .vetAnalyzers}}
	"{{.}}": true,
{{- end }}
}