math/big: Big.Int inconsistently marshals to JSON

[TACIXAT]

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

$ go version
go version go1.11 linux/amd64

Does this issue reproduce with the latest release?

Reproduces on go playground.

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

go env Output

$ go env
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/dg/.cache/go-build"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/home/dg/go"
GOPROXY=""
GORACE=""
GOROOT="/usr/local/go"
GOTMPDIR=""
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD=""
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-build283450947=/tmp/go-build -gno-record-gcc-switches"

What did you do?

Marshal a big.Int to JSON and it doesn't work.

Marshal a big.Int to JSON when inside a struct and it doesn't work.

Marshal a big.Int to JSON when it's inside a slice of structs and it does work.

package main

import (
	"fmt"
	"math/big"
	"encoding/json"
)

type Simple struct {
	I big.Int
}

type List struct {
	S []Simple
}

func main() {
	i := big.Int{}
	b := []byte{
		0x55, 0x55, 0x55, 0x55, 0x55, 
		0x55, 0x55, 0x55, 0x55, 0x55}
		
	i.SetBytes(b)
	
	fmt.Println("b", b)
	fmt.Println("i", i)
	
	// marshal and unmarshal big int
	j, _ := json.Marshal(i)
	// fmt.Println("ji", j)
	
	i2 := big.Int{}
	_ = json.Unmarshal(j, &i2)
	fmt.Println("i2", i2)
	
	// marshal and unmarshal big int in struct
	s := Simple{
		I: i}
		
	j, _ = json.Marshal(s)
	// fmt.Println("js", j)
	
	s2 := Simple{}
	_ = json.Unmarshal(j, &s2)
	fmt.Println("s2", s2)
	
	// marshal and unmarshal big int in struct in list
	l := List{}
	l.S = append(l.S, s)
	
	j, _ = json.Marshal(l)
	// fmt.Println("jl", j)
	
	l2 := List{}
	_ = json.Unmarshal(j, &l2)
	fmt.Println("l2", l2)
}

b [85 85 85 85 85 85 85 85 85 85]
i {false [1431655765 1431655765 21845]}
i2 {false []}
s2 {{false []}}
l2 {[{{false [1431655765 1431655765 21845]}}]}

https://play.golang.org/p/1pI0OCtLQDa

What did you expect to see?

Either it to fail consistently or work consistently.

What did you see instead?

The big.Int sometimes marshals correctly and sometimes does not.

What do you want out of this issue?

I'm mostly just curious why it works sometimes.

[dgryski]

You're ignoring the errors:

math/big: cannot unmarshal "{}" into a *big.Int

[TACIXAT]

Yes, that happens because it does not marshal correctly. Why does it marshal correctly when it is in a slice of structs but not alone or simply in the struct?

[TACIXAT]

For example, neither of these throw errors but fail to encode correctly.

package main

import (
	"fmt"
	"math/big"
	"encoding/json"
)

type Simple struct {
	I big.Int
}

type List struct {
	S []Simple
}

func main() {
	i := big.Int{}
	b := []byte{
		0x55, 0x55, 0x55, 0x55, 0x55, 
		0x55, 0x55, 0x55, 0x55, 0x55}
		
	i.SetBytes(b)
	
	fmt.Println("b", b)
	fmt.Println("i", i)
	
	// marshal and unmarshal big int
	j, err := json.Marshal(i)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("ji", j)
	
	// marshal and unmarshal big int in struct
	s := Simple{
		I: i}
		
	j, err = json.Marshal(s)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("js", j)
	
	// marshal and unmarshal big int in struct in list
	l := List{}
	l.S = append(l.S, s)
	
	j, _ = json.Marshal(l)
	fmt.Println("jl", j)
	
	l2 := List{}
	_ = json.Unmarshal(j, &l2)
	fmt.Println("l2", l2)
}

b [85 85 85 85 85 85 85 85 85 85]
i {false [1431655765 1431655765 21845]}
ji [123 125]
js [123 34 73 34 58 123 125 125]
jl [123 34 83 34 58 91 123 34 73 34 58 52 48 50 57 55 53 50 55 51 50 48 52 56 55 54 51 57 49 53 54 56 55 50 53 125 93 125]
l2 {[{{false [1431655765 1431655765 21845]}}]}

[AlexRouSg]

https://golang.org/pkg/math/big/#Int.MarshalJSON
func (x *Int) MarshalJSON() ([]byte, error)
Note the pointer receiver.

It is failing to marshal in those situations because the MarshalJSON method has a pointer receiver and you are passing a value and reflect.ValueOf(i).CanAddr() is false so there is no way for the json package to call the method.

See https://golang.org/pkg/reflect/#Value.CanAddr

A value is addressable if it is an element of a slice, an element of an addressable array, a field of an addressable struct, or the result of dereferencing a pointer

[TACIXAT]

Thanks!