UpgradeHintProcessor code improvements

- Optimized collections usage. Less enumerations, used exact capacity where possible.
- Some results of UpgradeHintProcessor's work passed to further use
  to elimitate recalculations (e.g. non-connector types)
- ClassifiedCollection extended with method alowing to get item count in each class group
- Ordinal string comparison where possible
- general code clean-up and formatting

Author: alex-kulakov

Orm/Xtensive.Orm/Collections/ClassifiedCollection.cs

@@ -124,6 +124,12 @@ public IEnumerable<TClass> GetClasses()
       return classified.Keys;
     }
 
+    public int GetItemCount(TClass @class)
+    {
+      var items = classified.GetValueOrDefault(@class);
+      return items != null ? items.Count : 0;
+    }
+
     #region IEnumerable<...> members
 
     IEnumerator IEnumerable.GetEnumerator()

Orm/Xtensive.Orm/Collections/TypeClassifier.cs

@@ -29,6 +29,11 @@ public IEnumerable<TItem> GetItems<TClass>()
       return GetItems(typeof (TClass));
     }
 
+    public int GetItemCount<TClass>()
+    {
+      return GetItemCount(typeof(TClass));
+    }
+
     // Constructors
 
     /// <inheritdoc/>

Orm/Xtensive.Orm/Core/Extensions/CollectionExtensions.cs

@@ -207,5 +207,33 @@ public static IEnumerable<TSource> ReverseList<TSource>(this IList<TSource> sour
       for (var i = source.Count - 1; i >= 0; i--)
         yield return source[i];
     }
+
+    /// <summary>
+    /// Projects each element of a sequence into two elements of new form and adds it to the first or the second array respectively.
+    /// </summary>
+    /// <typeparam name="TSource">Type of source sequence.</typeparam>
+    /// <typeparam name="TFirst">Type of elements of first result array.</typeparam>
+    /// <typeparam name="TSecond">Type of elements of first result array.</typeparam>
+    /// <param name="source">A collection of values to invoke a transform functions on.</param>
+    /// <param name="firstArraySelector">A transform function to apply to each element to get element of the first array.</param>
+    /// <param name="secondArraySelector">A transform function to apply to each element to get element of the second array.</param>
+    /// <returns>Pair of two arrays.</returns>
+    internal static Pair<TFirst[], TSecond[]> SelectToArrays<TSource, TFirst,TSecond>(
+      this ICollection<TSource> source, Func<TSource, TFirst> firstArraySelector, Func<TSource, TSecond> secondArraySelector)
+    {
+      ArgumentValidator.EnsureArgumentNotNull(source, nameof(source));
+      ArgumentValidator.EnsureArgumentNotNull(firstArraySelector, nameof(firstArraySelector));
+      ArgumentValidator.EnsureArgumentNotNull(secondArraySelector, nameof(secondArraySelector));
+
+      var first = new TFirst[source.Count];
+      var second = new TSecond[source.Count];
+      var index = 0;
+      foreach (var item in source) {
+        first[index] = firstArraySelector(item);
+        second[index] = secondArraySelector(item);
+        index++;
+      }
+      return new Pair<TFirst[], TSecond[]>(first, second);
+    }
   }
 }

Orm/Xtensive.Orm/Orm/Upgrade/Internals/Extensions/DomainModelExtensions.cs

@@ -28,6 +28,7 @@ internal sealed class HintGenerator
     private readonly StoredDomainModel extractedModel;
     private readonly StoredDomainModel currentModel;
 
+    private readonly UpgradeHintsProcessingResult processingResults;
     private readonly Dictionary<StoredTypeInfo, StoredTypeInfo> typeMapping;
     private readonly Dictionary<StoredTypeInfo, StoredTypeInfo> reverseTypeMapping;
     private readonly Dictionary<StoredFieldInfo, StoredFieldInfo> fieldMapping;
@@ -721,45 +722,40 @@ private static InvalidOperationException TypeIsNotInHierarchy(string type)
 
     // Constructors
 
