code stringlengths 10 1.34M | language stringclasses 1
value |
|---|---|
// 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 |
// $G $D/$F.dir/bug0.go && errchk $G $D/$F.dir/bug1.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 |
// 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() {
L:
for i := 0; i < 1; i++ {
L1:
for {
break L
}
panic("BUG: not reached - break")
if false {
goto L1
}
}
... | 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
swap(x, y int) (u, v int) {
return y, x
}
func
main() {
a := 1;
b := 2;
a, b = swap(swap(a, b));
if a != 2 || b != 1 {
pa... | 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 isuint(i uint) { }
func main() {
i := ^uint(0);
isuint(i);
}
| 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 1556
package foo
type I interface {
m() int
}
type T int
var _ I = T(0) // GCCGO_ERROR "incompatible"
func (T) m(buf []byte) (a in... | 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 struct { s string }
var t = T{"hi"}
func main() {}
/*
bug112.go:6: illegal conversion of constant to 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.
package main
func main() {
data := make(map[int]string, 1)
data[0] = "hello, "
data[0] += "world!"
if data[0] != "hello, world!" {
panic("BUG: " ... | 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 (x, // GCCGO_ERROR "previous"
x int) { // ERROR "redeclared|redefinition" "duplicate"
}
| 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.
// Used to crash compiler in interface type equality check.
package p
type I1 interface {
F() interface{I1}
}
type I2 interface {
F(... | 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.
// issue 1136
package main
import "fmt"
func log1(f string, argv ...interface{}) {
fmt.Printf("log: %s\n", fmt.Sprintf(f, argv...))
}
func mai... | 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 1172
package main
func main() {
var i interface{}
c := make(chan int, 1)
c <- 1
select {
case i = <-c: // error on this line
}
if i !... | 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 1664
package main
func main() {
var i uint = 33
var a = (1<<i) + 4.5 // ERROR "shift of type float64|invalid.*shift"
println(a)
... | 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.
// Issue 3044.
// Multiple valued expressions in return lists.
package p
func Two() (a, b int)
// F used to compile.
func F() (x interface{}, ... | 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 2343
package main
type T struct {}
func (t *T) pm() {}
func (t T) m() {}
func main() {
p := &T{}
p.pm()
p.m()
q := &p
q.m() ... | 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 |
// $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 |
// 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 := string(bug); // ERROR "undef"
}
| 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.
package main
type T struct {
// legal according to spec
x int
y (int)
int
*float64
// not legal according to spec
(complex128) // ERROR... | Go |
// $G $D/$F.dir/bug0.go && $G $D/$F.dir/bug1.go && errchk $G $D/$F.dir/bug2.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 |
// $G $D/bug191.dir/a.go && $G $D/bug191.dir/b.go && $G $D/$F.go && $L $F.$A
// 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 . "./a"
import . "./b"
var _ T
var _ V
func main() {
}
| Go |
// 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 p
type T struct {
X, Y int
}
type I interface {
M(T)
}
| Go |
// 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
import (
p0 "./bug0"
p1 "./bug1"
)
// both p0.T and p1.T are struct { X, Y int }.
var v0 p0.T
var v1 p1.T
// interfaces involving the two
typ... | Go |
// 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 p
type T struct {
X, Y int
}
type I interface {
M(T)
}
| Go |
// 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
import (
p0 "./bug0"
p1 "./bug1"
"reflect"
"strings"
)
var v0 p0.T
var v1 p1.T
type I0 interface {
M(p0.T)
}
type I1 interface {
M(p1.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.
// 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 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 {
i int
}
func main() {
var ta []*T;
ta = new([1]*T)[0:];
ta[0] = nil;
}
/*
bug045.go:13: fatal error: goc: exit 1
*/
| 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.
// issue 1900
package main
func getArgs(data map[string]interface{}, keys ...string) map[string]string {
ret := map[string]string{}
var... | 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.
// Test case for issue 475. This file should compile.
package main
import . "unsafe"
func main() {
var x int
println(Sizeof(x))
}
/*
bug239.go... | 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.
// check that initialization loop is diagnosed
// and that closure cannot be used to hide it.
// error message is not standard format, so no errc... | 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 |
// 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(x int, y ...int) // ok
func g(x int, y float) (...) // ERROR "[.][.][.]" "final argument"
func h(x, y ...int) // ERROR "... | 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.
// Use //line to set the line number of the next line to 20.
//line fixedbugs/bug305.go:20
package p
// Introduce an error which should be rep... | 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 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() {
const a uint64 = 10;
var b int64 = a; // ERROR "convert|cannot|incompatible"
}
| 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.
// Issue 2497
package main
type Header struct{}
func (h Header) Method() {}
var _ interface{} = Header{}
func main() {
type X Header
var _ in... | 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 |
// 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.
// Issue 2821
package main
type matrix struct {
e []int
}
func (a matrix) equal() bool {
for _ = range a.e {
}
return true
}
func main() {
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.
package main
func f() int { // ERROR "return|control"
if false {
return 0;
}
// we should not be able to return successfully w/o a return s... | 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
// Interface
type I interface { F() int }
// Implements interface
type S struct { }
func (s *S) F() int { return 1 }
// Allocates S but ... | 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 http://code.google.com/p/go/issues/detail?id=700
package main
import "os"
func f() (e int) {
_ = &e
return 999
}
func main() {
i... | 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.
package b
func init() {
println("b");
}
type V int;
| 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.
package a
func init() {
println("a");
}
type T 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 1951
package foo
import "unsafe"
var v = unsafe.Sizeof // ERROR "must be called"
| Go |
// errchk $G -e $D/$F.dir/[ab].go
// 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 1284
package bug313
/*
6g bug313.dir/[ab].go
Before:
bug313.dir/b.go:7: internal compiler error: fault
Now:
bug... | Go |
// 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
import . "fmt"
func b() {
Println()
}
| Go |
// 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
import "fmt"
func a() {
fmt.DoesNotExist() // ERROR "undefined"
}
| Go |
// $G $D/$F.dir/bug0.go &&
// $G $D/$F.dir/bug1.go &&
// $G $D/$F.dir/bug2.go &&
// errchk $G -e $D/$F.dir/bug3.go &&
// $L bug2.$A &&
// ./$A.out || echo BUG: failed to 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 ... | 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 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 |
// 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.
// http://code.google.com/p/go/issues/detail?id=3119
package main
import "fmt"
func main() {
s := "hello"
fmt.Println(s == "")
fmt.Println(s +... | 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() {
switch ; { case false: return; } // compiles; should be an error (should be simplevardecl before ;)
}
| 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 |
// 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 g byte = 123
var f *byte = &g
var b = make([]byte, 5)
func main() {
b[0:1][0] = *f
if b[0] != 123 {
println("want 123 got", b[0])... | Go |
// $G $D/bug302.dir/p.go && pack grc pp.a p.$A && $G $D/bug302.dir/main.go
// 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.
| Go |
// $G $D/$F.dir/p.go && $G $D/$F.dir/main.go && $L main.$A && ./$A.out || echo BUG: should not fail
// 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 |
// 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 |
// 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 struct {
s string;
}
func main() {
s := "";
l1 := len(s);
var t T;
l2 := len(t.s); // BUG: cannot take len() of a string... | 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 R interface { duplicate() }
type S interface { duplicate() }
type T interface { R; S } // ERROR "duplicate"
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 I interface {
m(map[I] bool); // ok
}
type S struct {
m map[S] bool; // ERROR "map key 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
type A []int;
type M map[int] int;
func main() {
var a *A = &A{0};
var m *M = &M{0 : 0}; // should be legal to use & here for cons... | 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 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.
// Caused a gccgo crash on compilation.
// bug304.go: In function ‘p.f’:
// bug304.go:15:2: internal compiler error: in copy_tree_r, at tree-inline... | Go |
// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go && $G $D/$F.dir/three.go
// 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 |
// 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 |
// 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 string
type I int
type F float64
func (S) m() {}
func (I) m() {}
func (F) m() {}
func main() {
c := make(chan interface {
m()... | 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.
// Used to die dividing by zero; issue 879.
package main
var mult [3][...]byte = [3][5]byte{} // ERROR "\.\.\."
| 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 Type interface {
TypeName() string;
}
type TInt struct {
}
// TInt
func (i *TInt) TypeName() string {
return "int";
}
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 1606.
package main
func main() {
var x interface{}
switch t := x.(type) {
case 0: // ERROR "type"
t.x = 1 // ERROR "type interf... | 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=800
package main
var log string
type T int
func (t T) a(s string) T {
log += "a(" + s + ")"
retur... | 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 |
// 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 main
type T []int
func (t T) m()
func main() {
_ = T{}
}
// bug245.go:14: fatal error: method mismatch: T for 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.
// Test case for issue 789. The bug only appeared for GOARCH=386.
package main
func main() {
i := 0
x := 0
a := (x & 1) << uint(1-i)
s := uint(... | 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.
// Used to panic because 8g was generating incorrect
// code for converting a negative float to a uint64.
package main
func main() {
var x float32 =... | 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 2563
package foo
func fn(a float32) {}
var f func(arg int) = fn // ERROR "cannot use fn .type func.float32.. as type func.int. in as... | 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 |
// 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"
func main() {
ok := true;
var a, b, c, x, y, z int;
f := func() int { b--; return -b };
// this fails on 6g: apparently ... | 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 |
// 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 T1 int
type T2 []T1
type T3 T2
func F1(T2) {
}
func (p *T1) M1() T3 {
return nil
}
func (p T3) M2() {
}
| 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.
// The gccgo compiler would fail on the import statement.
// two.go:10:13: error: use of undefined type ‘one.T2’
package two
import "./one"
var V one.T3
| Go |
// 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
import (
"bufio"
"./io"
goio "io"
)
func main() {
// The errors here complain that io.X != io.X
// for different values of io so they shoul... | Go |
// 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 io
type Writer interface {
WrongWrite()
}
type SectionReader struct {
X int
}
func SR(*SectionReader) {}
| 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() {
k, l, m := 0,0,0;
_, _, _ = k, l, m;
}
| 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 dosplit(wait chan int ){
select {
case <-wait:
}
}
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.
// 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 |
// 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
package bug235
type T struct {
x [4]byte
}
var p *T
var v = *p
| 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
type S1 struct {
i int
}
type S2 struct {
i int
}
type S3 struct {
S1
S2
}
type S4 struct {
S3
S1
}
func main() {
var s4 S4
if s... | 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 |
// 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 |
// 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 2276.
// Check that the error messages says
// bug381.go:29: unsafe.Alignof(0) not used
// and not
// bug381.go:29: 4 not used
// Is... | 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 2549
/* Used to die with
missing typecheck: [7f5bf07b4438]
. AS l(45)
. . NAME-main.autotmp_0017 u(1) a(1) l(45) x(0+0) class(PAU... | 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 c = 3
var x = c.String() // ERROR "String"
| 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.
// Issue 1368.
package main
func main() {
a := complex(2, 2)
a /= 2
}
/*
bug315.go:13: internal compiler error: optoas: no entry DIV-complex
*/... | 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 |
// 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 interface { m() }
type T struct { m func() }
type M struct {}
func (M) m() {}
func main() {
var t T
var m M
var i 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
func main() {
var s2 string = "\a\b\f\n\r\t\v"; // \r is miscompiled
_ = s2;
}
/*
main.go.c: In function ‘main_main’:
main.go.c:20: err... | 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 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 T int
func main() {}
// issue 1474
// important: no newline on end of next line.
// 6g used to print <epoch> instead of... | 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.
// Issue 2423
package main
func main() {
var x interface{} = "hello"
switch x {
case "hello":
default:
println("FAIL")
}
}
| 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.