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 |
// 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 |
// 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 |
// 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 |
// $G $D/$F.dir/one.go && $G $D/$F.dir/two.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 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 |
// $G $D/$F.dir/one.go && $G $D/$F.dir/two.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 |
// $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
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 |
// 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 |
// 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 t []int
var s string;
var m map[string]int;
func main() {
println(t["hi"]); // ERROR "integer"
println(s["hi"]); // ERROR "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
import "os"
func P(a []string) string {
s := "{";
for i := 0; i < 2; i++ {
if i > 0 {
s += ","
}
s += `"` + a[i] + `"`;
}
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
func main() {
var c00 uint8 = '\0'; // ERROR "oct|char"
var c01 uint8 = '\07'; // ERROR "oct|char"
var cx0 uint8 = '\x0'; // ... | 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 f() {}
func main() {
x := 0;
// this compiles
switch x {
case 0: f();
default: f();
}
// this doesn't but it should
//... | 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 |
// 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() {
fired := false; _ = fired;
}
/*
bug9.go:5: defaultlit: unknown literal: LITERAL-B0 a(1)
bug9.go:5: fatal error: addvar: n=... | 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 one
func Foo() (n int64, _ *int) {
return 42, nil
}
| 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 two
import _ "./one"
| 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 lib
type I interface {
m() string
}
type T struct{}
// m is not accessible from outside this package.
func (t *T) m() string {
return "lib.T.m"
}
| 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() {
// should allow at most 2 sizes
a := make([]int, 10, 20, 30, 40); // ERROR "too many"
}
| 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
import (
"runtime"
"strings"
)
func f() {
var x *string
for _, i := range *x { // THIS IS LINE 17
println(i)
}
}
func g() {
}... | 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 T // ERROR "recursive"
| 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 (
Point struct {
x, y float64
}
Polar Point
)
func main() {
}
/*
bug7.go:5: addtyp: renaming Point to Polar
main.go.c:14: erro... | 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 "unsafe"
func main() {
// works
addr := uintptr(0x234)
x1 := (*int)(unsafe.Pointer(addr))
// fails
x2 := (*int)(unsafe.Point... | 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 |
// 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(a T) T { return a } // ERROR "undefined"
func main() {
x := f(0);
_ = x;
}
| Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.