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
// Test for correct heap-moving of escaped variables.
// It is hard to check for the allocations, but it is easy
// to check that if you c... | 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.
// Verify that incorrect invocations of the complex predeclared function are detected.
// Does not compile.
package main
var (
f32 float32
f6... | 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 that incorrect short declarations and redeclarations are detected.
// Does not compile.
package main
func f1() int {... | Go |
// true
// 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 main
// can't use local path with -u, use -I. instead
import "pkg" // ERROR "import unsafe package"
func main() {
print(pkg.Float32bits(1.0... | Go |
// $G $D/pkg.go && pack grc pkg.a pkg.$A 2> /dev/null && rm pkg.$A && errchk $G -I. -u $D/main.go
// rm -f pkg.a
// 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 |
// true
// 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.
// a package that uses unsafe on the inside but not in it's api
package pkg
import "unsafe"
// this should be inlinable
func Float32bits(f float32) ... | Go |
// $G $D/pkg.go && pack grcS pkg.a pkg.$A 2> /dev/null && rm pkg.$A && $G -I. -u $D/main.go
// rm -f pkg.a
// 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 2009 The Go 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 types can be parenthesized.
package main
func f(interface{})
func g() {}
func main() {
f(map[string]string{"a":"b","c":"d"})
f([...... | 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 |
// 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 n int
func f() int {
n++
return n
}
func main() {
x := []int{0,1,2,3,4,5,6,7,8,9,10}
n = 5
y := x[f():f()]
if len(y) != 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.
package main
import "os"
func main() {
x := 4
a, b, c, d := func(i int) (p int, q int, r int, s int) { return 1, i, 3, x }(2)
if a != 1 || b != 2 ... | 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 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 typed and untyped negative zero floating point constants
// are treated as equivalent to zero constants.
package main
import "math"
cons... | 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.
// Gccgo used to crash compiling this.
package main
func foo() (int, int) {
return 1, 2
}
var c = b
var a, b = foo()
var d = b + 1
func main() {
i... | 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
const big uint64 = 1<<63
func f(a uint64) uint64 {
return a << big
}
func main() {
f(1)
}
/*
main·f: doasm: notfound from=75 to=13 ... | 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 i int = 100
i = i << -3 // ERROR "overflows|negative"
}
/*
ixedbugs/bug016.go:7: overflow converting constant ... | 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 2582
package main
type T struct{}
func (T) cplx() complex128 {
for false {
} // avoid inlining
return complex(1, 0)
}
func (T) cplx2() c... | 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 "fmt" // GCCGO_ERROR "previous"
var fmt int // ERROR "redecl|redefinition"
| 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 2598
package foo
return nil // ERROR "non-declaration statement outside function body|expected declaration"
| 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() {
type T struct {
s string
f float64
}
var s string = "hello"
var f float64 = 0.2
t := T{s, f}
type M map[int]int
... | 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 that structures pack densely, according to the alignment of the largest field.
package main
import (
"fmt"
"os"
"strconv"
)
type T1 struct ... | 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
const s string = "foo";
func main() {
i := len(s); // should be legal to take len() of a constant
_ = i;
}
/*
uetli:~/Source/go1/... | 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 |
// 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.
// Used to run out of registers on 8g. Issue 868.
package main
func main() {
var r uint32
var buf [4]byte
a := buf[0:4]
r = (((((uint32(a[3]... | 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 |
// 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 used to incorrectly give an error when compiling this.
package p
func F() (i int) {
for first := true; first; first = false {
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 len int; // len should not be a keyword - this doesn't compile
_ = len;
}
| Go |
// compiledir
// Copyright 2009 The Go 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 |
// 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 bug232
type I interface { X(...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.
package bug063
const c = 0 ^ 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
type T struct
{
f int;
}
// 6g used to get confused by the f:1 above
// and allow uses of f that would be silently
// dropped dur... | 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 2627 -- unsafe.Pointer type isn't handled nicely in some errors
package main
import "unsafe"
func main() {
var x *int
_ = unsafe.Po... | 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 main
import "./p1"
type MyObject struct {
p1.Fer
}
func main() {
var b p1.Fer = &p1.Object{}
p1.PrintFer(b)
va... | 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 p1
import "fmt"
type Fer interface {
f() string
}
type Object struct {}
func (this *Object) f() string {
return "Ob... | 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 T1 struct {
x, y int
}
type T2 struct {
z, w byte
}
type T3 T1
type MyInt int
func (MyInt) m(*T1) {}
func main() {
{
var i in... | 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 I1 interface {
m() I2
I2 // GCCGO_ERROR "loop|interface"
}
type I2 interface {
I1 // ERROR "loop|interface"
}
var i1 I1... | 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 Alloc(i int) int {
switch i {
default:
return 5;
case 1:
return 1;
case 10:
return 10;
}
return 0
}
func main() {
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
import "os"
type S struct { i int }
func (p *S) Get() int { return p.i }
type Empty interface {
}
type Getter interface {
Get() 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.
package main
func f(a int64) int64 {
const b int64 = 0;
n := a &^ b;
return n;
}
func main() {
f(1)
}
/*
bug156.go:7: constant 18446744073709... | 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 g() {}
func f1() (a, b int) {
a, b = 2, 1
g() // defeat optimizer
return a, b
}
func f2() (a, b int) {
a, b = 1, 2
g() // defe... | 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.
// This is a test case for issue 804.
package main
func f() [10]int {
return [10]int{}
}
var m map[int][10]int
func main() {
f()[1] = 2 //... | 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 main
import "./p"
func main() {}
var _ p.A
| 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 p
type A struct {
s struct{int}
}
func (a *A) f() {
a.s = struct{int}{0}
}
| 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 bug150
type T int
func (t T) M()
type M interface { M() }
func g() (T, T)
func f() (a, b M) {
a, b = g();
return;
}
/*
bugs/bug150.g... | 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 |
// 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 f() {
exit:
;
goto exit
}
func main() {
exit:
; // this should be legal (labels not properly scoped?)
goto exit
}
/*
uetli:~... | 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.
// The no-op conversion here used to confuse the compiler
// into doing a load-effective-address of nil.
package main
import "reflect"
type T interf... | 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 |
// 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.
// RESOLUTION: This program is illegal. We should reject all unnecessary backslashes.
package main
const c = '\''; // this works
const s = "\... | 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 p
func f() (_ int, err error) {
return
}
func g() (x int, _ error) {
return
}
func h() (_ int, _ error) {
return
}
func i() (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 frexp() (a int, b float64) {
return 1, 2.0
}
func main() {
a, b := frexp();
_, _ = a, b;
}
/*
bug056.go:8: illegal types for ope... | 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 2576
package bug
type T struct { a int }
func f(t T) {
switch _, _ = t.a, t.a; {}
} | 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() {
v := [...]string{"a", "b"};
_ = v;
}
func main() {
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 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 |
// 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 main() {
var s S;
s.p = &s;
... | 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 f1() (x int, y float64) {
return
}
func f2(x int, y float64) {
return
}
func main() {
f2(f1()) // this should be a legal cal... | Go |
// compiledir
// Copyright 2009 The Go 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 1993.
// error used to have last line number in file
package main
func bla1() bool {
return false
}
func bla5() bool {
_ = 1
fals... | 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 s [8]string
func
init() {
s = [...]string{ "now", "is", "the", "time", "to", "fix", "this", "bug"}
}
func
main() {
}
| 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
var x [10][0]byte
var y = make([]struct{}, 10)
func main() {
if &x[1] != &x[2] {
println("BUG: bug352 [0]byte")
}
if &y[1] != &y[2]... | 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 foo(a []int) int {
return a[0] // this seems to do the wrong thing
}
func main() {
a := &[]int{12}
if x := (*a)[0]; x != 12 {
p... | 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.
// Valid program, gccgo reported an error.
// bug307.go:14:6: error: complex arguments must have identical types
package main
func main() {
var 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 1369.
package main
const (
c = complex(1, 2)
r = real(c) // was: const initializer must be constant
i = imag(c) // was: const initiali... | 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.
// Functions that the inliner exported incorrectly.
package one
type T int
// Issue 2678
func F1(T *T) bool { return T == nil }
// Issue 2682.
func F2(c ch... | 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.F1(nil)
one.F2(nil)
one.F3()
o... | 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 three
import "./two"
var x = two.F()
var v = two.V
| 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 |
// compiledir
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Issue 1802
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() /* no return type */ {}
func main() {
x := f(); // ERROR "mismatch|as value|no type"
}
| 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 1787.
package main
import "unsafe"
const x = unsafe.Sizeof([8]byte{})
func main() {
var b [x]int
_ = b
}
/*
bug338.go:14: array bou... | 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 := 10;
d := 7;
var x [10]int;
i := 0;
/* this works:
q := c/d;
x[i] = q;
*/
// this doesn't:
x[i] = c/d; // BUG ... | 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.
// Test cases for revised conversion rules.
package main
func main() {
type NewInt int
i0 := 0
var i1 int = 1
var i2 NewInt = 1
i0 = i0
i... | 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 "fmt"
var s string
func accum(args ...interface{}) {
s += fmt.Sprintln(args...)
}
func f(){
v := 0.0
for i := 0; i < 3; i++ {... | Go |
// run
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
type S struct {
}
func (p *S) M() {
}
type I interface {
M();
}
func main() {
var p *S = nil;
var i I = p; // this should be possib... | 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 |
// 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=920
package main
type X struct { x []X }
func main() {
type Y struct { x []Y } // used to get inval... | 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=915
package main
type T struct {
x int
}
var t = &T{42}
var i interface{} = t
var tt, ok = i.(*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=589
package main
func main() {
n := int64(100)
x := make([]int, n)
x[99] = 234;
z := x[n-1]
if... | 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 crash; issue 961.
package main
type ByteSize float64
const (
_ = iota; // ignore first value by assigning to blank identifier
K... | 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=589
package main
import "unsafe"
var bug = false
var minus1 = -1
var big int64 = 10 | 1<<32
var g1... | 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 U // bogus "invalid recursive type T" from 6g
type U int
const x T = 123
type V V // ERROR "invalid recursive type"
| 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 2206. Incorrect sign extension of div arguments.
package main
func five(x int64) {
if x != 5 {
panic(x)
}
}
func main() {
// 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 "reflect"
type S1 struct{ i int }
type S2 struct{ S1 }
func main() {
typ := reflect.TypeOf(S2{})
f := typ.Field(0)
if f.Name !... | 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 |
// 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 struct{}
type P *T
func (t *T) Meth() {}
func (t T) Meth2() {}
func main() {
t := &T{}
p := P(t)
p.Meth() // ERROR "u... | Go |
// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go && $G $D/$F.go && $L $F.$A && ./$A.out
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Test converting a type defined in a different package to an
// interfa... | 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.
// gc used to overflow a counter when a variable was
// mentioned 256 times, and generate stack corruption.
package main
func main() {
F(1)
}
func F... | 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 1411.
package main
const ui uint = 0
const i int = ui // ERROR "type"
| 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 used to crash compiling this.
package p
type E int
func (e E) P() *E { return &e }
const (
C1 E = 0
C2 = C1
)
func F() *E {
return ... | 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 3824.
// Method calls are ignored when deciding initialization
// order.
package main
type T int
func (r T) Method1() int { return a }
func ... | 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 |
// 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 P
var x int
func foo() {
print(P.x); // ERROR "undefined"
}
/*
uetli:~/Source/go1/test/bugs gri$ 6g bug085.go
bug085.go:6: P: undefi... | 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
var V0 func() int;
var V1 func() (a int);
var V2 func() (a, b 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 main
import P "./bug0"
func main() {
a0 := P.V0(); // works
a1 := P.V1(); // works
a2, b2 := P.V2(); // doesn't work
_, _, _, _ = a0, a1, a2, ... | 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 initializing struct fields out of order still runs
// functions in the right order. This failed with gccgo.
package main
type S struct {... | 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=692
package main
var fooCount = 0
var barCount = 0
var balCount = 0
func foo() (int, in... | 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 (
"./p"
)
type T struct{ *p.S }
type I interface {
get()
}
func main() {
var t T
p.F(t)
var x interface{} = t
_, ok := x.(I)
if ok ... | 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 p
type T struct{ x int }
type S struct{}
func (p *S) get() {
}
type I interface {
get()
}
func F(i I) {
i.get()
}
| 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 Bar
import _ "chanbug"
| Go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.