align xlang struct serialization

Author: chaokunyang

cpp/fory/serialization/struct_serializer.h

@@ -318,12 +318,12 @@ template <typename T> struct CompileTimeFieldHelpers {
     }
   }
 
-  /// Returns true if the field at Index is nullable.
+  /// Returns true if the field at Index is nullable for fingerprint computation.
   /// This checks:
   /// 1. If the field is a fory::field<>, use its is_nullable metadata
   /// 2. Else if FORY_FIELD_TAGS is defined, use that metadata
-  /// 3. Otherwise, use legacy behavior: requires_ref_metadata_v (optional,
-  ///    shared_ptr, unique_ptr are all nullable)
+  /// 3. Otherwise, use xlang defaults: only std::optional is nullable
+  ///    (For xlang: nullable=false by default, except for Optional types)
   template <size_t Index> static constexpr bool field_nullable() {
     if constexpr (FieldCount == 0) {
       return false;
@@ -339,11 +339,12 @@ template <typename T> struct CompileTimeFieldHelpers {
       else if constexpr (::fory::detail::has_field_tags_v<T>) {
         return ::fory::detail::GetFieldTagEntry<T, Index>::is_nullable;
       }
-      // For non-wrapped types, use legacy behavior:
-      // optional, shared_ptr, unique_ptr are all "nullable" in terms of
-      // wire format (they write ref/null flags)
+      // For non-wrapped types, use xlang defaults:
+      // Only std::optional is nullable (field_is_nullable_v returns true for
+      // optional). For xlang consistency, shared_ptr/unique_ptr are NOT
+      // nullable by default - users must explicitly mark them as nullable.
       else {
-        return requires_ref_metadata_v<RawFieldType>;
+        return field_is_nullable_v<RawFieldType>;
       }
     }
   }

go/fory/pointer.go

@@ -60,6 +60,26 @@ func (s *ptrToValueSerializer) Write(ctx *WriteContext, refMode RefMode, writeTy
 			return
 		}
 		ctx.Buffer().WriteInt8(NotNullValueFlag)
+	case RefModeNone:
+		// For RefModeNone with nullable=false, we should NOT write any null flag.
+		// The xlang protocol expects the value data directly without any header.
+		// If the pointer is nil, write a zero/default value for the underlying type.
+		// This can happen in schema evolution when a field is missing from the remote data.
+		if value.IsNil() {
+			// Create a zero value for the underlying type and write it
+			zeroValue := reflect.New(value.Type().Elem()).Elem()
+			if writeType {
+				typeInfo, err := ctx.TypeResolver().getTypeInfo(zeroValue, true)
+				if err != nil {
+					ctx.SetError(FromError(err))
+					return
+				}
+				ctx.TypeResolver().WriteTypeInfo(ctx.Buffer(), typeInfo, ctx.Err())
+			}
+			s.valueSerializer.WriteData(ctx, zeroValue)
+			return
+		}
+		// Do NOT write any flag - just continue to write the value data
 	}
 	if writeType {
 		// Always use TypeResolver to get the correct TypeID from registered TypeInfo
@@ -116,6 +136,9 @@ func (s *ptrToValueSerializer) Read(ctx *ReadContext, refMode RefMode, readType
 		if flag == NullFlag {
 			return
 		}
+	case RefModeNone:
+		// For RefModeNone with nullable=false, no null flag was written.
+		// Just continue to read the value data directly.
 	}
 	if readType {
 		// Read type info - in compatible mode this contains the serializer with fieldDefs

go/fory/skip.go

@@ -673,17 +673,8 @@ func skipValue(ctx *ReadContext, fieldDef FieldDef, readRefFlag bool, isField bo
 }
 
 // fieldNeedWriteRef determines if a field needs a ref flag based on its type and nullability
+// For xlang: only nullable fields need ref/null header. Non-nullable fields are written directly.
+// This matches the xlang spec where nullable=false means no null flag is written.
 func fieldNeedWriteRef(typeId TypeId, nullable bool) bool {
-	if nullable {
-		return true
-	}
-	// Non-nullable container types still need ref tracking
-	switch typeId {
-	case LIST, SET, MAP:
-		return true
-	case STRING, BINARY:
-		return true
-	default:
-		return false
-	}
+	return nullable
 }