Merge branch '6.0' into 7.0

# Conflicts:
#	Orm/Xtensive.Orm.Tests/Linq/CustomExpressionCompilers.cs

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Linq/CustomExpressionCompilers.cs

@@ -5,13 +5,13 @@
 // Created:    2009.11.13
 
 using System;
+using System.Linq;
 using System.Linq.Expressions;
 using NUnit.Framework;
 using Xtensive.Core;
 using Xtensive.Linq;
 using Xtensive.Orm.Configuration;
 using Xtensive.Orm.Tests.Linq.CustomExpressionCompilersModel;
-using System.Linq;
 
 namespace Xtensive.Orm.Tests.Linq.CustomExpressionCompilersModel
 {
@@ -80,24 +80,21 @@ public int InstanceMethod(int value)
       return value * Id;
     }
   }
-}
 
-namespace Xtensive.Orm.Tests.Linq
-{
-  [CompilerContainer(typeof (Expression))]
+  [CompilerContainer(typeof(Expression))]
   internal static class CustomLinqCompilerContainer
   {
-    [Compiler(typeof (Person), "Fullname", TargetKind.PropertyGet)]
+    [Compiler(typeof(Person), "Fullname", TargetKind.PropertyGet)]
     public static Expression FullName(Expression personExpression)
     {
       Expression<Func<Person, string>> ex = person => person.FirstName + " " + person.LastName;
       return ex.BindParameters(personExpression);
     }
 
-    [Compiler(typeof (Person), "AddPrefix", TargetKind.Method)]
+    [Compiler(typeof(Person), "AddPrefix", TargetKind.Method)]
     public static Expression AddPrefix(Expression personExpression, Expression prefixExpression)
     {
-      Expression<Func<Person, string, string>> ex =  (person, prefix) => prefix + person.LastName;
+      Expression<Func<Person, string, string>> ex = (person, prefix) => prefix + person.LastName;
       return ex.BindParameters(personExpression, prefixExpression);
     }
 
@@ -108,22 +105,24 @@ public static Expression Current(Expression assignmentExpression)
       return ex.BindParameters(assignmentExpression);
     }
   }
+}
 
