feat: pseudo.Type.Format() implements fmt.Formatter

Author: ARR4N

core/state/snapshot/snapshot_test.go

@@ -119,7 +119,7 @@ func TestDiskLayerExternalInvalidationFullFlatten(t *testing.T) {
 	}
 	// Since the base layer was modified, ensure that data retrievals on the external reference fail
 	if acc, err := ref.Account(common.HexToHash("0x01")); err != ErrSnapshotStale {
-		t.Errorf("stale reference returned account: %+v (err: %v)", acc, err)
+		t.Errorf("stale reference returned account: %#x (err: %v)", acc, err)
 	}
 	if slot, err := ref.Storage(common.HexToHash("0xa1"), common.HexToHash("0xb1")); err != ErrSnapshotStale {
 		t.Errorf("stale reference returned storage slot: %#x (err: %v)", slot, err)
@@ -169,7 +169,7 @@ func TestDiskLayerExternalInvalidationPartialFlatten(t *testing.T) {
 	}
 	// Since the base layer was modified, ensure that data retrievals on the external reference fail
 	if acc, err := ref.Account(common.HexToHash("0x01")); err != ErrSnapshotStale {
-		t.Errorf("stale reference returned account: %+v (err: %v)", acc, err)
+		t.Errorf("stale reference returned account: %#x (err: %v)", acc, err)
 	}
 	if slot, err := ref.Storage(common.HexToHash("0xa1"), common.HexToHash("0xb1")); err != ErrSnapshotStale {
 		t.Errorf("stale reference returned storage slot: %#x (err: %v)", slot, err)
@@ -231,7 +231,7 @@ func TestDiffLayerExternalInvalidationPartialFlatten(t *testing.T) {
 	}
 	// Since the accumulator diff layer was modified, ensure that data retrievals on the external reference fail
 	if acc, err := ref.Account(common.HexToHash("0x01")); err != ErrSnapshotStale {
-		t.Errorf("stale reference returned account: %+v (err: %v)", acc, err)
+		t.Errorf("stale reference returned account: %#x (err: %v)", acc, err)
 	}
 	if slot, err := ref.Storage(common.HexToHash("0xa1"), common.HexToHash("0xb1")); err != ErrSnapshotStale {
 		t.Errorf("stale reference returned storage slot: %#x (err: %v)", slot, err)
@@ -280,7 +280,7 @@ func TestPostCapBasicDataAccess(t *testing.T) {
 	// shouldErr checks that an account access errors as expected
 	shouldErr := func(layer *diffLayer, key string) error {
 		if data, err := layer.Account(common.HexToHash(key)); err == nil {
-			return fmt.Errorf("expected error, got data %+v", data)
+			return fmt.Errorf("expected error, got data %x", data)
 		}
 		return nil
 	}

core/types/rlp_payload.libevm.go

@@ -17,6 +17,7 @@
 package types
 
 import (
+	"fmt"
 	"io"
 
 	"github.com/ethereum/go-ethereum/libevm/pseudo"
@@ -40,6 +41,10 @@ func RegisterExtras[SA any]() ExtraPayloads[SA] {
 	}
 	var extra ExtraPayloads[SA]
 	registeredExtras = &extraConstructors{
+		stateAccountType: func() string {
+			var x SA
+			return fmt.Sprintf("%T", x)
+		}(),
 		newStateAccount:   pseudo.NewConstructor[SA]().Zero,
 		cloneStateAccount: extra.cloneStateAccount,
 	}
@@ -49,6 +54,7 @@ func RegisterExtras[SA any]() ExtraPayloads[SA] {
 var registeredExtras *extraConstructors
 
 type extraConstructors struct {
+	stateAccountType  string
 	newStateAccount   func() *pseudo.Type
 	cloneStateAccount func(*StateAccountExtra) *StateAccountExtra
 }
@@ -123,6 +129,7 @@ func (e *StateAccountExtra) payload() *pseudo.Type {
 var _ interface {
 	rlp.Encoder
 	rlp.Decoder
+	fmt.Formatter
 } = (*StateAccountExtra)(nil)
 
 // EncodeRLP implements the [rlp.Encoder] interface.
@@ -151,3 +158,18 @@ func (e *StateAccountExtra) DecodeRLP(s *rlp.Stream) error {
 		return s.Decode(e.t)
 	}
 }
+
+// Format implements the [fmt.Formatter] interface.
+func (e *StateAccountExtra) Format(s fmt.State, verb rune) {
+	var out string
+	switch r := registeredExtras; {
+	case r == nil:
+		out = "<nil>"
+	case e == nil, e.t == nil:
+		out = fmt.Sprintf("<nil>[*StateAccountExtra[%s]]", r.stateAccountType)
+	default:
+		e.t.Format(s, verb)
+		return
+	}
+	_, _ = s.Write([]byte(out))
+}

libevm/pseudo/fmt.go

@@ -0,0 +1,56 @@
+// Copyright 2024 the libevm authors.
+//
+// The libevm additions to go-ethereum are free software: you can redistribute
+// them and/or modify them under the terms of the GNU Lesser General Public License
+// as published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The libevm additions are distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package pseudo
+
+import (
+	"fmt"
+)
+
+var _ = []fmt.Formatter{
+	(*Type)(nil),
+	(*Value[struct{}])(nil),
+	(*concrete[struct{}])(nil),
+}
+
+// Format implements the [fmt.Formatter] interface.
+func (t *Type) Format(s fmt.State, verb rune) {
+	switch {
+	case t == nil, t.val == nil:
+		writeToFmtState(s, "<nil>[pseudo.Type[unknown]]")
+	default:
+		t.val.Format(s, verb)
+	}
+}
+
+// Format implements the [fmt.Formatter] interface.
+func (v *Value[T]) Format(s fmt.State, verb rune) { v.t.Format(s, verb) }
+
+func (c *concrete[T]) Format(s fmt.State, verb rune) {
+	switch {
+	case c == nil:
+		writeToFmtState(s, "<nil>[pseudo.Type[%T]]", concrete[T]{}.val)
+	default:
+		// Respects the original formatting directive. fmt all the way down!
+		format := fmt.Sprintf("pseudo.Type[%%T]{%s}", fmt.FormatString(s, verb))
+		writeToFmtState(s, format, c.val, c.val)
+	}
+}
+
+func writeToFmtState(s fmt.State, format string, a ...any) {
+	// There is no way to bubble errors out from a `fmt.Formatter`.
+	_, _ = s.Write([]byte(fmt.Sprintf(format, a...)))
+}

libevm/pseudo/fmt_test.go

@@ -0,0 +1,82 @@
+// Copyright 2024 the libevm authors.
+//
+// The libevm additions to go-ethereum are free software: you can redistribute
+// them and/or modify them under the terms of the GNU Lesser General Public License
+// as published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The libevm additions are distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package pseudo
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormat(t *testing.T) {
+	tests := []struct {
+		name         string
+		from         any
+		format       string
+		wantContains []string
+	}{
+		{
+			name:         "width",
+			from:         42,
+			format:       "%04d",
+			wantContains: []string{"int", "0042"},
+		},
+		{
+			name:         "precision",
+			from:         float64(2),
+			format:       "%.5f",
+			wantContains: []string{"float64", "2.00000"},
+		},
+		{
+			name:         "flag",
+			from:         42,
+			format:       "%+d",
+			wantContains: []string{"int", "+42"},
+		},
+		{
+			name:         "verb",
+			from:         42,
+			format:       "%x",
+			wantContains: []string{"int", "2a"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := fmt.Sprintf(tt.format, fromAny(t, tt.from))
+			for _, want := range tt.wantContains {
+				assert.Containsf(t, got, want, "fmt.Sprintf(%q, From(%T[%[2]v]))", tt.format, tt.from)
+			}
+		})
+	}
+}
+
+func fromAny(t *testing.T, x any) *Type {
+	t.Helper()
+
+	// Without this, the function will be From[any]().
+	switch x := x.(type) {
+	case int:
+		return From(x).Type
+	case float64:
+		return From(x).Type
+	default:
+		t.Fatalf("Bad test setup: add type case for %T", x)
+		return nil
+	}
+}

libevm/pseudo/type.go

@@ -193,6 +193,7 @@ type value interface {
 	json.Unmarshaler
 	rlp.Encoder
 	rlp.Decoder
+	fmt.Formatter
 }
 
 type concrete[T any] struct {