| // Copyright 2014 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 issues |
| |
| import "fmt" |
| |
| func issue7035() { |
| type T struct{ X int } |
| _ = func() { |
| fmt.Println() // must refer to imported fmt rather than the fmt below |
| } |
| fmt := new(T) |
| _ = fmt.X |
| } |
| |
| func issue8066() { |
| const ( |
| _ = float32(340282356779733661637539395458142568447) |
| _ = float32(340282356779733661637539395458142568448 /* ERROR cannot convert */ ) |
| ) |
| } |
| |
| // Check that a missing identifier doesn't lead to a spurious error cascade. |
| func issue8799a() { |
| x, ok := missing /* ERROR undeclared */ () |
| _ = !ok |
| _ = x |
| } |
| |
| func issue8799b(x int, ok bool) { |
| x, ok = missing /* ERROR undeclared */ () |
| _ = !ok |
| _ = x |
| } |
| |
| func issue9182() { |
| type Point C /* ERROR undeclared */ .Point |
| // no error for composite literal based on unknown type |
| _ = Point{x: 1, y: 2} |
| } |
| |
| func f0() (a []int) { return } |
| func f1() (a []int, b int) { return } |
| func f2() (a, b []int) { return } |
| |
| func append_([]int, ...int) {} |
| |
| func issue9473(a []int, b ...int) { |
| // variadic builtin function |
| _ = append(f0()) |
| _ = append(f0(), f0()...) |
| _ = append(f1()) |
| _ = append(f2 /* ERROR cannot use .* in argument */ ()) |
| _ = append(f2()... /* ERROR cannot use ... */ ) |
| _ = append(f0(), f1 /* ERROR 2-valued f1 */ ()) |
| _ = append(f0(), f2 /* ERROR 2-valued f2 */ ()) |
| _ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...) |
| _ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...) |
| |
| // variadic user-defined function |
| append_(f0()) |
| append_(f0(), f0()...) |
| append_(f1()) |
| append_(f2 /* ERROR cannot use .* in argument */ ()) |
| append_(f2()... /* ERROR cannot use ... */ ) |
| append_(f0(), f1 /* ERROR 2-valued f1 */ ()) |
| append_(f0(), f2 /* ERROR 2-valued f2 */ ()) |
| append_(f0(), f1 /* ERROR 2-valued f1 */ ()...) |
| append_(f0(), f2 /* ERROR 2-valued f2 */ ()...) |
| } |
| |
| // Check that embedding a non-interface type in an interface results in a good error message. |
| func issue10979() { |
| type _ interface { |
| int /* ERROR int is not an interface */ |
| } |
| type T struct{} |
| type _ interface { |
| T /* ERROR T is not an interface */ |
| } |
| type _ interface { |
| nosuchtype /* ERROR undeclared name: nosuchtype */ |
| } |
| type _ interface { |
| fmt /* ERROR Nosuchtype not declared by package fmt */ .Nosuchtype |
| } |
| type _ interface { |
| nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype |
| } |
| type I interface { |
| I /* ERROR I\.m \(value of type func\(I\)\) is not a type */ .m |
| m() |
| } |
| } |
| |
| // issue11347 |
| // These should not crash. |
| var a1, b1 /* ERROR cycle */ , c1 /* ERROR cycle */ b1 = 0 > 0<<""[""[c1]]>c1 |
| var a2, b2 /* ERROR cycle */ = 0 /* ERROR mismatch */ /* ERROR mismatch */ > 0<<""[b2] |
| var a3, b3 /* ERROR cycle */ = int /* ERROR mismatch */ /* ERROR mismatch */ (1<<""[b3]) |
| |
| // issue10260 |
| // Check that error messages explain reason for interface assignment failures. |
| type ( |
| I0 interface{} |
| I1 interface{ foo() } |
| I2 interface{ foo(x int) } |
| T0 struct{} |
| T1 struct{} |
| T2 struct{} |
| ) |
| |
| func (*T1) foo() {} |
| func (*T2) foo(x int) {} |
| |
| func issue10260() { |
| var ( |
| i0 I0 |
| i1 I1 |
| i2 I2 |
| t0 *T0 |
| t1 *T1 |
| t2 *T2 |
| ) |
| i1 = i0 /* ERROR cannot use .* missing method foo */ |
| i1 = t0 /* ERROR cannot use .* missing method foo */ |
| i1 = i2 /* ERROR cannot use .* wrong type for method foo */ |
| i1 = t2 /* ERROR cannot use .* wrong type for method foo */ |
| i2 = i1 /* ERROR cannot use .* wrong type for method foo */ |
| i2 = t1 /* ERROR cannot use .* wrong type for method foo */ |
| |
| _ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ } |
| _ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ } |
| _ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ } |
| _ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ } |
| _ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ } |
| _ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ } |
| |
| // a few more - less exhaustive now |
| |
| f := func(I1, I2){} |
| f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo */) |
| |
| _ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ } |
| _ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ } |
| _ = []I1{i0 /* ERROR cannot use .* missing method foo */ } |
| _ = []I1{i2 /* ERROR cannot use .* wrong type for method foo */ } |
| _ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ } |
| _ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ } |
| |
| make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */ |
| make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */ |
| } |
| |
| // Check that constants representable as integers are in integer form |
| // before being used in operations that are only defined on integers. |
| func issue14229() { |
| // from the issue |
| const _ = int64(-1<<63) % 1e6 |
| |
| // related |
| const ( |
| a int = 3 |
| b = 4.0 |
| _ = a / b |
| _ = a % b |
| _ = b / a |
| _ = b % a |
| ) |
| } |
| |
| // Check that in a n:1 variable declaration with type and initialization |
| // expression the type is distributed to all variables of the lhs before |
| // the initialization expression assignment is checked. |
| func issue15755() { |
| // from issue |
| var i interface{} |
| type b bool |
| var x, y b = i.(b) |
| _ = x == y |
| |
| // related: we should see an error since the result of f1 is ([]int, int) |
| var u, v []int = f1 /* ERROR cannot use f1 */ () |
| _ = u |
| _ = v |
| } |