Merge pull request #31 from servicetitan/readonly-segment-struct

alex-kulakov · web-flow · commit ee8b13fb4767 · 2020-05-14T19:27:42.000+05:00
Make Segment struct readonly. Pass it by reference. Access it as field.
diff --git a/Orm/Xtensive.Orm/Core/Extensions/EnumerableExtensions.cs b/Orm/Xtensive.Orm/Core/Extensions/EnumerableExtensions.cs
@@ -312,7 +312,7 @@ public static T[] ToArray<T>(this IEnumerable<T> sequence, int length)
     /// Gets the items from the segment.
     /// </summary>
     /// <param name="segment">The segment.</param>
-    public static IEnumerable<int> GetItems(this Segment<int> segment)
+    public static IEnumerable<int> GetItems(this in Segment<int> segment)
     {
       return Enumerable.Range(segment.Offset, segment.Length);
     }
diff --git a/Orm/Xtensive.Orm/Core/Segment.cs b/Orm/Xtensive.Orm/Core/Segment.cs
@@ -19,7 +19,7 @@ namespace Xtensive.Core
   /// <typeparam name="T">The type of segment boundaries.</typeparam>
   [Serializable]
   [DebuggerDisplay("Offset = {Offset}, Length = {Length}")]
-  public struct Segment<T>
+  public readonly struct Segment<T>
   {
     private static ArithmeticStruct<T> arithmetic = ArithmeticStruct<T>.Default;
 
@@ -87,7 +87,7 @@ public override int GetHashCode()
     /// <param name="segment">The segment.</param>
     /// <param name="offsetShift">The offset shift.</param>
     /// <returns>The result of the operator.</returns>
-    public static Segment<T> operator +(Segment<T> segment, T offsetShift)
+    public static Segment<T> operator +(in Segment<T> segment, T offsetShift)
     {
       var newOffset = arithmetic.Add(segment.Offset, offsetShift);
       return new Segment<T>(newOffset, segment.Length);
@@ -99,7 +99,7 @@ public override int GetHashCode()
     /// <param name="segment">The segment.</param>
     /// <param name="offsetShift">The offset shift.</param>
     /// <returns>The result of the operator.</returns>
-    public static Segment<T> operator -(Segment<T> segment, T offsetShift)
+    public static Segment<T> operator -(in Segment<T> segment, T offsetShift)
     {
       var newOffset = arithmetic.Subtract(segment.Offset, offsetShift);
       return new Segment<T>(newOffset, segment.Length);
diff --git a/Orm/Xtensive.Orm/Orm/Internals/TupleExtensions.cs b/Orm/Xtensive.Orm/Orm/Internals/TupleExtensions.cs
@@ -33,7 +33,7 @@ public static bool ContainsNonEmptyValues(this Tuple target)
       return false;
     }
 
-    public static bool ContainsEmptyValues(this Tuple target, Segment<int> segment)
+    public static bool ContainsEmptyValues(this Tuple target, in Segment<int> segment)
     {
       for (int i = segment.Offset; i < segment.EndOffset; i++) {
         var state = target.GetFieldState(i);
@@ -43,7 +43,7 @@ public static bool ContainsEmptyValues(this Tuple target, Segment<int> segment)
       return false;
     }
 
-    public static bool ContainsNonEmptyValues(this Tuple target, Segment<int> segment)
+    public static bool ContainsNonEmptyValues(this Tuple target, in Segment<int> segment)
     {
       for (int i = segment.Offset; i < segment.EndOffset; i++) {
         var state = target.GetFieldState(i);
@@ -53,7 +53,7 @@ public static bool ContainsNonEmptyValues(this Tuple target, Segment<int> segmen
       return false;
     }
 
-    public static bool AreAllColumnsAvalilable(this Tuple target, Segment<int> segment)
+    public static bool AreAllColumnsAvalilable(this Tuple target, in Segment<int> segment)
     {
       for (int i = segment.Offset; i < segment.EndOffset; i++) {
         var state = target.GetFieldState(i);
@@ -63,7 +63,7 @@ public static bool AreAllColumnsAvalilable(this Tuple target, Segment<int> segme
       return true;
     }
 
-    public static bool IsAtLeastOneColumAvailable(this Tuple target, Segment<int> segment)
+    public static bool IsAtLeastOneColumAvailable(this Tuple target, in Segment<int> segment)
     {
       for (int i = segment.Offset; i < segment.EndOffset; i++) {
         var state = target.GetFieldState(i);
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/ColumnExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/ColumnExpression.cs
@@ -7,30 +7,29 @@
 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using Xtensive.Collections;
 using Xtensive.Core;
 
 namespace Xtensive.Orm.Linq.Expressions
 {
   internal class ColumnExpression : ParameterizedExpression,
     IMappedExpression
   {
-    public Segment<int> Mapping { get; private set; }
+    internal readonly Segment<int> Mapping;
 
     public Expression Remap(int offset, Dictionary<Expression, Expression> processedExpressions)
     {
       if (!CanRemap)
         return this;
-      var mapping = new Segment<int>(Mapping.Offset + offset, 1);
-      return new ColumnExpression(Type, mapping, OuterParameter, DefaultIfEmpty);
+      var newMapping = new Segment<int>(Mapping.Offset + offset, 1);
+      return new ColumnExpression(Type, newMapping, OuterParameter, DefaultIfEmpty);
     }
 
     public Expression Remap(int[] map, Dictionary<Expression, Expression> processedExpressions)
     {
       if (!CanRemap)
         return this;
-      var mapping = new Segment<int>(map.IndexOf(Mapping.Offset), 1);
-      return new ColumnExpression(Type, mapping, OuterParameter, DefaultIfEmpty);
+      var newMapping = new Segment<int>(map.IndexOf(Mapping.Offset), 1);
+      return new ColumnExpression(Type, newMapping, OuterParameter, DefaultIfEmpty);
     }
 
     public Expression BindParameter(ParameterExpression parameter)
@@ -63,13 +62,13 @@ public override string ToString()
     // Constructors
 
     protected ColumnExpression(
-      Type type, 
-      Segment<int> mapping, 
-      ParameterExpression parameterExpression, 
+      Type type,
+      in Segment<int> mapping,
+      ParameterExpression parameterExpression,
       bool defaultIfEmpty)
       : base(ExtendedExpressionType.Column, type, parameterExpression, defaultIfEmpty)
     {
-      Mapping = mapping;
+      this.Mapping = mapping;
     }
   }
 }
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/ConstructorExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/ConstructorExpression.cs
@@ -29,11 +29,6 @@ internal class ConstructorExpression : ParameterizedExpression,
 
     public IEnumerable<Expression> ConstructorArguments { get; private set; }
 
-    public Segment<int> Mapping
-    {
-      get { throw new NotSupportedException(); }
-    }
-
     public Expression BindParameter(ParameterExpression parameter, Dictionary<Expression, Expression> processedExpressions)
     {
       Func<Expression, Expression> genericBinder =
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/EntityExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/EntityExpression.cs
@@ -21,11 +21,6 @@ internal class EntityExpression : ParameterizedExpression,
 
     public TypeInfo PersistentType { get; private set; }
 
-    public Segment<int> Mapping
-    {
-      get { throw new NotSupportedException(); }
-    }
-
     public KeyExpression Key { get; private set; }
 
     public List<PersistentFieldExpression> Fields
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/EntityFieldExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/EntityFieldExpression.cs
@@ -176,7 +176,7 @@ private EntityFieldExpression(
       TypeInfo persistentType, 
       FieldInfo field, 
       List<PersistentFieldExpression> fields,
-      Segment<int> mapping, 
+      in Segment<int> mapping,
       KeyExpression key, 
       EntityExpression entity, 
       ParameterExpression parameterExpression, 
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/FieldExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/FieldExpression.cs
@@ -43,8 +43,8 @@ public override Expression Remap(int offset, Dictionary<Expression, Expression>
         return result;
       }
 
-      var mapping = new Segment<int>(Mapping.Offset + offset, Mapping.Length);
-      result = new FieldExpression(ExtendedExpressionType.Field, Field, mapping, OuterParameter, DefaultIfEmpty);
+      var newMapping = new Segment<int>(Mapping.Offset + offset, Mapping.Length);
+      result = new FieldExpression(ExtendedExpressionType.Field, Field, newMapping, OuterParameter, DefaultIfEmpty);
       if (owner == null) {
         return result;
       }
@@ -72,8 +72,8 @@ public override Expression Remap(int[] map, Dictionary<Expression, Expression> p
           Owner.Remap(map, processedExpressions);
         return null;
       }
-      var mapping = new Segment<int>(offset, Mapping.Length);
-      result = new FieldExpression(ExtendedExpressionType.Field, Field, mapping, OuterParameter, DefaultIfEmpty);
+      var newMapping = new Segment<int>(offset, Mapping.Length);
+      result = new FieldExpression(ExtendedExpressionType.Field, Field, newMapping, OuterParameter, DefaultIfEmpty);
       if (owner == null)
         return result;
 
@@ -130,7 +130,7 @@ public static FieldExpression CreateField(FieldInfo field, int offset)
     protected FieldExpression(
       ExtendedExpressionType expressionType, 
       FieldInfo field, 
-      Segment<int> mapping, 
+      in Segment<int> mapping,
       ParameterExpression parameterExpression, 
       bool defaultIfEmpty)
       : base(expressionType, field.Name, field.ValueType, mapping, field.UnderlyingProperty, parameterExpression, defaultIfEmpty)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/FullTextExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/FullTextExpression.cs
@@ -22,12 +22,6 @@ internal class FullTextExpression : ParameterizedExpression,
 
     public EntityExpression EntityExpression { get; private set; }
 
-    /// <exception cref="NotSupportedException"><c>NotSupportedException</c>.</exception>
-    public Segment<int> Mapping
-    {
-      get { throw new NotSupportedException(); }
-    }
-
     public Expression BindParameter(ParameterExpression parameter, Dictionary<Expression, Expression> processedExpressions)
     {
       Expression result;
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/Interfaces/IMappedExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/Interfaces/IMappedExpression.cs
@@ -12,7 +12,6 @@ namespace Xtensive.Orm.Linq.Expressions
 {
   internal interface IMappedExpression
   {
-    Segment<int> Mapping { get; }
     Expression BindParameter(ParameterExpression parameter, Dictionary<Expression, Expression> processedExpressions);
     Expression RemoveOuterParameter(Dictionary<Expression, Expression> processedExpressions);
     Expression Remap(int offset, Dictionary<Expression, Expression> processedExpressions);
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/KeyExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/KeyExpression.cs
@@ -34,12 +34,12 @@ public override Expression Remap(int offset, Dictionary<Expression, Expression>
     // in case processedExpressions dictionary already contains a result.
     private Expression RemapWithNoCheck(int offset, Dictionary<Expression, Expression> processedExpressions)
     {
-      var mapping = new Segment<int>(Mapping.Offset + offset, Mapping.Length);
+      var newMapping = new Segment<int>(Mapping.Offset + offset, Mapping.Length);
 
       FieldExpression Remap(FieldExpression f) => (FieldExpression) f.Remap(offset, processedExpressions);
 
       var fields = KeyFields.Select(Remap).ToArray(KeyFields.Count);
-      var result = new KeyExpression(EntityType, fields, mapping, UnderlyingProperty, OuterParameter, DefaultIfEmpty);
+      var result = new KeyExpression(EntityType, fields, newMapping, UnderlyingProperty, OuterParameter, DefaultIfEmpty);
 
       processedExpressions.Add(this, result);
       return result;
@@ -147,7 +147,7 @@ public static KeyExpression Create(TypeInfo entityType, int offset)
     private KeyExpression(
       TypeInfo entityType, 
       IReadOnlyList<FieldExpression> keyFields,
-      Segment<int> segment, 
+      in Segment<int> segment,
       PropertyInfo underlyingProperty, 
       ParameterExpression parameterExpression, 
       bool defaultIfEmpty)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/LocalCollectionExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/LocalCollectionExpression.cs
@@ -18,11 +18,6 @@ namespace Xtensive.Orm.Linq.Expressions
   internal class LocalCollectionExpression : ParameterizedExpression,
     IMappedExpression
   {
-    public Segment<int> Mapping
-    {
-      get { return default(Segment<int>); }
-    }
-
     public Expression SourceExpression { get;private set; }
     public IDictionary<MemberInfo, IMappedExpression> Fields { get; set; }
     public Expression MaterializationExpression { get; private set; }
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/PersistentFieldExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/PersistentFieldExpression.cs
@@ -15,9 +15,10 @@ namespace Xtensive.Orm.Linq.Expressions
   internal abstract class PersistentFieldExpression : ParameterizedExpression,
     IMappedExpression
   {
+    internal Segment<int> Mapping;
+
     public string Name { get; private set; }
     public PropertyInfo UnderlyingProperty { get; private set; }
-    public virtual Segment<int> Mapping { get; protected set; }
     public abstract Expression BindParameter(ParameterExpression parameter, Dictionary<Expression, Expression> processedExpressions);
     public abstract Expression RemoveOuterParameter(Dictionary<Expression, Expression> processedExpressions);
     public abstract Expression Remap(int offset, Dictionary<Expression, Expression> processedExpressions);
@@ -35,7 +36,7 @@ protected PersistentFieldExpression(
       ExtendedExpressionType expressionType, 
       string name, 
       Type type, 
-      Segment<int> segment, 
+      in Segment<int> segment,
       PropertyInfo underlyingProperty,
       ParameterExpression parameterExpression,
       bool defaultIfEmpty)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/StructureExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/StructureExpression.cs
@@ -19,6 +19,7 @@ internal sealed class StructureExpression : ParameterizedExpression,
     IPersistentExpression
   {
     private List<PersistentFieldExpression> fields;
+    internal Segment<int> Mapping;
     public TypeInfo PersistentType { get; private set; }
 
     public bool IsNullable { get; set; }
@@ -34,8 +35,6 @@ private set
       }
     }
 
-    public Segment<int> Mapping{ get; private set;}
-
     public Expression Remap(int offset, Dictionary<Expression, Expression> processedExpressions)
     {
       if (!CanRemap)
@@ -118,14 +117,18 @@ public Expression RemoveOuterParameter(Dictionary<Expression, Expression> proces
       return result;
     }
 
-    public static StructureExpression CreateLocalCollectionStructure(TypeInfo typeInfo, Segment<int> mapping)
+    public static StructureExpression CreateLocalCollectionStructure(TypeInfo typeInfo, in Segment<int> mapping)
     {
-      if (!typeInfo.IsStructure)
+      if (!typeInfo.IsStructure) {
         throw new ArgumentException(string.Format(Strings.ExTypeXIsNotStructure, typeInfo.Name));
-      var result = new StructureExpression(typeInfo, mapping);
-      result.Fields = typeInfo.Fields
-        .Select(f => BuildNestedFieldExpression(f, mapping.Offset))
-        .ToList();
+      }
+
+      var sourceFields = typeInfo.Fields;
+      var destinationFields = new List<PersistentFieldExpression>(sourceFields.Count);
+      var result = new StructureExpression(typeInfo, mapping) {Fields = destinationFields};
+      foreach (var field in sourceFields) {
+        destinationFields.Add(BuildNestedFieldExpression(field, mapping.Offset));
+      }
       return result;
     }
 
@@ -147,10 +150,10 @@ private static PersistentFieldExpression BuildNestedFieldExpression(FieldInfo ne
 
     private StructureExpression(
       TypeInfo persistentType, 
-      Segment<int> mapping)
+      in Segment<int> mapping)
       : base(ExtendedExpressionType.Structure, persistentType.UnderlyingType, null, false)
     {
-      Mapping = mapping;
+      this.Mapping = mapping;
       PersistentType = persistentType;
     }
   }
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/StructureFieldExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/StructureFieldExpression.cs
@@ -46,8 +46,8 @@ public override Expression Remap(int offset, Dictionary<Expression, Expression>
       if (processedExpressions.TryGetValue(this, out value))
         return value;
 
-      var mapping = new Segment<int>(Mapping.Offset + offset, Mapping.Length);
-      var result = new StructureFieldExpression(PersistentType, Field, mapping, OuterParameter, DefaultIfEmpty);
+      var newMapping = new Segment<int>(Mapping.Offset + offset, Mapping.Length);
+      var result = new StructureFieldExpression(PersistentType, Field, newMapping, OuterParameter, DefaultIfEmpty);
       processedExpressions.Add(this, result);
       var processedFields = Fields
         .Select(f => f.Remap(offset, processedExpressions))
@@ -183,7 +183,7 @@ private static PersistentFieldExpression BuildNestedFieldExpression(FieldInfo ne
     private StructureFieldExpression(
       TypeInfo persistentType, 
       FieldInfo structureField, 
-      Segment<int> mapping, 
+      in Segment<int> mapping,
       ParameterExpression parameterExpression, 
       bool defaultIfEmpty)
       : base(ExtendedExpressionType.StructureField, structureField, mapping, parameterExpression, defaultIfEmpty)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Expressions/SubQueryExpression.cs b/Orm/Xtensive.Orm/Orm/Linq/Expressions/SubQueryExpression.cs
@@ -23,12 +23,6 @@ internal class SubQueryExpression : ParameterizedExpression,
 
     public ApplyParameter ApplyParameter { get; private set; }
 
-    /// <exception cref="NotSupportedException"><c>NotSupportedException</c>.</exception>
-    public virtual Segment<int> Mapping
-    {
-      get { throw new NotSupportedException(); }
-    }
-
     public virtual Expression BindParameter(ParameterExpression parameter, Dictionary<Expression, Expression> processedExpressions)
     {
       return this;
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Materialization/ExpressionMaterializer.cs b/Orm/Xtensive.Orm/Orm/Linq/Materialization/ExpressionMaterializer.cs
@@ -496,7 +496,7 @@ private static Tuple BuildPersistentTuple(Tuple tuple, Tuple tuplePrototype, int
       return result;
     }
 
-    private static Tuple GetTupleSegment(Tuple tuple, Segment<int> segment)
+    private static Tuple GetTupleSegment(Tuple tuple, in Segment<int> segment)
     {
       return tuple.GetSegment(segment).ToRegular();
     }
diff --git a/Orm/Xtensive.Orm/Orm/Model/FieldInfo.cs b/Orm/Xtensive.Orm/Orm/Model/FieldInfo.cs
diff --git a/Orm/Xtensive.Orm/Tuples/Transform/CutOutTransform.cs b/Orm/Xtensive.Orm/Tuples/Transform/CutOutTransform.cs
diff --git a/Orm/Xtensive.Orm/Tuples/Transform/SegmentTransform.cs b/Orm/Xtensive.Orm/Tuples/Transform/SegmentTransform.cs
diff --git a/Orm/Xtensive.Orm/Tuples/TupleExtensions.cs b/Orm/Xtensive.Orm/Tuples/TupleExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ public static T[] ToArray<T>(this IEnumerable<T> sequence, int length)`
`312`	`312`	`/// Gets the items from the segment.`
`313`	`313`	`/// </summary>`
`314`	`314`	`/// <param name="segment">The segment.</param>`
`315`		`- public static IEnumerable<int> GetItems(this Segment<int> segment)`
	`315`	`+ public static IEnumerable<int> GetItems(this in Segment<int> segment)`
`316`	`316`	`{`
`317`	`317`	`return Enumerable.Range(segment.Offset, segment.Length);`
`318`	`318`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public static bool ContainsNonEmptyValues(this Tuple target)`
`33`	`33`	`return false;`
`34`	`34`	`}`
`35`	`35`
`36`		`- public static bool ContainsEmptyValues(this Tuple target, Segment<int> segment)`
	`36`	`+ public static bool ContainsEmptyValues(this Tuple target, in Segment<int> segment)`
`37`	`37`	`{`
`38`	`38`	`for (int i = segment.Offset; i < segment.EndOffset; i++) {`
`39`	`39`	`var state = target.GetFieldState(i);`
`@@ -43,7 +43,7 @@ public static bool ContainsEmptyValues(this Tuple target, Segment<int> segment)`
`43`	`43`	`return false;`
`44`	`44`	`}`
`45`	`45`
`46`		`- public static bool ContainsNonEmptyValues(this Tuple target, Segment<int> segment)`
	`46`	`+ public static bool ContainsNonEmptyValues(this Tuple target, in Segment<int> segment)`
`47`	`47`	`{`
`48`	`48`	`for (int i = segment.Offset; i < segment.EndOffset; i++) {`
`49`	`49`	`var state = target.GetFieldState(i);`
`@@ -53,7 +53,7 @@ public static bool ContainsNonEmptyValues(this Tuple target, Segment<int> segmen`
`53`	`53`	`return false;`
`54`	`54`	`}`
`55`	`55`
`56`		`- public static bool AreAllColumnsAvalilable(this Tuple target, Segment<int> segment)`
	`56`	`+ public static bool AreAllColumnsAvalilable(this Tuple target, in Segment<int> segment)`
`57`	`57`	`{`
`58`	`58`	`for (int i = segment.Offset; i < segment.EndOffset; i++) {`
`59`	`59`	`var state = target.GetFieldState(i);`
`@@ -63,7 +63,7 @@ public static bool AreAllColumnsAvalilable(this Tuple target, Segment<int> segme`
`63`	`63`	`return true;`
`64`	`64`	`}`
`65`	`65`
`66`		`- public static bool IsAtLeastOneColumAvailable(this Tuple target, Segment<int> segment)`
	`66`	`+ public static bool IsAtLeastOneColumAvailable(this Tuple target, in Segment<int> segment)`
`67`	`67`	`{`
`68`	`68`	`for (int i = segment.Offset; i < segment.EndOffset; i++) {`
`69`	`69`	`var state = target.GetFieldState(i);`
Original file line number	Diff line number	Diff line change
`@@ -7,30 +7,29 @@`
`7`	`7`	`using System;`
`8`	`8`	`using System.Collections.Generic;`
`9`	`9`	`using System.Linq.Expressions;`
`10`		`-using Xtensive.Collections;`
`11`	`10`	`using Xtensive.Core;`
`12`	`11`
`13`	`12`	`namespace Xtensive.Orm.Linq.Expressions`
`14`	`13`	`{`
`15`	`14`	`internal class ColumnExpression : ParameterizedExpression,`
`16`	`15`	`IMappedExpression`
`17`	`16`	`{`
`18`		`- public Segment<int> Mapping { get; private set; }`
	`17`	`+ internal readonly Segment<int> Mapping;`
`19`	`18`
`20`	`19`	`public Expression Remap(int offset, Dictionary<Expression, Expression> processedExpressions)`
`21`	`20`	`{`
`22`	`21`	`if (!CanRemap)`
`23`	`22`	`return this;`
`24`		`- var mapping = new Segment<int>(Mapping.Offset + offset, 1);`
`25`		`- return new ColumnExpression(Type, mapping, OuterParameter, DefaultIfEmpty);`
	`23`	`+ var newMapping = new Segment<int>(Mapping.Offset + offset, 1);`
	`24`	`+ return new ColumnExpression(Type, newMapping, OuterParameter, DefaultIfEmpty);`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`public Expression Remap(int[] map, Dictionary<Expression, Expression> processedExpressions)`
`29`	`28`	`{`
`30`	`29`	`if (!CanRemap)`
`31`	`30`	`return this;`
`32`		`- var mapping = new Segment<int>(map.IndexOf(Mapping.Offset), 1);`
`33`		`- return new ColumnExpression(Type, mapping, OuterParameter, DefaultIfEmpty);`
	`31`	`+ var newMapping = new Segment<int>(map.IndexOf(Mapping.Offset), 1);`
	`32`	`+ return new ColumnExpression(Type, newMapping, OuterParameter, DefaultIfEmpty);`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`public Expression BindParameter(ParameterExpression parameter)`
`@@ -63,13 +62,13 @@ public override string ToString()`
`63`	`62`	`// Constructors`
`64`	`63`
`65`	`64`	`protected ColumnExpression(`
`66`		`- Type type,`
`67`		`- Segment<int> mapping,`
`68`		`- ParameterExpression parameterExpression,`
	`65`	`+ Type type,`
	`66`	`+ in Segment<int> mapping,`
	`67`	`+ ParameterExpression parameterExpression,`
`69`	`68`	`bool defaultIfEmpty)`
`70`	`69`	`: base(ExtendedExpressionType.Column, type, parameterExpression, defaultIfEmpty)`
`71`	`70`	`{`
`72`		`- Mapping = mapping;`
	`71`	`+ this.Mapping = mapping;`
`73`	`72`	`}`
`74`	`73`	`}`
`75`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@ namespace Xtensive.Orm.Linq.Expressions`
`12`	`12`	`{`
`13`	`13`	`internal interface IMappedExpression`
`14`	`14`	`{`
`15`		`- Segment<int> Mapping { get; }`
`16`	`15`	`Expression BindParameter(ParameterExpression parameter, Dictionary<Expression, Expression> processedExpressions);`
`17`	`16`	`Expression RemoveOuterParameter(Dictionary<Expression, Expression> processedExpressions);`
`18`	`17`	`Expression Remap(int offset, Dictionary<Expression, Expression> processedExpressions);`