perf: Improved performance in GenericTypesChecker and DictInitializer

Author: SolidAlloy

Editor/AssemblyCreator/AssemblyCreatorHelper.cs

@@ -27,8 +27,6 @@ private static ConstructorInfo AddComponentMenuConstructor
                         null,
                         new[] { typeof(string) },
                         null);
-
-                    Assert.IsNotNull(_addComponentMenuConstructor);
                 }
 
                 return _addComponentMenuConstructor;
@@ -49,8 +47,6 @@ public static MethodInfo GetTypeFromHandle
                         null,
                         new[] { typeof(RuntimeTypeHandle) },
                         null);
-
-                    Assert.IsNotNull(_getTypeFromHandle);
                 }
 
                 return _getTypeFromHandle;

Editor/AssemblyCreator/MenuItemsCreator.cs

@@ -31,8 +31,6 @@ private static MethodInfo CreateAsset
                         null,
                         new[] { typeof(Type), typeof(string) },
                         null);
-
-                    Assert.IsNotNull(_createAsset);
                 }
 
                 return _createAsset;
@@ -67,8 +65,6 @@ private static ConstructorInfo MenuItemConstructor
                         null,
                         new[] { typeof(string) },
                         null);
-
-                    Assert.IsNotNull(_menuItemConstructor);
                 }
 
                 return _menuItemConstructor;

Editor/Drawers/GenericUnityObjectHelper.cs

@@ -4,7 +4,6 @@
     using SolidUtilities.Editor.Helpers;
     using UnityEditor;
     using UnityEngine;
-    using UnityEngine.Assertions;
     using Object = UnityEngine.Object;
 
     /// <summary>

Editor/Drawers/TypeReferenceWithBaseTypesDrawer.cs

@@ -17,8 +17,7 @@ internal class TypeReferenceWithBaseTypesDrawer : TypeReferencePropertyDrawer
 
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {
-            Assert.IsNotNull(label);
-            Assert.IsFalse(label == GUIContent.none);
+            Assert.IsFalse(label is null || label == GUIContent.none);
             position = EditorGUI.PrefixLabel(position, label);
             DrawTypeReferenceField(position, property);
         }

Editor/GeneratedTypesDatabase/GenerationDatabase.Serialization.cs

@@ -29,9 +29,6 @@ public void Initialize()
             if (_genericArgumentKeys != null)
                 throw new InvalidOperationException("The asset is already initialized.");
 
-            if (! typeof(GenericTypeInfo).IsSerializable)
-                throw new SerializationException($"Cannot initialize a database with {typeof(GenericTypeInfo)} because the type is not serializable.");
-
             _argumentGenericTypesDict = new FastIterationDictionary<ArgumentInfo, List<GenericTypeInfo>>();
             _argumentsPool = new Pool<ArgumentInfo>();
             _genericTypeArgumentsDict = new FastIterationDictionary<GenericTypeInfo, List<ConcreteClass>>();

Editor/GeneratedTypesDatabase/GenerationDatabase.cs

@@ -46,6 +46,10 @@ internal abstract partial class GenerationDatabase<TUnityObject> :
 
         public GenericTypeInfo[] InstanceGenericTypes => _genericTypeArgumentsDict.KeysCollection;
 
