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

package main

const c1 = iota
const c2 = iota

const c3 = 0 + iota<<8
const c4 = 1 + iota<<8

func main() {
	if c1 != 0 {
		panic(c1)
	}
	if c2 != 0 {
		panic(c2)
	}

	if c3 != 0 {
		panic(c3)
	}
	if c4 != 1 {
		panic(c4)
	}

	const c5 = iota
	const c6 = iota

	if c5 != 0 {
		panic(c5)
	}
	if c6 != 0 {
		panic(c6)
	}

const (
	zero os.FileMode = 0
	M1
	M2
	M3
)

// Package constants.
const (
	_ int = iota
	I1
	I2
)

// Unexported constants counting from blank iota.
// See issue 9615.
const (
	_   = iota
	one = iota + 1
)

// Blanks not in doc output:

// S has a padding field.
type S struct {
	H uint32
	_ uint8
	A uint8
}

func _() {}

// Copyright 2009 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 main

const X = iota

func f(x int) { }

func main() {
	f(X);
	f(iota);	// ERROR "iota"
	f(X);

			rune +
			string +
			true +
			uint +
			uint8 +
			uint16 +
			uint32 +
			uint64 +
			uintptr +
			iota
	if n != NUM*(NUM-1)/2 {
		fmt.Println("BUG: wrong n", n, NUM*(NUM-1)/2)
		runtime.Breakpoint() // panic is inaccessible
	}
}

const (
	// cannot use iota here, because iota = 38 below
	append     = 1
	bool       = 2
	byte       = 3
	complex    = 4
	complex64  = 5
	complex128 = 6

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

// Tests correct reporting of line numbers for errors involving iota,
// Issue #8183.
package foo

const (
	ok = byte(iota + 253)
	bad
	barn
	bard // ERROR "constant 256 overflows byte|integer constant overflow|cannot convert"
)

const (
	c = len([1 - iota]int{})
	d
	e // ERROR "array bound must be non-negative|negative array bound|invalid array length"

	len := int(2)
	println(len(slice)) // ERROR "cannot call non-function len .type int., declared at LINE-1|expected function|cannot call non-function len"
	const iota = 1
	println(iota(slice)) // ERROR "cannot call non-function iota .type int., declared at LINE-1|expected function|cannot call non-function iota"

const (
	assignBlank codeAssign = iota
	assignDef
	assignExpr
)

// A codeDecl distinguishes among declaration encodings.
type codeDecl int

func (c codeDecl) Marker() pkgbits.SyncMarker { return pkgbits.SyncDecl }
func (c codeDecl) Value() int                 { return int(c) }

const (
	declEnd codeDecl = iota
	declFunc
	declMethod
	declVar
	declOther

package syscall

const (
	AF_UNSPEC = iota
	AF_UNIX
	AF_INET
	AF_INET6
)

const (
	SOCK_STREAM = 1 + iota
	SOCK_DGRAM
	SOCK_RAW
	SOCK_SEQPACKET
)

const (
	IPPROTO_IP   = 0
	IPPROTO_IPV4 = 4
	IPPROTO_IPV6 = 0x29
	IPPROTO_TCP  = 6
	IPPROTO_UDP  = 0x11
)

const (
	SOMAXCONN = 0x80
)

const (
	_ = iota
	IPV6_V6ONLY
	SO_ERROR
)

package issue16153

// original test case
const (
	x1 uint8 = 255
	Y1       = 256
)

// variations
const (
	x2 uint8 = 255
	Y2
)

const (
	X3 int64 = iota
	Y3       = 1
)

const (
	X4 int64 = iota
	Y4

namespace mlir {
namespace odml {
// The following 5 different forms of mhlo::iota will be matched:
// 1. IotaOp.
// 2. IotaOp + BroadCastInDim.
// 3. IotaOp + Reshape.
// 4. Constant (folded Iota) + BroadCastInDim.
// 5. Constant (folded result).
// Moreover, the dimensions has to match the iota_dimension.
bool MatchIota(DenseIntElementsAttr dimensions, Value iota);
}  // namespace odml
}  // namespace mlir