-    public HintGenerator(Dictionary<StoredTypeInfo, StoredTypeInfo> typeMapping,
-      Dictionary<StoredTypeInfo, StoredTypeInfo> reverseTypeMapping,
-      Dictionary<StoredFieldInfo, StoredFieldInfo> fieldMapping,
-      NativeTypeClassifier<UpgradeHint> hints,
+    public HintGenerator(UpgradeHintsProcessingResult hintsProcessingResult,
       HandlerAccessor handlers,
       MappingResolver resolver,
       StorageModel extractedStorageModel,
       StoredDomainModel currentDomainModel,
       StoredDomainModel extractedDomainModel)
     {
-      ArgumentValidator.EnsureArgumentNotNull(typeMapping, "typeMapping");
-      ArgumentValidator.EnsureArgumentNotNull(reverseTypeMapping, "reverseTypeMapping");
-      ArgumentValidator.EnsureArgumentNotNull(fieldMapping, "fieldMapping");
-      ArgumentValidator.EnsureArgumentNotNull(hints, "hints");
-      ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers");
-      ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver");
-      ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel");
-      ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel");
-      ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel");
-
-      this.typeMapping = typeMapping;
-      this.reverseTypeMapping = reverseTypeMapping;
-      this.fieldMapping = fieldMapping;
-      this.hints = hints;
+      ArgumentValidator.EnsureArgumentNotNull(hintsProcessingResult, nameof(hintsProcessingResult));
+      ArgumentValidator.EnsureArgumentNotNull(handlers, nameof(handlers));
+      ArgumentValidator.EnsureArgumentNotNull(resolver, nameof(resolver));
+      ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, nameof(extractedStorageModel));
+      ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
+      ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, nameof(extractedDomainModel));
 
-      extractedModelFields = new Dictionary<StoredTypeInfo, StoredFieldInfo[]>();
+      processingResults = hintsProcessingResult;
+
+      typeMapping = hintsProcessingResult.TypeMapping;
+      reverseTypeMapping = hintsProcessingResult.ReverseTypeMapping;
+      fieldMapping = hintsProcessingResult.FieldMapping;
+      hints = hintsProcessingResult.Hints;
 
       this.extractedStorageModel = extractedStorageModel;
       this.resolver = resolver;
-
       nameBuilder = handlers.NameBuilder;
 
       currentModel = currentDomainModel;
       currentModel.UpdateReferences();
 
+      extractedModelFields = new Dictionary<StoredTypeInfo, StoredFieldInfo[]>();
       extractedModel = extractedDomainModel;
 
-      foreach (var type in extractedModel.Types)
+      foreach (var type in extractedModel.Types) {
         extractedModelFields.Add(type, type.Fields.Flatten(f => f.Fields, null, true).ToArray());
+      }
     }
   }
 }

Orm/Xtensive.Orm/Orm/Upgrade/Internals/HintGenerator.cs

@@ -1,12 +1,14 @@
-// Copyright (C) 2015 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2015-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2015.01.22
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Xtensive.Collections;
+using Xtensive.Core;
 using Xtensive.Orm.Model.Stored;
 using Xtensive.Orm.Upgrade.Internals.Interfaces;
 
@@ -24,14 +26,17 @@ public UpgradeHintsProcessingResult Process(IEnumerable<UpgradeHint> inputHints)
       var fieldMapping = new Dictionary<StoredFieldInfo, StoredFieldInfo>();
       var reverseFieldMapping = new Dictionary<StoredFieldInfo, StoredFieldInfo>();
       var currentModelTypes = currentDomainModel.Types.ToDictionary(t => t.UnderlyingType);
-      var suspiciousTypes = new List<StoredTypeInfo>();
-
-      return new UpgradeHintsProcessingResult(hints, typeMapping, reverseTypeMapping, fieldMapping, reverseFieldMapping, currentModelTypes, suspiciousTypes);
+      var suspiciousTypes = new HashSet<StoredTypeInfo>();
 
+      return new UpgradeHintsProcessingResult(
+        hints, typeMapping, reverseTypeMapping, fieldMapping, reverseFieldMapping, currentModelTypes,
+        suspiciousTypes, Array.Empty<StoredTypeInfo>(), Array.Empty<StoredTypeInfo>());
     }
 
     public NullUpgradeHintsProcessor(StoredDomainModel currentDomainModel)
     {
+      ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel));
+
       this.currentDomainModel = currentDomainModel;
     }
   }

Orm/Xtensive.Orm/Orm/Upgrade/Internals/NullUpgradeHintsProcessor.cs

