File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.19.4/src/cmd/compile/internal/types2/testdata/check

opt / golang / 1.19.4 / src / cmd / compile / internal / types2 / testdata / check /

📁 ..
📄 blank.go(203 B)
📄 builtins0.go(23.81 KB)
📄 builtins1.go(5.46 KB)
📄 chans.go(1.66 KB)
📄 compliterals.go(442 B)
📄 const0.go(9.18 KB)
📄 const1.go(8.56 KB)
📄 constdecl.go(3.67 KB)
📄 conversions0.go(1.71 KB)
📄 conversions1.go(5.07 KB)
📄 cycles0.go(2.85 KB)
📄 cycles1.go(781 B)
📄 cycles2.go(1.12 KB)
📄 cycles3.go(675 B)
📄 cycles4.go(2.03 KB)
📄 cycles5.go(2.98 KB)
📄 decls0.go(3.97 KB)
📄 decls1.go(3.6 KB)
📁 decls2
📄 decls3.go(4.24 KB)
📄 decls4.go(3.1 KB)
📄 decls5.go(363 B)
📄 errors.go(2.16 KB)
📄 expr0.go(3.7 KB)
📄 expr1.go(2.61 KB)
📄 expr2.go(4.92 KB)
📄 expr3.go(15.42 KB)
📄 funcinference.go(2.07 KB)
📄 go1_12.go(1.07 KB)
📄 go1_13.go(402 B)
📄 go1_16.go(343 B)
📄 go1_8.go(333 B)
📄 gotos.go(5.77 KB)
📄 importC.go(1.23 KB)
📁 importdecl0
📁 importdecl1
📄 init0.go(1.91 KB)
📄 init1.go(1.46 KB)
📄 init2.go(3.51 KB)
📁 issue25008
📄 issues0.go(11.44 KB)
📄 issues1.go(6.02 KB)
📄 labels.go(3.25 KB)
📄 linalg.go(2.24 KB)
📄 literals.go(2.35 KB)
📄 main0.go(361 B)
📄 main1.go(250 B)
📄 map0.go(2.82 KB)
📄 map1.go(3.4 KB)
📄 methodsets.go(3.44 KB)
📄 shifts.go(12.62 KB)
📄 slices.go(1.51 KB)
📄 stmt0.go(18.68 KB)
📄 stmt1.go(3.31 KB)
📄 typeinference.go(1.38 KB)
📄 typeinst0.go(1.62 KB)
📄 typeinst1.go(5.65 KB)
📄 typeinstcycles.go(384 B)
📄 typeparams.go(15.06 KB)
📄 unions.go(2.15 KB)
📄 vardecl.go(5.47 KB)

Editing: const0.go

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

// constant declarations

package const0

import "unsafe"

// constants declarations must be initialized by constants
var x = 0
const c0 = x /* ERROR "not constant" */

// typed constants must have constant types
const _ interface /* ERROR invalid constant type */ {} = 0

func _ () {
	const _ interface /* ERROR invalid constant type */ {} = 0
	for i := 0; i < 10; i++ {} // don't crash with non-nil iota here
}

// untyped constants
const (
	// boolean values
	ub0 = false
	ub1 = true
	ub2 = 2 < 1
	ub3 = ui1 == uf1
	ub4 = true /* ERROR "mismatched types untyped bool and untyped int" */ == 0

// integer values
	ui0 = 0
	ui1 = 1
	ui2 = 42
	ui3 = 3141592653589793238462643383279502884197169399375105820974944592307816406286
	ui4 = -10

ui5 = ui0 + ui1
	ui6 = ui1 - ui1
	ui7 = ui2 * ui1
	ui8 = ui3 / ui3
	ui9 = ui3 % ui3

ui10 = 1 / 0 /* ERROR "division by zero" */
	ui11 = ui1 / 0 /* ERROR "division by zero" */
	ui12 = ui3 / ui0 /* ERROR "division by zero" */
	ui13 = 1 % 0 /* ERROR "division by zero" */
	ui14 = ui1 % 0 /* ERROR "division by zero" */
	ui15 = ui3 % ui0 /* ERROR "division by zero" */

ui16 = ui2 & ui3
	ui17 = ui2 | ui3
	ui18 = ui2 ^ ui3
	ui19 = 1 /* ERROR "invalid operation" */ % 1.0

// floating point values
	uf0 = 0.
	uf1 = 1.
	uf2 = 4.2e1
	uf3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
	uf4 = 1e-1

uf5 = uf0 + uf1
	uf6 = uf1 - uf1
	uf7 = uf2 * uf1
	uf8 = uf3 / uf3
	uf9 = uf3 /* ERROR "not defined" */ % uf3

uf10 = 1 / 0 /* ERROR "division by zero" */
	uf11 = uf1 / 0 /* ERROR "division by zero" */
	uf12 = uf3 / uf0 /* ERROR "division by zero" */

uf16 = uf2 /* ERROR "not defined" */ & uf3
	uf17 = uf2 /* ERROR "not defined" */ | uf3
	uf18 = uf2 /* ERROR "not defined" */ ^ uf3

// complex values
	uc0 = 0.i
	uc1 = 1.i
	uc2 = 4.2e1i
	uc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
	uc4 = 1e-1i

uc5 = uc0 + uc1
	uc6 = uc1 - uc1
	uc7 = uc2 * uc1
	uc8 = uc3 / uc3
	uc9 = uc3 /* ERROR "not defined" */ % uc3

uc10 = 1 / 0 /* ERROR "division by zero" */
	uc11 = uc1 / 0 /* ERROR "division by zero" */
	uc12 = uc3 / uc0 /* ERROR "division by zero" */

uc16 = uc2 /* ERROR "not defined" */ & uc3
	uc17 = uc2 /* ERROR "not defined" */ | uc3
	uc18 = uc2 /* ERROR "not defined" */ ^ uc3
)

