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

package expr3

import "time"

func indexes() {
	_ = 1 /* ERROR "cannot index" */ [0]
	_ = indexes /* ERROR "cannot index" */ [0]
	_ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]

	var a [10]int
	_ = a[true /* ERROR "cannot convert" */ ]
	_ = a["foo" /* ERROR "cannot convert" */ ]
	_ = a[1.1 /* ERROR "truncated" */ ]
	_ = a[1.0]
	_ = a[- /* ERROR "negative" */ 1]
	_ = a[- /* ERROR "negative" */ 1 :]
	_ = a[: - /* ERROR "negative" */ 1]
	_ = a[: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
	_ = a[0: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
	_ = a[0: /* ERROR "2nd index required" */ :10]
	_ = a[:10:10]

	var a0 int
	a0 = a[0]
	_ = a0
	var a1 int32
	a1 = a /* ERROR "cannot use .* in assignment" */ [1]
	_ = a1

	_ = a[9]
	_ = a[10 /* ERROR "index .* out of bounds" */ ]
	_ = a[1 /* ERROR "overflows" */ <<100]
	_ = a[1<< /* ERROR "constant shift overflow" */ 1000] // no out-of-bounds follow-on error
	_ = a[10:]
	_ = a[:10]
	_ = a[10:10]
	_ = a[11 /* ERROR "index .* out of bounds" */ :]
	_ = a[: 11 /* ERROR "index .* out of bounds" */ ]
	_ = a[: 1 /* ERROR "overflows" */ <<100]
	_ = a[:10:10]
	_ = a[:11 /* ERROR "index .* out of bounds" */ :10]
	_ = a[:10:11 /* ERROR "index .* out of bounds" */ ]
	_ = a[10:0 /* ERROR "invalid slice indices" */ :10]
	_ = a[0:10:0 /* ERROR "invalid slice indices" */ ]
	_ = a[10:0 /* ERROR "invalid slice indices" */:0]
	_ = &a /* ERROR "cannot take address" */ [:10]

	pa := &a
	_ = pa[9]
	_ = pa[10 /* ERROR "index .* out of bounds" */ ]
	_ = pa[1 /* ERROR "overflows" */ <<100]
	_ = pa[10:]
	_ = pa[:10]
	_ = pa[10:10]
	_ = pa[11 /* ERROR "index .* out of bounds" */ :]
	_ = pa[: 11 /* ERROR "index .* out of bounds" */ ]
	_ = pa[: 1 /* ERROR "overflows" */ <<100]
	_ = pa[:10:10]
	_ = pa[:11 /* ERROR "index .* out of bounds" */ :10]
	_ = pa[:10:11 /* ERROR "index .* out of bounds" */ ]
	_ = pa[10:0 /* ERROR "invalid slice indices" */ :10]
	_ = pa[0:10:0 /* ERROR "invalid slice indices" */ ]
	_ = pa[10:0 /* ERROR "invalid slice indices" */ :0]
	_ = &pa /* ERROR "cannot take address" */ [:10]

	var b [0]int
	_ = b[0 /* ERROR "index .* out of bounds" */ ]
	_ = b[:]
	_ = b[0:]
	_ = b[:0]
	_ = b[0:0]
	_ = b[0:0:0]
	_ = b[1 /* ERROR "index .* out of bounds" */ :0:0]

	var s []int
	_ = s[- /* ERROR "negative" */ 1]
	_ = s[- /* ERROR "negative" */ 1 :]
	_ = s[: - /* ERROR "negative" */ 1]
	_ = s[0]
	_ = s[1:2]
	_ = s[2:1 /* ERROR "invalid slice indices" */ ]
	_ = s[2:]
	_ = s[: 1 /* ERROR "overflows" */ <<100]
	_ = s[1 /* ERROR "overflows" */ <<100 :]
	_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
	_ = s[: /* ERROR "2nd index required" */ :  /* ERROR "3rd index required" */ ]
	_ = s[:10:10]
	_ = s[10:0 /* ERROR "invalid slice indices" */ :10]
	_ = s[0:10:0 /* ERROR "invalid slice indices" */ ]
	_ = s[10:0 /* ERROR "invalid slice indices" */ :0]
	_ = &s /* ERROR "cannot take address" */ [:10]

	var m map[string]int
	_ = m[0 /* ERROR "cannot use .* in map index" */ ]
	_ = m /* ERROR "cannot slice" */ ["foo" : "bar"]
	_ = m["foo"]
	// ok is of type bool
	type mybool bool
	var ok mybool
	_, ok = m["bar"]
	_ = ok
	_ = m/* ERROR "mismatched types int and untyped string" */[0 /* ERROR "cannot use 0" */ ] + "foo"

	var t string
	_ = t[- /* ERROR "negative" */ 1]
	_ = t[- /* ERROR "negative" */ 1 :]
	_ = t[: - /* ERROR "negative" */ 1]
	_ = t[1:2:3 /* ERROR "3-index slice of string" */ ]
	_ = "foo"[1:2:3 /* ERROR "3-index slice of string" */ ]
	var t0 byte
	t0 = t[0]
	_ = t0
	var t1 rune
	t1 = t /* ERROR "cannot use .* in assignment" */ [2]
	_ = t1
	_ = ("foo" + "bar")[5]
	_ = ("foo" + "bar")[6 /* ERROR "index .* out of bounds" */ ]

	const c = "foo"
	_ = c[- /* ERROR "negative" */ 1]
	_ = c[- /* ERROR "negative" */ 1 :]
	_ = c[: - /* ERROR "negative" */ 1]
	var c0 byte
	c0 = c[0]
	_ = c0
	var c2 float32
	c2 = c /* ERROR "cannot use .* in assignment" */ [2]
	_ = c[3 /* ERROR "index .* out of bounds" */ ]
	_ = ""[0 /* ERROR "index .* out of bounds" */ ]
	_ = c2

	_ = s[1<<30] // no compile-time error here

	// issue 4913
	type mystring string
	var ss string
	var ms mystring
	var i, j int
	ss = "foo"[1:2]
	ss = "foo"[i:j]
	ms = "foo" /* ERROR "cannot use .* in assignment" */ [1:2]
	ms = "foo" /* ERROR "cannot use .* in assignment" */ [i:j]
	_, _ = ss, ms
}

type T struct {
	x int
	y func()
}

func (*T) m() {}

func method_expressions() {
	_ = T.a /* ERROR "no field or method" */
	_ = T.x /* ERROR "has no method" */
	_ = T.m /* ERROR "cannot call pointer method m on T" */
	_ = (*T).m

	var f func(*T) = T.m /* ERROR "cannot call pointer method m on T" */
	var g func(*T) = (*T).m
	_, _ = f, g

	_ = T.y /* ERROR "has no method" */
	_ = (*T).y /* ERROR "has no method" */
}

func struct_literals() {
	type T0 struct {
		a, b, c int
	}

	type T1 struct {
		T0
		a, b int
		u float64
		s string
	}

	// keyed elements
	_ = T1{}
	_ = T1{a: 0, 1 /* ERROR "mixture of .* elements" */ }
	_ = T1{aa /* ERROR "unknown field" */ : 0}
	_ = T1{1 /* ERROR "invalid field name" */ : 0}
	_ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
	_ = T1{a: "foo" /* ERROR "cannot use .* in struct literal" */ }
	_ = T1{c /* ERROR "unknown field" */ : 0}
	_ = T1{T0: { /* ERROR "missing type" */ }} // struct literal element type may not be elided
	_ = T1{T0: T0{}}
	_ = T1{T0 /* ERROR "invalid field name" */ .a: 0}

	// unkeyed elements
	_ = T0{1, 2, 3}
	_ = T0{1, b /* ERROR "mixture" */ : 2, 3}
	_ = T0{1, 2} /* ERROR "too few values" */
	_ = T0{1, 2, 3, 4  /* ERROR "too many values" */ }
	_ = T0{1, "foo" /* ERROR "cannot use .* in struct literal" */, 3.4  /* ERROR "cannot use .*\(truncated\)" */}

	// invalid type
	type P *struct{
		x int
	}
	_ = P /* ERROR "invalid composite literal type" */ {}

	// unexported fields
	_ = time.Time{}
	_ = time.Time{sec /* ERROR "unknown field" */ : 0}
	_ = time.Time{
		0 /* ERROR implicit assignment to unexported field wall in time.Time literal */,
		0 /* ERROR implicit assignment */ ,
		nil /* ERROR implicit assignment */ ,
	}
}

func array_literals() {
	type A0 [0]int
	_ = A0{}
	_ = A0{0 /* ERROR "index .* out of bounds" */}
	_ = A0{0 /* ERROR "index .* out of bounds" */ : 0}

	type A1 [10]int
	_ = A1{}
	_ = A1{0, 1, 2}
	_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /* ERROR "index .* out of bounds" */ }
	_ = A1{- /* ERROR "negative" */ 1: 0}
	_ = A1{8: 8, 9}
	_ = A1{8: 8, 9, 10 /* ERROR "index .* out of bounds" */ }
	_ = A1{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
	_ = A1{5: 5, 6, 7, 3: 3, 4}
	_ = A1{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
	_ = A1{10 /* ERROR "index .* out of bounds" */ : 10, 10 /* ERROR "index .* out of bounds" */ : 10}
	_ = A1{5: 5, 6, 7, 3: 3, 1 /* ERROR "overflows" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
	_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
	_ = A1{2.0}
	_ = A1{2.1 /* ERROR "truncated" */ }
	_ = A1{"foo" /* ERROR "cannot use .* in array or slice literal" */ }

	// indices must be integer constants
	i := 1
	const f = 2.1
	const s = "foo"
	_ = A1{i /* ERROR "index i must be integer constant" */ : 0}
	_ = A1{f /* ERROR "truncated" */ : 0}
	_ = A1{s /* ERROR "cannot convert" */ : 0}

	a0 := [...]int{}
	assert(len(a0) == 0)

	a1 := [...]int{0, 1, 2}
	assert(len(a1) == 3)
	var a13 [3]int
	var a14 [4]int
	a13 = a1
	a14 = a1 /* ERROR "cannot use .* in assignment" */
	_, _ = a13, a14

	a2 := [...]int{- /* ERROR "negative" */ 1: 0}
	_ = a2

	a3 := [...]int{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
	assert(len(a3) == 5) // somewhat arbitrary

	a4 := [...]complex128{0, 1, 2, 1<<10-2: -1i, 1i, 400: 10, 12, 14}
	assert(len(a4) == 1024)

	// composite literal element types may be elided
	type T []int
	_ = [10]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
	a6 := [...]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
	assert(len(a6) == 8)

	// recursively so
	_ = [10][10]T{{}, [10]T{{}}, {{1, 2, 3}}}

	// from the spec
	type Point struct { x, y float32 }
	_ = [...]Point{Point{1.5, -3.5}, Point{0, 0}}
	_ = [...]Point{{1.5, -3.5}, {0, 0}}
	_ = [][]int{[]int{1, 2, 3}, []int{4, 5}}
	_ = [][]int{{1, 2, 3}, {4, 5}}
	_ = [...]*Point{&Point{1.5, -3.5}, &Point{0, 0}}
	_ = [...]*Point{{1.5, -3.5}, {0, 0}}
}

func slice_literals() {
	type S0 []int
	_ = S0{}
	_ = S0{0, 1, 2}
	_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	_ = S0{- /* ERROR "negative" */ 1: 0}
	_ = S0{8: 8, 9}
	_ = S0{8: 8, 9, 10}
	_ = S0{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
	_ = S0{5: 5, 6, 7, 3: 3, 4}
	_ = S0{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
	_ = S0{10: 10, 10 /* ERROR "duplicate index" */ : 10}
	_ = S0{5: 5, 6, 7, 3: 3, 1 /* ERROR "overflows" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
	_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
	_ = S0{2.0}
	_ = S0{2.1 /* ERROR "truncated" */ }
	_ = S0{"foo" /* ERROR "cannot use .* in array or slice literal" */ }

	// indices must be resolved correctly
	const index1 = 1
	_ = S0{index1: 1}
	_ = S0{index2: 2}
	_ = S0{index3 /* ERROR "undeclared name" */ : 3}

	// indices must be integer constants
	i := 1
	const f = 2.1
	const s = "foo"
	_ = S0{i /* ERROR "index i must be integer constant" */ : 0}
	_ = S0{f /* ERROR "truncated" */ : 0}
	_ = S0{s /* ERROR "cannot convert" */ : 0}

	// composite literal element types may be elided
	type T []int
	_ = []T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
	_ = [][]int{{1, 2, 3}, {4, 5}}

	// recursively so
	_ = [][]T{{}, []T{{}}, {{1, 2, 3}}}

	// issue 17954
	type T0 *struct { s string }
	_ = []T0{{}}
	_ = []T0{{"foo"}}

	type T1 *struct{ int }
	_ = []T1{}
	_ = []T1{{0}, {1}, {2}}

	type T2 T1
	_ = []T2{}
	_ = []T2{{0}, {1}, {2}}

	_ = map[T0]T2{}
	_ = map[T0]T2{{}: {}}
}

const index2 int = 2

type N int
func (N) f() {}

func map_literals() {
	type M0 map[string]int
	type M1 map[bool]int
	type M2 map[*int]int

	_ = M0{}
	_ = M0{1 /* ERROR "missing key" */ }
	_ = M0{1 /* ERROR "cannot use .* in map literal" */ : 2}
	_ = M0{"foo": "bar" /* ERROR "cannot use .* in map literal" */ }
	_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }

	_ = map[interface{}]int{2: 1, 2 /* ERROR "duplicate key" */ : 1}
	_ = map[interface{}]int{int(2): 1, int16(2): 1}
	_ = map[interface{}]int{int16(2): 1, int16 /* ERROR "duplicate key" */ (2): 1}

	type S string

	_ = map[interface{}]int{"a": 1, "a" /* ERROR "duplicate key" */ : 1}
	_ = map[interface{}]int{"a": 1, S("a"): 1}
	_ = map[interface{}]int{S("a"): 1, S /* ERROR "duplicate key" */ ("a"): 1}
	_ = map[interface{}]int{1.0: 1, 1.0 /* ERROR "duplicate key" */: 1}
	_ = map[interface{}]int{int64(-1): 1, int64 /* ERROR "duplicate key" */ (-1) : 1}
	_ = map[interface{}]int{^uint64(0): 1, ^ /* ERROR "duplicate key" */ uint64(0): 1}
	_ = map[interface{}]int{complex(1,2): 1, complex /* ERROR "duplicate key" */ (1,2) : 1}

	type I interface {
		f()
	}

	_ = map[I]int{N(0): 1, N(2): 1}
	_ = map[I]int{N(2): 1, N /* ERROR "duplicate key" */ (2): 1}

	// map keys must be resolved correctly
	key1 := "foo"
	_ = M0{key1: 1}
	_ = M0{key2: 2}
	_ = M0{key3 /* ERROR "undeclared name" */ : 2}

	var value int
	_ = M1{true: 1, false: 0}
	_ = M2{nil: 0, &value: 1}

	// composite literal element types may be elided
	type T [2]int
	_ = map[int]T{0: T{3, 4}, 1: {5, 6}}

	// recursively so
	_ = map[int][]T{0: {}, 1: {{}, T{1, 2}}}

	// composite literal key types may be elided
	_ = map[T]int{T{3, 4}: 0, {5, 6}: 1}

	// recursively so
	_ = map[[2]T]int{{}: 0, {{}}: 1, [2]T{{}}: 2, {T{1, 2}}: 3}

	// composite literal element and key types may be elided
	_ = map[T]T{{}: {}, {1, 2}: T{3, 4}, T{4, 5}: {}}
	_ = map[T]M0{{} : {}, T{1, 2}: M0{"foo": 0}, {1, 3}: {"foo": 1}}

	// recursively so
	_ = map[[2]T][]T{{}: {}, {{}}: {{}, T{1, 2}}, [2]T{{}}: nil, {T{1, 2}}: {{}, {}}}

	// from the spec
	type Point struct { x, y float32 }
	_ = map[string]Point{"orig": {0, 0}}
	_ = map[*Point]string{{0, 0}: "orig"}

	// issue 17954
	type T0 *struct{ s string }
	type T1 *struct{ int }
	type T2 T1

	_ = map[T0]T2{}
	_ = map[T0]T2{{}: {}}
}

var key2 string = "bar"

type I interface {
	m()
}

type I2 interface {
	m(int)
}

type T1 struct{}
type T2 struct{}

func (T2) m(int) {}

type mybool bool

func type_asserts() {
	var x int
	_ = x /* ERROR "not an interface" */ .(int)

	var e interface{}
	var ok bool
	x, ok = e.(int)
	_ = ok

	// ok value is of type bool
	var myok mybool
	_, myok = e.(int)
	_ = myok

	var t I
	_ = t /* ERROR "use of .* outside type switch" */ .(type)
	_ = t /* ERROR "m has pointer receiver" */ .(T)
	_ = t.(*T)
	_ = t /* ERROR "missing method m" */ .(T1)
	_ = t /* ERROR "wrong type for method m" */ .(T2)
	_ = t /* STRICT "wrong type for method m" */ .(I2) // only an error in strict mode (issue 8561)

	// e doesn't statically have an m, but may have one dynamically.
	_ = e.(I2)
}

func f0() {}
func f1(x int) {}
func f2(u float32, s string) {}
func fs(s []byte) {}
func fv(x ...int) {}
func fi(x ... interface{}) {}
func (T) fm(x ...int)

func g0() {}
func g1() int { return 0}
func g2() (u float32, s string) { return }
func gs() []byte { return nil }

func _calls() {
	var x int
	var y float32
	var s []int

	f0()
	_ = f0 /* ERROR "used as value" */ ()
	f0(g0 /* ERROR "too many arguments" */ )

	f1(0)
	f1(x)
	f1(10.0)
	f1() /* ERROR "not enough arguments in call to f1\n\thave \(\)\n\twant \(int\)" */
	f1(x, y /* ERROR "too many arguments in call to f1\n\thave \(int, float32\)\n\twant \(int\)" */ )
	f1(s /* ERROR "cannot use .* in argument" */ )
	f1(x ... /* ERROR "cannot use ..." */ )
	f1(g0 /* ERROR "used as value" */ ())
	f1(g1())
	f1(g2 /* ERROR "too many arguments in call to f1\n\thave \(float32, string\)\n\twant \(int\)" */ ())

	f2() /* ERROR "not enough arguments in call to f2\n\thave \(\)\n\twant \(float32, string\)" */
	f2(3.14) /* ERROR "not enough arguments in call to f2\n\thave \(number\)\n\twant \(float32, string\)" */
	f2(3.14, "foo")
	f2(x /* ERROR "cannot use .* in argument" */ , "foo")
	f2(g0 /* ERROR "used as value" */ ())
	f2(g1()) /* ERROR "not enough arguments in call to f2\n\thave \(int\)\n\twant \(float32, string\)" */
	f2(g2())

	fs() /* ERROR "not enough arguments" */
	fs(g0 /* ERROR "used as value" */ ())
	fs(g1 /* ERROR "cannot use .* in argument" */ ())
	fs(g2 /* ERROR "too many arguments" */ ())
	fs(gs())

	fv()
	fv(1, 2.0, x)
	fv(s /* ERROR "cannot use .* in argument" */ )
	fv(s...)
	fv(x /* ERROR "cannot use" */ ...)
	fv(1, s /* ERROR "too many arguments" */ ...)
	fv(gs /* ERROR "cannot use .* in argument" */ ())
	fv(gs /* ERROR "cannot use .* in argument" */ ()...)

	var t T
	t.fm()
	t.fm(1, 2.0, x)
	t.fm(s /* ERROR "cannot use .* in argument" */ )
	t.fm(g1())
	t.fm(1, s /* ERROR "too many arguments" */ ...)
	t.fm(gs /* ERROR "cannot use .* in argument" */ ())
	t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)

	T.fm(t, )
	T.fm(t, 1, 2.0, x)
	T.fm(t, s /* ERROR "cannot use .* in argument" */ )
	T.fm(t, g1())
	T.fm(t, 1, s /* ERROR "too many arguments" */ ...)
	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
	T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)

	var i interface{ fm(x ...int) } = t
	i.fm()
	i.fm(1, 2.0, x)
	i.fm(s /* ERROR "cannot use .* in argument" */ )
	i.fm(g1())
	i.fm(1, s /* ERROR "too many arguments" */ ...)
	i.fm(gs /* ERROR "cannot use .* in argument" */ ())
	i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)

	fi()
	fi(1, 2.0, x, 3.14, "foo")
	fi(g2())
	fi(0, g2)
	fi(0, g2 /* ERROR "2-valued g2" */ ())
}

func issue6344() {
	type T []interface{}
	var x T
	fi(x...) // ... applies also to named slices
}
