fix: require explicit Go named registration

Author: chaokunyang

go/fory/fory.go

@@ -824,7 +824,8 @@ func readHeaderSlow(ctx *ReadContext, bitmap byte) {
 
 // Serialize - type T inferred, serializer auto-resolved.
 // The serializer handles its own ref/type info writing internally.
-// Falls back to reflection-based serialization for unregistered types.
+// Uses reflection-based serializers for supported non-struct types. Structs must
+// be registered explicitly before serialization.
 // Note: For structs, T must be a pointer to struct (*MyStruct), not struct value.
 //
 // IMPORTANT: The returned byte slice is a zero-copy view of the internal buffer.

go/fory/fory_test.go

@@ -295,6 +295,46 @@ func TestSerializeStructSimple(t *testing.T) {
 	}
 }
 
+type explicitRegistrationUser struct {
+	Name string
+}
+
+func TestNamedStructRegistrationCoversPointer(t *testing.T) {
+	fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(false))
+	require.NoError(t, fory.RegisterStructByName(explicitRegistrationUser{}, "example.User"))
+
+	value := explicitRegistrationUser{Name: "alice"}
+	buf := NewByteBuffer(nil)
+	require.NoError(t, fory.SerializeWithCallback(buf, value, nil))
+	var decodedValue explicitRegistrationUser
+	require.NoError(t, fory.DeserializeWithCallbackBuffers(
+		NewByteBuffer(buf.GetByteSlice(0, buf.WriterIndex())),
+		&decodedValue,
+		nil))
+	require.Equal(t, value, decodedValue)
+
+	data, err := fory.Marshal(&value)
+	require.NoError(t, err)
+	var decodedPointer explicitRegistrationUser
+	require.NoError(t, fory.Unmarshal(data, &decodedPointer))
+	require.Equal(t, value, decodedPointer)
+}
+
+func TestUnregisteredStructSerializationFails(t *testing.T) {
+	value := explicitRegistrationUser{Name: "bob"}
+
+	fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(false))
+	buf := NewByteBuffer(nil)
+	err := fory.SerializeWithCallback(buf, value, nil)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "must be registered explicitly")
+
+	fory = NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(false))
+	_, err = fory.Marshal(&value)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "must be registered explicitly")
+}
+
 func TestRegisterById(t *testing.T) {
 	fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(false))
 	type simple struct {

go/fory/fory_typed_test.go

@@ -171,7 +171,7 @@ func TestDeserializeByteSliceAcceptsUint8ArrayRootType(t *testing.T) {
 }
 
 // TestSerializeGenericComplex tests Serialize[T]/DeserializeWithCallbackBuffers[T] with complex types.
-// These fall back to reflection-based serialization.
+// Struct wrappers must be registered explicitly before reflection-based serialization.
 func TestSerializeGenericComplex(t *testing.T) {
 	f := NewFory(WithXlang(false), WithRefTracking(true))
 
@@ -199,6 +199,7 @@ func TestSerializeGenericComplex(t *testing.T) {
 		type SliceWrapper struct {
 			Items []int32
 		}
+		require.NoError(t, f.RegisterStructByName(SliceWrapper{}, "example.SliceWrapper"))
 		original := SliceWrapper{Items: []int32{1, 2, 3, 4, 5}}
 		data, err := Serialize(f, &original)
 		require.NoError(t, err)
@@ -214,6 +215,7 @@ func TestSerializeGenericComplex(t *testing.T) {
 		type MapWrapper struct {
 			Items map[string]int32
 		}
+		require.NoError(t, f.RegisterStructByName(MapWrapper{}, "example.MapWrapper"))
 		original := MapWrapper{Items: map[string]int32{"a": 1, "b": 2, "c": 3}}
 		data, err := Serialize(f, &original)
 		require.NoError(t, err)

go/fory/threadsafe/fory_test.go

@@ -144,6 +144,7 @@ func TestDeserialize(t *testing.T) {
 		type SliceWrapper struct {
 			Items []int32
 		}
+		require.NoError(t, f.RegisterStructByName(SliceWrapper{}, "threadsafe.SliceWrapper"))
 		original := SliceWrapper{Items: []int32{1, 2, 3, 4, 5}}
 		data, err := Serialize(f, &original)
 		require.NoError(t, err)

go/fory/type_resolver.go

@@ -1045,20 +1045,8 @@ func (r *TypeResolver) getTypeInfo(value reflect.Value, create bool) (*TypeInfo,
 			return ptrInfo, nil
 		}
 
-		// Element type not registered - try auto-registration for structs
 		if elemType.Kind() == reflect.Struct {
-			// First register the value type
-			elemPkgPath := elemType.PkgPath()
-			elemTypeName := elemType.Name()
-			if err := r.registerStructByName(elemType, elemPkgPath, elemTypeName); err != nil {
-				// Might already be registered, that's okay
-				_ = err
-			}
-			// Now the pointer type should be registered
-			if info, ok := r.typesInfo[type_]; ok {
-				return info, nil
-			}
-			return nil, fmt.Errorf("failed to find registered pointer type %v", type_)
+			return nil, fmt.Errorf("struct type %s must be registered explicitly before serializing %s", elemType, type_)
 		}
 
 		// For primitive types and other types, we can auto-create pointer serializer
@@ -1081,6 +1069,8 @@ func (r *TypeResolver) getTypeInfo(value reflect.Value, create bool) (*TypeInfo,
 		return nil, fmt.Errorf("pointer element type %v must be registered", elemType)
 	case type_.Kind() == reflect.Interface:
 		return nil, fmt.Errorf("interface types must be registered explicitly")
+	case type_.Kind() == reflect.Struct:
+		return nil, fmt.Errorf("struct type %s must be registered explicitly", type_)
 	case pkgPath == "" && typeName == "":
 		// Allow anonymous collection types (maps, slices, arrays) without registration
 		kind := type_.Kind()
@@ -1808,23 +1798,7 @@ func (r *TypeResolver) createSerializer(type_ reflect.Type, mapInStruct bool) (s
 	case reflect.Struct:
 		serializer := r.typeToSerializers[type_]
 		if serializer == nil {
-			// In xlang/compatible mode, auto-register struct types
-			if r.isXlang || r.fory.config.Compatible {
-				// Use the type's actual package path and name for auto-registration
-				pkgPath := type_.PkgPath()
-				typeName := type_.Name()
-				if typeName == "" {
-					return nil, fmt.Errorf("cannot auto-register anonymous struct type %s", type_.String())
-				}
-				// For auto-registered types, use package path as namespace and type name
-				if err := r.registerStructByName(type_, pkgPath, typeName); err != nil {
-					return nil, fmt.Errorf("failed to auto-register struct %s: %w", type_.String(), err)
-				}
-				serializer = r.typeToSerializers[type_]
-			}
-			if serializer == nil {
-				return nil, fmt.Errorf("struct type %s not registered", type_.String())
-			}
+			return nil, fmt.Errorf("struct type %s must be registered explicitly", type_.String())
 		}
 		return serializer, nil
 	}