panic: reflect: call of reflect.Value.IsZero on zero Value

[vault-thirteen]

What version of Go are you using (go version)?

$ go version
go version go1.16.4 linux/amd64

Does this issue reproduce with the latest release?

yes

What operating system and processor architecture are you using (go env)?

Operating System is XUbuntu 20.10 (amd64).
CPU is Intel Xeon E5-2678 v3

GOARCH="amd64"
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"

go env Output

$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/***/.cache/go-build"
GOENV="/home/***/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/home/***/go/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/home/***/go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/usr/local/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GOVCS=""
GOVERSION="go1.16.4"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD="/dev/null"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build740936505=/tmp/go-build -gno-record-gcc-switches"

What did you do?

I try to run the IsZero() Method on an Object of reflect.Value Type.
In the Debugger I reach the Code which in Comments is said to be unreachable.

panic: reflect: call of reflect.Value.IsZero on zero Value

goroutine 1 [running]:
reflect.Value.IsZero(0x0, 0x0, 0x0, 0x0)
        /usr/local/go/src/reflect/value.go:1134 +0x70b

// IsZero reports whether v is the zero value for its type.
// It panics if the argument is invalid.
func (v Value) IsZero() bool {
	switch v.kind() {

//...

default:
		// This should never happens, but will act as a safeguard for
		// later, as a default value doesn't makes sense here.
		panic(&ValueError{"reflect.Value.IsZero", v.Kind()})
	}
}

https://play.golang.org/p/o5j2PKXxpwJ

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"reflect"
)

type JsonObject = map[string]interface{}

type ResponseRaw struct {
	Records []JsonObject
}

func main() {
	text := `[{"x": 1, "y": 2}, {"z": 3, "zz": 4, "step": 123}, {}, {"id": 999}, {"q": "test", "lto": {"a": 8, "step": 456}}, null]`
	rr, err := parseValidJson([]byte(text))
	if err != nil {
		log.Println(err)
	}
	fmt.Println("rr:", rr)
}

func parseValidJson(jsonText []byte) (rr *ResponseRaw, err error) {
	responseAnonymous := make([]interface{}, 0)

	err = json.Unmarshal(jsonText, &responseAnonymous)
	if err != nil {
		return nil, err
	}

	rr = &ResponseRaw{
		Records: make([]JsonObject, 0),
	}

	for _, arrayItem := range responseAnonymous {
		arrayItemAsJsonObject, ok := arrayItem.(JsonObject)
		if !ok {
			arrayItemValue := reflect.ValueOf(arrayItem)
			// Here we may receive an empty Value, i.e. reflect.Value{}.
			// When we receive it and check it for Zero Value, we reach that
			// Part of the Code which should be unreachable.
			if arrayItemValue.IsZero() {
				continue
			}
			if arrayItemValue.IsNil() {
				continue
			}
			// The built-in JSON Parser thinks that an empty Object '{}' is an
			// empty Slice of Objects. It may be a Bug in the Parser.
			arrayItemType := reflect.TypeOf(arrayItem)
			if arrayItemType.Kind() == reflect.Slice {
				continue
			}

			return nil, errors.New("json object parsing error")
		}

		rr.Records = append(rr.Records, arrayItemAsJsonObject)
	}

	return rr, nil
}

What did you expect to see?

I expected to see the reflect.Value.IsZero() Method returning a boolean Value.

What did you see instead?

I saw the reflect.Value.IsZero() Method reaching the unreachable code and panicing.

[AlexRouSg]

Add a Printf like so

fmt.Printf("%#v\n", arrayItem)
arrayItemValue := reflect.ValueOf(arrayItem)

You are calling reflect.ValueOf(nil)
Since nil has no type, it reaches the default case.

[seankhliao]

IsZero reports whether v is the zero value for its type

Where "its" refers to the value represented by reflect.Value and not reflect.Value itself. I think you want reflect.Value.IsValid

Closing the panic is working as intended

[vault-thirteen]

The Comments in the Library are wrong and misleading.