+        [CanBeNull]
+        public static string GetCachedGenericTypeGUID(string typeNameAndAssembly)
+            => Instance._genericTypesPool.GetGUID(typeNameAndAssembly);
+
         public static void AddGenericType(GenericTypeInfo genericTypeInfo)
         {
             Instance.AddGenericTypeImpl(genericTypeInfo);
@@ -60,7 +64,7 @@ public void AddGenericTypeImpl(GenericTypeInfo genericTypeInfo)
 
         public static void AddConcreteClass(Type genericTypeWithoutArgs, Type[] genericArgs, string assemblyGUID)
         {
-            var genericTypeInfo = new GenericTypeInfo(genericTypeWithoutArgs);
+            var genericTypeInfo = GenericTypeInfo.Instantiate<TUnityObject>(genericTypeWithoutArgs);
 
             int genericArgsLength = genericArgs.Length;
             var arguments = new ArgumentInfo[genericArgsLength];

Editor/GeneratedTypesDatabase/Pool.cs

@@ -2,31 +2,39 @@
 {
     using System;
     using System.Collections.Generic;
+    using JetBrains.Annotations;
 
     internal class Pool<T>
+        where T : TypeInfo
     {
         private readonly Dictionary<T, T> _dict;
+        private readonly Dictionary<string, string> _typeNameGUIDDict;
 
         public Pool(int capacity = 0)
         {
             _dict = new Dictionary<T, T>(capacity);
+            _typeNameGUIDDict = new Dictionary<string, string>(capacity);
         }
 
         public T GetOrAdd(T item)
         {
             if (_dict.TryGetValue(item, out T existingItem))
                 return existingItem;
 
-            _dict[item] = item;
+            _dict.Add(item, item);
+            _typeNameGUIDDict.Add(item.TypeNameAndAssembly, item.GUID);
             return item;
         }
 
         public void AddRange(T[] items)
         {
             foreach (T item in items)
             {
-                if (! _dict.ContainsKey(item))
-                    _dict.Add(item, item);
+                if (_dict.ContainsKey(item))
+                    continue;
+
+                _dict.Add(item, item);
+                _typeNameGUIDDict.Add(item.TypeNameAndAssembly, item.GUID);
             }
         }
 
@@ -36,11 +44,20 @@ public void ChangeItem(ref T item, Action<T> changeItem)
             {
                 item = existingItem;
                 _dict.Remove(item);
+                _typeNameGUIDDict.Remove(item.TypeNameAndAssembly);
             }
 
             changeItem(item);
 
-            _dict[item] = item;
+            _dict.Add(item, item);
+            _typeNameGUIDDict.Add(item.TypeNameAndAssembly, item.GUID);
+        }
+
+        [CanBeNull]
+        public string GetGUID(string typeNameAndAssembly)
+        {
+            _typeNameGUIDDict.TryGetValue(typeNameAndAssembly, out string guid);
+            return guid;
         }
     }
 }

Editor/GeneratedTypesDatabase/TypeInfo/GenericTypeInfo.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Linq;
+    using GenericUnityObjects.Util;
     using NUnit.Framework;
     using SolidUtilities.Helpers;
     using UnityEngine;
@@ -29,13 +30,26 @@ public GenericTypeInfo(string typeFullName, string assemblyName, string guid, st
             _argNames = argNames;
         }
 
-        public GenericTypeInfo(Type type, string typeGUID = null)
-            : base(type, typeGUID)
+        private GenericTypeInfo(Type type, string typeNameAndAssembly, string guid)
+            : base(type, typeNameAndAssembly, guid)
         {
+            // Assert can be expensive when called many times, and there may be hundreds of GenericTypeInfos in
+            // a large project that are constructed after each domain reload.
+#if GENERIC_UNITY_OBJECTS_DEBUG
             Assert.IsTrue(type.IsGenericTypeDefinition);
+#endif
+
             _argNames = type.GetGenericArguments().Select(argType => argType.Name).ToArray();
         }
 
+        public static GenericTypeInfo Instantiate<TObject>(Type type)
+            where TObject : UnityEngine.Object
+        {
+            string typeNameAndAssembly = TypeUtility.GetTypeNameAndAssembly(type);
+            string guid = GenerationDatabase<TObject>.GetCachedGenericTypeGUID(typeNameAndAssembly);
+            return new GenericTypeInfo(type, typeNameAndAssembly, guid);
+        }
+
         public void UpdateArgNames(string[] newNames) => _argNames = newNames;
 
         public void UpdateArgNames(Type[] newTypes)

Editor/GeneratedTypesDatabase/TypeInfo/TypeInfo.cs

@@ -33,8 +33,20 @@ protected TypeInfo(Type type, string typeGUID = null)
             _guid = typeGUID ?? GetClassGUID(type);
         }
 
+        protected TypeInfo(Type type, string typeNameAndAssembly, string typeGUID)
+        {
+            Type = type;
+            _typeNameAndAssembly = typeNameAndAssembly;
+            _guid = typeGUID ?? GetClassGUID(type);
+        }
+
         private string GetClassGUID(Type type)
         {
+            string guid = GenerationDatabase<MonoBehaviour>.GetCachedGenericTypeGUID(_typeNameAndAssembly);
+
+            if (guid != null)
+                return guid;
+
             if (TypeCannotHaveGUID())
                 return string.Empty;
 
@@ -56,7 +68,7 @@ public string TypeFullName
             }
         }
 
