code stringlengths 10 1.34M | language stringclasses 1
value |
|---|---|
// Copyright 2009 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 chanbug
var C chan<- (chan int)
var D chan<- func()
var E func() chan int
var F func() (func())
| Go |
// errorcheck
// Copyright 2009 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 main
type I int
type S struct { f map[I]int }
var v1 = S{ make(map[int]int) } // ERROR "cannot|illegal|incompatible|wrong"
var v2 map[I]... | Go |
// run
// Copyright 2009 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 main
type S struct {
a []int
}
var s = &S{make([]int, 10)}
func main() {
s.a[f()] = 1 // 6g used to call f twice here
}
var n int
func f(... | Go |
// run
// Copyright 2009 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 main
func main() {
var b [0]byte
s := string(b[0:]) // out of bounds trap
if s != "" {
panic("bad convert")
}
var b1 = [5]byte{'h', 'e',... | Go |
// $G $D/$F.dir/lib.go && $G $D/$F.go && $L $F.$A && ./$A.out
// 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.
// Tests that method calls through an interface always
// call the locally defined method localT... | Go |
// run
// Copyright 2010 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.
// Test order of evaluation in tuple assignments.
package main
var i byte = 0
var a [30]byte
func f() *byte {
i++
return &a[i-1]
}
func gbyte() byt... | Go |
// run
// Copyright 2010 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.
// Test case for issue 849.
package main
type I interface {
f()
}
var callee string
var error_ bool
type T int
func (t *T) f() { callee = "f" }
f... | Go |
// errorcheck
// Copyright 2009 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 main
func main() {
var s string = nil; // ERROR "illegal|invalid|incompatible|cannot"
}
| Go |
// errorcheck
// Copyright 2009 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 main
func f() (int, bool) { return 0, true }
func main() {
x, y := f(), 2; // ERROR "multi"
_, _ = x, y
}
| Go |
// run
// Copyright 2010 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.
// http://code.google.com/p/go/issues/detail?id=807
package main
type Point struct {
X, Y int64
}
type Rect struct {
Min, Max Point
}
func (p Poi... | Go |
// compile
// 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.
// gccgo crashed compiling this.
package p
var v struct{ I }
type I interface{}
| Go |
// errorcheck
// Copyright 2009 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 main
const (
c3div2 = 3/2;
f3div2 = 3./2.;
)
func assert(t bool, s string) {
if !t {
panic(s)
}
}
func main() {
var i int;
var... | Go |
// build
// Copyright 2009 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 main
func f1() {
type T struct {
x int
}
}
func f2() {
type T struct {
x float64
}
}
func main() {
f1()
f2()
}
/*
1606416576: co... | Go |
// $G $D/bug160.dir/x.go && $G $D/bug160.dir/y.go && $L y.$A && ./$A.out
// Copyright 2009 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.
nothing to see here
| Go |
// run
// Copyright 2009 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 main
const B32 = 1<<32 - 1
const C32 = (-1) & ((1 << 32) - 1)
const D32 = ^0
func main() {
if B32 != 0xFFFFFFFF {
println("1<<32 - 1 is", B... | Go |
// errorcheck
// Copyright 2011 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.
// Issue 2452.
// Check that the error messages says
// bug378.go:17: 1 + 2 not used
// and not
// bug378.go:17: 1 not used
package main
fun... | Go |
// run
// Copyright 2009 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 main
func main() {
Foo: {
return;
}
goto Foo;
}
/*
bug5.go:4: Foo undefined
bug5.go:4: fatal error: walktype: switch 1 unknown op GOTO l(4... | Go |
// errorcheck
// Copyright 2009 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 main
func main() {
var x int;
x := 0; // ERROR "declar|:="
_ = x;
}
| Go |
// errorcheck
// Copyright 2009 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.
// Used to crash
// http://code.google.com/p/go/issues/detail?id=204
package main
func () x() // ERROR "no receiver"
func (a b, c d) x() // ER... | Go |
// cmpout
// 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.
// Multiple inlined calls to a function that causes
// redundant address loads.
package main
func F(v [2]float64) [2]float64 {
return [2]float64{... | Go |
// errorcheck
// Copyright 2009 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 main
func main() {
s := vlong(0); // ERROR "undef"
}
| Go |
// errorcheck
// Copyright 2009 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 main
type T *struct {}
func (x T) M () {} // ERROR "pointer|receiver"
/*
bug046.go:7: illegal <this> pointer
*/
| Go |
// compile
// Copyright 2011 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.
// issue 2086
// was calling makeclosure twice on the closure
package bug354
type Inner struct {
F func() error
}
type Outer struct {
Inners [... | Go |
// $G $D/$F.dir/chanbug.go && $G -I. $D/$F.dir/chanbug2.go
// Copyright 2009 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.
ignored
| Go |
// errorcheck
// Copyright 2011 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.
// Issue 2500
package foo
// Check that we only get root cause message, no further complaints about r undefined
func (r *indexWriter) foo() {}... | Go |
// errorcheck
// Copyright 2009 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 main
var x int
var a = []int{ x: 1} // ERROR "constant"
var b = [...]int{ x : 1} // ERROR "constant"
var c = map[int]int{ x: 1}
| Go |
// errorcheck
// Copyright 2009 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 main
type S struct {
a, b int
}
func main() {
s1 := S{a: 7}; // ok - field is named
s3 := S{7, 11}; // ok - all fields have values
... | Go |
// 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.
package one
type I1 interface {
f()
}
type S1 struct {
}
func (s S1) f() {
}
func F1(i1 I1) {
}
| Go |
// 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.
package two
import "./one"
type S2 struct {
one.S1
}
| Go |
// run
// Copyright 2010 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 main
var a [10]int
var b [1e1]int
func main() {
if len(a) != 10 || len(b) != 10 {
println("len", len(a), len(b))
panic("fail")
}
}
| Go |
// compile
// 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.
// gccgo crashed compiling this file.
package p
var V = "a" > "b"
| Go |
// errorcheck
// Copyright 2009 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 main
type T int
type U int
var x int
var t T = int(0) // ERROR "cannot use|incompatible"
var t1 T = int(x) // ERROR "cannot use|incomp... | Go |
// run
// 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.
// Test that when the compiler expands append inline it does not
// overwrite a value before it needs it (issue 3369).
package main
func main() {
s ... | Go |
// errorcheck
// Copyright 2009 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 main
type S struct {
a int
}
type PS *S
func (p *S) get() int {
return p.a
}
func fn(p PS) int {
// p has type PS, and PS has no me... | Go |
// compile
// Copyright 2009 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.
// Crashes 6g, 8g
// http://code.google.com/p/go/issues/detail?id=238
package main
func main() {
bar := make(chan bool);
select {
case _ = <-ba... | Go |
// errorcheck
// Copyright 2009 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 main
func main() {
x := 0;
if x { // ERROR "x.*int|bool"
}
}
| Go |
// compile
// Copyright 2009 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 bug219
func f(func()) int { return 0 }
// this doesn't work:
// bug219.go:16: syntax error near if
func g1() {
if x := f(func() {
if tr... | Go |
// errorcheck
// Copyright 2011 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 main
// Issue 2623
var m = map[string]int {
"abc":1,
1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
}
| Go |
// compile
// Copyright 2009 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 main
func main() {
c := make(chan int);
ok := false;
var i int;
i, ok = <-c; // works
_, _ = i, ok;
ca := new([2]chan int);
i, ... | Go |
// errorcheck
// Copyright 2009 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.
// Test case for issue 471. This file shouldn't compile.
package main
const a *int = 1 // ERROR "convert|wrong|invalid"
const b [2]int =... | Go |
// errorcheck
// Copyright 2011 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.
// Issue 1871.
package p
type a interface {
foo(x int) (x int) // ERROR "redeclared|redefinition"
}
var b interface {
bar(y int) (y int) //... | Go |
// run
// Copyright 2009 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 main
func main() {
prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
"xxxxxxxxxx"+
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
... | Go |
// compile
// 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.
// gccgo crashed compiling this.
package p
type T *T
func f(t T) {
println(t, *t)
}
| Go |
// run
// Copyright 2009 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 main
func main() {
var cu0 uint16 = '\u1234';
var cU1 uint32 = '\U00101234';
_, _ = cu0, cU1;
}
/*
bug13.go:4: missing '
bug13.go:4: syntax ... | Go |
// compile
// 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.
// Was failing to compile with 'invalid receiver' due to
// incomplete type definition evaluation. Issue 3709.
package p
type T1 struct { F *T2 ... | Go |
// errorcheck
// Copyright 2009 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 main
func main() {
var buf [10]int;
for ; len(buf); { // ERROR "bool"
}
}
/*
uetli:/home/gri/go/test/bugs gri$ 6g bug209.go
bug209.... | Go |
// compile
// Copyright 2009 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 bug151
type S string
type Empty interface {}
func (v S) Less(e Empty) bool {
return v < e.(S);
}
/*
bugs/bug151.go:10: illegal types fo... | Go |
// compile
// Copyright 2009 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 main
func main() {
if true {
} else {
L1:
goto L1
}
if true {
} else {
goto L2
L2:
main()
}
}
/*
These should be legal accor... | Go |
// errorcheck
// Copyright 2010 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.
// https://code.google.com/p/gofrontend/issues/detail?id=1
package main
func f1() {
a, b := f() // ERROR "mismatch|does not match"
_ = a
_ ... | Go |
// compile
// Copyright 2011 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.
// Used to cause a typechecking loop error.
package pkg
type T map[int]string
var q = &T{}
| Go |
// run
// Copyright 2010 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.
// http://code.google.com/p/go/issues/detail?id=749
package main
func f() (ok bool) { return false }
func main() {
var i interface{}
i = f
_ = i.... | Go |
// errorcheck
// 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.
package p
type T struct {
X int
}
func (t *T) X() {} // ERROR "type T has both field and method named X"
| Go |
// $G $D/$F.dir/b.go && $G $D/$F.dir/a.go
// rm -f a.$A b.$A
// Copyright 2011 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.
// Issue 1705.
unused (see script at top of file)
| Go |
// run
// Copyright 2010 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.
// http://code.google.com/p/go/issues/detail?id=846
package main
func x() (a int, b bool) {
defer func(){
a++
}()
a, b = y()
return
}
func x2(... | Go |
// run
// Copyright 2011 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 main
type T1 struct {
Next *T2
}
type T2 T1
type T3 struct {
Next *T4
}
type T4 T5
type T5 T6
type T6 T7
type T7 T8
type T8 T9
type T9 T3... | Go |
// run
// Copyright 2009 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 main
type I interface{}
func foo1(i int) int { return i }
func foo2(i int32) int32 { return i }
func main() {
var i I
i = 1
var v1 = i.... | Go |
// errorcheck
// Copyright 2009 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 main
import os "os"
type _ os.FileInfo
func f() (os int) {
// In the next line "os" should refer to the result variable, not
// to th... | Go |
// $G $D/$F.go && $L $F.$A && ! ./$A.out || echo BUG: bug429
// 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.
// Should print deadlock message, not hang.
package main
func main() {
select {}
}
| Go |
// compile
// Copyright 2010 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.
// This is a test case for issue 788.
package main
func main() {
var a [1]complex64
t := a[0]
_ = real(t) // this works
_ = real(a[0]) // t... | Go |
// compile
// Copyright 2011 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.
// Issue 2674
package main
const dow = "\000\003"
func main() {
println(int(dow[1]))
}
| Go |
// run
// Copyright 2009 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 main
func main() {
c := make(chan bool, 1);
select {
case _ = <-c:
panic("BUG: recv should not");
default:
}
c <- true;
select {
cas... | Go |
// errorcheck
// Copyright 2009 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 main
const ( F = 1 )
func fn(i int) int {
if i == F() { // ERROR "func"
return 0
}
return 1
}
| Go |
// errorcheck
// Copyright 2009 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 main
func f() int { } // ERROR "return|control"
func g() (foo int) { } // ERROR "return|control"
| Go |
// errorcheck
// Copyright 2009 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 main
func f() string {
return 0 // ERROR "conversion|type"
}
| Go |
// errorcheck
// Copyright 2009 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 main
func main() {
L:
for {
for {
break L2 // ERROR "L2"
continue L2 // ERROR "L2"
}
}
L1:
x := 1
_ = x
for {
break... | Go |
// errorcheck
// Copyright 2009 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 main
func f1() {
exit:
print("hi\n")
goto exit
}
func f2() {
const c = 1234
}
func f3() {
i := c // ERROR "undef"
}
func main() {... | Go |
// errorcheck
// Copyright 2009 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 main
type I1 interface { I2 } // ERROR "interface"
type I2 int
type I3 interface { int } // ERROR "interface"
type S struct {
x inter... | Go |
// run
// Copyright 2009 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 main
func f(i int, f float64) {
i = 8
f = 8.0
return
}
func main() {
f(3, float64(5))
}
/*
bug10.go:5: i undefined
bug10.go:6: illegal c... | Go |
// compile
// Copyright 2009 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 main
type Foo interface { }
type T struct {}
func (t *T) foo() {}
func main() {
t := new(T);
var i interface {};
f, ok := i.(Foo);
_,... | Go |
// run
// Copyright 2009 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 main
var ncall int;
type Iffy interface {
Me() Iffy
}
type Stucky struct {
n int
}
func (s *Stucky) Me() Iffy {
ncall++;
return s
}
fun... | Go |
// run
// Copyright 2010 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.
// Used to call wrong methods; issue 1290.
package main
type S struct {
}
func (S) a() int{
return 0
}
func (S) b() int{
return 1
}
func main() {
... | Go |
// errorcheck
// Copyright 2011 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.
// issue 2089 - internal compiler error
package main
import (
"io"
"os"
)
func echo(fd io.ReadWriterCloser) { // ERROR "undefined.*io.ReadW... | Go |
// run
// Copyright 2009 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 main
func panic1(s string) bool {
panic(s);
}
func main() {
x := false && panic1("first") && panic1("second");
x = x == true && panic1("fir... | Go |
// errorcheck
// Copyright 2011 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.
// Issue 2520
package main
func main() {
if 2e9 { } // ERROR "2e.09|expected bool"
if 3.14+1i { } // ERROR "3.14 . 1i|expected bool"
}
| Go |
// run
// Copyright 2009 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 main
func shift(x int) int { return 1 << (1 << (1 << (uint(x)))) }
func main() {
if n := shift(2); n != 1<<(1<<(1<<2)) {
println("bad shift... | Go |
// errorcheck
// Copyright 2011 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 main
func main() {
x := ""
x = +"hello" // ERROR "invalid operation.*string|expected numeric"
x = +x // ERROR "invalid operation.*... | Go |
// errorcheck
// Copyright 2009 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 main
import "testing"
func main() {
var t testing.T
// make sure error mentions that
// name is unexported, not just "name not fo... | Go |
// run
// Copyright 2009 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 main
import "os"
import "strconv"
type Test struct {
f float64
in string
out string
}
var tests = []Test{
Test{123.5, "123.5", "123.5"... | Go |
// run
// Copyright 2009 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 main
import "fmt"
type Buffer int
func (*Buffer) Read() {}
type Reader interface {
Read()
}
func f() *Buffer { return nil }
func g() Read... | Go |
// errorcheck
// Copyright 2009 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 main
func f9(a int) (i int, f float64) {
i := 9 // ERROR "redecl|no new"
f := float64(9) // ERROR "redecl|no new"
return i, ... | Go |
// compile
// Copyright 2009 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.
// Used to crash the compiler.
// http://code.google.com/p/go/issues/detail?id=88
package main
func main() {
x := make(map[int]int, 10);
x[0], x... | Go |
// errorcheck
// Copyright 2011 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.
// issue 1192 - detail in error
package main
func foo() (a, b, c int) {
return 0, 1 2.01 // ERROR "unexpected literal 2.01|expected ';' or '... | Go |
// run
// Copyright 2011 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.
// Troublesome floating point constants. Issue 1463.
package main
import "fmt"
func check(test string, got, want float64) bool {
if got != want {
... | Go |
// compile
// Copyright 2010 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 bug250
type I1 interface {
m() I2
}
type I2 interface {
I1
}
var i1 I1 = i2
var i2 I2
var i2a I2 = i1
| Go |
// run
// Copyright 2010 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.
// Test for issue 778: Map key values that are assignment
// compatible with the map key type must be accepted according
// to the spec: http://golang.... | Go |
// run
// Copyright 2010 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.
// Issue 1011. Removing either #1 or #3 avoided the crash at #2.
package main
import (
"io"
"strings"
)
func readU16BE(b []byte) uint16 {
b[0] =... | Go |
// errorcheck
// Copyright 2009 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 main
func atom(s string) {
if s == nil { // ERROR "nil|incompatible"
return;
}
}
func main() {}
/*
bug047.go:4: fatal error: strin... | Go |
// run
// Copyright 2009 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 main
type Box struct {};
var m map[string] *Box;
func main() {
m := make(map[string] *Box);
s := "foo";
var x *Box = nil;
m[s] = x;
}
/*
... | Go |
// compiledir
// 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.
package ignored
| Go |
// errorcheck
// Copyright 2009 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.
func main() { // ERROR "package"
}
| Go |
// compile
// Copyright 2009 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 foo
import "fmt"
func f() {
fmt.Println();
fmt := 1;
_ = fmt;
}
| Go |
// compile
// Copyright 2009 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 main
type t int
func main() {
t := 0;
_ = t;
}
/*
bug145.go:8: t is type, not var
*/
| Go |
// errorcheck
// Copyright 2009 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.
// Used to crash the compiler.
// http://code.google.com/p/go/issues/detail?id=158
package main
type A struct { a A } // ERROR "recursive"
func... | Go |
// compiledir
// Copyright 2011 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 ignored
| Go |
// $G $D/$F.dir/p1.go && $G $D/$F.dir/main.go && $L main.$A && ./$A.out
// 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.
package ignored
| Go |
// compile
// Copyright 2010 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.
// Test cases for conversion syntax.
package main
type (
A [3]int
S struct {
x int
}
P *S
F func(x int) int
I interface {
m(x int) int
... | Go |
// errorcheck
// Copyright 2010 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.
// 6g accepts the program below even though it is syntactically incorrect:
// Each statement in the list of statements for each case clause must... | Go |
// run
// Copyright 2009 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 main
type T struct {
x, y int
}
func (t *T) m(a int, b float64) int {
return (t.x + a) * (t.y + int(b))
}
func main() {
var t *T = new(T)... | Go |
// 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.
package one
// Issue 2687
type T struct { int }
func New(i int) T { return T{i} }
| Go |
// 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.
// Use the functions in one.go so that the inlined
// forms get type-checked.
package two
import "./one"
func use() {
_ = one.New(1)
} | Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.