if isNumeric(x.typ) && isNumeric(typ) {
			// numeric conversion : error msg
			//
			// integer -> integer : overflows
			// integer -> float   : overflows (actually not possible)
			// float   -> integer : truncated
			// float   -> float   : overflows
			//
			if !isInteger(x.typ) && isInteger(typ) {
				return nil, TruncatedFloat
			} else {
				return nil, NumericOverflow
			}
		}

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

package main

func main() {
	var i int = 100
	i = i << -3 // ERROR "overflows|negative"
}

/*
ixedbugs/bug016.go:7: overflow converting constant to <uint32>UINT32
fixedbugs/bug016.go:7: illegal types for operand: AS
	(<int32>INT32)

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

package math

/*
	Hypot -- sqrt(p*p + q*q), but overflows only if the result does.
*/

// Hypot returns [Sqrt](p*p + q*q), taking care to avoid
// unnecessary overflow and underflow.
//
// Special cases are:
//
//	Hypot(±Inf, q) = +Inf
//	Hypot(p, ±Inf) = +Inf
//	Hypot(NaN, q) = NaN
//	Hypot(p, NaN) = NaN

	z = z >> y
}

type myuint uint

func _(x, y uint, z myuint) {
	x = x + 1
	x = x + - /* ERROR "overflows uint" */ 1
	x = x + 1.0
	x = x + 1.1 // ERROR "truncated to uint"
	x = x + y
	x = x - y
	x = x * y
	x = x / y
	x = x % y
	x = x << y
	x = x >> y

	z = z + 1
	z = x + - /* ERROR "overflows uint" */ 1
	z = z + 1.0
	z = z + 1.1 // ERROR "truncated to uint"
	z = z /* ERROR "mismatched types" */ + y

// var f [e]int  // ok with Go 1.17 because an error was reported for e; leads to an error for Go 1.18
var f [ee]int      // ERROR "undefined|undeclared"
var g [1 << 65]int // ERROR "array bound is too large|overflows|invalid array length"
var h [len(a)]int  // ok

func ff() string

	_ = make(T, -1)    // ERROR "negative"
	_ = make(T, 0.5)   // ERROR "constant 0.5 truncated to integer|non-integer len argument|truncated to int"
	_ = make(T, 1.0)   // ok
	_ = make(T, 1<<63) // ERROR "len argument too large|overflows int"
	_ = make(T, 0, -1) // ERROR "negative cap|must not be negative"
	_ = make(T, 10, 0) // ERROR "len larger than cap|length and capacity swapped"

package main

func f(a int64) int64 {
	const b int64 = 0;
	n := a &^ b;
	return n;
}

func main() {
	f(1)
}

/*
bug156.go:7: constant 18446744073709551615 overflows int64

		if xe < -1<<12 || 1<<12 < xe {
			// catch xe before it overflows the left shift below
			// Since i !=0 it has at least one bit still set, so ae will accumulate xe
			// on at least one more iteration, ae += xe is a lower bound on ae
			// the lower bound on ae exceeds the size of a float64 exp
			// so the final call to Ldexp will produce under/overflow (0/Inf)
			ae += xe
			break
		}
		if i&1 == 1 {
			a1 *= x1

func (e *encoder) Int(n int) {
	if n < 0 || int(int32(n)) != n {
		base.Fatalf("go: attempting to write an int to the index that overflows int32")
	}
	e.Uint32(uint32(n))
}

func (e *encoder) IntAt(n int, at int) {
	if n < 0 || int(int32(n)) != n {
		base.Fatalf("go: attempting to write an int to the index that overflows int32")
	}
	binary.LittleEndian.PutUint32(e.b[at:], uint32(n))

// integer")

package issue11371

const a int = 1.1        // ERROR "constant 1.1 truncated to integer|floating-point constant truncated to integer|truncated to int|truncated"
const b int = 1e20       // ERROR "overflows int|integer constant overflow|truncated to int|truncated"
const c int = 1 + 1e-70  // ERROR "constant truncated to integer|truncated to int|truncated"
const d int = 1 - 1e-70  // ERROR "constant truncated to integer|truncated to int|truncated"