package a
type X struct{ f, g int }
func f(x, y *X) {
if x == nil {
print(x.f) // want "nil dereference in field selection"
} else {
print(x.f)
}
if x == nil {
if nil != y {
print(1)
panic(0)
}
x.f = 1 // want "nil dereference in field selection"
y.f = 1 // want "nil dereference in field selection"
}
var f func()
if f == nil { // want "tautological condition: nil == nil"
go f() // want "nil dereference in dynamic function call"
} else {
// This block is unreachable,
// so we don't report an error for the
// nil dereference in the call.
defer f()
}
}
func f2(ptr *[3]int, i interface{}) {
if ptr != nil {
print(ptr[:])
*ptr = [3]int{}
print(*ptr)
} else {
print(ptr[:]) // want "nil dereference in slice operation"
*ptr = [3]int{} // want "nil dereference in store"
print(*ptr) // want "nil dereference in load"
if ptr != nil { // want "impossible condition: nil != nil"
// Dominated by ptr==nil and ptr!=nil,
// this block is unreachable.
// We do not report errors within it.
print(*ptr)
}
}
if i != nil {
print(i.(interface{ f() }))
} else {
print(i.(interface{ f() })) // want "nil dereference in type assertion"
}
}
func g() error { return nil }
func f3() error {
err := g()
if err != nil {
return err
}
if err != nil && err.Error() == "foo" { // want "impossible condition: nil != nil"
print(0)
}
ch := make(chan int)
if ch == nil { // want "impossible condition: non-nil == nil"
print(0)
}
if ch != nil { // want "tautological condition: non-nil != nil"
print(0)
}
return nil
}
func h(err error, b bool) {
if err != nil && b {
return
} else if err != nil {
panic(err)
}
}
func i(*int) error {
for {
if err := g(); err != nil {
return err
}
}
}
func f4(x *X) {
if x == nil {
panic(x)
}
}
func f5(x *X) {
panic(nil) // want "panic with nil value"
}
func f6(x *X) {
var err error
panic(err) // want "panic with nil value"
}
func f7() {
x, err := bad()
if err != nil {
panic(0)
}
if x == nil {
panic(err) // want "panic with nil value"
}
}
func bad() (*X, error) {
return nil, nil
}
func f8() {
var e error
v, _ := e.(interface{})
print(v)
}
func f9(x interface {
a()
b()
c()
}) {
x.b() // we don't catch this panic because we don't have any facts yet
xx := interface {
a()
b()
}(x)
if xx != nil {
return
}
x.c() // want "nil dereference in dynamic method call"
xx.b() // want "nil dereference in dynamic method call"
xxx := interface{ a() }(xx)
xxx.a() // want "nil dereference in dynamic method call"
if unknown() {
panic(x) // want "panic with nil value"
}
if unknown() {
panic(xx) // want "panic with nil value"
}
if unknown() {
panic(xxx) // want "panic with nil value"
}
}
func f10() {
s0 := make([]string, 0)
if s0 == nil { // want "impossible condition: non-nil == nil"
print(0)
}
var s1 []string
if s1 == nil { // want "tautological condition: nil == nil"
print(0)
}
s2 := s1[:][:]
if s2 == nil { // want "tautological condition: nil == nil"
print(0)
}
}
func unknown() bool {
return false
}
func f11(a interface{}) {
switch a.(type) {
case nil:
return
}
switch a.(type) {
case nil: // want "impossible condition: non-nil == nil"
return
}
}
func f12(a interface{}) {
switch a {
case nil:
return
}
switch a {
case 5,
nil: // want "impossible condition: non-nil == nil"
return
}
}
type Y struct {
innerY
}
type innerY struct {
value int
}
func f13() {
var d *Y
print(d.value) // want "nil dereference in field selection"
}
func f14() {
var x struct{ f string }
if x == struct{ f string }{} { // we don't catch this tautology as we restrict to reference types
print(x)
}
}
func f15(x any) {
ptr, ok := x.(*int)
if ok {
return
}
println(*ptr) // want "nil dereference in load"
}
func f16(x any) {
ptr, ok := x.(*int)
if !ok {
println(*ptr) // want "nil dereference in load"
return
}
println(*ptr)
}
func f18(x any) {
ptr, ok := x.(*int)
if ok {
println(ptr)
// falls through
}
println(*ptr)
}
// Regression test for https://github.com/golang/go/issues/65674:
// spurious "nil deference in slice index operation" when the
// index was subject to a range loop.
func f19(slice []int, array *[2]int, m map[string]int, ch chan int) {
if slice == nil {
// A range over a nil slice is dynamically benign,
// but still signifies a programmer mistake.
//
// Since SSA has melted down the control structure,
// so we can only report a diagnostic about the
// index operation, with heuristics for "range".
for range slice { // nothing to report here
}
for _, v := range slice { // want "range of nil slice"
_ = v
}
for i := range slice {
_ = slice[i] // want "range of nil slice"
}
{
var i int
for i = range slice {
}
_ = slice[i] // want "index of nil slice"
}
for i := range slice {
if i < len(slice) {
_ = slice[i] // want "range of nil slice"
}
}
if len(slice) > 3 {
_ = slice[2] // want "index of nil slice"
}
for i := 0; i < len(slice); i++ {
_ = slice[i] // want "index of nil slice"
}
}
if array == nil {
// (The v var is necessary, otherwise the SSA
// code doesn't dereference the pointer.)
for _, v := range array { // want "nil dereference in array index operation"
_ = v
}
}
if m == nil {
for range m { // want "range over nil map"
}
m["one"] = 1 // want "nil dereference in map update"
}
if ch == nil {
for range ch { // want "receive from nil channel"
}
<-ch // want "receive from nil channel"
ch <- 0 // want "send to nil channel"
}
}
Codebase Browser
gotools