[ecnepsnai]

@seankhliao perhaps we could discuss how the documentation for IsZero could be improved to clarify the point you just highlighted? I do agree with @vault-thirteen that it's not entirely clear, and the panic error message is a unhelpful.

[Sora233]

Can't call IsZero() on zero Value.

This panic message is counter-intuitive and confusing.

[jingjingwang]

did a search on google and ended up here. This piece of documentation is misleading. Users would expect X.isZero() to return true when X is zero instead of a panic.

[adammw]

Agreed, would like to see some explicit call out in the documentation for this that IsZero cannot be called on a zero value.

[ianlancetaylor]

How do you suggest we clarify the documentation?

Current documentation is https://pkg.go.dev/reflect#Value.IsZero .

[Sora233]

How do you suggest we clarify the documentation?

Current documentation is https://pkg.go.dev/reflect#Value.IsZero .

I think the problem is below:

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a *int
	var b func()
	var c interface{}
	fmt.Println(reflect.ValueOf(a).Kind())    // output ptr
	fmt.Println(reflect.ValueOf(a).IsZero())

	fmt.Println(reflect.ValueOf(b).Kind())    // output func
	fmt.Println(reflect.ValueOf(b).IsZero())

	fmt.Println(reflect.ValueOf(c).Kind())    // output invalid
	fmt.Println(reflect.ValueOf(c).IsZero())  // panic here
}

As a and b both work, I can infer that c should be the zero value of interface{}.
But that's wrong.

So we should clarify that nil is the zero value of ptr and func but interface{}.

Why not?

What is the zero value of interface{}?

[ianlancetaylor]

The problem you are describing is due to the nature of interface types in Go, and to the fact that the reflect package is built on interface types. A value of interface type always describes some other value. When you pass a value of interface type to reflect.ValueOf, you get a reflection object describing that other value, not the value of interface type.

To work with interface values with the reflect package you generally need to use pointers. This doesn't have anything to do with IsZero, it's just how the reflect package works.

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var c interface{}

	fmt.Println(reflect.ValueOf(&c).Elem().Kind())
	fmt.Println(reflect.ValueOf(&c).Elem().IsZero())
}

[Sora233]

Maybe I misused the reflect package, but the panic message actually made me confused for a while:

panic: reflect: call of reflect.Value.IsZero on zero Value

e.Kind.String() showing on invalid Value is enough, I think.
And the word invalid can lead us to IsValid()

go/src/reflect/value.go

Lines 166 to 171 in 99fa49e

	func (e *ValueError) Error() string {
	if e.Kind == 0 {
	return "reflect: call of " + e.Method + " on zero Value"
	}
	return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value"
	}

[jamesandariese]

I ended up here for similar reasons.

According to the docs on reflect.Value.MethodByName:

It returns the zero Value if no method was found.

This code at the bottom of this post seems to meet that criteria but panics instead because the zero value of Value is not the same as the non-zero Value representing the zero value of a type. Maybe if references to "the zero Value" said instead "invalid Value" since the docs also say this about reflect.Value.IsValid():

Most functions and methods never return an invalid Value. If one does, its documentation states the conditions explicitly.

Which I would expect would mean the docs say something like "It returns an invalid Value if no method was found".

---

code which seemed good until I searched google and landed here:

package main

import (
	"fmt"
	"reflect"
)

type Stuff struct{}

func (s *Stuff) Hello() {
	return
}

func main() {
	stuff := Stuff{}
	stuffVal := reflect.ValueOf(&stuff)
	v := stuffVal.MethodByName("Things")
	fmt.Println(v.IsZero())
}

[xlab]

Can't add anything useful, but will say I ended up there today as well!

Basically, one needs to call IsValid before IsZero, thanks for that clarification at least.

[Cy-Tek]

Just wanted to put another +1 that having the documentation of other reflect functions say something like: "an invalid zero value" would have saved me a lot of time trying to figure out why IsZero was panicking on what it was seemingly designed for. Thanks to everyone who worked through this before me so I could move forward with my project!