1// Copyright 2012 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// statements
6
7package stmt0
8
9func assignments0() (int, int) {
10	var a, b, c int
11	var ch chan int
12	f0 := func() {}
13	f1 := func() int { return 1 }
14	f2 := func() (int, int) { return 1, 2 }
15	f3 := func() (int, int, int) { return 1, 2, 3 }
16
17	a, b, c = 1, 2, 3
18	a, b, c = 1 /* ERROR "assignment mismatch: 3 variables but 2 values" */ , 2
19	a, b, c = 1 /* ERROR "assignment mismatch: 3 variables but 4 values" */ , 2, 3, 4
20	_, _, _ = a, b, c
21
22	a = f0 /* ERROR "used as value" */ ()
23	a = f1()
24	a = f2 /* ERROR "assignment mismatch: 1 variable but f2 returns 2 values" */ ()
25	a, b = f2()
26	a, b, c = f2 /* ERROR "assignment mismatch: 3 variables but f2 returns 2 values" */ ()
27	a, b, c = f3()
28	a, b = f3 /* ERROR "assignment mismatch: 2 variables but f3 returns 3 values" */ ()
29
30	a, b, c = <- /* ERROR "assignment mismatch: 3 variables but 1 value" */ ch
31
32	return /* ERROR "not enough return values\n\thave ()\n\twant (int, int)" */
33	return 1 /* ERROR "not enough return values\n\thave (number)\n\twant (int, int)" */
34	return 1, 2
35	return 1, 2, 3 /* ERROR "too many return values\n\thave (number, number, number)\n\twant (int, int)" */
36}
37
38func assignments1() {
39	b, i, f, c, s := false, 1, 1.0, 1i, "foo"
40	b = i /* ERRORx `cannot use .* in assignment` */
41	i = f /* ERRORx `cannot use .* in assignment` */
42	f = c /* ERRORx `cannot use .* in assignment` */
43	c = s /* ERRORx `cannot use .* in assignment` */
44	s = b /* ERRORx `cannot use .* in assignment` */
45
46	v0, v1, v2 := 1 /* ERROR "assignment mismatch" */ , 2, 3, 4
47	_, _, _ = v0, v1, v2
48
49	b = true
50
51	i += 1
52	i /* ERROR "mismatched types int and untyped string" */+= "foo"
53
54	f -= 1
55	f /= 0
56	f = float32(0)/0 /* ERROR "division by zero" */
57	f /* ERROR "mismatched types float64 and untyped string" */-= "foo"
58
59	c *= 1
60	c /= 0
61
62	s += "bar"
63	s /* ERROR "mismatched types string and untyped int" */+= 1
64
65	var u64 uint64
66	u64 += 1<<u64
67
68	undefined /* ERROR "undefined" */ = 991
69
70	// test cases for issue 5800
71	var (
72		_ int = nil /* ERROR "cannot use nil as int value in variable declaration" */
73		_ [10]int = nil /* ERROR "cannot use nil as [10]int value in variable declaration" */
74		_ []byte = nil
75		_ struct{} = nil /* ERROR "cannot use nil as struct{} value in variable declaration" */
76		_ func() = nil
77		_ map[int]string = nil
78		_ chan int = nil
79	)
80
81	// test cases for issue 5500
82	_ = func() (int, bool) {
83		var m map[int]int
84		return m /* ERROR "not enough return values" */ [0]
85	}
86
87	g := func(int, bool){}
88	var m map[int]int
89	g(m[0]) /* ERROR "not enough arguments" */
90
91	// assignments to _
92	_ = nil /* ERROR "use of untyped nil" */
93	_ = 1  << /* ERROR "constant shift overflow" */ 1000
94	(_) = 0
95}
96
97func assignments2() {
98	type mybool bool
99	var m map[string][]bool
100	var s []bool
101	var b bool
102	var d mybool
103	_ = s
104	_ = b
105	_ = d
106
107	// assignments to map index expressions are ok
108	s, b = m["foo"]
109	_, d = m["bar"]
110	m["foo"] = nil
111	m["foo"] = nil /* ERROR "assignment mismatch: 1 variable but 2 values" */ , false
112	_ = append(m["foo"])
113	_ = append(m["foo"], true)
114
115	var c chan int
116	_, b = <-c
117	_, d = <-c
118	<- /* ERROR "cannot assign" */ c = 0
119	<-c = 0 /* ERROR "assignment mismatch: 1 variable but 2 values" */ , false
120
121	var x interface{}
122	_, b = x.(int)
123	x /* ERROR "cannot assign" */ .(int) = 0
124	x.(int) = 0 /* ERROR "assignment mismatch: 1 variable but 2 values" */ , false
125
126	assignments2 /* ERROR "used as value" */ () = nil
127	int /* ERROR "not an expression" */ = 0
128}
129
130func issue6487() {
131	type S struct{x int}
132	_ = &S /* ERROR "cannot take address" */ {}.x
133	_ = &( /* ERROR "cannot take address" */ S{}.x)
134	_ = (&S{}).x
135	S /* ERROR "cannot assign" */ {}.x = 0
136	(&S{}).x = 0
137
138	type M map[string]S
139	var m M
140	m /* ERROR "cannot assign to struct field" */ ["foo"].x = 0
141	_ = &( /* ERROR "cannot take address" */ m["foo"].x)
142	_ = &m /* ERROR "cannot take address" */ ["foo"].x
143}
144
145func issue6766a() {
146	a, a /* ERROR "a repeated on left side of :=" */ := 1, 2
147	_ = a
148	a, b, b /* ERROR "b repeated on left side of :=" */ := 1, 2, 3
149	_ = b
150	c, c /* ERROR "c repeated on left side of :=" */, b := 1, 2, 3
151	_ = c
152	a, b := /* ERROR "no new variables" */ 1, 2
153}
154
155func shortVarDecls1() {
156	const c = 0
157	type d int
158	a, b, c /* ERROR "cannot assign" */ , d /* ERROR "cannot assign" */  := 1, "zwei", 3.0, 4
159	var _ int = a // a is of type int
160	var _ string = b // b is of type string
161}
162
163func incdecs() {
164	const c = 3.14
165	c /* ERROR "cannot assign" */ ++
166	s := "foo"
167	s /* ERROR "invalid operation" */ --
168	3.14 /* ERROR "cannot assign" */ ++
169	var (
170		x int
171		y float32
172		z complex128
173	)
174	x++
175	y--
176	z++
177}
178
179func sends() {
180	var ch chan int
181	var rch <-chan int
182	var x int
183	x <- /* ERROR "cannot send" */ x
184	rch <- /* ERROR "cannot send" */ x
185	ch <- "foo" /* ERRORx `cannot use .* in send` */
186	ch <- x
187}
188
189func selects() {
190	select {}
191	var (
192		ch chan int
193		sc chan <- bool
194	)
195	select {
196	case <-ch:
197	case (<-ch):
198	case t := <-ch:
199		_ = t
200	case t := (<-ch):
201		_ = t
202	case t, ok := <-ch:
203		_, _ = t, ok
204	case t, ok := (<-ch):
205		_, _ = t, ok
206	case <-sc /* ERROR "cannot receive from send-only channel" */ :
207	}
208	select {
209	default:
210	default /* ERROR "multiple defaults" */ :
211	}
212	select {
213	case a, b := <-ch:
214		_, b = a, b
215	case x /* ERROR "send or receive" */ :
216	case a /* ERROR "send or receive" */ := ch:
217	}
218
219	// test for issue 9570: ch2 in second case falsely resolved to
220	// ch2 declared in body of first case
221	ch1 := make(chan int)
222	ch2 := make(chan int)
223	select {
224	case <-ch1:
225		var ch2 /* ERROR "declared and not used: ch2" */ chan bool
226	case i := <-ch2:
227		print(i + 1)
228	}
229}
230
231func gos() {
232	go 1; /* ERROR "must be function call" */
233	go int /* ERROR "go requires function call, not conversion" */ (0)
234	go ( /* ERROR "expression in go must not be parenthesized" */ gos())
235	go gos()
236	var c chan int
237	go close(c)
238	go len /* ERROR "go discards result" */ (c)
239}
240
241func defers() {
242	defer 1; /* ERROR "must be function call" */
243	defer int /* ERROR "defer requires function call, not conversion" */ (0)
244	defer ( /* ERROR "expression in defer must not be parenthesized" */ defers())
245	defer defers()
246	var c chan int
247	defer close(c)
248	defer len /* ERROR "defer discards result" */ (c)
249}
250
251func breaks() {
252	var x, y int
253
254	break /* ERROR "break" */
255	{
256		break /* ERROR "break" */
257	}
258	if x < y {
259		break /* ERROR "break" */
260	}
261
262	switch x {
263	case 0:
264		break
265	case 1:
266		if x == y {
267			break
268		}
269	default:
270		break
271		break
272	}
273
274	var z interface{}
275	switch z.(type) {
276	case int:
277		break
278	}
279
280	for {
281		break
282	}
283
284	var a []int
285	for _ = range a {
286		break
287	}
288
289	for {
290		if x == y {
291			break
292		}
293	}
294
295	var ch chan int
296	select {
297	case <-ch:
298		break
299	}
300
301	select {
302	case <-ch:
303		if x == y {
304			break
305		}
306	default:
307		break
308	}
309}
310
311func continues() {
312	var x, y int
313
314	continue /* ERROR "continue" */
315	{
316		continue /* ERROR "continue" */
317	}
318
319	if x < y {
320		continue /* ERROR "continue" */
321	}
322
323	switch x {
324	case 0:
325		continue /* ERROR "continue" */
326	}
327
328	var z interface{}
329	switch z.(type) {
330	case int:
331		continue /* ERROR "continue" */
332	}
333
334	var ch chan int
335	select {
336	case <-ch:
337		continue /* ERROR "continue" */
338	}
339
340	for i := 0; i < 10; i++ {
341		continue
342		if x < y {
343			continue
344			break
345		}
346		switch x {
347		case y:
348			continue
349		default:
350			break
351		}
352		select {
353		case <-ch:
354			continue
355		}
356	}
357
358	var a []int
359	for _ = range a {
360		continue
361		if x < y {
362			continue
363			break
364		}
365		switch x {
366		case y:
367			continue
368		default:
369			break
370		}
371		select {
372		case <-ch:
373			continue
374		}
375	}
376}
377
378func returns0() {
379	return
380	return 0 /* ERROR "too many return values" */
381}
382
383func returns1(x float64) (int, *float64) {
384	return 0, &x
385	return /* ERROR "not enough return values" */
386	return "foo" /* ERRORx `cannot .* in return statement` */, x /* ERRORx `cannot use .* in return statement` */
387	return 0, &x, 1 /* ERROR "too many return values" */
388}
389
390func returns2() (a, b int) {
391	return
392	return 1, "foo" /* ERRORx `cannot use .* in return statement` */
393	return 1, 2, 3 /* ERROR "too many return values" */
394	{
395		type a int
396		return 1, 2
397		return /* ERROR "result parameter a not in scope at return" */
398	}
399}
400
401func returns3() (_ int) {
402	return
403	{
404		var _ int // blank (_) identifiers never shadow since they are in no scope
405		return
406	}
407}
408
409func switches0() {
410	var x int
411
412	switch x {
413	}
414
415	switch x {
416	default:
417	default /* ERROR "multiple defaults" */ :
418	}
419
420	switch {
421	case 1  /* ERROR "cannot convert" */ :
422	}
423
424	true := "false"
425	_ = true
426	// A tagless switch is equivalent to the bool
427        // constant true, not the identifier 'true'.
428	switch {
429	case "false" /* ERROR "cannot convert" */:
430	}
431
432	switch int32(x) {
433	case 1, 2:
434	case x /* ERROR "invalid case x in switch on int32(x) (mismatched types int and int32)" */ :
435	}
436
437	switch x {
438	case 1 /* ERROR "overflows" */ << 100:
439	}
440
441	switch x {
442	case 1:
443	case 1 /* ERROR "duplicate case" */ :
444	case ( /* ERROR "duplicate case" */ 1):
445	case 2, 3, 4:
446	case 5, 1 /* ERROR "duplicate case" */ :
447	}
448
449	switch uint64(x) {
450	case 1<<64 - 1:
451	case 1 /* ERROR "duplicate case" */ <<64 - 1:
452	case 2, 3, 4:
453	case 5, 1 /* ERROR "duplicate case" */ <<64 - 1:
454	}
455
456	var y32 float32
457	switch y32 {
458	case 1.1:
459	case 11/10: // integer division!
460	case 11. /* ERROR "duplicate case" */ /10:
461	case 2, 3.0, 4.1:
462	case 5.2, 1.10 /* ERROR "duplicate case" */ :
463	}
464
465	var y64 float64
466	switch y64 {
467	case 1.1:
468	case 11/10: // integer division!
469	case 11. /* ERROR "duplicate case" */ /10:
470	case 2, 3.0, 4.1:
471	case 5.2, 1.10 /* ERROR "duplicate case" */ :
472	}
473
474	var s string
475	switch s {
476	case "foo":
477	case "foo" /* ERROR "duplicate case" */ :
478	case "f" /* ERROR "duplicate case" */ + "oo":
479	case "abc", "def", "ghi":
480	case "jkl", "foo" /* ERROR "duplicate case" */ :
481	}
482
483	type T int
484	type F float64
485	type S string
486	type B bool
487	var i interface{}
488	switch i {
489	case nil:
490	case nil: // no duplicate detection
491	case (*int)(nil):
492	case (*int)(nil): // do duplicate detection
493	case 1:
494	case byte(1):
495	case int /* ERROR "duplicate case" */ (1):
496	case T(1):
497	case 1.0:
498	case F(1.0):
499	case F /* ERROR "duplicate case" */ (1.0):
500	case "hello":
501	case S("hello"):
502	case S /* ERROR "duplicate case" */ ("hello"):
503	case 1==1, B(false):
504	case false, B(2==2):
505	}
506
507	// switch on array
508	var a [3]int
509	switch a {
510	case [3]int{1, 2, 3}:
511	case [3]int{1, 2, 3}: // no duplicate detection
512	case [ /* ERROR "mismatched types" */ 4]int{4, 5, 6}:
513	}
514
515	// switch on channel
516	var c1, c2 chan int
517	switch c1 {
518	case nil:
519	case c1:
520	case c2:
521	case c1, c2: // no duplicate detection
522	}
523}
524
525func switches1() {
526	fallthrough /* ERROR "fallthrough statement out of place" */
527
528	var x int
529	switch x {
530	case 0:
531		fallthrough /* ERROR "fallthrough statement out of place" */
532		break
533	case 1:
534		fallthrough
535	case 2:
536		fallthrough; ; ; // trailing empty statements are ok
537	case 3:
538	default:
539		fallthrough; ;
540	case 4:
541		fallthrough /* ERROR "cannot fallthrough final case in switch" */
542	}
543
544	var y interface{}
545	switch y.(type) {
546	case int:
547		fallthrough /* ERROR "cannot fallthrough in type switch" */ ; ; ;
548	default:
549	}
550
551	switch x {
552	case 0:
553		if x == 0 {
554			fallthrough /* ERROR "fallthrough statement out of place" */
555		}
556	}
557
558	switch x {
559	case 0:
560		goto L1
561		L1: fallthrough; ;
562	case 1:
563		goto L2
564		goto L3
565		goto L4
566		L2: L3: L4: fallthrough
567	default:
568	}
569
570	switch x {
571	case 0:
572		goto L5
573		L5: fallthrough
574	default:
575		goto L6
576		goto L7
577		goto L8
578		L6: L7: L8: fallthrough /* ERROR "cannot fallthrough final case in switch" */
579	}
580
581	switch x {
582	case 0:
583		fallthrough; ;
584	case 1:
585		{
586			fallthrough /* ERROR "fallthrough statement out of place" */
587		}
588	case 2:
589		fallthrough
590	case 3:
591		fallthrough /* ERROR "fallthrough statement out of place" */
592		{ /* empty block is not an empty statement */ }; ;
593	default:
594		fallthrough /* ERROR "cannot fallthrough final case in switch" */
595	}
596
597	switch x {
598	case 0:
599		{
600			fallthrough /* ERROR "fallthrough statement out of place" */
601		}
602	}
603}
604
605func switches2() {
606	// untyped nil is not permitted as switch expression
607	switch nil /* ERROR "use of untyped nil" */ {
608	case 1, 2, "foo": // don't report additional errors here
609	}
610
611	// untyped constants are converted to default types
612	switch 1<<63-1 {
613	}
614	switch 1 /* ERRORx `cannot use .* as int value.*\(overflows\)` */ << 63 {
615	}
616	var x int
617	switch 1.0 {
618	case 1.0, 2.0, x /* ERROR "mismatched types int and float64" */ :
619	}
620	switch x {
621	case 1.0:
622	}
623
624	// untyped bools become of type bool
625	type B bool
626	var b B = true
627	switch x == x {
628	case b /* ERROR "mismatched types B and bool" */ :
629	}
630	switch {
631	case b /* ERROR "mismatched types B and bool" */ :
632	}
633}
634
635func issue11667() {
636	switch 9223372036854775808 /* ERRORx `cannot use .* as int value.*\(overflows\)` */ {
637	}
638	switch 9223372036854775808 /* ERRORx `cannot use .* as int value.*\(overflows\)` */ {
639	case 9223372036854775808:
640	}
641	var x int
642	switch x {
643	case 9223372036854775808 /* ERROR "overflows int" */ :
644	}
645	var y float64
646	switch y {
647	case 9223372036854775808:
648	}
649}
650
651func issue11687() {
652	f := func() (_, _ int) { return }
653	switch f /* ERROR "multiple-value f" */ () {
654	}
655	var x int
656	switch f /* ERROR "multiple-value f" */ () {
657	case x:
658	}
659	switch x {
660	case f /* ERROR "multiple-value f" */ ():
661	}
662}
663
664type I interface {
665	m()
666}
667
668type I2 interface {
669	m(int)
670}
671
672type T struct{}
673type T1 struct{}
674type T2 struct{}
675
676func (T) m() {}
677func (T2) m(int) {}
678
679func typeswitches() {
680	var i int
681	var x interface{}
682
683	switch x.(type) {}
684	switch (x /* ERROR "outside type switch" */ .(type)) {}
685
686	switch x.(type) {
687	default:
688	default /* ERROR "multiple defaults" */ :
689	}
690
691	switch x /* ERROR "declared and not used" */ := x.(type) {}
692	switch _ /* ERROR "no new variable on left side of :=" */ := x.(type) {}
693
694	switch x := x.(type) {
695	case int:
696		var y int = x
697		_ = y
698	}
699
700	switch x /* ERROR "x declared and not used" */ := i /* ERROR "not an interface" */ .(type) {}
701
702	switch t := x.(type) {
703	case nil:
704		var v bool = t /* ERRORx `cannot use .* in variable declaration` */
705		_ = v
706	case int:
707		var v int = t
708		_ = v
709	case float32, complex64:
710		var v float32 = t /* ERRORx `cannot use .* in variable declaration` */
711		_ = v
712	default:
713		var v float32 = t /* ERRORx `cannot use .* in variable declaration` */
714		_ = v
715	}
716
717	var t I
718	switch t.(type) {
719	case T:
720	case T1 /* ERROR "missing method m" */ :
721	case T2 /* ERROR "wrong type for method m" */ :
722	case I2 /* STRICT "wrong type for method m" */ : // only an error in strict mode (issue 8561)
723	}
724
725
726	{
727		x := 1
728		v := 2
729		switch v /* ERROR "v (variable of type int) is not an interface" */ .(type) {
730		case int:
731			println(x)
732			println(x / 0 /* ERROR "invalid operation: division by zero" */)
733		case 1 /* ERROR "1 is not a type" */:
734		}
735	}
736}
737
738// Test that each case clause uses the correct type of the variable
739// declared by the type switch (issue 5504).
740func typeswitch0() {
741	switch y := interface{}(nil).(type) {
742	case int:
743		func() int { return y + 0 }()
744	case float32:
745		func() float32 { return y }()
746	}
747}
748
749// Test correct scope setup.
750// (no redeclaration errors expected in the type switch)
751func typeswitch1() {
752	var t I
753	switch t := t; t := t.(type) {
754	case nil:
755		var _ I = t
756	case T:
757		var _ T = t
758	default:
759		var _ I = t
760	}
761}
762
763// Test correct typeswitch against interface types.
764type A interface { a() }
765type B interface { b() }
766type C interface { a(int) }
767
768func typeswitch2() {
769	switch A(nil).(type) {
770	case A:
771	case B:
772	case C /* STRICT "cannot have dynamic type" */: // only an error in strict mode (issue 8561)
773	}
774}
775
776func typeswitch3(x interface{}) {
777	switch x.(type) {
778	case int:
779	case float64:
780	case int /* ERROR "duplicate case" */ :
781	}
782
783	switch x.(type) {
784	case nil:
785	case int:
786	case nil /* ERROR "duplicate case" */ , nil /* ERROR "duplicate case" */ :
787	}
788
789	type F func(int)
790	switch x.(type) {
791	case nil:
792	case int, func(int):
793	case float32, func /* ERROR "duplicate case" */ (x int):
794	case F:
795	}
796}
797
798func fors1() {
799	for {}
800	var i string
801	_ = i
802	for i := 0; i < 10; i++ {}
803	for i := 0; i < 10; j /* ERROR "cannot declare" */ := 0 {}
804}
805
806func rangeloops1() {
807	var (
808		a [10]float32
809		b []string
810		p *[10]complex128
811		pp **[10]complex128
812		s string
813		m map[int]bool
814		c chan int
815		sc chan<- int
816		rc <-chan int
817		xs struct{}
818	)
819
820	for range xs /* ERROR "cannot range over" */ {}
821	for _ = range xs /* ERROR "cannot range over" */ {}
822	for i := range xs /* ERROR "cannot range over" */ { _ = i }
823
824	for range a {}
825	for i := range a {
826		var ii int
827		ii = i
828		_ = ii
829	}
830	for i, x := range a {
831		var ii int
832		ii = i
833		_ = ii
834		var xx float64
835		xx = x /* ERRORx `cannot use .* in assignment` */
836		_ = xx
837	}
838	var ii int
839	var xx float32
840	for ii, xx = range a {}
841	_, _ = ii, xx
842
843	for range b {}
844	for i := range b {
845		var ii int
846		ii = i
847		_ = ii
848	}
849	for i, x := range b {
850		var ii int
851		ii = i
852		_ = ii
853		var xx string
854		xx = x
855		_ = xx
856	}
857
858	for range s {}
859	for i := range s {
860		var ii int
861		ii = i
862		_ = ii
863	}
864	for i, x := range s {
865		var ii int
866		ii = i
867		_ = ii
868		var xx rune
869		xx = x
870		_ = xx
871	}
872
873	for range p {}
874	for _, x := range p {
875		var xx complex128
876		xx = x
877		_ = xx
878	}
879
880	for range pp /* ERROR "cannot range over" */ {}
881	for _, x := range pp /* ERROR "cannot range over" */ {}
882
883	for range m {}
884	for k := range m {
885		var kk int32
886		kk = k /* ERRORx `cannot use .* in assignment` */
887		_ = kk
888	}
889	for k, v := range m {
890		var kk int
891		kk = k
892		_ = kk
893		if v {}
894	}
895
896	for range c {}
897	for _, _ /* ERROR "only one iteration variable" */ = range c {}
898	for e := range c {
899		var ee int
900		ee = e
901		_ = ee
902	}
903	for _ = range sc /* ERROR "cannot range over" */ {}
904	for _ = range rc {}
905
906	// constant strings
907	const cs = "foo"
908	for range cs {}
909	for range "" {}
910	for i, x := range cs { _, _ = i, x }
911	for i, x := range "" {
912		var ii int
913		ii = i
914		_ = ii
915		var xx rune
916		xx = x
917		_ = xx
918	}
919}
920
921func rangeloops2() {
922	type I int
923	type R rune
924
925	var a [10]int
926	var i I
927	_ = i
928	for i /* ERRORx `cannot use .* in assignment` */ = range a {}
929	for i /* ERRORx `cannot use .* in assignment` */ = range &a {}
930	for i /* ERRORx `cannot use .* in assignment` */ = range a[:] {}
931
932	var s string
933	var r R
934	_ = r
935	for i /* ERRORx `cannot use .* in assignment` */ = range s {}
936	for i /* ERRORx `cannot use .* in assignment` */ = range "foo" {}
937	for _, r /* ERRORx `cannot use .* in assignment` */ = range s {}
938	for _, r /* ERRORx `cannot use .* in assignment` */ = range "foo" {}
939}
940
941func issue6766b() {
942	for _ := /* ERROR "no new variables" */ range "" {}
943	for a, a /* ERROR "redeclared" */ := range "" { _ = a }
944	var a int
945	_ = a
946	for a, a /* ERROR "redeclared" */ := range []int{1, 2, 3} { _ = a }
947}
948
949// Test that despite errors in the range clause,
950// the loop body is still type-checked (and thus
951// errors reported).
952func issue10148() {
953	for y /* ERROR "declared and not used" */ := range "" {
954		_ = "" /* ERROR "mismatched types untyped string and untyped int" */ + 1
955	}
956	for range 1.5 /* ERROR "cannot range over 1.5 (untyped float constant)" */ {
957		_ = "" /* ERROR "mismatched types untyped string and untyped int" */ + 1
958	}
959	for y := range 1.5 /* ERROR "cannot range over 1.5 (untyped float constant)" */ {
960		_ = "" /* ERROR "mismatched types untyped string and untyped int" */ + 1
961	}
962}
963
964func labels0() {
965	goto L0
966	goto L1
967	L0:
968	L1:
969	L1 /* ERROR "already declared" */ :
970	if true {
971		goto L2
972		L2:
973		L0 /* ERROR "already declared" */ :
974	}
975	_ = func() {
976		goto L0
977		goto L1
978		goto L2
979		L0:
980		L1:
981		L2:
982	}
983}
984
985func expression_statements(ch chan int) {
986	expression_statements(ch)
987	<-ch
988	println()
989
990	0 /* ERROR "not used" */
991	1 /* ERROR "not used" */ +2
992	cap /* ERROR "not used" */ (ch)
993	println /* ERROR "must be called" */
994}
995