1// Copyright 2014 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
5package issues
6
7import "fmt"
8
9func issue7035() {
10	type T struct{ X int }
11	_ = func() {
12		fmt.Println() // must refer to imported fmt rather than the fmt below
13	}
14	fmt := new(T)
15	_ = fmt.X
16}
17
18func issue8066() {
19	const (
20		_ = float32(340282356779733661637539395458142568447)
21		_ = float32(340282356779733661637539395458142568448 /* ERROR cannot convert */ )
22	)
23}
24
25// Check that a missing identifier doesn't lead to a spurious error cascade.
26func issue8799a() {
27	x, ok := missing /* ERROR undeclared */ ()
28	_ = !ok
29	_ = x
30}
31
32func issue8799b(x int, ok bool) {
33	x, ok = missing /* ERROR undeclared */ ()
34	_ = !ok
35	_ = x
36}
37
38func issue9182() {
39	type Point C /* ERROR undeclared */ .Point
40	// no error for composite literal based on unknown type
41	_ = Point{x: 1, y: 2}
42}
43
44func f0() (a []int)         { return }
45func f1() (a []int, b int)  { return }
46func f2() (a, b []int)      { return }
47
48func append_([]int, ...int) {}
49
50func issue9473(a []int, b ...int) {
51	// variadic builtin function
52	_ = append(f0())
53	_ = append(f0(), f0()...)
54	_ = append(f1())
55	_ = append(f2 /* ERROR cannot use .* in argument */ ())
56	_ = append(f2()... /* ERROR cannot use ... */ )
57	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
58	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
59	_ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...)
60	_ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...)
61
62	// variadic user-defined function
63	append_(f0())
64	append_(f0(), f0()...)
65	append_(f1())
66	append_(f2 /* ERROR cannot use .* in argument */ ())
67	append_(f2()... /* ERROR cannot use ... */ )
68	append_(f0(), f1 /* ERROR 2-valued f1 */ ())
69	append_(f0(), f2 /* ERROR 2-valued f2 */ ())
70	append_(f0(), f1 /* ERROR 2-valued f1 */ ()...)
71	append_(f0(), f2 /* ERROR 2-valued f2 */ ()...)
72}
73
74// Check that embedding a non-interface type in an interface results in a good error message.
75func issue10979() {
76	type _ interface {
77		int /* ERROR int is not an interface */
78	}
79	type T struct{}
80	type _ interface {
81		T /* ERROR T is not an interface */
82	}
83	type _ interface {
84		nosuchtype /* ERROR undeclared name: nosuchtype */
85	}
86	type _ interface {
87		fmt /* ERROR Nosuchtype not declared by package fmt */ .Nosuchtype
88	}
89	type _ interface {
90		nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype
91	}
92	type I interface {
93		I /* ERROR I\.m \(value of type func\(I\)\) is not a type */ .m
94		m()
95	}
96}
97
98// issue11347
99// These should not crash.
100var a1, b1 /* ERROR cycle */ , c1 /* ERROR cycle */ b1 = 0 > 0<<""[""[c1]]>c1
101var a2, b2 /* ERROR cycle */ = 0 /* ERROR cannot initialize */ /* ERROR cannot initialize */ > 0<<""[b2]
102var a3, b3 /* ERROR cycle */ = int /* ERROR cannot initialize */ /* ERROR cannot initialize */ (1<<""[b3])
103
104// issue10260
105// Check that error messages explain reason for interface assignment failures.
106type (
107	I0 interface{}
108	I1 interface{ foo() }
109	I2 interface{ foo(x int) }
110	T0 struct{}
111	T1 struct{}
112	T2 struct{}
113)
114
115func (*T1) foo() {}
116func (*T2) foo(x int) {}
117
118func issue10260() {
119	var (
120		i0 I0
121		i1 I1
122		i2 I2
123		t0 *T0
124		t1 *T1
125		t2 *T2
126	)
127	i1 = i0 /* ERROR cannot use .* missing method foo */
128	i1 = t0 /* ERROR cannot use .* missing method foo */
129	i1 = i2 /* ERROR cannot use .* wrong type for method foo */
130	i1 = t2 /* ERROR cannot use .* wrong type for method foo */
131	i2 = i1 /* ERROR cannot use .* wrong type for method foo */
132	i2 = t1 /* ERROR cannot use .* wrong type for method foo */
133
134	_ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ }
135	_ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ }
136	_ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ }
137	_ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ }
138	_ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ }
139	_ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ }
140
141	// a few more - less exhaustive now
142
143	f := func(I1, I2){}
144	f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo */)
145
146	_ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
147	_ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
148	_ = []I1{i0 /* ERROR cannot use .* missing method foo */ }
149	_ = []I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
150	_ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ }
151	_ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ }
152
153	make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
154	make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
155}
156
157// Check that constants representable as integers are in integer form
158// before being used in operations that are only defined on integers.
159func issue14229() {
160	// from the issue
161	const _ = int64(-1<<63) % 1e6
162
163	// related
164	const (
165		a int = 3
166		b = 4.0
167		_ = a / b
168		_ = a % b
169		_ = b / a
170		_ = b % a
171	)
172}
173
174// Check that in a n:1 variable declaration with type and initialization
175// expression the type is distributed to all variables of the lhs before
176// the initialization expression assignment is checked.
177func issue15755() {
178	// from issue
179	var i interface{}
180	type b bool
181	var x, y b = i.(b)
182	_ = x == y
183
184	// related: we should see an error since the result of f1 is ([]int, int)
185	var u, v []int = f1 /* ERROR cannot use f1 */ ()
186	_ = u
187	_ = v
188}
189
190// Test that we don't get "declared but not used"
191// errors in the context of invalid/C objects.
192func issue20358() {
193	var F C /* ERROR "undeclared" */ .F
194	var A C /* ERROR "undeclared" */ .A
195	var S C /* ERROR "undeclared" */ .S
196	type T C /* ERROR "undeclared" */ .T
197	type P C /* ERROR "undeclared" */ .P
198
199	// these variables must be "used" even though
200	// the LHS expressions/types below in which
201	// context they are used are unknown/invalid
202	var f, a, s1, s2, s3, t, p int
203
204	_ = F(f)
205	_ = A[a]
206	_ = S[s1:s2:s3]
207	_ = T{t}
208	_ = P{f: p}
209}
210