perf: Decreased serialization time of TypeReference

Author: SolidAlloy

Editor/Util/Sedgewick.cs

@@ -51,7 +51,7 @@ private static void SortInPlace(TypeItem[] input, int a, int n, int depth)
 
             int r;
 
-            for (; ; )
+            while (true)
             {
                 while (pb <= pc && (r = empty ? (input[pb].Path.Length - depth) : ((depth == input[pb].Path.Length) ? -1 : (input[pb].Path[depth] - partVal))) <= 0)
                 {

Editor/Util/TypeCache.cs

@@ -8,21 +8,21 @@
     /// </summary>
     internal static class TypeCache
     {
-        private static readonly Dictionary<string, Type> TypeDict = new Dictionary<string, Type>();
+        private static readonly Dictionary<string, Type> _typeDict = new Dictionary<string, Type>();
 
         /// <summary>
         /// Get type from TypeCache if it is cached.
         /// Otherwise, find the type, cache it, and return it to the caller.
         /// </summary>
-        /// <param name="typeName">Type name, followed by a comma and assembly name.</param>
+        /// <param name="typeNameAndAssembly">Type name, followed by a comma and assembly name.</param>
         /// <returns>Cached class type.</returns>
-        public static Type GetType(string typeName)
+        public static Type GetType(string typeNameAndAssembly)
         {
-            if (TypeDict.TryGetValue(typeName, out Type type))
+            if (_typeDict.TryGetValue(typeNameAndAssembly, out Type type))
                 return type;
 
-            type = ! string.IsNullOrEmpty(typeName) ? Type.GetType(typeName) : null;
-            TypeDict[typeName] = type;
+            type = string.IsNullOrEmpty(typeNameAndAssembly) ? null : Type.GetType(typeNameAndAssembly);
+            _typeDict[typeNameAndAssembly] = type;
             return type;
         }
     }

Runtime/Attributes/InheritsAttribute.cs

@@ -12,7 +12,7 @@
     [AttributeUsage(AttributeTargets.Field)]
     public class InheritsAttribute : TypeOptionsAttribute
     {
-        private readonly Type[] _baseTypes;
+        public Type[] BaseTypes;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="InheritsAttribute"/> class using one base type and optional
@@ -27,13 +27,13 @@ public InheritsAttribute(Type baseType, [CanBeNull] params Type[] additionalBase
         {
             if (additionalBaseTypes == null || additionalBaseTypes.Length == 0)
             {
-                _baseTypes = new[] { baseType };
+                BaseTypes = new[] { baseType };
             }
             else
             {
-                _baseTypes = new Type[additionalBaseTypes.Length+1];
-                additionalBaseTypes.CopyTo(_baseTypes, 0);
-                _baseTypes[additionalBaseTypes.Length] = baseType;
+                BaseTypes = new Type[additionalBaseTypes.Length+1];
+                additionalBaseTypes.CopyTo(BaseTypes, 0);
+                BaseTypes[additionalBaseTypes.Length] = baseType;
             }
         }
 
@@ -46,7 +46,7 @@ public InheritsAttribute(Type baseType, [CanBeNull] params Type[] additionalBase
         [PublicAPI]
         public InheritsAttribute(Type[] baseTypes)
         {
-            _baseTypes = baseTypes;
+            BaseTypes = baseTypes;
         }
 
         /// <summary>
@@ -66,20 +66,20 @@ public InheritsAttribute(Type[] baseTypes)
         /// <inheritdoc/>
         internal override bool MatchesRequirements(Type type)
         {
-            if (_baseTypes.Contains(type) && !IncludeBaseType)
+            if (BaseTypes.Contains(type) && !IncludeBaseType)
             {
                 return false;
             }
 
             // Include base type in the drop-down even if it is abstract.
             // If the user set IncludeBaseType to true, they probably want to include the base type in the dropdown
             // even though it is abstract.
-            if (_baseTypes.Contains(type))
+            if (BaseTypes.Contains(type))
                 return true;
 
             bool passesAbstractConstraint = AllowAbstract || !type.IsAbstract;
 
-            return _baseTypes.All(type.InheritsFrom) && passesAbstractConstraint && base.MatchesRequirements(type);
+            return BaseTypes.All(type.InheritsFrom) && passesAbstractConstraint && base.MatchesRequirements(type);
         }
     }
 }

Runtime/TypeReference.cs

@@ -198,6 +198,13 @@ private void LogTypeNotFoundIfNeeded()
 
         private void SetClassGuidIfExists(Type type)
         {
+            // common case optimization
+            if (TypeCannotHaveGUID())
+            {
+                GUID = string.Empty;
+                return;
+            }
+
             try
             {
                 GUID = GetClassGUID(type);
@@ -210,6 +217,26 @@ private void SetClassGuidIfExists(Type type)
             }
         }
 
+        private bool TypeCannotHaveGUID()
+        {
+            if (string.IsNullOrEmpty(TypeNameAndAssembly))
+                return false;
+
+            int charAfterWhiteSpace = TypeNameAndAssembly.IndexOf(' ') + 1;
+
+            string assemblyName = TypeNameAndAssembly.Substring(
+                charAfterWhiteSpace,
+                TypeNameAndAssembly.Length - charAfterWhiteSpace);
+
+            return assemblyName == "mscorlib"
+                   || assemblyName == "netstandard"
+                   || assemblyName.StartsWith("System.")
+                   || assemblyName.StartsWith("Microsoft.")
+                   || assemblyName.StartsWith("Unity.")
+                   || assemblyName.StartsWith("UnityEngine.")
+                   || assemblyName.StartsWith("UnityEditor.");
+        }
+
         [CanBeNull]
         private Type TryGetTypeFromSerializedFields()
         {