-        public bool RetrieveType<TObject>(out Type type, out bool retrievedFromGUID)
+        public bool RetrieveType<TObject>(out Type type, out bool retrievedFromGUID, bool updateGUID = true)
             where TObject : Object
         {
             retrievedFromGUID = false;
@@ -71,8 +83,10 @@ public bool RetrieveType<TObject>(out Type type, out bool retrievedFromGUID)
 
             if (Type != null)
             {
+                if (updateGUID)
+                    UpdateGUIDIfNeeded<TObject>();
+
                 type = Type;
-                UpdateGUIDIfNeeded<TObject>();
                 return true;
             }
 
@@ -89,10 +103,18 @@ public bool RetrieveType<TObject>(out Type type, out bool retrievedFromGUID)
             return Type != null;
         }
 
-        public Type RetrieveType<TObject>()
+        /// <summary> Retrieves type stored in this <see cref="TypeInfo"/> instance. </summary>
+        /// <param name="updateGUID">
+        /// Whether to try updating GUID if the type was found using typeNameAndAssembly. It is strongly not
+        /// recommended to use. The only case when it can be to false is after all generic types are updated, to
+        /// improve performance. See <see cref="DictInitializer{TObject}"/>. /
+        /// </param>
+        /// <typeparam name="TObject"> Type derived from <see cref="UnityEngine.Object"/>. </typeparam>
+        /// <returns> A retrieved type or <c>null</c>, if the type was not found by typeNameAndAssembly or GUID. </returns>
+        public Type RetrieveType<TObject>(bool updateGUID = true)
             where TObject : Object
         {
-            RetrieveType<TObject>(out Type type, out bool _);
+            RetrieveType<TObject>(out Type type, out bool _, updateGUID);
             return type;
         }
 
@@ -106,27 +128,21 @@ public void UpdateNameAndAssembly(Type newType) =>
 
         public bool Equals(TypeInfo p)
         {
-            // If parameter is null, return false.
             if (ReferenceEquals(p, null))
             {
                 return false;
             }
 
-            // Optimization for a common success case.
             if (ReferenceEquals(this, p))
             {
                 return true;
             }
 
-            // If run-time types are not exactly the same, return false.
             if (this.GetType() != p.GetType())
             {
                 return false;
             }
 
-            // Return true if the fields match.
-            // Note that the base class is not invoked because it is
-            // System.Object, which defines Equals as reference equality.
             return TypeNameAndAssembly == p.TypeNameAndAssembly && _guid == p._guid;
         }
 
@@ -184,7 +200,7 @@ private void UpdateGUIDIfNeeded<TObject>()
             if (TypeAtGUIDIsSame())
                 return;
 
-            string newGUID = AssetSearcher.GetClassGUID(Type); //
+            string newGUID = AssetSearcher.GetClassGUID(Type);
 
             if (string.IsNullOrEmpty(newGUID) || GUID == newGUID)
                 return;
@@ -199,14 +215,14 @@ private void UpdateGUIDIfNeeded<TObject>()
             }
             else
             {
-                throw new TypeLoadException($"{nameof(UpdateGUIDIfNeeded)} method doesn't know of this inheritor of {nameof(TypeInfo)} yet: {GetType()}.");
+                throw new TypeLoadException(
+                    $"{nameof(UpdateGUIDIfNeeded)} method doesn't know of this inheritor " +
+                    $"of {nameof(TypeInfo)} yet: {GetType()}.");
             }
         }
 
         private bool TypeAtGUIDIsSame()
         {
-            // Check if asset at guid contains the same type
-            // If it doesn't contain the same type or no type at all, search GUID of the type elsewhere
             string path = AssetDatabase.GUIDToAssetPath(GUID);
             if (path.Length == 0)
                 return false;

Editor/GenericTypesAnalyzer/DictInitializer.cs

@@ -26,7 +26,7 @@ public static void Initialize()
             {
                 var concreteClasses = GenerationDatabase<TObject>.GetConcreteClasses(behaviourInfo);
 
-                Type behaviourType = behaviourInfo.RetrieveType<TObject>();
+                Type behaviourType = behaviourInfo.RetrieveType<TObject>(false);
 
                 var concreteClassesDict = new Dictionary<Type[], Type>(concreteClasses.Length, default(TypeArrayComparer));