Cleanup codec constants

codec/manager.go

@@ -13,6 +13,8 @@ import (
 )
 
 const (
+	CodecVersionSize = wrappers.ShortLen
+
 	// default max size, in bytes, of something being marshalled by Marshal()
 	defaultMaxSize = 256 * units.KiB
 
@@ -102,8 +104,8 @@ func (m *manager) Size(version uint16, value interface{}) (int, error) {
 
 	res, err := c.Size(value)
 
-	// Add [wrappers.ShortLen] for the codec version
-	return wrappers.ShortLen + res, err
+	// Add [CodecVersionSize] for the codec version
+	return CodecVersionSize + res, err
 }
 
 // To marshal an interface, [value] must be a pointer to the interface.

codec/reflectcodec/type_codec.go

@@ -25,8 +25,6 @@ const (
 var (
 	_ codec.Codec = (*genericCodec)(nil)
 
-	errMarshalNil              = errors.New("can't marshal nil pointer or interface")
-	errUnmarshalNil            = errors.New("can't unmarshal nil")
 	errNeedPointer             = errors.New("argument to unmarshal must be a pointer")
 	errRecursiveInterfaceTypes = errors.New("recursive interface types")
 )
@@ -84,7 +82,7 @@ func New(typer TypeCodec, tagNames []string) codec.Codec {
 
 func (c *genericCodec) Size(value interface{}) (int, error) {
 	if value == nil {
-		return 0, errMarshalNil // can't marshal nil
+		return 0, nil // can't marshal nil, we return zero size
 	}
 
 	size, _, err := c.size(reflect.ValueOf(value), nil /*=typeStack*/)
@@ -120,14 +118,14 @@ func (c *genericCodec) size(
 		return wrappers.StringLen(value.String()), false, nil
 	case reflect.Ptr:
 		if value.IsNil() {
-			return 0, false, errMarshalNil
+			return 0, false, nil // can't marshal nil, we return zero size
 		}
 
 		return c.size(value.Elem(), typeStack)
 
 	case reflect.Interface:
 		if value.IsNil() {
-			return 0, false, errMarshalNil
+			return 0, false, nil // can't marshal nil, we return zero size
 		}
 
 		underlyingValue := value.Interface()
@@ -154,10 +152,6 @@ func (c *genericCodec) size(
 			return 0, false, err
 		}
 
-		if size == 0 {
-			return 0, false, fmt.Errorf("can't marshal slice of zero length values: %w", codec.ErrMarshalZeroLength)
-		}
-
 		// For fixed-size types we manually calculate lengths rather than
 		// processing each element separately to improve performance.
 		if constSize {
@@ -294,7 +288,7 @@ func (c *genericCodec) size(
 // To marshal an interface, [value] must be a pointer to the interface
 func (c *genericCodec) MarshalInto(value interface{}, p *wrappers.Packer) error {
 	if value == nil {
-		return errMarshalNil // can't marshal nil
+		return codec.ErrMarshalNil // can't marshal nil
 	}
 
 	return c.marshal(reflect.ValueOf(value), p, nil /*=typeStack*/)
@@ -341,13 +335,13 @@ func (c *genericCodec) marshal(
 		return p.Err
 	case reflect.Ptr:
 		if value.IsNil() {
-			return errMarshalNil
+			return codec.ErrMarshalNil
 		}
 
 		return c.marshal(value.Elem(), p, typeStack)
 	case reflect.Interface:
 		if value.IsNil() {
-			return errMarshalNil
+			return codec.ErrMarshalNil
 		}
 
 		underlyingValue := value.Interface()
@@ -502,7 +496,7 @@ func (c *genericCodec) marshal(
 // interface
 func (c *genericCodec) Unmarshal(bytes []byte, dest interface{}) error {
 	if dest == nil {
-		return errUnmarshalNil
+		return codec.ErrUnmarshalNil
 	}
 
 	p := wrappers.Packer{

codec/test_codec.go

@@ -8,11 +8,15 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils/wrappers"
 )
 
 var (
 	Tests = []func(c GeneralCodec, t testing.TB){
 		TestStruct,
+		TestPartiallyFilledStruct,
+		TestSliceWithEmptyElements,
 		TestRegisterStructTwice,
 		TestUInt32,
 		TestUIntPtr,
@@ -241,6 +245,85 @@ func TestStruct(codec GeneralCodec, t testing.TB) {
 	require.Equal(myStructInstance, *myStructUnmarshaled)
 }
 
+func TestPartiallyFilledStruct(codec GeneralCodec, t testing.TB) {
+	require := require.New(t)
+
+	manager := NewDefaultManager()
+	require.NoError(manager.RegisterCodec(0, codec))
+
+	// a nil pointer cannot be marshalled but we can get its size
+	var nilStruct *myStruct
+	_, err := manager.Marshal(0, nilStruct)
+	require.ErrorIs(err, ErrMarshalNil)
+
+	bytesLen, err := manager.Size(0, nilStruct)
+	require.NoError(err)
+	require.Equal(CodecVersionSize, bytesLen)
+
+	// an empty struct cannot be marshalled but we can get its size
+	emptyStruct := &myStruct{}
+	_, err = manager.Marshal(0, nilStruct)
+	require.ErrorIs(err, ErrMarshalNil)
+
+	emptyStructLen := CodecVersionSize + 117
+	bytesLen, err = manager.Size(0, emptyStruct)
+	require.NoError(err)
+	require.Equal(emptyStructLen, bytesLen)
+
+	// an partially filled struct cannot be marshalled but we can get its size
+	elem := &MyInnerStruct{
+		Str: "a",
+	}
+	elemLen := CodecVersionSize + wrappers.StringLen(elem.Str)
+
+	partialStruct := &myStruct{
+		InnerStruct2: elem,
+	}
+	partialStructLen := emptyStructLen + elemLen - CodecVersionSize
+	bytesLen, err = manager.Size(0, partialStruct)
+	require.NoError(err)
+	require.Equal(partialStructLen, bytesLen)
+}
+
+func TestSliceWithEmptyElements(codec GeneralCodec, t testing.TB) {
+	require := require.New(t)
+
+	manager := NewDefaultManager()
+	require.NoError(manager.RegisterCodec(0, codec))
+
+	// a non-empty slice with nil pointers cannot be marshalled but we can get its size
+	slice := make([]*MyInnerStruct, 10)
+
+	_, err := manager.Marshal(0, slice)
+	require.ErrorIs(err, ErrMarshalNil)
+
+	emptySliceLen := CodecVersionSize + wrappers.IntLen // Codec version + slice size. Slice elements have zero size
+	bytesLen, err := manager.Size(0, slice)
+	require.NoError(err)
+	require.Equal(emptySliceLen, bytesLen)
+
+	elem := &MyInnerStruct{
+		Str: "aaa",
+	}
+	elemLen := CodecVersionSize + wrappers.StringLen(elem.Str)
+	bytesLen, err = manager.Size(0, elem)
+	require.NoError(err)
+	require.Equal(elemLen, bytesLen)
+
+	// we can fill some elements and leave other empty. Size will be sub-additive
+	slice[1] = elem
+	sliceLen := emptySliceLen + elemLen - CodecVersionSize // codec version is marshelled only once
+	bytesLen, err = manager.Size(0, slice)
+	require.NoError(err)
+	require.Equal(sliceLen, bytesLen)
+
+	slice[5] = elem
+	sliceLen += elemLen - CodecVersionSize // codec version is marshelled only once
+	bytesLen, err = manager.Size(0, slice)
+	require.NoError(err)
+	require.Equal(sliceLen, bytesLen)
+}
+
 func TestRegisterStructTwice(codec GeneralCodec, t testing.TB) {
 	require := require.New(t)
 
@@ -773,8 +856,9 @@ func TestSliceWithEmptySerializationError(codec GeneralCodec, t testing.TB) {
 	_, err := manager.Marshal(0, val)
 	require.ErrorIs(err, ErrMarshalZeroLength)
 
+	// we cannot marshal/unmarshal an empty slice, but we can ask its size
 	_, err = manager.Size(0, val)
-	require.ErrorIs(err, ErrMarshalZeroLength)
+	require.NoError(err)
 
 	b := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x01} // codec version (0x00, 0x00) then (0x00, 0x00, 0x00, 0x01) for numElts
 

vms/platformvm/state/metadata_validator.go

@@ -6,6 +6,7 @@ package state
 import (
 	"time"
 
+	"github.com/ava-labs/avalanchego/codec"
 	"github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils/constants"
@@ -17,7 +18,7 @@ import (
 // [preDelegateeRewardMetadata].
 //
 // CodecVersionLen + UpDurationLen + LastUpdatedLen + PotentialRewardLen
-const preDelegateeRewardSize = wrappers.ShortLen + 3*wrappers.LongLen
+const preDelegateeRewardSize = codec.CodecVersionSize + 3*wrappers.LongLen
 
 var _ validatorState = (*metadata)(nil)