code stringlengths 10 1.34M | language stringclasses 1
value |
|---|---|
// $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
func shift(x int) int {
return 1<<(1<<(1<<(uint(x))));
}
func main() {
if n := shift(2); n != 1<<(1<<(1... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug120
// 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;... | 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 |
// 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 f9(a int) (i int, f float) {
i := 9; // ERROR "redecl|no new"
f := float(9); // ERROR "redecl|no new"
return i, f... | 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 atom(s string) {
if s == nil { // ERROR "nil|incompatible"
return;
}
}
func main() {}
/*
bug047.go:4: fatal erro... | 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 |
// 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.
func main() { // ERROR "package"
}
| 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
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
type T struct {
x, y int;
}
func (t *T) m(a int, b float) int {
return (t.x+a) * (t.y+int(b));
}
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
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
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
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 f() {}
func main() {
x := 0;
// this compiles
switch x {
case 0: f();
default: 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
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 main() {
// should allow at most 2 sizes
a := make([]int, 10, 20, 30, 40); // ERROR "too many"
}
| 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 (
Point struct { x, y float };
Polar Point
)
func main() {
}
/*
bug7.go:5: addtyp: renaming Point... | 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 T) T { return a } // ERROR "undefined"
func main() {
x := f(0);
_ = 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 || 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 |
// $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 || 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 || 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 P
const a = 0;
func f(a int) {
a = 0;
}
/*
bug161.go:8: operation LITERAL not allowed in assignment cont... | 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() {
s1 := "hi";
s2 := "ho";
s1 += s2;
}
| 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 || 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
import (
OS "os" // should require semicolon here; this is no different from other decls
IO "io" // ERROR "missing|synt... | 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
// 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 |
// $G $D/$F.go || echo BUG: bug174
// 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 uint;
println(1<<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.
package main
import "os"
func fn() {
var e os.Error
if e == nil { // ERROR "syntax error|expected ';'"
}
}
| Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug159
// 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 { ... | 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.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
type T struct { m map[int]int }
func main() {
t := new(T);
t.m = make(map[int]int);
var x int;
var ok ... | 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 || 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 || 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;
func main() {
a := &A{0};
b := &A{0, 1};
_, _ = a, b;
}
/*
uetli:~/Source/go1/test/b... | 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 := uint(10);
ss := 1<<s;
y1 := float(ss);
y2 := float(1<<s); // ERROR "shift"
y3 := string(1<<s); //... | 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 |
// ! $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 |
// 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 main() {
// 6g used to compile these as two different
// hash codes so it missed the duplication
// and worse, comp... | 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 && $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 s string;
s = "0000000000000000000000000000000000000000000000000000000000"[0:7];
_ = ... | 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 |
// $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 && $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 && $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 |
// ! $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 |
// $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() {
i5 := 5;
switch { // compiler crash fixable with 'switch true'
case i5 < 5: dummy := 0;... | 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
const c = 1;
func main() {
c := 0;
_ = c;
}
/*
bug144.go:8: left side of := must be a name
bug144.g... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should not panic
// 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"
func f0() string {
const f = 3.141592;
return fmt.Sprintf("%... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should compile and 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 v1 = T1(1)
var v2 = T2{2}
var v3 = T3{0:3, 1:4}
var v4 = T4{0:5, 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() {
var v interface{} = 0;
switch x := v.(type) {
case int:
fallthrough; // ERROR "fallthrough"
default:
... | 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 u30 uint64 = 0;
var u31 uint64 = 1;
_, _ = u30, u31;
var u32 uint64 = 1844674407370... | 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 |
//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
func f() {
var x struct { T };
var y struct { T T };
x = y; // ERROR "cannot|incompatible"
_ = x;
}
type T1... | 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 Service struct {
rpc [2]int;
}
func (s *Service) Serve(a int64) {
if a != 1234 { panic(a, " not 12... | 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
// 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 panic because 6g didn't generate
// the code to fill in the ... argument to fmt.Sprint.
package main
import... | 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
// 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() {
nchar := 0;
a := []int { '日', '本', '語', 0xFFFD };
for _, char := range "日本語\xc0" {
if n... | Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug147
// 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 "time"
func main() {
var count int;
c := make(chan byte);
go func(c chan byte... | 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 v1 = ([10]int)(nil); // ERROR "illegal|nil|invalid"
var v2 [10]int = nil; // ERROR "illegal|nil|incompatible"
var v3 [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
type T struct {
x, x int // ERROR "duplicate"
}
| 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 bug2
import _ "./bug1"
import "./bug0"
type T2 struct { t bug0.T }
func fn(p *T2) int {
// This reference should be invalid, because bug0.T.i is lo... | 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
type T struct { i 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 bug1
import "./bug0"
type T struct { t bug0.T }
| Go |
// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug116
// 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() {
bad := false;
if (-5>>1) != -3 {
println("-5>>1 =", -5>>1, "want -3"... | 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 func()
type I interface {
f, g (); // ERROR "syntax|signature"
}
type J interface {
h T; // ERROR "syntax|signa... | Go |
// $G $D/$F.go || echo BUG: bug173
// 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.
// these used to fail because the runtime
// functions that get called to implement them
// expected string, not T.
package... | 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
// same const identifier declared twice should not be accepted
const none = 0 // GCCGO_ERROR "previous"
const none = 1; /... | 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
const X = iota
func f(x int) { }
func main() {
f(X);
f(iota); // ERROR "iota"
f(X);
}
| 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() {
if ; false {} // compiles; should be an error (should be simplevardecl before ;)
}
| 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 bug0
type t0 struct {
}
var V0 t0
| 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"
// This is expected to fail--t0 is in package bug0 and should not be
// visible here in package bug1. The test for failure is i... | 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 putint(digits *string) {
var i byte;
i = (*digits)[7]; // compiles
i = digits[7]; // ERROR "illegal|is not|invali... | 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 {
nelem int;
elem []Element;
}
func New() *Vector {
v :... | 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 |
// $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() {
m := make(map[int]int);
m[0] = 0;
m[0]++;
if m[0] != 1 {
print("map does ... | 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() {
L1:
L2: for i := 0; i < 10; i++ {
print(i);
break L2;
}
L3: ;
L4: for i := 0; i < 1... | 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 exit int;
exit:
_ = exit;
}
| 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 && ./$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 |
// 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 |
// 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() {
L: ; // ';' terminates empty statement => L does not apply to for loop
for i := 0; i < 10; i++ {
println... | 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
// 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 x = 2;
/*
bug081.go:3: first constant must evaluate an expression
Bus 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() {
var i33 int64;
if i33 == (1<<64) -1 { // ERROR "overflow"
}
}
| 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 "sort"
func main() {
sort.Sort(nil);
var x int;
sort(x); // ERROR "package"
}
| 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 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 || 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 && $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 x int;
switch x {
case 0:
{}
case 1:
x = 0;
}
}
/*
bug0.go:8: case statement ou... | Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.