No struct checks for default for internal usage

- everywhere inside the project transformations are perforemed on valid
  descriptors so we can skip checks of structs, transformations are public though
  so we have to keep validation in public ctor

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/EntitySetBase.cs

@@ -1055,7 +1055,6 @@ protected EntitySetBase(Entity owner, FieldInfo field)
         var domain = Session.Domain;
         var itemType = domain.Model.Types[Field.ItemType];
         auxilaryTypeKeyTransform = new ConcatTransform(
-          false,
           owner.TypeInfo.Key.TupleDescriptor,
           itemType.Key.TupleDescriptor);
       }

Orm/Xtensive.Orm/Orm/Internals/KeyRemapper.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2014-2020 Xtensive LLC.
+// Copyright (C) 2014-2020 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
@@ -53,7 +53,7 @@ private void RemapEntitySetReference(RemapContext context, ReferenceFieldChangeI
       var fieldOwnerKey = context.TryRemapKey(info.FieldOwner);
       var fieldValueKey = context.TryRemapKey(info.FieldValue);
 
-      var transformer = new ConcatTransform(false, fieldOwnerKey.Value.Descriptor, fieldValueKey.Value.Descriptor);
+      var transformer = new ConcatTransform(fieldOwnerKey.Value.Descriptor, fieldValueKey.Value.Descriptor);
       var combinedTuple = transformer.Apply(TupleTransformType.Tuple, fieldOwnerKey.Value, fieldValueKey.Value);
 
       var newCombinedKey = Key.Create(Session.Domain, Session.StorageNodeId, fieldAssociation.AuxiliaryType, TypeReferenceAccuracy.ExactType, combinedTuple);

Orm/Xtensive.Orm/Orm/Linq/Materialization/MaterializationContext.cs

@@ -92,8 +92,8 @@ public TypeMapping GetTypeMapping(int entityIndex, TypeInfo approximateType, int
       ArraySegment<int> allIndexes = MaterializationHelper.CreateSingleSourceMap(descriptor.Count, typeColumnMap);
       ArraySegment<int> keyIndexes = allIndexes.Slice(0, keyInfo.TupleDescriptor.Count);
 
-      var transform    = new MapTransform(true, descriptor, allIndexes);
-      var keyTransform = new MapTransform(true, keyInfo.TupleDescriptor, keyIndexes);
+      var transform    = new MapTransform(descriptor, allIndexes);
+      var keyTransform = new MapTransform(keyInfo.TupleDescriptor, keyIndexes);
 
       result = new TypeMapping(type, keyTransform, transform, keyIndexes);
 

Orm/Xtensive.Orm/Orm/Model/FieldInfo.cs

@@ -699,7 +699,7 @@ private void CreateMappingInfo()
 
       if (IsEntity || IsStructure) {
         valueExtractor = new SegmentTransform(
-          false, reflectedType.TupleDescriptor, new Segment<int>(mappingInfo.Offset, mappingInfo.Length));
+          reflectedType.TupleDescriptor, new Segment<int>(mappingInfo.Offset, mappingInfo.Length));
       }
     }
 

Orm/Xtensive.Orm/Orm/Rse/Transformation/RedundantColumnRemover.cs

@@ -46,7 +46,7 @@ protected override RawProvider VisitRaw(RawProvider provider)
       var mapping = mappings[provider];
       if (mapping.SequenceEqual(Enumerable.Range(0, provider.Header.Length)))
         return provider;
-      var mappingTransform = new MapTransform(true, provider.Header.TupleDescriptor, mapping);
+      var mappingTransform = new MapTransform(provider.Header.TupleDescriptor, mapping);
       var newExpression = RemapRawProviderSource(provider.Source, mappingTransform);
       return new RawProvider(provider.Header.Select(mapping), newExpression);
     }

Orm/Xtensive.Orm/Tuples/Transform/ConcatTransform.cs

@@ -87,12 +87,29 @@ public override string ToString()
     /// <param name="second">The <see cref="TupleDescriptor"/> of the second source <see cref="Tuple"/>.</param>
     public ConcatTransform(bool isReadOnly, TupleDescriptor first, TupleDescriptor second)
     {
-      ArgumentValidator.EnsureArgumentIsNotDefault(first, nameof(first));
-      ArgumentValidator.EnsureArgumentIsNotDefault(second, nameof(second));
+      if (first == default)
+        throw new ArgumentException("Argument is default instance.", nameof(first));
+
+      if (second == default)
+        throw new ArgumentException("Argument is default instance.", nameof(second));
 
       IsReadOnly = isReadOnly;
       Descriptor = first.ConcatWith(second);
       this.sourceParts = (first.Count, second.Count);
     }