type (
	mybool bool
	myint int
	myfloat float64
	mycomplex complex128
)

// typed constants
const (
	// boolean values
	tb0 bool = false
	tb1 bool = true
	tb2 mybool = 2 < 1
	tb3 mybool = ti1 /* ERROR "mismatched types" */ == tf1

// integer values
	ti0 int8 = ui0
	ti1 int32 = ui1
	ti2 int64 = ui2
	ti3 myint = ui3 /* ERROR "overflows" */
	ti4 myint = ui4

ti5 = ti0 /* ERROR "mismatched types" */ + ti1
	ti6 = ti1 - ti1
	ti7 = ti2 /* ERROR "mismatched types" */ * ti1
	ti8 = ti3 / ti3
	ti9 = ti3 % ti3

ti10 = 1 / 0 /* ERROR "division by zero" */
	ti11 = ti1 / 0 /* ERROR "division by zero" */
	ti12 = ti3 /* ERROR "mismatched types" */ / ti0
	ti13 = 1 % 0 /* ERROR "division by zero" */
	ti14 = ti1 % 0 /* ERROR "division by zero" */
	ti15 = ti3 /* ERROR "mismatched types" */ % ti0

ti16 = ti2 /* ERROR "mismatched types" */ & ti3
	ti17 = ti2 /* ERROR "mismatched types" */ | ti4
	ti18 = ti2 ^ ti5 // no mismatched types error because the type of ti5 is unknown

// floating point values
	tf0 float32 = 0.
	tf1 float32 = 1.
	tf2 float64 = 4.2e1
	tf3 myfloat = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
	tf4 myfloat = 1e-1

tf5 = tf0 + tf1
	tf6 = tf1 - tf1
	tf7 = tf2 /* ERROR "mismatched types" */ * tf1
	tf8 = tf3 / tf3
	tf9 = tf3 /* ERROR "not defined" */ % tf3

tf10 = 1 / 0 /* ERROR "division by zero" */
	tf11 = tf1 / 0 /* ERROR "division by zero" */
	tf12 = tf3 /* ERROR "mismatched types" */ / tf0

tf16 = tf2 /* ERROR "mismatched types" */ & tf3
	tf17 = tf2 /* ERROR "mismatched types" */ | tf3
	tf18 = tf2 /* ERROR "mismatched types" */ ^ tf3

// complex values
	tc0 = 0.i
	tc1 = 1.i
	tc2 = 4.2e1i
	tc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
	tc4 = 1e-1i

tc5 = tc0 + tc1
	tc6 = tc1 - tc1
	tc7 = tc2 * tc1
	tc8 = tc3 / tc3
	tc9 = tc3 /* ERROR "not defined" */ % tc3

tc10 = 1 / 0 /* ERROR "division by zero" */
	tc11 = tc1 / 0 /* ERROR "division by zero" */
	tc12 = tc3 / tc0 /* ERROR "division by zero" */

tc16 = tc2 /* ERROR "not defined" */ & tc3
	tc17 = tc2 /* ERROR "not defined" */ | tc3
	tc18 = tc2 /* ERROR "not defined" */ ^ tc3
)

// initialization cycles
const (
	a /* ERROR "initialization cycle" */ = a
	b /* ERROR "initialization cycle" */ , c /* ERROR "initialization cycle" */, d, e = e, d, c, b // TODO(gri) should only have one cycle error
	f float64 = d
)

// multiple initialization
const (
	a1, a2, a3 = 7, 3.1415926, "foo"
	b1, b2, b3 = b3, b1, 42
	c1, c2, c3  /* ERROR "missing init expr for c3" */ = 1, 2
	d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
	_p0 = assert(a1 == 7)
	_p1 = assert(a2 == 3.1415926)
	_p2 = assert(a3 == "foo")
	_p3 = assert(b1 == 42)
	_p4 = assert(b2 == 42)
	_p5 = assert(b3 == 42)
)

func _() {
	const (
		a1, a2, a3 = 7, 3.1415926, "foo"
		b1, b2, b3 = b3, b1, 42
		c1, c2, c3  /* ERROR "missing init expr for c3" */ = 1, 2
		d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
		_p0 = assert(a1 == 7)
		_p1 = assert(a2 == 3.1415926)
		_p2 = assert(a3 == "foo")
		_p3 = assert(b1 == 42)
		_p4 = assert(b2 == 42)
		_p5 = assert(b3 == 42)
	)
}

