Add type policy and candidate provider interfaces

Introduces IIntrinsicTypePolicy, ITypeCandiateProvider, and ITypeCompatibilityPolicy interfaces with default implementations for type filtering and compatibility checks. Adds Unity 2023.2+ specific implementations to support generic variance in type compatibility and candidate discovery. These abstractions improve extensibility and support for advanced type scenarios in SerializeReferenceExtensions.

Author: mackysoft

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Editor/IIntrinsicTypePolicy.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace MackySoft.SerializeReferenceExtensions.Editor
+{
+    public interface IIntrinsicTypePolicy
+    {
+        bool IsAllowed (Type candiateType);
+    }
+
+    public sealed class DefaultIntrinsicTypePolicy : IIntrinsicTypePolicy
+    {
+
+        public static readonly DefaultIntrinsicTypePolicy Instance = new DefaultIntrinsicTypePolicy();
+
+        public bool IsAllowed (Type candiateType)
+        {
+            return
+                (candiateType.IsPublic || candiateType.IsNestedPublic || candiateType.IsNestedPrivate) &&
+                !candiateType.IsAbstract &&
+                !candiateType.IsGenericType &&
+                !typeof(UnityEngine.Object).IsAssignableFrom(candiateType) &&
+                Attribute.IsDefined(candiateType, typeof(SerializableAttribute)) &&
+                !Attribute.IsDefined(candiateType, typeof(HideInTypeMenuAttribute));
+        }
+    }
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Editor/IIntrinsicTypePolicy.cs.meta

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+
+namespace MackySoft.SerializeReferenceExtensions.Editor
+{
+    public interface ITypeCandiateProvider
+	{
+		IEnumerable<Type> GetTypeCandidates (Type baseType);
+    }
+
+    public sealed class DefaultTypeCandiateProvider : ITypeCandiateProvider
+    {
+
+        public static readonly DefaultTypeCandiateProvider Instance = new DefaultTypeCandiateProvider(DefaultIntrinsicTypePolicy.Instance);
+
+        private readonly IIntrinsicTypePolicy intrinsicTypePolicy;
+
+        public DefaultTypeCandiateProvider (IIntrinsicTypePolicy intrinsicTypePolicy)
+        {
+            this.intrinsicTypePolicy = intrinsicTypePolicy ?? throw new ArgumentNullException(nameof(intrinsicTypePolicy));
+        }
+
+        public IEnumerable<Type> GetTypeCandidates (Type baseType)
+        {
+            return TypeCache.GetTypesDerivedFrom(baseType)
+                .Append(baseType)
+                .Where(intrinsicTypePolicy.IsAllowed);
+        }
+    }
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Editor/ITypeCandiateProvider.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace MackySoft.SerializeReferenceExtensions.Editor
+{
+    public interface ITypeCompatibilityPolicy
+    {
+        bool IsCompatible (Type baseType, Type candiateType);
+    }
+
+    public sealed class DefaultTypeCompatibilityPolicy : ITypeCompatibilityPolicy
+    {
+
+        public static readonly DefaultTypeCompatibilityPolicy Instance = new DefaultTypeCompatibilityPolicy();
+        
+        public bool IsCompatible (Type baseType, Type candiateType)
+        {
+            if (baseType == null)
+            {
+                throw new ArgumentNullException(nameof(baseType));
+            }
+            if (candiateType == null)
+            {
+                throw new ArgumentNullException(nameof(candiateType));
+            }
+
+            if (baseType.IsGenericTypeDefinition || baseType.ContainsGenericParameters)
+            {
+                return false;
+            }
+
+            return baseType.IsAssignableFrom(candiateType);
+        }
+    }
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Editor/ITypeCandiateProvider.cs.meta

@@ -0,0 +1,128 @@
+using System;
+using System.Reflection;
+
+namespace MackySoft.SerializeReferenceExtensions.Editor
+{
+#if UNITY_2023_2_OR_NEWER
+    public sealed class Unity_2023_2_OrNewer_GenericVarianceTypeCompatibilityPolicy : ITypeCompatibilityPolicy
+    {
+
+        public static readonly Unity_2023_2_OrNewer_GenericVarianceTypeCompatibilityPolicy Instance = new Unity_2023_2_OrNewer_GenericVarianceTypeCompatibilityPolicy();
+
+        public bool IsCompatible (Type baseType, Type candiateType)
+        {
+            if (baseType == null)
+            {
+                throw new ArgumentNullException(nameof(baseType));
+            }
+            if (candiateType == null)
+            {
+                throw new ArgumentNullException(nameof(candiateType));
+            }
+
+            // If not generic, fall back to standard assignability check
+            if (!baseType.IsGenericType)
+            {
+                return baseType.IsAssignableFrom(candiateType);
+            }
+
+            if (baseType.IsGenericTypeDefinition || baseType.ContainsGenericParameters)
+            {
+                return false;
+            }
+
+            // NOTE: baseType is constructed generic type
+            Type genericTypeDefinition = baseType.GetGenericTypeDefinition();
+            Type[] targetTypeArguments = baseType.GetGenericArguments();
+            Type[] genericTypeParameters = genericTypeDefinition.GetGenericArguments();
+
+            // Check interfaces
+            foreach (Type interfaceType in candiateType.GetInterfaces())
+            {
+                if (!interfaceType.IsGenericType)
+                {
+                    continue;
+                }
+                if (interfaceType.GetGenericTypeDefinition() != genericTypeDefinition)
+                {
+                    continue;
+                }
+
+                Type[] sourceTypeArguments = interfaceType.GetGenericArguments();
+                if (AreAllGenericArgumentsCompatible(genericTypeParameters, targetTypeArguments, sourceTypeArguments))
+                {
+                    return true;
+                }
+            }
+
+            // Check base types
+            for (Type t = candiateType; t != null && t != typeof(object); t = t.BaseType)
+            {
+                if (!t.IsGenericType)
+                {
+                    continue;
+                }
+                if (t.GetGenericTypeDefinition() != genericTypeDefinition)
+                {
+                    continue;
+                }
+
+                Type[] sourceTypeArguments = t.GetGenericArguments();
+                if (AreAllGenericArgumentsCompatible(genericTypeParameters, targetTypeArguments, sourceTypeArguments))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool AreAllGenericArgumentsCompatible (Type[] genericTypeParameters, Type[] targetTypeArguments, Type[] sourceTypeArguments)
+        {
+            if (genericTypeParameters.Length != targetTypeArguments.Length)
+            {
+                return false;
+            }
+            if (sourceTypeArguments.Length != targetTypeArguments.Length)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < genericTypeParameters.Length; i++)
+            {
+                var variance = genericTypeParameters[i].GenericParameterAttributes & GenericParameterAttributes.VarianceMask;
+
+                Type sourceTypeArgument = sourceTypeArguments[i];
+                Type targetTypeArgument = targetTypeArguments[i];
+
+                if (variance == GenericParameterAttributes.Contravariant)
+                {
+                    // NOTE: in T = source must be able to accept the target.
+                    if (!sourceTypeArgument.IsAssignableFrom(targetTypeArgument))
+                    {
+                        return false;
+                    }
+                }
+                else if (variance == GenericParameterAttributes.Covariant)
+                {
+                    // NOTE: out T = target must be able to accept the source.
+                    if (!targetTypeArgument.IsAssignableFrom(sourceTypeArgument))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    // invariant
+                    if (sourceTypeArgument != targetTypeArgument)
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+#endif
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Editor/ITypeCompatibilityPolicy.cs

@@ -0,0 +1,104 @@
+#if UNITY_2023_2_OR_NEWER
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace MackySoft.SerializeReferenceExtensions.Editor
+{
+    public sealed class Unity_2023_2_OrNewer_TypeCandiateProvider : ITypeCandiateProvider
+    {
+
+        public static readonly Unity_2023_2_OrNewer_TypeCandiateProvider Instance = new Unity_2023_2_OrNewer_TypeCandiateProvider(
+            DefaultIntrinsicTypePolicy.Instance,
+            Unity_2023_2_OrNewer_GenericVarianceTypeCompatibilityPolicy.Instance
+        );
+
+        private Dictionary<Type, List<Type>> m_TypeCache = new Dictionary<Type, List<Type>>();
+
+        private readonly IIntrinsicTypePolicy m_IntrinsicTypePolicy;
+        private readonly ITypeCompatibilityPolicy m_TypeCompatibilityPolicy;
+
+        private Unity_2023_2_OrNewer_TypeCandiateProvider (
+            IIntrinsicTypePolicy intrinsicTypePolicy,
+            ITypeCompatibilityPolicy typeCompatibilityPolicy
+        )
+        {
+            m_IntrinsicTypePolicy = intrinsicTypePolicy ?? throw new ArgumentNullException(nameof(intrinsicTypePolicy));
+            m_TypeCompatibilityPolicy = typeCompatibilityPolicy ?? throw new ArgumentNullException(nameof(typeCompatibilityPolicy));
+        }
+
+        public IEnumerable<Type> GetTypeCandidates (Type baseType)
+        {
+            if (!baseType.IsGenericType)
+            {
+                return DefaultTypeCandiateProvider.Instance.GetTypeCandidates(baseType);
+            }
+
+            return GetTypesWithGeneric(baseType);
+        }
+
+        private IEnumerable<Type> GetTypesWithGeneric (Type baseType)
+        {
+            if (m_TypeCache.TryGetValue(baseType, out List<Type> result))
+            {
+                return result;
+            }
+
+            result = new List<Type>();
+
+            IEnumerable<Type> types = EnumerateAllTypesSafely();
+            foreach (Type type in types)
+            {
+                if (!m_IntrinsicTypePolicy.IsAllowed(type))
+                {
+                    continue;
+                }
+                if (!m_TypeCompatibilityPolicy.IsCompatible(baseType, type))
+                {
+                    continue;
+                }
+
+                result.Add(type);
+            }
+
+            // Include the base type itself if allowed
+            if (m_IntrinsicTypePolicy.IsAllowed(baseType) && m_TypeCompatibilityPolicy.IsCompatible(baseType, baseType))
+            {
+                result.Add(baseType);
+            }
+
+            m_TypeCache.Add(baseType, result);
+            return result;
+        }
+
+        private static IEnumerable<Type> EnumerateAllTypesSafely ()
+        {
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                Type[] types;
+                try
+                {
+                    types = asm.GetTypes();
+                }
+                catch (ReflectionTypeLoadException ex)
+                {
+                    types = ex.Types;
+                }
+
+                if (types == null)
+                {
+                    continue;
+                }
+
+                foreach (var t in types)
+                {
+                    if (t != null)
+                    {
+                        yield return t;
+                    }
+                }
+            }
+        }
+    }
+}
+#endif