+
+
+    /// <summary>
+    /// Initializes a new instance of this type.
+    /// </summary>
+    /// <param name="first">The <see cref="TupleDescriptor"/> of the first source <see cref="Tuple"/>.</param>
+    /// <param name="second">The <see cref="TupleDescriptor"/> of the second source <see cref="Tuple"/>.</param>
+    // WARNING !!!!! NO CHECKS FOR DEFAULT VALUES FOR THE SAKE OF PEFRORMANCE
+    internal ConcatTransform(TupleDescriptor first, TupleDescriptor second)
+    {
+      IsReadOnly = false;
+      Descriptor = first.ConcatWith(second);
+      this.sourceParts = (first.Count, second.Count);
+    }
   }
 }

Orm/Xtensive.Orm/Tuples/Transform/MapTransform.cs

@@ -81,12 +81,29 @@ public override string ToString()
     /// <param name="map"><see cref="Map"/> property value.</param>
     public MapTransform(bool isReadOnly, TupleDescriptor descriptor, IReadOnlyList<int> map)
     {
-      ArgumentValidator.EnsureArgumentIsNotDefault(descriptor, nameof(descriptor));
+      if (descriptor == default)
+        throw new ArgumentException("Argument is default instance.",nameof(descriptor));
 
       IsReadOnly = isReadOnly;
       Descriptor = descriptor;
 
       this.map = map ?? throw new ArgumentNullException(nameof(map));
     }
+
+
+
+    /// <summary>
+    /// Initializes a new instance of this type with <see cref="IsReadOnly"/> = <see langword="true"/>.
+    /// </summary>
+    /// <param name="descriptor">The <see cref="TupleDescriptor"/> of the target <see cref="Tuple"/>.</param>
+    /// <param name="map"><see cref="Map"/> property value.</param>
+    // BE CAREFUL, NO VALIDATION OF PARAMETERS for the sake of performance
+    internal MapTransform(TupleDescriptor descriptor, IReadOnlyList<int> map)
+    {
+      IsReadOnly = true;
+      Descriptor = descriptor;
+
+      this.map = map ?? throw new ArgumentNullException(nameof(map));
+    }
   }
 }

Orm/Xtensive.Orm/Tuples/Transform/SegmentTransform.cs

@@ -75,10 +75,23 @@ public override string ToString()
     /// <param name="segment">The segment to extract.</param>
     public SegmentTransform(bool isReadOnly, TupleDescriptor sourceDescriptor, in Segment<int> segment)
     {
-      ArgumentValidator.EnsureArgumentIsNotDefault(sourceDescriptor, nameof(sourceDescriptor));
+      if (sourceDescriptor == default)
+        throw new ArgumentException("Argument is default instance.", nameof(sourceDescriptor));
 
       IsReadOnly = isReadOnly;
+      Descriptor = sourceDescriptor.Segment(segment);
+      this.segment = segment;
+    }
 
+    /// <summary>
+    /// Initializes a new instance of this type.
+    /// </summary>
+    /// <param name="sourceDescriptor">The <see cref="TupleDescriptor"/> of the source <see cref="Tuple"/>.</param>
+    /// <param name="segment">The segment to extract.</param>
+    // WARNING !!!!! NO CHECKS FOR DEFAULT VALUES FOR THE SAKE OF PEFRORMANCE
+    internal SegmentTransform(TupleDescriptor sourceDescriptor, in Segment<int> segment)
+    {
+      IsReadOnly = false;
       Descriptor = sourceDescriptor.Segment(segment);
       this.segment = segment;
     }

Orm/Xtensive.Orm/Tuples/TupleExtensions.cs

@@ -115,7 +115,7 @@ public static void CopyTo(this Tuple source, Tuple target, IReadOnlyList<int> ma
     /// <returns></returns>
     public static Tuple Concat(this Tuple left, Tuple right)
     {
-      var transform = new ConcatTransform(false, left.Descriptor, right.Descriptor);
+      var transform = new ConcatTransform(left.Descriptor, right.Descriptor);
       return transform.Apply(TupleTransformType.TransformedTuple, left, right);
     }
 
@@ -127,7 +127,7 @@ public static Tuple Concat(this Tuple left, Tuple right)
     /// <returns></returns>
     public static Tuple GetSegment(this Tuple tuple, in Segment<int> segment)
     {
-      var transform = new SegmentTransform(false, tuple.Descriptor, segment);
+      var transform = new SegmentTransform(tuple.Descriptor, segment);
       return transform.Apply(TupleTransformType.TransformedTuple, tuple);
     }