code stringlengths 10 1.34M | language stringclasses 1
value |
|---|---|
// $G $D/$F.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 main
type Scope struct {
entries map[string] *Object;
}
type Type struct {
scope *Scope;
}
type Object struct {
typ *Type;
}
f... | Go |
// $G $D/$F.go && $L $F.$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.
package main
type Element interface {
}
type Vector struct {
elem []Element;
}
func (v *Vector) At(i int) Element {
... | Go |
// errchk $G $D/$F.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 main
func main() {
s := vlong(0); // ERROR "undef"
}
| Go |
// $G $D/$F.go && $L $F.$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.
package main
import "reflect"
type S1 struct { i int }
type S2 struct { S1 }
func main() {
typ := reflect.Typeof(S2{}).... | Go |
// $G $D/$F.go && $L $F.$A || echo BUG: bug155
// 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 big uint64 = 1<<63
func f(a uint64) uint64 {
return a << big
}
func main() {
f(1)
}
/*
... | Go |
// errchk $G $D/$F.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 main
func main() {
x := string{'a', 'b', '\n'}; // ERROR "composite"
print(x);
}
| Go |
// errchk $G $D/$F.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.
// RESOLUTION: This program is illegal. We should reject all unnecessary backslashes.
package main
const c = '\''; // this works
cons... | Go |
// errchk $G $D/$F.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 main
func main() {
type Slice []byte;
a := [...]byte{ 0 };
b := Slice(&a); // This should be OK.
c := Slice(a); // ERROR "... | Go |
// errchk $G $D/$F.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 main
var t []int
var s string;
var m map[string]int;
func main() {
println(t["hi"]); // ERROR "integer"
println(s["hi"]); // ... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
var i int;
var j int;
if true {}
{ return }
i = 0;
if true {} else i++;
type s struct... | Go |
// $G $D/$F.go || echo BUG: fails incorrectly
// 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() (x int, y float) {
return;
}
func f2 (x int, y float) {
return;
}
func main() {
... | Go |
// errchk $G $D/$F.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 main
func main() {
// should allow at most 2 sizes
a := make([]int, 10, 20, 30, 40); // ERROR "too many"
}
| Go |
// errchk $G $D/$F.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 main
const X = iota
func f(x int) { }
func main() {
f(X);
f(iota); // ERROR "iota"
f(X);
}
| Go |
// ! $G $D/$F.go >/dev/null
// # ignoring error messages...
// 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 := float(0);
s := float(0); // BUG redeclaration
}
| Go |
// ! $G $D/$F.go >/dev/null
// # ignoring error messages...
// 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 z [3]byte;
z := new([3]byte); // BUG redeclaration
}
| Go |
// errchk $G -e $D/$F.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 main
func main() {
L:
for {
for {
break L2; // ERROR "L2"
continue L2; // ERROR "L2"
}
}
L1:
x := 1;
_ = x;
f... | Go |
// $G $D/$F.go || echo BUG: bug150
// 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 (t T) M()
type M interface { M() }
func g() (T, T)
func f() (a, b M) {
a, b = g();
retu... | Go |
// $G $D/$F.go || echo BUG: should 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 f(a float) float {
e := 1.0;
e = e * a;
return e;
}
/*
6g bugs/bug109.go
bugs/bug109.go:5: ill... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func g() { }
func f1() (a, b int) {
a, b = 2, 1;
g(); // defeat optimizer
return a, b;
}
func f2() (a... | Go |
// errchk $G $D/$F.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 main
func main() {
var i33 int64;
if i33 == (1<<64) -1 { // ERROR "overflow"
}
}
| Go |
// $G $D/$F.go || echo BUG should 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 |
// $G $D/$F.go && $L $F.$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.
package main
import "os"
func P(a []string) string {
s := "{";
for i := 0; i < 2; i++ {
if i > 0 {
s += ","
}... | Go |
// errchk $G $D/$F.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 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 ... | Go |
// errchk $G $D/$F.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 main
func main() {
var s int = 0;
var x int = 0;
x = x << s; // ERROR "illegal|inval|shift"
x = x >> s; // ERROR "illegal|... | Go |
// $G $D/$F.go && $L $F.$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.
package main
import "os"
const (
x float = iota;
g float = 4.5 * iota;
);
func main() {
if g == 0.0 { print("zero\... | Go |
// $G $D/$F.go && $L $F.$A || echo BUG: const bug
// 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 a = 0
func f() {
const a = 5
}
func main() {
if a != 0 {
panic("a=", a)
}
}
| Go |
// $G $D/$F.go && $L $F.$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.
package main
type S struct {
a []int;
}
var s = &S{make([]int, 10)}
func main() {
s.a[f()] = 1 // 6g used to call f ... | Go |
// $G $D/$F.go && $L $F.$A && ! ./$A.out || echo BUG: should crash
// 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 {a, b int};
func f(x interface{}) interface{} {
type T struct ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should 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"
type I interface { send(chan <- int) }
type S struct { v int }
func ... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
var i int;
i = '\'';
i = '\\';
var s string;
s = "\"";
_, _ = i, s;
}
/*
bug.go:5: unk... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
fired := false; _ = fired;
}
/*
bug9.go:5: defaultlit: unknown literal: LITERAL-B0 a(1)
bu... | Go |
// errchk $G $D/$F.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 main
func f() {
a := true;
a |= a; // ERROR "illegal.*OR|bool|expected"
}
| 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 x
const Zero = 0.0
const Ten = 10.0
| 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 main
import "os"
import "./x"
func main() {
if x.Zero != 0 {
println("x.Zero = ", x.Zero);
os.Exit(1);
}
if x.Ten != 10 {
println("x.Ten = "... | Go |
// $G $D/$F.go && $L $F.$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.
package main
import "os"
func main() {
// This bug doesn't arise with [...]int, or []interface{} or [3]interface{}.
... | Go |
// $G $D/$F.go || echo BUG: should 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() {
x := 0;
// this compiles
switch x {
case 0:
}
// this doesn't but should
switch... | Go |
// errchk $G $D/$F.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 main
func main() {
var c00 uint8 = '\0'; // ERROR "oct|char"
var c01 uint8 = '\07'; // ERROR "oct|char"
var cx0 uint8 = '\x... | Go |
// $G $D/$F.go || echo BUG should 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 Send(c chan int) int {
select {
default:
return 1;
}
return 2;
}
| Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
s := 0;
for _, v := range []int{1} {
s += v;
}
if s != 1 {
println("BUG: s =", s);
... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug142
// 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"... | Go |
// $G $D/$F.go && $L $F.$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.
package main
var s [8]string
func
init()
{
s = [...]string{ "now", "is", "the", "time", "to", "fix", "this", "... | Go |
// $G $D/$F.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 main
const c = 0 ^ 0
| Go |
// $G $D/bug160.dir/x.go && $G $D/bug160.dir/y.go && $L y.$A x.$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 |
// $G $D/$F.dir/bug0.go && $G $D/$F.dir/bug1.go || echo BUG: fails incorrectly
// 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 |
// errchk $G $D/$F.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 main
func main() {
var x int64 = 0;
println(x != nil); // ERROR "illegal|incompatible|nil"
println(0 != nil); // ERROR "illega... | Go |
// $G $D/$F.go || echo BUG should 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 {} else L1: ;
if {} else L2: main() ;
}
/*
These should be legal according to the s... | Go |
// $G $D/$F.go || echo BUG: should 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() {
var b1 []byte;
s1 := string(b1);
println(len(s1)); // prints 0
b2 := ([]byte)(nil)... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug196
// 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 m = map[int]int{ 0: 0, 1: 0 }
var nf = 0
var i int
func multi() (int, int) {
ret... | 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 bug0
const A = -1
| 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 bug1
import _ "./bug0"
| Go |
// errchk $G $D/$F.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 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 us... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
switch ; { case true: return; default: return }
}
/*
bug003.go:6: fatal error: walkswitch: ... | Go |
// errchk $G $D/$F.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 main
func f1() {
exit:
print("hi\n");
}
func f2() {
const c = 1234;
}
func f3() {
i := c; // ERROR "undef"
}
func main()... | Go |
// $G $D/$F.go || echo BUG should 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() {
x := false;
func () { if x { println(1); } }(); // this does not compile
fun... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should 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() {
v := [...]string{"a", "b"};
_ = v;
}
func main() {
f();
}
| Go |
// $G $D/$F.go && $L $F.$A && ./$A.out >/dev/null 2>&1 || echo BUG: bug206
// 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 "go/ast";
func g(list []ast.Expr) {
n := len(list)-1;
printl... | Go |
// $G $D/$F.go || echo BUG: compiler crashes
// 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 rat struct {
den int;
}
func (u *rat) pr() {
}
type dch struct {
dat chan *rat;
}
func ... | Go |
// errchk $G $D/$F.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 main
import "fmt" // GCCGO_ERROR "previous"
var fmt int // ERROR "redecl|redefinition"
| Go |
// errchk $G $D/$F.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 main
func f() int {
return 0;
}
func main() {
const n = f(); // ERROR "const"
}
| Go |
// $G $D/$F.go && $L $F.$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.
package main
import "fmt"
type Buffer int
func (*Buffer) Read() {
}
type Reader interface { Read() }
func f() *Buffe... | Go |
// $G $D/$F.go || echo BUG: should 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 f() {}
func main() {
x := 0;
// this compiles
switch x {
case 0: f();
default: f();
}
/... | Go |
// $G $D/$F.go || echo BUG: bug151
// 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 Empty interface {}
func (v S) Less(e Empty) bool {
return v < e.(S);
}
/*
bugs/bug151.g... | Go |
// $G $D/$F.go || echo BUG129
// 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 |
// $G $D/$F.go || echo BUG should 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
var digits string;
func putint(buf []byte, i, base, val int, digits string) {
buf[i] = digits[val];
... | Go |
// errchk $G $D/$F.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 main
func main (x int) { // GCCGO_ERROR "previous"
var x int; // ERROR "redecl|redefinition"
}
| Go |
// $G $D/$F.go || echo BUG: should 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 S struct {
p *S;
s []S;
m map[int] S;
c chan S;
i interface { f(S); };
f func(S) S;
}
func... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: fails incorrectly
// 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 {
}
func (p *S) M() {
print("M\n");
}
type I interface {
... | Go |
// errchk $G $D/$F.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 main
func main() {
var x int;
x := 0; // ERROR "declar|:="
_ = x;
}
| Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG wrong result
// 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;
func main() {
var a [3]A;
for i := 0; i < 3; i++ {
a[i] = A{i}... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
var i, k int;
outer:
for k=0; k<2; k++ {
print("outer loop top k ", k, "\n");
if k !=... | Go |
// errchk $G $D/$F.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 main
func f() (int, bool) { return 0, true }
func main() {
x, y := f(), 2; // ERROR "multi"
}
| Go |
// $G $D/$F.go && $L $F.$A && (./$A.out || echo BUG: bug114 failed)
// 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 m... | 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 |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
L:
for i := 0; i < 1; i++ {
L1:
for {
break L;
}
panic("BUG: not reached - break")... | Go |
// $G $D/$F.go || echo BUG: compilation should succeed
// 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 = s... | Go |
// $G $D/$F.go || echo BUG: bug115 should 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 |
// $G $D/$F.go || echo BUG should 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 const... | Go |
// ! $G $D/$F.go >/dev/null
// # ignoring error messages...
// 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, x int) { // BUG redeclaration error
}
| Go |
// errchk $G $D/$F.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 main
func main() {
s := string(bug); // ERROR "undef"
}
| 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 |
// $G $D/$F.go && $L $F.$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.
package main
type T struct {
i int
}
func main() {
var ta []*T;
ta = new([1]*T);
ta[0] = nil;
}
/*
bug045.go:13: ... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func shift(x int) int {
return 1<<(1<<(1<<(uint(x))));
}
func main() {
if n := shift(2); n != 1<<(1<<(1... | Go |
// errchk $G $D/$F.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 main
func main() {
const a uint64 = 10;
var b int64 = a; // ERROR "convert|cannot|incompatible"
}
| Go |
// errchk $G $D/$F.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 main
func main() {
x := 0;
if x { // ERROR "x.*int|bool"
}
}
| Go |
// errchk $G $D/$F.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 main
func f() int { // ERROR "return|control"
if false {
return 0;
}
// we should not be able to return successfully w/o a ... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should not crash
// 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 str... | 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 |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
switch ; { case false: return; } // compiles; should be an error (should be simplevardecl ... | Go |
// $G $D/$F.go && $L $F.$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.
package main
type Box struct {};
var m map[string] *Box;
func main() {
m := make(map[string] *Box);
s := "foo";
var... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug168
// 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]... | Go |
// errchk $G $D/$F.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 main
func f(args ...) {
}
func main() {
f(nil); // ERROR "nil"
}
| Go |
// errchk $G $D/$F.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 main
func f() string {
return 0 // ERROR "conversion|type"
}
| Go |
// $G $D/$F.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 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 st... | Go |
// errchk $G $D/$F.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 main
type R interface { duplicate() }
type S interface { duplicate() }
type T interface { R; S } // ERROR "duplicate"
func main... | Go |
// errchk $G $D/$F.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 main
type I interface {
m(map[I] bool); // ok
}
type S struct {
m map[S] bool; // ERROR "map key type"
}
| Go |
// $G $D/$F.go || echo BUG should 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 ... | Go |
// $G $D/$F.go && $L $F.$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.
package main
func main() {
prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
"xxxxxxxxxx"+
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx... | Go |
// errchk $G $D/$F.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 main
const ( F = 1 )
func fn(i int) int {
if i == F() { // ERROR "func"
return 0
}
return 1
}
| Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.