feat: support underlying basic types in rlpgen

Author: ceyonur

rlp/rlpgen/gen.go

@@ -373,6 +373,30 @@ 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 := baseOp.(basicOp)
+	op.typ = named // Use the named type as the main type instead of the underlying basic type
+
+	// For decoding, we want to decode as the underlying basic type and convert to named type
+	// So we need to set decResultType to the underlying basic type
+	op.decResultType = basic
+
+	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
@@ -684,6 +708,9 @@ 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)
 		}

rlp/rlpgen/testdata/alias.in.txt

@@ -14,9 +14,11 @@ type (
     // Demonstrate recursive unaliasing
     intermediate = uint256.Int
     Uint256      = intermediate
+    Uint64T uint64 // This is not an alias, it's a new type
 )
 
 type Test struct {
     BigAlias     Big
     Uint256Alias Uint256
+    Uint64NewT Uint64T
 }

rlp/rlpgen/testdata/alias.out.txt

@@ -12,6 +12,7 @@ func (obj *Test) EncodeRLP(_w io.Writer) error {
 	}
 	w.WriteBigInt(&obj.BigAlias)
 	w.WriteUint256(&obj.Uint256Alias)
+	w.WriteUint64(uint64(obj.Uint64NewT))
 	w.ListEnd(_tmp0)
 	return w.Flush()
 }
@@ -34,6 +35,13 @@ func (obj *Test) DecodeRLP(dec *rlp.Stream) error {
 			return err
 		}
 		_tmp0.Uint256Alias = _tmp2
+		// Uint64NewT:
+		_tmp3, err := dec.Uint64()
+		if err != nil {
+			return err
+		}
+		_tmp4 := Uint64T(_tmp3)
+		_tmp0.Uint64NewT = _tmp4
 		if err := dec.ListEnd(); err != nil {
 			return err
 		}

rlp/rlpgen/types.go

@@ -113,6 +113,16 @@ 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()