// iota
const (
	iota0 = iota
	iota1 = iota
	iota2 = iota*2
	_a0 = assert(iota0 == 0)
	_a1 = assert(iota1 == 1)
	_a2 = assert(iota2 == 4)
	iota6 = iota*3

iota7
	iota8
	_a3 = assert(iota7 == 21)
	_a4 = assert(iota8 == 24)
)

const (
	_b0 = iota
	_b1 = assert(iota + iota2 == 5)
	_b2 = len([iota]int{}) // iota may appear in a type!
	_b3 = assert(_b2 == 2)
	_b4 = len(A{})
)

type A [iota /* ERROR "cannot use iota" */ ]int

// constant expressions with operands across different
// constant declarations must use the right iota values
const (
	_c0 = iota
	_c1
	_c2
	_x = _c2 + _d1 + _e0 // 3
)

const (
	_d0 = iota
	_d1
)

const (
	_e0 = iota
)

var _ = assert(_x == 3)

// special cases
const (
	_n0 = nil /* ERROR "not constant" */
	_n1 = [ /* ERROR "not constant" */ ]int{}
)

// iotas must not be usable in expressions outside constant declarations
type _ [iota /* ERROR "iota outside constant decl" */ ]byte
var _ = iota /* ERROR "iota outside constant decl" */
func _() {
	_ = iota /* ERROR "iota outside constant decl" */
	const _ = iota
	_ = iota /* ERROR "iota outside constant decl" */
}

func _() {
	iota := 123
	const x = iota /* ERROR "is not constant" */
	var y = iota
	_ = y
}

// iotas are usable inside closures in constant declarations (#22345)
const (
	_ = iota
	_ = len([iota]byte{})
	_ = unsafe.Sizeof(iota)
	_ = unsafe.Sizeof(func() { _ = iota })
	_ = unsafe.Sizeof(func() { var _ = iota })
	_ = unsafe.Sizeof(func() { const _ = iota })
	_ = unsafe.Sizeof(func() { type _ [iota]byte })
	_ = unsafe.Sizeof(func() { func() int { return iota }() })
)

// verify inner and outer const declarations have distinct iotas
const (
	zero = iota
	one  = iota
	_    = unsafe.Sizeof(func() {
		var x [iota]int // [2]int
		const (
			Zero = iota
			One
			Two
			_ = unsafe.Sizeof([iota-1]int{} == x) // assert types are equal
			_ = unsafe.Sizeof([Two]int{} == x)    // assert types are equal
		)
		var z [iota]int                           // [2]int
		_ = unsafe.Sizeof([2]int{} == z)          // assert types are equal
	})
	three = iota // the sequence continues
)
var _ [three]int = [3]int{} // assert 'three' has correct value

var (
	_ = iota /* ERROR "iota outside constant decl" */
	_ = unsafe.Sizeof(iota  /* ERROR "iota outside constant decl" */ )
	_ = unsafe.Sizeof(func() { _ = iota /* ERROR "iota outside constant decl" */ })
	_ = unsafe.Sizeof(func() { var _ = iota /* ERROR "iota outside constant decl" */ })
	_ = unsafe.Sizeof(func() { type _ [iota /* ERROR "iota outside constant decl" */ ]byte })
	_ = unsafe.Sizeof(func() { func() int { return iota /* ERROR "iota outside constant decl" */ }() })
)

// constant arithmetic precision and rounding must lead to expected (integer) results
var _ = []int64{
	0.0005 * 1e9,
	0.001 * 1e9,
	0.005 * 1e9,
	0.01 * 1e9,
	0.05 * 1e9,
	0.1 * 1e9,
	0.5 * 1e9,
	1 * 1e9,
	5 * 1e9,
}

const _ = unsafe.Sizeof(func() {
	const _ = 0
	_ = iota

const (
	   zero = iota
	   one
	)
	assert(one == 1)
	assert(iota == 0)
})

// issue #52438
const i1 = iota
const i2 = iota
const i3 = iota

func _() {
	assert(i1 == 0)
	assert(i2 == 0)
	assert(i3 == 0)

const i4 = iota
	const i5 = iota
	const i6 = iota

assert(i4 == 0)
	assert(i5 == 0)
	assert(i6 == 0)
}

// untyped constants must not get arbitrarily large
const prec = 512 // internal maximum precision for integers
const maxInt = (1<<(prec/2) - 1) * (1<<(prec/2) + 1) // == 1<<prec - 1

const _ = maxInt + /* ERROR constant addition overflow */ 1
const _ = -maxInt - /* ERROR constant subtraction overflow */ 1
const _ = maxInt ^ /* ERROR constant bitwise XOR overflow */ -1
const _ = maxInt * /* ERROR constant multiplication overflow */ 2
const _ = maxInt << /* ERROR constant shift overflow */ 2
const _ = 1 << /* ERROR constant shift overflow */ prec

const _ = ^ /* ERROR constant bitwise complement overflow */ maxInt

X7ROOT File Manager

Editing: const0.go

Upload File

Create Folder