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

// statements

package stmt0

func _() {
	b, i, f, c, s := false, 1, 1.0, 1i, "foo"
	b = i /* ERROR "cannot assign" */
	i = f /* ERROR "cannot assign" */
	f = c /* ERROR "cannot assign" */
	c = s /* ERROR "cannot assign" */
	s = b /* ERROR "cannot assign" */

	v0 /* ERROR "mismatch" */, v1, v2 := 1, 2, 3, 4

	b = true

	i += 1
	i += "foo" /* ERROR "cannot convert.*int" */

	f -= 1
	f -= "foo" /* ERROR "cannot convert.*float64" */

	c *= 1
	c /= 0 /* ERROR "division by zero" */

	s += "bar"
	s += 1 /* ERROR "cannot convert.*string" */

	var u64 uint64
	u64 += 1<<u64

	undeclared /* ERROR "undeclared" */ = 991
}

func incdecs() {
	const c = 3.14
	c /* ERROR "cannot assign" */ ++
	s := "foo"
	s /* ERROR "cannot convert" */ --
	3.14 /* ERROR "cannot assign" */ ++
	var (
		x int
		y float32
		z complex128
	)
	x++
	y--
	z++
}

func sends() {
	var ch chan int
	var rch <-chan int
	var x int
	x /* ERROR "cannot send" */ <- x
	rch /* ERROR "cannot send" */ <- x
	ch <- "foo" /* ERROR "cannot convert" */
	ch <- x
}

func selects() {
	select {}
	var (
		ch chan int
		sc chan <- bool
		x int
	)
	select {
	case <-ch:
		ch <- x
	case t, ok := <-ch:
		x = t
	case <-sc /* ERROR "cannot receive from send-only channel" */ :
	}
	select {
	default:
	default /* ERROR "multiple defaults" */ :
	}
}

func gos() {
	go 1 /* ERROR "expected function/method call" */
	go gos()
	var c chan int
	go close(c)
	go len(c) // TODO(gri) this should not be legal
}

func defers() {
	defer 1 /* ERROR "expected function/method call" */
	defer defers()
	var c chan int
	defer close(c)
	defer len(c) // TODO(gri) this should not be legal
}

func switches() {
	var x int

	switch x {
	default:
	default /* ERROR "multiple defaults" */ :
	}

	switch {
	case 1  /* ERROR "cannot convert" */ :
	}

	switch int32(x) {
	case 1, 2:
	case x /* ERROR "cannot compare" */ :
	}

	switch x {
	case 1 /* ERROR "overflows" */ << 100:
	}

	switch x {
	case 1:
	case 1 /* ERROR "duplicate case" */ :
	case 2, 3, 4:
	case 1 /* ERROR "duplicate case" */ :
	}

	// TODO(gri) duplicate 64bit values that don't fit into an int64 are not yet detected
	switch uint64(x) {
	case 1<<64-1:
	case 1<<64-1:
	}
}

type I interface {
	m()
}

type I2 interface {
	m(int)
}

type T struct{}
type T1 struct{}
type T2 struct{}

func (T) m() {}
func (T2) m(int) {}

func typeswitches() {
	var i int
	var x interface{}

	switch x.(type) {}
	switch (x /* ERROR "outside type switch" */ .(type)) {}

	switch x.(type) {
	default:
	default /* ERROR "multiple defaults" */ :
	}

	switch x := x.(type) {}

	switch x := x.(type) {
	case int:
		var y int = x
	}

	switch x := i /* ERROR "not an interface" */ .(type) {}

	switch t := x.(type) {
	case nil:
		var v bool = t /* ERROR "cannot initialize" */
	case int:
		var v int = t
	case float32, complex64:
		var v float32 = t /* ERROR "cannot initialize" */
	default:
		var v float32 = t /* ERROR "cannot initialize" */
	}

	var t I
	switch t.(type) {
	case T:
	case T1 /* ERROR "missing method m" */ :
	case T2 /* ERROR "wrong type for method m" */ :
	case I2 /* ERROR "wrong type for method m" */ :
	}
}

func typeswitch0() {
	switch y := interface{}(nil).(type) {
	case int:
		// TODO(gri) y has the wrong type here (type-checking
		// of captured variable is delayed)
		// func() int { return y + 0 }()
	}
}

func rangeloops() {
	var (
		x int
		a [10]float32
		b []string
		p *[10]complex128
		pp **[10]complex128
		s string
		m map[int]bool
		c chan int
		sc chan<- int
		rc <-chan int
	)

	for _ = range x /* ERROR "cannot range over" */ {}
	for i := range x /* ERROR "cannot range over" */ {}

	for i := range a {
		var ii int
		ii = i
	}
	for i, x := range a {
		var ii int
		ii = i
		var xx float64
		xx = x /* ERROR "cannot assign" */
	}
	var ii int
	var xx float32
	for ii, xx := range a {}

	for i := range b {
		var ii int
		ii = i
	}
	for i, x := range b {
		var ii int
		ii = i
		var xx string
		xx = x
	}

	for i := range s {
		var ii int
		ii = i
	}
	for i, x := range s {
		var ii int
		ii = i
		var xx rune
		xx = x
	}

	for _, x := range p {
		var xx complex128
		xx = x
	}

	for _, x := range pp /* ERROR "cannot range over" */ {}

	for k := range m {
		var kk int32
		kk = k /* ERROR "cannot assign" */
	}
	for k, v := range m {
		var kk int
		kk = k
		if v {}
	}

	for _, _ /* ERROR "only one iteration variable" */ = range c {}
	for e := range c {
		var ee int
		ee = e
	}
	for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
	for _ = range rc {}

	// constant strings
	const cs = "foo"
	for i, x := range cs {}
	for i, x := range "" {
		var ii int
		ii = i
		var xx rune
		xx = x
	}
}