func f(done chan struct{}) {
select {
- case done: // ERROR "must be receive", "not used"
- case (chan struct{})(done): // ERROR "must be receive"
+ case done: // ERROR "must be receive|expected .*<-.* or .*=" "not used"
+ case (chan struct{})(done): // ERROR "must be receive|expected .*<-.* or .*="
}
}
}
var (
- _ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2"
- _ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3"
- _ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3"
+ _ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2|unknown field"
+ _ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3|unknown field"
+ _ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3|unknown field"
)
package p
-var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
+var x int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
func f() {
- var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
- var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
- a = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
- b := three() // ERROR "assignment mismatch: 1 variable but three returns 3 values"
+ var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
+ var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
+ a = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context"
+ b := three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|single variable set to multiple-value|multiple-value function call in single-value context"
_, _ = a, b
}
type T struct{}
var _ = S{
- f: &T{}, // ERROR "cannot use &T{}"
+ f: &T{}, // ERROR "cannot use &T{}|incompatible type"
}
var _ = P{
- f: T{}, // ERROR "cannot use T{}"
+ f: T{}, // ERROR "cannot use T{}|incompatible type"
}
var a = []int{1,2,3}
func _(len int) {
- _ = len(a) // ERROR "cannot call non-function"
+ _ = len(a) // ERROR "cannot call non-function|expected function"
}
var cap = false
-var _ = cap(a) // ERROR "cannot call non-function"
+var _ = cap(a) // ERROR "cannot call non-function|expected function"
package p
type _ struct {
- F sync.Mutex // ERROR "undefined: sync"
+ F sync.Mutex // ERROR "undefined: sync|expected package"
}
type _ struct {
- sync.Mutex // ERROR "undefined: sync"
+ sync.Mutex // ERROR "undefined: sync|expected package"
}
type _ interface {
- sync.Mutex // ERROR "undefined: sync"
+ sync.Mutex // ERROR "undefined: sync|expected package|expected signature or type name"
}
import "unsafe"
-type T [uintptr(unsafe.Pointer(nil))]int // ERROR "non-constant array bound"
+type T [uintptr(unsafe.Pointer(nil))]int // ERROR "non-constant array bound|array bound is not constant"
func f() {
- _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0)
+ _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // GCCGO_ERROR "non-integer type for left operand of shift"
}
import "unsafe"
func f() {
- _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "invalid operation: .*shift of type float64.*"
+ _ = complex(1<<uintptr(unsafe.Pointer(nil)), 0) // ERROR "invalid operation: .*shift of type float64.*|non-integer type for left operand of shift"
}
type E struct{}
-func (T) b() {} // ERROR "field and method named b"
-func (*T) E() {} // ERROR "field and method named E"
+func (T) b() {} // ERROR "field and method named b|redeclares struct field name"
+func (*T) E() {} // ERROR "field and method named E|redeclares struct field name"
func _() {
var x T
package p
-func f(a, b, c, d ...int) {} // ERROR "non-final parameter a"
-func g(a ...int, b ...int) {} // ERROR "non-final parameter a"
-func h(...int, ...int, float32) {} // ERROR "non-final parameter"
+func f(a, b, c, d ...int) {} // ERROR "non-final parameter a|only permits one name"
+func g(a ...int, b ...int) {} // ERROR "non-final parameter a|must be last parameter"
+func h(...int, ...int, float32) {} // ERROR "non-final parameter|must be last parameter"
-type a func(...float32, ...interface{}) // ERROR "non-final parameter"
+type a func(...float32, ...interface{}) // ERROR "non-final parameter|must be last parameter"
type b interface {
- f(...int, ...int) // ERROR "non-final parameter"
- g(a ...int, b ...int, c float32) // ERROR "non-final parameter a"
+ f(...int, ...int) // ERROR "non-final parameter|must be last parameter"
+ g(a ...int, b ...int, c float32) // ERROR "non-final parameter a|must be last parameter"
valid(...int)
}
func main() {
var e interface{}
switch e := e.(type) {
- case G: // ERROR "undefined: G"
+ case G: // ERROR "undefined: G|undefined type .*G"
e.M() // ok: this error should be ignored because the case failed its typecheck
- case E: // ERROR "undefined: E"
+ case E: // ERROR "undefined: E|undefined type .*E"
e.D() // ok: this error should be ignored because the case failed its typecheck
case Stringer:
// ok: this error should not be ignored to prove that passing legs aren't left out
- _ = e.(T) // ERROR "undefined: T"
+ _ = e.(T) // ERROR "undefined: T|undefined type .*T"
}
}
GlobalName string
}
-var t = T{Name: "foo"} // ERROR "unknown field 'Name' in struct literal of type T"
+var t = T{Name: "foo"} // ERROR "unknown field 'Name' in struct literal of type T|unknown field .*Name.* in .*T"
func (t T) Name() string {
return t.GlobalName
package main
func _() {
- x := 7 // ERROR "x declared but not used"
+ x := 7 // ERROR ".*x.* declared but not used"
}
package main
func main() {
- var c, d = 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values"
- var e, f, g = 1, 2 // ERROR "assignment mismatch: 3 variables but 2 values"
+ var c, d = 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|wrong number of initializations"
+ var e, f, g = 1, 2 // ERROR "assignment mismatch: 3 variables but 2 values|wrong number of initializations"
}
package main
func main() {
- var a, b = 1 // ERROR "assignment mismatch: 2 variables but 1 values"
- _ = 1, 2 // ERROR "assignment mismatch: 1 variables but 2 values"
- c, d := 1 // ERROR "assignment mismatch: 2 variables but 1 values"
- e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values"
+ var a, b = 1 // ERROR "assignment mismatch: 2 variables but 1 values|wrong number of initializations"
+ _ = 1, 2 // ERROR "assignment mismatch: 1 variables but 2 values|number of variables does not match"
+ c, d := 1 // ERROR "assignment mismatch: 2 variables but 1 values|wrong number of initializations"
+ e, f := 1, 2, 3 // ERROR "assignment mismatch: 2 variables but 3 values|wrong number of initializations"
}
const (
_ = 1_ // ERROR "'_' must separate successive digits"
- _ = 0b // ERROR "binary literal has no digits"
- _ = 0o // ERROR "octal literal has no digits"
- _ = 0x // ERROR "hexadecimal literal has no digits"
+ _ = 0b // ERROR "binary literal has no digits|invalid numeric literal"
+ _ = 0o // ERROR "octal literal has no digits|invalid numeric literal"
+ _ = 0x // ERROR "hexadecimal literal has no digits|invalid numeric literal"
_ = 0xde__ad // ERROR "'_' must separate successive digits"
)
package p
const x = 1i
-const y = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex"
-const z = x < 2i // ERROR "invalid operation: .*not defined on untyped complex"
+const y = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
+const z = x < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
func f() {
- _ = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex"
- _ = 1i < 2 // ERROR "invalid operation: .*not defined on untyped complex"
- _ = 1 < 2i // ERROR "invalid operation: .*not defined on untyped complex"
+ _ = 1i < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
+ _ = 1i < 2 // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
+ _ = 1 < 2i // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"
c := 1i
- _ = c < 2i // ERROR "invalid operation: .*not defined on complex128"
+ _ = c < 2i // ERROR "invalid operation: .*not defined on complex128|non-ordered type"
}
package p
var v uint
-var x = []byte((1 << v) + 1) // ERROR "cannot convert"
+var x = []byte((1 << v) + 1) // ERROR "cannot convert|non-integer type for left operand of shift"
package p
func _() {
- go func() { // no error here about goroutine
- send <-
- }() // ERROR "expecting expression"
+ go func() { // no error here about goroutine
+ send <- // GCCGO_ERROR "undefined name"
+ }() // ERROR "expecting expression|expected operand"
}
func _() {
defer func() { // no error here about deferred function
- 1 +
- }() // ERROR "expecting expression"
+ 1 + // GCCGO_ERROR "value computed is not used"
+ }() // ERROR "expecting expression|expected operand"
}
func _() {
- _ = (1 +) // ERROR "expecting expression"
- _ = a[2 +] // ERROR "expecting expression"
- _ = []int{1, 2, 3 + } // ERROR "expecting expression"
+ _ = (1 +) // ERROR "expecting expression|expected operand"
+ _ = a[2 +] // ERROR "expecting expression|expected operand|undefined name"
+ _ = []int{1, 2, 3 + } // ERROR "expecting expression|expected operand"
}
func f(v int) {
switch v {
case zero, one:
- case two, one: // ERROR "previous case at LINE-1"
+ case two, one: // ERROR "previous case at LINE-1|duplicate case in switch"
case three:
- case 3: // ERROR "previous case at LINE-1"
- case iii: // ERROR "previous case at LINE-2"
+ case 3: // ERROR "previous case at LINE-1|duplicate case in switch"
+ case iii: // ERROR "previous case at LINE-2|duplicate case in switch"
}
}
var _ = map[string]int{
"a": 0,
b: 1,
- "a": 2, // ERROR "previous key at LINE-2"
- "b": 3, // ERROR "previous key at LINE-2"
- "b": 4, // ERROR "previous key at LINE-3"
+ "a": 2, // ERROR "previous key at LINE-2|duplicate key in map literal"
+ "b": 3, // GC_ERROR "previous key at LINE-2"
+ "b": 4, // GC_ERROR "previous key at LINE-3"
}
var s = []string{
1: "dup",
- 1: "dup", // ERROR "duplicate index in slice literal: 1"
+ 1: "dup", // ERROR "duplicate index in slice literal: 1|duplicate value for index 1"
}
type t struct{ x int }
func f1() {
- t{}.M() // ERROR "t{}.M undefined \(type t has no field or method M\)"
- t{x: 1}.M() // ERROR "t{...}.M undefined \(type t has no field or method M\)"
+ t{}.M() // ERROR "t{}.M undefined \(type t has no field or method M\)|undefined field or method .*M"
+ t{x: 1}.M() // ERROR "t{...}.M undefined \(type t has no field or method M\)|undefined field or method .*M"
}
func f2() (*t, error) {
- return t{}.M() // ERROR "t{}.M undefined \(type t has no field or method M\)"
+ return t{}.M() // ERROR "t{}.M undefined \(type t has no field or method M\)|undefined field or method .*M|not enough arguments"
}
package p
func f() [2]int {
- return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{...} \(type \[3\]int\)"
+ return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{...} \(type \[3\]int\)|incompatible type"
}
func g() {
var x []int
- f(x, x...) // ERROR "have \(\[\]int, \.\.\.int\)"
+ f(x, x...) // ERROR "have \(\[\]int, \.\.\.int\)|too many arguments"
}
func f() {
var x *s
- _ = x == nil || len(x.slice) // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)"
- _ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)"
- _ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)"
- _ = len(x.slice) && x == nil // ERROR "invalid operation: .+ \(operator && not defined on int\)"
+ _ = x == nil || len(x.slice) // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|incompatible types"
+ _ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|incompatible types"
+ _ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)|incompatible types"
+ _ = len(x.slice) && x == nil // ERROR "invalid operation: .+ \(operator && not defined on int\)|incompatible types"
}
package p
-type T1 struct { // ERROR "invalid recursive type T1\n\tLINE: T1 refers to\n\tLINE+4: T2 refers to\n\tLINE: T1$"
+type T1 struct { // ERROR "invalid recursive type T1\n\tLINE: T1 refers to\n\tLINE+4: T2 refers to\n\tLINE: T1$|invalid recursive type"
f2 T2
}
-type T2 struct {
+type T2 struct { // GCCGO_ERROR "invalid recursive type"
f1 T1
}
-type a b
-type b c // ERROR "invalid recursive type b\n\tLINE: b refers to\n\tLINE+1: c refers to\n\tLINE: b$"
-type c b
+type a b // GCCGO_ERROR "invalid recursive type"
+type b c // ERROR "invalid recursive type b\n\tLINE: b refers to\n\tLINE+1: c refers to\n\tLINE: b$|invalid recursive type"
+type c b // GCCGO_ERROR "invalid recursive type"
type d e
type e f
-type f f // ERROR "invalid recursive type f\n\tLINE: f refers to\n\tLINE: f$"
+type f f // ERROR "invalid recursive type f\n\tLINE: f refers to\n\tLINE: f$|invalid recursive type"
-type g struct { // ERROR "invalid recursive type g\n\tLINE: g refers to\n\tLINE: g$"
+type g struct { // ERROR "invalid recursive type g\n\tLINE: g refers to\n\tLINE: g$|invalid recursive type"
h struct {
g
}
}
type w x
-type x y // ERROR "invalid recursive type x\n\tLINE: x refers to\n\tLINE+1: y refers to\n\tLINE+2: z refers to\n\tLINE: x$"
-type y struct{ z }
+type x y // ERROR "invalid recursive type x\n\tLINE: x refers to\n\tLINE+1: y refers to\n\tLINE+2: z refers to\n\tLINE: x$|invalid recursive type"
+type y struct{ z } // GCCGO_ERROR "invalid recursive type"
type z [10]x
type w2 w // refer to the type loop again
package p
-var c chan [2 << 16]byte // ERROR "channel element type too large"
+var c chan [2 << 16]byte // GC_ERROR "channel element type too large"
type T [1 << 17]byte
-var x chan T // ERROR "channel element type too large"
+var x chan T // GC_ERROR "channel element type too large"
package p
-var c chan [2 << 16]byte // ERROR "channel element type too large"
+var c chan [2 << 16]byte // GC_ERROR "channel element type too large"
func f() {
_ = 42
package main
func foo() (int, int) {
- return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)"
+ return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)|not enough arguments to return"
}
func foo2() {
- return int(2), 2 // ERROR "too many arguments to return\n\thave \(int, number\)\n\twant \(\)"
+ return int(2), 2 // ERROR "too many arguments to return\n\thave \(int, number\)\n\twant \(\)|return with value in function with no return type"
}
func foo3(v int) (a, b, c, d int) {
if v >= 0 {
- return 1 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int, int, int\)"
+ return 1 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int, int, int\)|not enough arguments to return"
}
- return 2, 3 // ERROR "not enough arguments to return\n\thave \(number, number\)\n\twant \(int, int, int, int\)"
+ return 2, 3 // ERROR "not enough arguments to return\n\thave \(number, number\)\n\twant \(int, int, int, int\)|not enough arguments to return"
}
func foo4(name string) (string, int) {
switch name {
case "cow":
- return "moo" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)"
+ return "moo" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|not enough arguments to return"
case "dog":
- return "dog", 10, true // ERROR "too many arguments to return\n\thave \(string, number, bool\)\n\twant \(string, int\)"
+ return "dog", 10, true // ERROR "too many arguments to return\n\thave \(string, number, bool\)\n\twant \(string, int\)|too many values in return statement"
case "fish":
- return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)"
+ return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|not enough arguments to return"
default:
return "lizard", 10
}
func foo5() (S, T, U) {
if false {
- return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(S, T, U\)"
+ return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(S, T, U\)|not enough arguments to return"
} else {
ptr := new(T)
- return ptr // ERROR "not enough arguments to return\n\thave \(\*T\)\n\twant \(S, T, U\)"
+ return ptr // ERROR "not enough arguments to return\n\thave \(\*T\)\n\twant \(S, T, U\)|not enough arguments to return"
}
- return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many arguments to return\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)"
+ return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many arguments to return\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)|too many values in return statement"
}
func foo6() (T, string) {
- return "T", true, true // ERROR "too many arguments to return\n\thave \(string, bool, bool\)\n\twant \(T, string\)"
+ return "T", true, true // ERROR "too many arguments to return\n\thave \(string, bool, bool\)\n\twant \(T, string\)|too many values in return statement"
}
package p
func f() uintptr {
- return nil // ERROR "cannot use nil as type uintptr in return argument"
+ return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type"
}
import "syscall"
-const A int = syscall.X // ERROR "undefined: syscall.X"
-const B int = voidpkg.X // ERROR "undefined: voidpkg"
+const A int = syscall.X // ERROR "undefined: syscall.X|undefined identifier .*syscall.X"
+const B int = voidpkg.X // ERROR "undefined: voidpkg|undefined name .*voidpkg"
package p
func f1() {
- for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :="
+ for a, a := range []int{1, 2, 3} { // ERROR "a.* repeated on left side of :="
println(a)
}
}
func f2() {
var a int
- for a, a := range []int{1, 2, 3} { // ERROR "a repeated on left side of :="
+ for a, a := range []int{1, 2, 3} { // ERROR "a.* repeated on left side of :="
println(a)
}
println(a)
f96 = f95 * 96
f97 = f96 * 97
f98 = f97 * 98
- f99 = f98 * 99 // ERROR "overflow"
+ f99 = f98 * 99 // GC_ERROR "overflow"
)
package main
func main() {
- _ = string(-4 + 2i + 2) // ERROR "-4 \+ 2i"
+ _ = string(-4 + 2i + 2) // ERROR "-4 \+ 2i|invalid type conversion"
}
func h(int, int) {}
func main() {
- f(g()) // ERROR "in argument to f"
- f(true) // ERROR "in argument to f"
- h(true, true) // ERROR "in argument to h"
+ f(g()) // ERROR "in argument to f|incompatible type"
+ f(true) // ERROR "in argument to f|incompatible type"
+ h(true, true) // ERROR "in argument to h|incompatible type"
}
package main
func main() {
- _ = [0]int{-1: 50} // ERROR "index must be non-negative integer constant"
- _ = [0]int{0: 0} // ERROR "index 0 out of bounds \[0:0\]"
- _ = [0]int{5: 25} // ERROR "index 5 out of bounds \[0:0\]"
- _ = [10]int{2: 10, 15: 30} // ERROR "index 15 out of bounds \[0:10\]"
- _ = [10]int{5: 5, 1: 1, 12: 12} // ERROR "index 12 out of bounds \[0:10\]"
+ _ = [0]int{-1: 50} // ERROR "index must be non-negative integer constant|index expression is negative"
+ _ = [0]int{0: 0} // ERROR "index 0 out of bounds \[0:0\]|out of range"
+ _ = [0]int{5: 25} // ERROR "index 5 out of bounds \[0:0\]|out of range"
+ _ = [10]int{2: 10, 15: 30} // ERROR "index 15 out of bounds \[0:10\]|out of range"
+ _ = [10]int{5: 5, 1: 1, 12: 12} // ERROR "index 12 out of bounds \[0:10\]|out of range"
}
package p
-var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal"
+var _ = []int{a: true, true} // ERROR "undefined: a" "cannot use true \(type untyped bool\) as type int in slice literal|undefined name .*a|incompatible type"
package main
func main() {
- _ = copy(nil, []int{}) // ERROR "use of untyped nil"
- _ = copy([]int{}, nil) // ERROR "use of untyped nil"
- _ = 1 + true // ERROR "mismatched types untyped int and untyped bool"
+ _ = copy(nil, []int{}) // ERROR "use of untyped nil|left argument must be a slice"
+ _ = copy([]int{}, nil) // ERROR "use of untyped nil|second argument must be slice or string"
+ _ = 1 + true // ERROR "mismatched types untyped int and untyped bool|incompatible types"
}
func f() {
_:
_:
- goto _ // ERROR "not defined"
+ goto _ // ERROR "not defined|undefined label"
}
func g(string, int, float64, ...string)
func main() {
- f(1, 0.5, "hello") // ERROR "not enough arguments"
+ f(1, 0.5, "hello") // ERROR "not enough arguments|incompatible type"
f("1", 2, 3.1, "4")
- f(1, 0.5, "hello", 4, 5) // ERROR "too many arguments"
- g(1, 0.5) // ERROR "not enough arguments"
+ f(1, 0.5, "hello", 4, 5) // ERROR "too many arguments|incompatible type"
+ g(1, 0.5) // ERROR "not enough arguments|incompatible type"
g("1", 2, 3.1)
- g(1, 0.5, []int{3, 4}...) // ERROR "not enough arguments"
+ g(1, 0.5, []int{3, 4}...) // ERROR "not enough arguments|incompatible type"
g("1", 2, 3.1, "4", "5")
- g(1, 0.5, "hello", 4, []int{5, 6}...) // ERROR "too many arguments"
+ g(1, 0.5, "hello", 4, []int{5, 6}...) // ERROR "too many arguments|truncated to integer"
}
c0 = 1 << 100
c1 = c0 * c0
c2 = c1 * c1
- c3 = c2 * c2 // ERROR "overflow"
+ c3 = c2 * c2 // GC_ERROR "overflow"
c4 = c3 * c3
c5 = c4 * c4
c6 = c5 * c5
c11 = c10 * c10
c12 = c11 * c11
c13 = c12 * c12
- c14 = c13 * c13
+ c14 = c13 * c13 // GCCGO_ERROR "overflow"
c15 = c14 * c14
c16 = c15 * c15
c17 = c16 * c16
type myPointer unsafe.Pointer
-const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant"
-const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant"
+const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant|invalid constant type"
+const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant|invalid constant type"
-const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant|invalid constant type"
+const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant|invalid constant type"
-const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant|expression is not constant"
+const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant|expression is no constant"
-const _ = []byte("") // ERROR "is not (a )?constant"
-const _ = []rune("") // ERROR "is not (a )?constant"
+const _ = []byte("") // ERROR "is not (a )?constant|invalid constant type"
+const _ = []rune("") // ERROR "is not (a )?constant|invalid constant type"
func f() {
var x []byte
- x++ // ERROR "invalid operation: x[+][+]"
+ x++ // ERROR "invalid operation: x[+][+]|non-numeric type"
}
func g() func(int)
func main() {
- Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo"
+ Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo|incompatible type|not enough arguments"
var i I
var t *T
- g()() // ERROR "not enough arguments in call to g\(\)"
- f() // ERROR "not enough arguments in call to f"
- i.M() // ERROR "not enough arguments in call to i\.M"
- I.M() // ERROR "not enough arguments in call to method expression I\.M"
- t.M() // ERROR "not enough arguments in call to t\.M"
- T.M() // ERROR "not enough arguments in call to method expression T\.M"
- (*T).M() // ERROR "not enough arguments in call to method expression \(\*T\)\.M"
+ g()() // ERROR "not enough arguments in call to g\(\)|not enough arguments"
+ f() // ERROR "not enough arguments in call to f|not enough arguments"
+ i.M() // ERROR "not enough arguments in call to i\.M|not enough arguments"
+ I.M() // ERROR "not enough arguments in call to method expression I\.M|not enough arguments"
+ t.M() // ERROR "not enough arguments in call to t\.M|not enough arguments"
+ T.M() // ERROR "not enough arguments in call to method expression T\.M|not enough arguments"
+ (*T).M() // ERROR "not enough arguments in call to method expression \(\*T\)\.M|not enough arguments"
}
package main
func main() {
- _ = []byte{"foo"} // ERROR "cannot use"
- _ = []int{"foo"} // ERROR "cannot use"
- _ = []rune{"foo"} // ERROR "cannot use"
+ _ = []byte{"foo"} // ERROR "cannot use|incompatible type"
+ _ = []int{"foo"} // ERROR "cannot use|incompatible type"
+ _ = []rune{"foo"} // ERROR "cannot use|incompatible type"
_ = []string{"foo"} // OK
}
package main
func main() {
- n.foo = 6 // ERROR "undefined: n in n.foo"
+ n.foo = 6 // ERROR "undefined: n in n.foo|undefined name .*n"
}
package p
-type T struct{ T } // ERROR "invalid recursive type T"
+type T struct{ T } // ERROR "invalid recursive type .*T"
func f() {
println(T{} == T{})
func g() (x []int, y float64) { return }
func main() {
- _ = append(f()) // ERROR "cannot use \[\]int value as type int in append"
- _ = append(g()) // ERROR "cannot use float64 value as type int in append"
+ _ = append(f()) // ERROR "cannot use \[\]int value as type int in append|incompatible type"
+ _ = append(g()) // ERROR "cannot use float64 value as type int in append|incompatible type"
}