Minor fixes and refactor changes

Author: arimger

Assets/Editor Toolbox/Editor/ContextMenu/Operations/SerializeReference/PasteSerializeReferenceOperation.cs

@@ -9,6 +9,7 @@ internal class PasteSerializeReferenceOperation : IContextMenuOperation
     {
         private bool IsAssignmentValid(SerializedProperty property, object newValue)
         {
+#if UNITY_2021_3_OR_NEWER
             if (newValue == null)
             {
                 return true;
@@ -24,7 +25,7 @@ private bool IsAssignmentValid(SerializedProperty property, object newValue)
             {
                 return true;
             }
-
+#endif
             return false;
         }
 

Assets/Editor Toolbox/Editor/Internal/Types/TypeAppearanceContext.cs.meta

@@ -86,6 +86,20 @@ internal static List<Type> GetDerivedTypesUsingTypesCache(Type parentType, Func<
             return typesList;
         }
 
+        internal static List<Type> GetDerivedTypes(Type parentType, Func<Type, Type> typeProcessor)
+        {
+#if UNITY_2019_2_OR_NEWER
+            return GetDerivedTypesUsingTypesCache(parentType, typeProcessor);
+#else
+            return GetDerviedTypesUsingAssemblies(parentType, typeProcessor);
+#endif
+        }
+
+        internal static bool CanBeSourceForGenericTypes(Type type)
+        {
+            return type.IsGenericType && !type.IsGenericTypeDefinition;
+        }
+
         public static TypesCachedCollection GetCollection(Type parentType)
         {
             return GetCollection(new TypeConstraintContext(parentType));
@@ -131,7 +145,7 @@ public static bool TryGetTypeFromManagedReferenceFullTypeName(string managedRefe
 
             const int typeFormatParts = 2;
 
-            var parts = managedReferenceFullTypeName.Split(' ', typeFormatParts, StringSplitOptions.None);
+            var parts = managedReferenceFullTypeName.Split(new char[] { ' ' }, typeFormatParts, StringSplitOptions.None);
             managedReferenceInstanceType = parts.Length == typeFormatParts
                 ? Type.GetType($"{parts[1]}, {parts[0]}") : null;
             if (managedReferenceInstanceType != null)
@@ -157,33 +171,34 @@ public static List<Type> FindTypes(TypeConstraintContext constraint)
                 var parentGenericArgs = parentGenericType.GetGenericArguments();
                 typesList = GetDerivedTypes(parentGenericType, (sourceType) =>
                 {
-                    //NOTE: type is a standard type implementation (even if generic), it means we can check the standard way
-                    if (!sourceType.IsGenericTypeDefinition)
+                    var targetType = sourceType;
+                    //NOTE: type is a generic definition, it means we can check if constraints are matched
+                    if (sourceType.IsGenericTypeDefinition)
                     {
-                        if (!IsTypeAssignableFrom(parentType, sourceType))
+                        var foundGenericArgs = sourceType.GetGenericArguments();
+                        if (foundGenericArgs.Length != parentGenericArgs.Length)
                         {
                             return null;
                         }
 
-                        return constraint.IsSatisfied(sourceType) ? sourceType : null;
+                        try
+                        {
+                            targetType = sourceType.MakeGenericType(parentType.GenericTypeArguments);
+                        }
+                        catch (ArgumentException)
+                        {
+                            //NOTE: that's the easiest way to check if all generic constraints are ok
+                            return null;
+                        }
                     }
 
-                    var foundGenericArgs = sourceType.GetGenericArguments();
-                    if (foundGenericArgs.Length != parentGenericArgs.Length)
+                    //NOTE: we need to check inheritance since all processed types are derived from the generic type definition
+                    if (!IsTypeAssignableFrom(parentType, targetType))
                     {
                         return null;
                     }
 
-                    try
-                    {
-                        var genericType = sourceType.MakeGenericType(parentType.GenericTypeArguments);
-                        return constraint.IsSatisfied(genericType) ? genericType : null;
-                    }
-                    catch (ArgumentException)
-                    {
-                        //NOTE: that's the easiest way to check if all generic constraints are ok
-                        return null;
-                    }
+                    return constraint.IsSatisfied(targetType) ? targetType : null;
                 });
             }
             else
@@ -206,20 +221,6 @@ public static List<Type> FindTypes(TypeConstraintContext constraint)
             }
 
             return typesList;
-
-            static bool CanBeSourceForGenericTypes(Type type)
-            {
-                return type.IsGenericType && !type.IsGenericTypeDefinition;
-            }
-
-            static List<Type> GetDerivedTypes(Type parentType, Func<Type, Type> typeProcessor)
-            {
-#if UNITY_2019_2_OR_NEWER
-                return GetDerivedTypesUsingTypesCache(parentType, typeProcessor);
-#else
-                return GetDerviedTypesUsingAssemblies(parentType, typeProcessor);
-#endif
-            }
         }
 
         public static List<Type> FindTypes(TypeConstraintContext constraint, Assembly assembly)