fix: NGO CoreCLR compatibility

Resolves the NGO CoreCLR test failures and re-enables every test that was disabled for CoreCLR.

UUM-149592 - NetworkVariable serialization codegen not generated for some types
- CoreCLR enforces generic constraints on method instantiations and Mono does not. The ILPP-generated
  NetworkVariableSerializationHelper.InitializeSerialization emitted
  InitializeEqualityChecker_HashSet<HashSet<int>>, which violates T : IEquatable<T>, so CoreCLR rejected
  the whole method and every type registered by that assembly fell back to FallbackSerializer.
- Removed the IEquatable<T> constraint from InitializeEqualityChecker_HashSet<T> and
  EqualityEqualsHashSet<T>. Neither uses it, and #3891 already removed it from the rest of the HashSet
  serialization path to support nested HashSets.
- NetworkBehaviourILPP now validates every emitted serializer and equality checker call against its
  generic constraints, and reports a compile error instead of emitting IL that CoreCLR rejects.

UUM-149591 - integration tests fail to start server and client instances
- Mostly a consequence of UUM-149592: player prefabs with NetworkVariables threw during synchronization,
  so connections never completed.
- PeerDisconnectCallbackTests assumed client ids follow creation order. It now finds the target client
  by id.

UUM-149595 - DAHost player-prefab fetch throws "An item with the same key has already been added"
- NetworkClientAndPlayerObjectTests never cleared m_ChangedPlayerPrefabs between tests and keyed each
  fetched prefab on the last client's id. It now clears the dictionary on teardown and keys on the
  fetching client.

UUM-149597 - unexpected owner write-permission error
- OwnerPermissionHideTests assumed client ids follow creation order. Each object's owner is now chosen
  by client id.

Removed all ENABLE_CORECLR [Explicit] and [UnityCoreClrExplicitDisabled] attributes. Every previously
disabled test passes on CoreCLR (833/833), and the full PlayMode (5423 passed, 0 failed) and EditMode
(1371 passed) suites pass on a trunk CoreCLR editor.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Editor/CodeGen/CodeGenHelpers.cs

@@ -208,6 +208,148 @@ public static bool HasInterface(this TypeReference typeReference, string interfa
             }
         }
 
