Fastpath EntityManager.IsDefault (space-wizards#6735)

* Slim it down

Had the spawn mess included.

* fixes

* build fix

Author: metalgearsloth

Robust.Serialization.Generator/Generator.cs

@@ -198,6 +198,8 @@ private static (string, string)? GenerateForDataDefinition(
 
                 {{GetWriter(definition)}}
 
+                {{GetEquality(definition)}}
+
                 {{GetValidator(definition)}}
 
                 {{GetFieldDefinitions(definition)}}
@@ -1091,6 +1093,95 @@ public static void Write(
             """;
     }
 
+    private static string GetEquality(DataDefinition definition)
+    {
+        var builder = new StringBuilder();
+
+        if (definition.GetFirstDataDefinitionBaseType() is { } baseType)
+        {
+            builder.AppendLine($$"""
+                if (!{{baseType.ToDisplayString()}}.AreEqual(left, right, serialization, context))
+                    return false;
+                """);
+        }
+
+        foreach (var field in definition.Fields)
+        {
+            if (!definition.Type.Equals(field.Symbol.ContainingType, SymbolEqualityComparer.Default))
+                continue;
+
+            if (field.Attribute.ReadOnly)
+                continue;
+
+            var fieldType = field.Type.ToDisplayString();
+            if (IsMultidimensionalArray(field.Type))
+                fieldType = fieldType.Replace("*", "");
+
+            if (field.Type.NullableAnnotation == NullableAnnotation.Annotated &&
+                !fieldType.EndsWith("?"))
+            {
+                fieldType += "?";
+            }
+
+            var equalityExpression = GetFieldEqualityExpression(field, fieldType);
+
+            builder.AppendLine($$"""
+                if (!{{equalityExpression}})
+                    return false;
+                """);
+        }
+
+        builder.AppendLine("return true;");
+
+        return $$"""
+            public static bool AreEqual(
+                {{definition.GenericTypeName}} left,
+                {{definition.GenericTypeName}} right,
+                ISerializationManager serialization,
+                ISerializationContext? context = null)
+            {
+                {{builder}}
+            }
+            """;
+    }
+
+    private static string GetFieldEqualityExpression(DataField field, string fieldType)
+    {
+        var fieldName = field.Symbol.Name;
+
+        if (TryGetFastHashSetEquality(field.Type, $"left.{fieldName}", $"right.{fieldName}", out var hashSetEquality))
+            return hashSetEquality;
+
+        if (CanFieldUseDirectEquality(field))
+            return $"EqualityComparer<{fieldType}>.Default.Equals(left.{fieldName}, right.{fieldName})";
+
+        return $"serialization.DataFieldEquals<{fieldType}>(left.{fieldName}, right.{fieldName}, context)";
+    }
+
+    private static bool CanFieldUseDirectEquality(DataField field)
+    {
+        return CanTypeBeCopiedByValue(field.Type);
+    }
+
+    private static bool TryGetFastHashSetEquality(
+        ITypeSymbol type,
+        string leftAccess,
+        string rightAccess,
+        [NotNullWhen(true)] out string? equality)
+    {
+        equality = null;
+
+        if (type.WithNullableAnnotation(NullableAnnotation.None) is not INamedTypeSymbol namedType ||
+            !IsGenericCollectionType(namedType, "HashSet", 1))
+        {
+            return false;
+        }
+
+        equality =
+            $"ReferenceEquals({leftAccess}, {rightAccess}) || ({leftAccess} != null && {rightAccess} != null && {leftAccess}.SetEquals({rightAccess}))";
+        return true;
+    }
+
     private static string GetFieldDefinitions(DataDefinition definition)
     {
         var builder = new StringBuilder();

Robust.Shared.IntegrationTests/GameObjects/EntityManagerIsDefaultTests.cs

@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Spawners;
+using Robust.UnitTesting.Server;
+
+namespace Robust.UnitTesting.Shared.GameObjects;
+
+[TestFixture]
+internal sealed partial class EntityManagerIsDefaultTests
+{
+    private const string PrototypeId = "IsDefaultTestEntity";
+
+    private const string Prototypes = $"""
+        - type: entity
+          id: {PrototypeId}
+          name: test entity
+          description: test description
+          components:
+          - type: TimedDespawn
+            lifetime: 5
+        """;
+
+    [Test]
+    public void IsDefaultComparesAgainstPrototypeData()
+    {
+        var sim = RobustServerSimulation
+            .NewSimulation()
+            .RegisterComponents(factory =>
+            {
+                factory.RegisterClass<TimedDespawnComponent>();
+                factory.RegisterClass<PlacementReplacementComponent>();
+            })
+            .RegisterPrototypes(prototypes =>
+            {
+                prototypes.LoadString(Prototypes);
+                prototypes.ResolveResults();
+            })
+            .InitializeInstance();
+
+        var entMan = (EntityManager) sim.Resolve<IEntityManager>();
+        var map = sim.CreateMap().Uid;
+        var coords = new EntityCoordinates(map, default);
+        var entity = entMan.SpawnEntity(PrototypeId, coords);
+
+        Assert.That(entMan.IsDefault(entity), Is.True);
+
+        entMan.GetComponent<TimedDespawnComponent>(entity).Lifetime = 10;
+        Assert.That(entMan.IsDefault(entity), Is.False);
+        Assert.That(entMan.IsDefault(entity, new HashSet<string> { "TimedDespawn" }), Is.True);
+
+        entMan.GetComponent<TimedDespawnComponent>(entity).Lifetime = 5;
+        entMan.AddComponent<PlacementReplacementComponent>(entity);
+        Assert.That(entMan.IsDefault(entity), Is.False);
+    }
+
+    [Test]
+    public void DataFieldEqualsComparesHashSetsAsSets()
+    {
+        var sim = RobustServerSimulation
+            .NewSimulation()
+            .InitializeInstance();
+
+        var serialization = sim.Resolve<ISerializationManager>();
+
+        Assert.That(serialization.DataFieldEquals(
+            new HashSet<int> { 1, 2, 3 },
+            new HashSet<int> { 3, 2, 1 }), Is.True);
+
+        Assert.That(serialization.DataFieldEquals(
+            new HashSet<int> { 1, 2, 3 },
+            new HashSet<int> { 1, 2, 4 }), Is.False);
+    }
+}

Robust.Shared.IntegrationTests/Serialization/EqualityTest.cs

@@ -0,0 +1,62 @@
+using NUnit.Framework;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Robust.UnitTesting.Shared.Serialization;
+
+[TestFixture]
+internal sealed class EqualityTest : OurSerializationTest
+{
+    [Test]
+    public void DataFieldEqualsUsesRuntimeDataDefinition()
+    {
+        EqualityBase left = new EqualityDerived { BaseValue = 1, DerivedValue = 2 };
+        EqualityBase right = new EqualityDerived { BaseValue = 1, DerivedValue = 3 };
+
+        Assert.That(Serialization.DataFieldEquals(left, right), Is.False);
+
+        ((EqualityDerived) right).DerivedValue = 2;
+        Assert.That(Serialization.DataFieldEquals(left, right), Is.True);
+    }
+
+    [Test]
+    public void DataFieldEqualsUsesSerializedFieldsInsteadOfObjectEquals()
+    {
+        var left = new EqualityOverride { Value = 1 };
+        var right = new EqualityOverride { Value = 2 };
+
+        Assert.That(left.Equals(right), Is.True);
+        Assert.That(Serialization.DataFieldEquals(left, right), Is.False);
+        Assert.That(Serialization.DataFieldEquals<EqualityOverride[]>([left], [right]), Is.False);
+    }
+}
+
+[DataDefinition]
+public abstract partial class EqualityBase
+{
+    [DataField]
+    public int BaseValue;
+}
+
+[DataDefinition]
+public sealed partial class EqualityDerived : EqualityBase
+{
+    [DataField]
+    public int DerivedValue;
+}
+
+[DataDefinition]
+public sealed partial class EqualityOverride
+{
+    [DataField]
+    public int Value;
+
+    public override bool Equals(object? obj)
+    {
+        return obj is EqualityOverride;
+    }
+
+    public override int GetHashCode()
+    {
+        return 0;
+    }
+}

Robust.Shared/GameObjects/EntityManager.cs

@@ -180,12 +180,11 @@ public bool IsDefault(EntityUid uid, ICollection<string>? ignoredComps = null)
                 return false;
             }
 
-            var protoData = PrototypeManager.GetPrototypeData(prototype);
             var comps = _entCompIndex[uid];
+            var hasIgnoredComps = ignoredComps is { Count: > 0 };
 
             // Fast check if the component counts match.
-            // Note that transform and metadata are not included in the prototype data.
-            if (protoData.Count + 2 != comps.Count)
+            if (prototype.Components.Count + 2 != comps.Count)
                 return false;
 
             foreach (var component in comps)
@@ -195,34 +194,19 @@ public bool IsDefault(EntityUid uid, ICollection<string>? ignoredComps = null)
 
                 var compType = component.GetType();
 
-                if (compType == typeof(TransformComponent) || compType == typeof(MetaDataComponent))
+                if (compType == _xformReg.Type || compType == _metaReg.Type)
                     continue;
 
-                var compName = _componentFactory.GetComponentName(compType);
+                var compReg = _componentFactory.GetRegistration(compType);
 
-                if (ignoredComps?.Contains(compName) == true)
+                if (hasIgnoredComps && ignoredComps!.Contains(compReg.Name))
                     continue;
 
                 // If the component isn't on the prototype then it's custom.
-                if (!protoData.TryGetValue(compName, out var protoMapping))
+                if (!prototype.Components.TryGetValue(compReg.Name, out var protoEntry))
                     return false;
 
-                MappingDataNode compMapping;
-                try
-                {
-                    compMapping = _serManager.WriteValueAs<MappingDataNode>(compType, component, alwaysWrite: true, context: _context);
-                }
-                catch (Exception e)
-                {
-                    _sawmill.Error($"Failed to serialize {compName} component of entity prototype {prototype.ID}. Exception: {e.Message}");
-#if !EXCEPTION_TOLERANCE
-                    throw;
-#else
-                    return false;
-#endif
-                }
-
-                if (compMapping.AnyExcept(protoMapping))
+                if (!_serManager.DataFieldEquals(compReg.Type, component, protoEntry.Component, _context))
                     return false;
             }
 

Robust.Shared/Serialization/ISerializationGenerated.cs

@@ -64,6 +64,16 @@ static virtual void Write(
         throw new NotImplementedException();
     }
 
+    [Obsolete("Used only in serialization source generation internally")]
+    static virtual bool AreEqual(
+        T left,
+        T right,
+        ISerializationManager serialization,
+        ISerializationContext? context = null)
+    {
+        throw new NotImplementedException();
+    }
+
     /// <seealso cref="ISerializationManager.ValidateNode"/>
     [Obsolete("Use ISerializationManager.ValidateNode instead")]
     static virtual void Validate(

Robust.Shared/Serialization/Manager/Definition/DataDefinition.cs

@@ -31,6 +31,7 @@ internal sealed class DataDefinition<T> : DataDefinition where T : ISerializatio
         internal readonly PopulateDelegateSignature<T> Populate;
         internal readonly SerializeDelegateSignature<T> Serialize;
         internal readonly CopyDelegateSignature<T> CopyTo;
+        internal readonly EqualDelegateSignature<T> AreEqual;
 
         internal override PopulateDelegateSignature<object> PopulateObj { get; init; }
 #pragma warning restore CS0618
@@ -95,6 +96,7 @@ internal DataDefinition(SerializationManager manager, bool isRecord)
             Populate = T.Read;
             Serialize = T.Write;
             CopyTo = (source, ref target, ctx, context) => source.Copy(ref target, manager, ctx, context); // TODO source gen this one too!
+            AreEqual = T.AreEqual;
             FieldValidators = T.Validate;
             InstantiateObj = T.StaticInstantiateObject;
 #pragma warning restore CS0618

Robust.Shared/Serialization/Manager/Definition/DataDefinitionDelegates.cs

@@ -34,6 +34,14 @@ internal delegate void SerializeDelegateSignature<T>(
     ImmutableDictionary<string, object?> defaultValues
 );
 
+[Obsolete("Used only in source generation")]
+internal delegate bool EqualDelegateSignature<T>(
+    T left,
+    T right,
+    ISerializationManager serialization,
+    ISerializationContext? context
+);
+
 [Obsolete("Used only in source generation")]
 internal delegate void ValidateAllFieldsDelegate(
     Dictionary<string, ValidationNode> nodes,

Robust.Shared/Serialization/Manager/ISerializationManager.cs

@@ -266,6 +266,21 @@ T Read<T, TNode, TReader>(
 
         #endregion
 
+        #region Equality
+
+        /// <summary>
+        /// Compares serialized data fields structurally, including generated data definitions and collections.
+        /// </summary>
+        bool DataFieldEquals<T>(T left, T right, ISerializationContext? context = null);
+
+        /// <summary>
+        /// Compares serialized data fields structurally when their type is only known at runtime.
+        /// </summary>
+        [PreferGenericVariant]
+        bool DataFieldEquals(Type type, object? left, object? right, ISerializationContext? context = null);
+
+        #endregion
+
         #region Copy
 
         /// <summary>