reviews

Author: ceyonur

rlp/rlpgen/gen.go

@@ -373,29 +373,6 @@ func (op uint256Op) genDecode(ctx *genContext) (string, string) {
 	return result, b.String()
 }
 
-func (bctx *buildContext) makeNamedBasicOp(named *types.Named) (op, error) {
-	underlying := named.Underlying()
-	basic, ok := underlying.(*types.Basic)
-	if !ok {
-		return nil, fmt.Errorf("expected basic type, got %T", underlying)
-	}
-
-	// Use the existing makeBasicOp function to get the base operation
-	baseOp, err := bctx.makeBasicOp(basic)
-	if err != nil {
-		return nil, err
-	}
-
-	// Cast to basicOp and modify the typ field to use the named type
-	op, ok := baseOp.(basicOp)
-	if !ok {
-		return nil, fmt.Errorf("expected basicOp, got %T", baseOp)
-	}
-	op.typ = named // Use the named type as the main type instead of the underlying basic type
-
-	return op, nil
-}
-
 // encoderDecoderOp handles rlp.Encoder and rlp.Decoder.
 // In order to be used with this, the type must implement both interfaces.
 // This restriction may be lifted in the future by creating separate ops for
@@ -707,12 +684,15 @@ func (bctx *buildContext) makeOp(name *types.Named, typ types.Type, tags rlpstru
 		if typ == bctx.rawValueType {
 			return bctx.makeRawValueOp(), nil
 		}
-		if isNamedWithBasicUnderlying(typ) {
-			return bctx.makeNamedBasicOp(typ)
-		}
 		if bctx.isDecoder(typ) {
 			return nil, fmt.Errorf("type %v implements rlp.Decoder with non-pointer receiver", typ)
 		}
+		// libevm: named types are reduced to their underlying basic type in this loop.
+		// We're handling named types here by passing the named type as the main type.
+		// See [named.libevm.go] for more details.
+		if hasBasicUnderlying(typ) {
+			return bctx.makeNamedBasicOp(typ)
+		}
 		// TODO: same check for encoder?
 		return bctx.makeOp(typ, typ.Underlying(), tags)
 	case *types.Pointer:

rlp/rlpgen/gen_test.go

@@ -47,7 +47,7 @@ func init() {
 	}
 }
 
-var tests = []string{"uints", "nil", "rawvalue", "optional", "bigint", "uint256", "alias", "named"}
+var tests = []string{"uints", "nil", "rawvalue", "optional", "bigint", "uint256", "alias", "named.libevm"}
 
 func TestOutput(t *testing.T) {
 	for _, test := range tests {
@@ -66,7 +66,7 @@ func TestOutput(t *testing.T) {
 
 			// Set this environment variable to regenerate the test outputs.
 			if os.Getenv("WRITE_TEST_FILES") != "" {
-				os.WriteFile(outputFile, output, 0o644)
+				os.WriteFile(outputFile, output, 0644)
 			}
 
 			// Check if output matches.

rlp/rlpgen/named.libevm.go

@@ -0,0 +1,55 @@
+// Copyright 2025 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 main
+
+import (
+	"fmt"
+	"go/types"
+)
+
+// makeNamedBasicOp is a convenience wrapper for basicOp.
+// It returns a basicOp with the named type as the main type instead of the underlying basic type.
+func (bctx *buildContext) makeNamedBasicOp(named *types.Named) (op, error) {
+	underlying := named.Underlying()
+	basic, ok := underlying.(*types.Basic)
+	if !ok {
+		return nil, fmt.Errorf("expected basic type, got %T", underlying)
+	}
+
+	// We use basic op because it actually supports necessary conversions (through writeNeedsConversion and decodeNeedsConversion)
+	// for named types.
+	// The only problem with that is it does not support the named type as the main type.
+	// So we use the named type as the main type instead of the underlying basic type.
+	baseOp, err := bctx.makeBasicOp(basic)
+	if err != nil {
+		return nil, err
+	}
+
+	op, ok := baseOp.(basicOp)
+	if !ok {
+		return nil, fmt.Errorf("expected basicOp, got %T", baseOp)
+	}
+	op.typ = named
+
+	return op, nil
+}
+
+// hasBasicUnderlying checks whether `named` has an underlying basic type.
+func hasBasicUnderlying(named *types.Named) bool {
+	_, ok := named.Underlying().(*types.Basic)
+	return ok
+}

rlp/rlpgen/testdata/named.in.txt renamed to rlp/rlpgen/testdata/named.libevm.in.txt

@@ -113,16 +113,6 @@ func isByte(typ types.Type) bool {
 	return ok && basic.Kind() == types.Uint8
 }
 
-// isNamedWithBasicUnderlying checks whether 'typ' is a named type with an underlying basic type.
-func isNamedWithBasicUnderlying(typ types.Type) bool {
-	named, ok := typ.(*types.Named)
-	if !ok {
-		return false
-	}
-	_, ok = named.Underlying().(*types.Basic)
-	return ok
-}
-
 func resolveUnderlying(typ types.Type) types.Type {
 	for {
 		t := typ.Underlying()