+namespace Xtensive.Orm.Tests.Linq
+{
   public class CustomExpressionCompilers : AutoBuildTest
   {
     protected override DomainConfiguration BuildConfiguration()
     {
       var config = base.BuildConfiguration();
       config.Types.RegisterCaching(typeof (Person).Assembly, typeof (Person).Namespace);
-      config.Types.Register(typeof (CustomLinqCompilerContainer));
       RegisterLinqExtensions(config);
       return config;
     }
 
     private static void RegisterLinqExtensions(DomainConfiguration config)
     {
       var extensions = config.LinqExtensions;
-      var type = typeof (RegistrarTestEntity);
+      var type = typeof(RegistrarTestEntity);
       Expression<Func<int>> staticProperty = () => 0;
       extensions.Register(type.GetProperty("StaticProperty"), staticProperty);
       Expression<Func<RegistrarTestEntity, int>> instanceProperty = e => e.Id % 10;
@@ -137,35 +136,41 @@ private static void RegisterLinqExtensions(DomainConfiguration config)
     [Test]
     public void MainTest()
     {
-      using (var session = Domain.OpenSession()) {
-        using (var t = session.OpenTransaction()) {
-          Fill();
-          var expected1 = session.Query.All<Person>().AsEnumerable().OrderBy(p => p.Id).Select(p => p.Fullname).ToList();
-          Assert.Greater(expected1.Count, 0);
-          var fullNames1 = session.Query.All<Person>().OrderBy(p => p.Id).Select(p => p.Fullname).ToList();
-          Assert.IsTrue(expected1.SequenceEqual(fullNames1));
-
-          var expected2 = session.Query.All<Person>().AsEnumerable().OrderBy(p => p.Id).Select(p => p.AddPrefix("Mr. ")).ToList();
-          var fullNames2 = session.Query.All<Person>().OrderBy(p => p.Id).Select(p => p.AddPrefix("Mr. ")).ToList();
-          Assert.IsTrue(expected2.SequenceEqual(fullNames2));
-          // Rollback
-        }
+      using (var session = Domain.OpenSession())
+      using (var t = session.OpenTransaction()) {
+        Fill();
+        var expected1 = session.Query.All<Person>().AsEnumerable().OrderBy(p => p.Id).Select(p => p.Fullname).ToList();
+        Assert.Greater(expected1.Count, 0);
+        var fullNames1 = session.Query.All<Person>().OrderBy(p => p.Id).Select(p => p.Fullname).ToList();
+        Assert.IsTrue(expected1.SequenceEqual(fullNames1));
+
+        var expected2 = session.Query.All<Person>().AsEnumerable().OrderBy(p => p.Id).Select(p => p.AddPrefix("Mr. ")).ToList();
+        var fullNames2 = session.Query.All<Person>().OrderBy(p => p.Id).Select(p => p.AddPrefix("Mr. ")).ToList();
+        Assert.IsTrue(expected2.SequenceEqual(fullNames2));
+        // Rollback
       }
     }
 
     [Test]
     public void AssignmentCurrentTest()
     {
+      var baseDate = DateTime.Today;
+      (bool active, DateTime startDate, DateTime? endDate)[] dataset = new[] {
+        (true,  baseDate.AddYears(-20), (DateTime?)null),
+        (false, baseDate.AddYears(-20), (DateTime?)null),
+        (false, baseDate.AddYears(-5),  baseDate.AddYears(20)),
+        (true,  baseDate.AddYears(1),   baseDate.AddYears(20)),
+        (true,  baseDate.AddYears(-15), baseDate.AddYears(20)),
+      };
+
       using (var session = Domain.OpenSession())
       using (var t = session.OpenTransaction()) {
-        new Assignment() {Active = true, Start = new DateTime(2009, 11, 23), End = null};
-        new Assignment() {Active = false, Start = new DateTime(2009, 10, 3), End = null};
-        new Assignment() {Active = false, Start = new DateTime(2020, 01, 10), End = new DateTime(2044, 12, 3)};
-        new Assignment() {Active = true, Start = new DateTime(2026, 01, 10), End = new DateTime(2045, 11, 3)};
-        new Assignment() {Active = true, Start = new DateTime(2010, 01, 10), End = new DateTime(2035, 11, 3)};
+        foreach (var data in dataset) {
+          _ = new Assignment() { Active = data.active, Start = data.startDate, End = data.endDate };
+        }
 
         var currentCount = session.Query.All<Assignment>().Count(a => a.Current);
-        Assert.AreEqual(2, currentCount);
+        Assert.That(currentCount, Is.EqualTo(2));
         // Rollback
       }
     }
@@ -197,9 +202,9 @@ public void RegistrarTest()
 
     private void Fill()
     {
-      new Person {FirstName = "Ivan", LastName = "Semenov"};
-      new Person {FirstName = "John", LastName = "Smith"};
-      new Person {FirstName = "Andrew", LastName = "Politkovsky"};
+      _ = new Person { FirstName = "Ivan", LastName = "Semenov" };
+      _ = new Person { FirstName = "John", LastName = "Smith" };
+      _ = new Person { FirstName = "Andrew", LastName = "Politkovsky" };
     }
   }
 }

Orm/Xtensive.Orm/Linq/SerializableExpressions/Internals/SerializableExpressionToExpressionConverter.cs

@@ -14,8 +14,22 @@ namespace Xtensive.Linq.SerializableExpressions.Internals
 {
   internal sealed class SerializableExpressionToExpressionConverter
   {
+    private readonly struct LambdaParameterScope : IDisposable
+    {
+      private readonly SerializableExpressionToExpressionConverter converter;
+
+      public void Dispose() => converter.parameterScopes.Pop();
+
+      public LambdaParameterScope(SerializableExpressionToExpressionConverter converter, Dictionary<string, ParameterExpression> currentScope)
+      {
+        this.converter = converter;
+        this.converter.parameterScopes.Push(currentScope);
+      }
+    }
+
     private readonly SerializableExpression source;
     private readonly Dictionary<SerializableExpression, Expression> cache;
+    private readonly Stack<Dictionary<string, ParameterExpression>> parameterScopes;
 
     public Expression Convert()
     {
@@ -137,12 +151,12 @@ private Expression VisitConstant(SerializableConstantExpression c)
 
     private Expression VisitConditional(SerializableConditionalExpression c)
     {
-      return Expression.Condition(Visit(c.Test), Visit(c.IfTrue), Visit(c.IfFalse));
+      return Expression.Condition(Visit(c.Test), Visit(c.IfTrue), Visit(c.IfFalse), c.Type);
     }
 
     private Expression VisitParameter(SerializableParameterExpression p)
     {
-      return Expression.Parameter(p.Type, p.Name);
+      return GetCachedParameter(p.Type, p.Name) ?? Expression.Parameter(p.Type, p.Name);
     }
 
     private Expression VisitMemberAccess(SerializableMemberExpression m)
@@ -167,7 +181,10 @@ private Expression VisitMethodCall(SerializableMethodCallExpression mc)
 
     private Expression VisitLambda(SerializableLambdaExpression l)
     {
-      return FastExpression.Lambda(l.Type, Visit(l.Body), l.Parameters.Select(p => (ParameterExpression) Visit(p)));
+      var parameters = l.Parameters.Select(p => (ParameterExpression) Visit(p)).ToList();
+      using (CreateParameterScope(parameters)) {
+        return FastExpression.Lambda(l.Type, Visit(l.Body), parameters);
+      }
     }
 
     private Expression VisitNew(SerializableNewExpression n)
@@ -238,12 +255,49 @@ private IEnumerable<Expression> VisitExpressionSequence<T>(IEnumerable<T> expres
       return expressions.Select(e => Visit(e));
     }
 
+    private LambdaParameterScope CreateParameterScope(IReadOnlyList<ParameterExpression> lambdaParameters)
+    {
+      var parameters = new Dictionary<string, ParameterExpression>(lambdaParameters.Count);
+      foreach (var lambdaParameter in lambdaParameters) {
+        parameters.Add(lambdaParameter.Name, lambdaParameter);
+      }
+      return new LambdaParameterScope(this, parameters);
+    }
+
+    private ParameterExpression GetCachedParameter(Type type, string name)
+    {
+      var replacement = FindParameterFast(type, name);
+      if (replacement == null && parameterScopes.Count > 1)
+        return FindParameterSlow(type, name);
+      return replacement;
+    }
+
+    private ParameterExpression FindParameterFast(Type type, string name)
+    {
+      if (parameterScopes.Count > 0) {
+        var currentParameters = parameterScopes.Peek();
+        if (currentParameters.TryGetValue(name, out var replacement) && replacement.Type == type)
+          return replacement;
+      }
+      return null;
+    }
+
+    private ParameterExpression FindParameterSlow(Type type, string name)
+    {
+      foreach (var scope in parameterScopes) {
+        if (scope.TryGetValue(name, out var replacement) && replacement.Type == type)
+          return replacement;
+      }
+      return null;
+    }
+
     #endregion
 
     public SerializableExpressionToExpressionConverter(SerializableExpression source)
     {
       this.source = source;
       cache = new Dictionary<SerializableExpression, Expression>();
+      parameterScopes = new Stack<Dictionary<string, ParameterExpression>>();
     }
   }
 }