@@ -1,31 +1,36 @@
-// Copyright (C) 2015 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2015-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2015.01.22
 
 using System.Collections.Generic;
 using System.Linq;
 using Xtensive.Collections;
+using Xtensive.Core;
 using Xtensive.Orm.Model.Stored;
 
 namespace Xtensive.Orm.Upgrade.Internals
 {
   internal sealed class UpgradeHintsProcessingResult
   {
-    public NativeTypeClassifier<UpgradeHint> Hints { get; private set; }
+    public NativeTypeClassifier<UpgradeHint> Hints { get; }
 
-    public Dictionary<StoredTypeInfo, StoredTypeInfo> TypeMapping { get; private set; }
+    public Dictionary<StoredTypeInfo, StoredTypeInfo> TypeMapping { get; }
 
-    public Dictionary<StoredTypeInfo, StoredTypeInfo> ReverseTypeMapping { get; private set; }
+    public Dictionary<StoredTypeInfo, StoredTypeInfo> ReverseTypeMapping { get; }
 
-    public Dictionary<StoredFieldInfo, StoredFieldInfo> FieldMapping { get; private set; }
+    public Dictionary<StoredFieldInfo, StoredFieldInfo> FieldMapping { get; }
 
-    public Dictionary<StoredFieldInfo, StoredFieldInfo> ReverseFieldMapping { get; private set; }
+    public Dictionary<StoredFieldInfo, StoredFieldInfo> ReverseFieldMapping { get; }
 
-    public Dictionary<string, StoredTypeInfo> CurrentModelTypes { get; private set; }
+    public Dictionary<string, StoredTypeInfo> CurrentModelTypes { get; }
 
-    public List<StoredTypeInfo> SuspiciousTypes { get; set; }
+    public HashSet<StoredTypeInfo> SuspiciousTypes { get; }
+
+    public IReadOnlyList<StoredTypeInfo> CurrentNonConnectorTypes { get; }
+
+    public IReadOnlyList<StoredTypeInfo> ExtractedNonConnectorTypes { get; }
 
     public bool AreAllTypesMapped()
     {
@@ -44,15 +49,29 @@ public UpgradeHintsProcessingResult(NativeTypeClassifier<UpgradeHint> hints,
       Dictionary<StoredFieldInfo, StoredFieldInfo> fieldMapping,
       Dictionary<StoredFieldInfo, StoredFieldInfo> reverseFieldMapping,
       Dictionary<string, StoredTypeInfo> currentModelTypes,
-      List<StoredTypeInfo> suspiciousTypes)
+      HashSet<StoredTypeInfo> suspiciousTypes,
+      IReadOnlyList<StoredTypeInfo> currentNonConnectorTypes,
+      IReadOnlyList<StoredTypeInfo> extractedNonConnectorTypes)
     {
+      ArgumentValidator.EnsureArgumentNotNull(hints, nameof(hints));
+      ArgumentValidator.EnsureArgumentNotNull(typeMapping, nameof(typeMapping));
+      ArgumentValidator.EnsureArgumentNotNull(reverseTypeMapping, nameof(reverseTypeMapping));
+      ArgumentValidator.EnsureArgumentNotNull(fieldMapping, nameof(fieldMapping));
+      ArgumentValidator.EnsureArgumentNotNull(reverseFieldMapping, nameof(reverseFieldMapping));
+      ArgumentValidator.EnsureArgumentNotNull(currentModelTypes, nameof(currentModelTypes));
+      ArgumentValidator.EnsureArgumentNotNull(suspiciousTypes, nameof(suspiciousTypes));
+      ArgumentValidator.EnsureArgumentNotNull(currentNonConnectorTypes, nameof(suspiciousTypes));
+      ArgumentValidator.EnsureArgumentNotNull(extractedNonConnectorTypes, nameof(suspiciousTypes));
+
       Hints = hints;
       TypeMapping = typeMapping;
       ReverseTypeMapping = reverseTypeMapping;
       FieldMapping = fieldMapping;
       ReverseFieldMapping = reverseFieldMapping;
       CurrentModelTypes = currentModelTypes;
       SuspiciousTypes = suspiciousTypes;
+      CurrentNonConnectorTypes = currentNonConnectorTypes;
+      ExtractedNonConnectorTypes = extractedNonConnectorTypes;
     }
   }
 }