+        /// <summary>
+        /// Checks a generic method instantiation against the generic constraints of the method it instantiates.
+        /// Mono does not enforce these on the calls codegen emits, but CoreCLR does, and it rejects the entire
+        /// calling method if any single call in it violates them.
+        /// </summary>
+        /// <param name="method">The instantiation to validate.</param>
+        /// <param name="violation">Why the instantiation is invalid, or null when it is valid.</param>
+        /// <returns>True if every generic argument satisfies its parameter's constraints.</returns>
+        public static bool SatisfiesGenericConstraints(this GenericInstanceMethod method, out string violation)
+        {
+            var genericParameters = method.ElementMethod.Resolve().GenericParameters;
+            for (var i = 0; i < genericParameters.Count; ++i)
+            {
+                var parameter = genericParameters[i];
+                var argument = method.GenericArguments[i];
+                violation = GetConstraintViolation(parameter, argument, method.GenericArguments);
+                if (violation != null)
+                {
+                    violation = $"{argument.FullName} {violation} (required by {parameter.Name} on {method.ElementMethod.Name})";
+                    return false;
+                }
+            }
+
+            violation = null;
+            return true;
+        }
+
+        private static string GetConstraintViolation(GenericParameter parameter, TypeReference argument, IList<TypeReference> methodArguments)
+        {
+            var resolved = argument.Resolve();
+            if (resolved == null)
+            {
+                return "could not be resolved";
+            }
+
+            if (parameter.HasNotNullableValueTypeConstraint && (!resolved.IsValueType || resolved.FullName == typeof(Nullable<>).FullName))
+            {
+                return "is not a non-nullable value type";
+            }
+
+            if (parameter.HasReferenceTypeConstraint && resolved.IsValueType)
+            {
+                return "is not a reference type";
+            }
+
+            if (parameter.HasDefaultConstructorConstraint && !resolved.IsValueType && (resolved.IsAbstract || !HasPublicParameterlessConstructor(resolved)))
+            {
+                return "does not have a public parameterless constructor";
+            }
+
+            foreach (var constraint in parameter.Constraints)
+            {
+#if CECIL_CONSTRAINTS_ARE_TYPE_REFERENCES
+                var constraintType = constraint;
+#else
+                var constraintType = constraint.ConstraintType;
+#endif
+                // The unmanaged constraint is encoded as System.ValueType modreq(UnmanagedType); the runtime only checks the value type part.
+                if (constraintType is RequiredModifierType modifierType)
+                {
+                    constraintType = modifierType.ElementType;
+                }
+
+                constraintType = SubstituteGenericArguments(constraintType, GenericParameterType.Method, methodArguments);
+                if (constraintType.FullName == typeof(ValueType).FullName)
+                {
+                    continue;
+                }
+
+                if (!IsAssignableTo(argument, constraintType.FullName))
+                {
+                    return $"does not implement or derive from {constraintType.FullName}";
+                }
+            }
+
+            return null;
+        }
+
+        private static bool HasPublicParameterlessConstructor(TypeDefinition type)
+        {
+            foreach (var method in type.Methods)
+            {
+                if (method.IsConstructor && !method.IsStatic && method.IsPublic && !method.HasParameters)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool IsAssignableTo(TypeReference type, string targetFullName)
+        {
+            if (type.FullName == targetFullName)
+            {
+                return true;
+            }
+
+            var resolved = type.Resolve();
+            if (resolved == null)
+            {
+                return false;
+            }
+
+            // Interfaces and the base type are declared against the definition's own generic parameters, so close them over this instance's arguments.
+            var typeArguments = (type as GenericInstanceType)?.GenericArguments;
+            foreach (var implemented in resolved.Interfaces)
+            {
+                if (IsAssignableTo(SubstituteGenericArguments(implemented.InterfaceType, GenericParameterType.Type, typeArguments), targetFullName))
+                {
+                    return true;
+                }
+            }
+
+            return resolved.BaseType != null && IsAssignableTo(SubstituteGenericArguments(resolved.BaseType, GenericParameterType.Type, typeArguments), targetFullName);
+        }
+
+        private static TypeReference SubstituteGenericArguments(TypeReference type, GenericParameterType parameterType, IList<TypeReference> arguments)
+        {
+            if (arguments == null)
+            {
+                return type;
+            }
+
+            if (type is GenericParameter genericParameter && genericParameter.Type == parameterType)
+            {
+                return arguments[genericParameter.Position];
+            }
+
+            if (type is GenericInstanceType genericInstance)
+            {
+                var substituted = new GenericInstanceType(genericInstance.ElementType);
+                foreach (var argument in genericInstance.GenericArguments)
+                {
+                    substituted.GenericArguments.Add(SubstituteGenericArguments(argument, parameterType, arguments));
+                }
+                return substituted;
+            }
+
+            return type;
+        }
+
         public static bool IsSerializable(this TypeReference typeReference)
         {
             var typeSystem = typeReference.Module.TypeSystem;

com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -424,6 +424,19 @@ private void CreateNetworkVariableTypeInitializers(AssemblyDefinition assembly,
                     equalityMethod.GenericArguments.Add(type);
                 }
 
+                // A single call violating its constraints makes CoreCLR reject this whole method, dropping every registration in the assembly.
+                if (serializeMethod != null && !serializeMethod.SatisfiesGenericConstraints(out var serializeViolation))
+                {
+                    m_Diagnostics.AddError($"{type} cannot be used in a network variable - {serializeViolation}.");
+                    continue;
+                }
+
+                if (!equalityMethod.SatisfiesGenericConstraints(out var equalityViolation))
+                {
+                    m_Diagnostics.AddError($"{type} cannot be used in a network variable - {equalityViolation}.");
+                    continue;
+                }
+
                 if (serializeMethod != null)
                 {
                     instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(serializeMethod)));

com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/NetworkVariableEquality.cs

@@ -124,7 +124,7 @@ internal static bool EqualityEqualsList<TValueType>(ref List<TValueType> a, ref
             return true;
         }
 
-        internal static bool EqualityEqualsHashSet<TValueType>(ref HashSet<TValueType> a, ref HashSet<TValueType> b) where TValueType : IEquatable<TValueType>
+        internal static bool EqualityEqualsHashSet<TValueType>(ref HashSet<TValueType> a, ref HashSet<TValueType> b)
         {
             if (a == null != (b == null))
             {

com.unity.netcode.gameobjects/Runtime/NetworkVariable/Serialization/TypedILPPInitializers.cs

@@ -231,7 +231,7 @@ public static void InitializeEqualityChecker_List<T>()
         /// Registers an unmanaged type that will be checked for equality using T.Equals()
         /// </summary>
         /// <typeparam name="T">The type of elements in the HashSet</typeparam>
-        public static void InitializeEqualityChecker_HashSet<T>() where T : IEquatable<T>
+        public static void InitializeEqualityChecker_HashSet<T>()
         {
             NetworkVariableSerialization<HashSet<T>>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsHashSet;
         }

com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/DeferredDespawningTests.cs

@@ -53,9 +53,6 @@ protected override void OnServerAndClientsCreated()
 
 
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("NGO NetworkVariable serialization codegen not generated for some types on CoreCLR (falls back to FallbackSerializer), see https://jira.unity3d.com/browse/UUM-149592")]
-#endif
         public IEnumerator DeferredDespawning()
         {
             // Setup for test

com.unity.netcode.gameobjects/Tests/Runtime/DistributedAuthority/NetworkClientAndPlayerObjectTests.cs

@@ -30,6 +30,7 @@ public NetworkClientAndPlayerObjectTests(HostOrServer hostOrServer) : base(hostO
         protected override IEnumerator OnTearDown()
         {
             m_PlayerPrefabs.Clear();
+            m_ChangedPlayerPrefabs.Clear();
             return base.OnTearDown();
         }
 
@@ -47,7 +48,7 @@ protected override void OnNewClientCreated(NetworkManager networkManager)
         {
             if (m_DistributedAuthority)
             {
-                networkManager.OnFetchLocalPlayerPrefabToSpawn = FetchPlayerPrefabToSpawn;
+                networkManager.OnFetchLocalPlayerPrefabToSpawn = () => FetchPlayerPrefabToSpawn(networkManager);
             }
             base.OnNewClientCreated(networkManager);
         }
@@ -56,11 +57,10 @@ protected override void OnNewClientCreated(NetworkManager networkManager)
         /// Only for distributed authority mode
         /// </summary>
         /// <returns>a unique player prefab for the player</returns>
-        private GameObject FetchPlayerPrefabToSpawn()
+        private GameObject FetchPlayerPrefabToSpawn(NetworkManager networkManager)
         {
             var prefabObject = GetRandomPlayerPrefab();
-            var clientId = m_ClientNetworkManagers[m_ClientNetworkManagers.Length - 1].LocalClientId;
-            m_ChangedPlayerPrefabs.Add(clientId, prefabObject.GlobalObjectIdHash);
+            m_ChangedPlayerPrefabs.Add(networkManager.LocalClientId, prefabObject.GlobalObjectIdHash);
             return prefabObject.gameObject;
         }
 
@@ -155,9 +155,6 @@ private bool AllNetworkClientsValidated()
         /// Validates the same thing when a client late joins and when a client disconnects.
         /// </summary>
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("ValidateNetworkClients throws duplicate-key ArgumentException on CoreCLR (DAHost), see https://jira.unity3d.com/browse/UUM-149595")]
-#endif
         public IEnumerator ValidateNetworkClients()
         {
             // Validate the initial clients created

com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/Configuration/SinglePlayerSessions.cs

@@ -151,9 +151,6 @@ protected override void OnNewClientCreated(NetworkManager networkManager)
         }
 
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("NGO NetworkVariable serialization codegen not generated for some types on CoreCLR (falls back to FallbackSerializer), see https://jira.unity3d.com/browse/UUM-149592")]
-#endif
         public IEnumerator SwitchTransportTest()
         {
             var authority = GetAuthorityNetworkManager();

com.unity.netcode.gameobjects/Tests/Runtime/DocumentationCodeSamples/NetworkVariable/CustomSerializationDocsTests.cs

@@ -1,8 +1,5 @@
 using System.Collections;
 using System.Text;
-#if ENABLE_CORECLR
-using NUnit.Framework;
-#endif
 using Unity.Netcode;
 using Unity.Netcode.TestHelpers.Runtime;
 using UnityEngine;
@@ -176,9 +173,6 @@ private bool ValidateAllAreEqual(StringBuilder errorLog)
         }
 
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("NGO NetworkVariable serialization codegen not generated for some types on CoreCLR (falls back to FallbackSerializer), see https://jira.unity3d.com/browse/UUM-149592")]
-#endif
         public IEnumerator TestHealthCode()
         {
             var authority = GetAuthorityNetworkManager();

com.unity.netcode.gameobjects/Tests/Runtime/Messaging/MessageReceiveAllocationTests.cs

@@ -23,7 +23,6 @@ public void NotMeRpc()
 
     [TestFixture(HostOrServer.Host)]
     [TestFixture(HostOrServer.DAHost)]
-    [UnityCoreClrExplicitDisabled("https://jira.unity3d.com/browse/UUM-149591", "NGO multi-instance test sessions fail to start/connect or time out on CoreCLR")]
     internal class MessageReceiveAllocationTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 1;

com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectSynchronizationTests.cs

@@ -94,9 +94,6 @@ protected override void OnNewClientCreated(NetworkManager networkManager)
         }
 
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("NGO multi-instance test sessions fail to start/connect or time out on CoreCLR, see https://jira.unity3d.com/browse/UUM-149591")]
-#endif
         public IEnumerator NetworkObjectDeserializationFailure()
         {
             m_CurrentLogLevel = LogLevel.Nothing;
@@ -280,9 +277,6 @@ private void ValidateNetworkBehaviourWithNetworkVariables(NetworkObject authorit
         /// will still be initialized properly
         /// </summary>
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("NGO multi-instance test sessions fail to start/connect or time out on CoreCLR, see https://jira.unity3d.com/browse/UUM-149591")]
-#endif
         public IEnumerator NetworkBehaviourSynchronization()
         {
             var authority = GetAuthorityNetworkManager();
@@ -325,9 +319,6 @@ public IEnumerator NetworkBehaviourSynchronization()
         /// A basic validation for the NetworkBehaviour.OnSynchronize method
         /// </summary>
         [UnityTest]
-#if ENABLE_CORECLR
-        [Explicit("NGO multi-instance test sessions fail to start/connect or time out on CoreCLR, see https://jira.unity3d.com/browse/UUM-149591")]
-#endif
         public IEnumerator NetworkBehaviourOnSynchronize()
         {
             var authority = GetAuthorityNetworkManager();