Add support for DefaultExpressions in expression visitors

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations/Internals/ExpressionVisitor.cs

@@ -1,11 +1,12 @@
-// Copyright (C) 2019-2020 Xtensive LLC.
+// Copyright (C) 2019-2023 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq.Expressions;
+using Xtensive.Core;
 using Xtensive.Linq;
 
 namespace Xtensive.Orm.BulkOperations
@@ -95,6 +96,8 @@ protected virtual Expression Visit(Expression exp)
           return VisitConditional((ConditionalExpression) exp);
         case ExpressionType.Constant:
           return VisitConstant((ConstantExpression) exp);
+        case ExpressionType.Default:
+          return VisitDefault((DefaultExpression) exp);
         case ExpressionType.Parameter:
           return VisitParameter((ParameterExpression) exp);
         case ExpressionType.MemberAccess:
@@ -180,6 +183,11 @@ private Expression VisitConstant(ConstantExpression c)
       return c;
     }
 
+    private Expression VisitDefault(DefaultExpression d)
+    {
+      return d.ToConstantExpression();
+    }
+
     private ElementInit VisitElementInitializer(ElementInit initializer)
     {
       IEnumerable<Expression> arguments = VisitExpressionList(initializer.Arguments);

Orm/Xtensive.Orm/Core/Extensions/ExpressionExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2023 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexis Kochetov
@@ -12,6 +12,8 @@
 using Xtensive.Linq.SerializableExpressions.Internals;
 
 using System.Linq;
+using Xtensive.Reflection;
+using System.Collections.Concurrent;
 
 namespace Xtensive.Core
 {
@@ -20,6 +22,8 @@ namespace Xtensive.Core
   /// </summary>
   public static class ExpressionExtensions
   {
+    private readonly static ConcurrentDictionary<Type, object> StructDefaultValues = new();
+
     /// <summary>
     /// Formats the <paramref name="expression"/>.
     /// </summary>
@@ -105,12 +109,41 @@ public static SerializableExpression ToSerializableExpression(this Expression ex
     /// Converts specified <see cref="SerializableExpression"/> to <see cref="Expression"/>.
     /// </summary>
     /// <param name="expression">The expression to convert.</param>
-    /// <returns></returns>
+    /// <returns>Expression that represents given <see cref="SerializableExpression"/>.</returns>
     public static Expression ToExpression(this SerializableExpression expression)
     {
       return new SerializableExpressionToExpressionConverter(expression).Convert();
     }
 
+    /// <summary>
+    /// Converts <see cref="DefaultExpression"/> to <see cref="ConstantExpression"/>
+    /// with value of default value of type in the <paramref name="defaultExpression"/>.
+    /// </summary>
+    /// <param name="defaultExpression">The expression to convert.</param>
+    /// <returns>Result constant expression.</returns>
+    public static ConstantExpression ToConstantExpression(this DefaultExpression defaultExpression)
+    {
+      var value = GetDefaultValue(defaultExpression);
+
+      return Expression.Constant(value, defaultExpression.Type);
+    }
+
+    /// <summary>
+    /// Gets the value represented by given <see cref="DefaultExpression"/>.
+    /// </summary>
+    /// <param name="defaultExpression">The default value expression.</param>
+    /// <returns>Object value of default value.</returns>
+    public static object GetDefaultValue(this DefaultExpression defaultExpression)
+    {
+      if (defaultExpression.Type.IsValueType) {
+        return StructDefaultValues.GetOrAdd<DefaultExpression>(
+          defaultExpression.Type,
+          (type, expr) => { return ((Func<object>) Expression.Lambda(Expression.Convert(expr, WellKnownTypes.Object)).Compile()).Invoke(); },
+          defaultExpression);
+      }
+      return null;
+    }
+
     /// <summary>
     /// Gets return type of <see cref="LambdaExpression"/>.
     /// This method is used to write code that is compilable on .NET 3.5,

Orm/Xtensive.Orm/Linq/ExpressionVisitor.cs

@@ -1,13 +1,14 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2008-2023 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 Kochetov
 // Created:    2008.11.11
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq.Expressions;
+using Xtensive.Core;
 
 namespace Xtensive.Linq
 {
@@ -96,6 +97,12 @@ protected override Expression VisitConstant(ConstantExpression c)
       return c;
     }
 
+    /// <inheritdoc/>
+    protected override Expression VisitDefault(DefaultExpression d)
+    {
+      return d.ToConstantExpression();
+    }
+
     /// <inheritdoc/>
     protected override Expression VisitConditional(ConditionalExpression c)
     {

Orm/Xtensive.Orm/Linq/ExpressionVisitor{TResult}.cs

@@ -96,6 +96,9 @@ protected virtual TResult Visit(Expression e)
       case ExpressionType.Constant:
         result = VisitConstant((ConstantExpression) e);
         break;
+      case ExpressionType.Default:
+        result = VisitDefault((DefaultExpression) e);
+        break;
       case ExpressionType.Parameter:
         result = VisitParameter((ParameterExpression) e);
         break;
@@ -189,6 +192,13 @@ protected virtual TResult VisitUnknown(Expression e)
     /// <param name="c">The constant expression.</param>
     /// <returns>Visit result.</returns>
     protected abstract TResult VisitConstant(ConstantExpression c);
+
+    /// <summary>
+    /// Visits the default expression.
+    /// </summary>
+    /// <param name="d">The default expression.</param>
+    /// <returns>Visit result.</returns>
+    protected abstract TResult VisitDefault(DefaultExpression d);
 
     /// <summary>
     /// Visits the conditional expression.

Orm/Xtensive.Orm/Linq/ExpressionWriter.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2008-2021 Xtensive LLC.
+// Copyright (C) 2008-2023 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 Kochetov
@@ -213,7 +213,7 @@ protected virtual string GetOperator(ExpressionType type)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitBinary(BinaryExpression b)
+    protected override BinaryExpression VisitBinary(BinaryExpression b)
     {
       switch (b.NodeType) {
         case ExpressionType.ArrayIndex:
@@ -244,7 +244,7 @@ protected override Expression VisitBinary(BinaryExpression b)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitUnary(UnaryExpression u)
+    protected override UnaryExpression VisitUnary(UnaryExpression u)
     {
       switch (u.NodeType) {
         case ExpressionType.Convert:
@@ -307,7 +307,7 @@ protected virtual string GetTypeName(Type type)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitConditional(ConditionalExpression c)
+    protected override ConditionalExpression VisitConditional(ConditionalExpression c)
     {
       Visit(c.Test);
       WriteLine(IndentType.Inner);
@@ -335,7 +335,7 @@ protected override System.Collections.ObjectModel.ReadOnlyCollection<MemberBindi
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitConstant(ConstantExpression c)
+    protected override ConstantExpression VisitConstant(ConstantExpression c)
     {
       var type = c.Type;
       if (type.Name.IndexOf("__DisplayClass", StringComparison.Ordinal) > 0 &&
@@ -400,6 +400,14 @@ protected override Expression VisitConstant(ConstantExpression c)
       return c;
     }
 
+    protected override DefaultExpression VisitDefault(DefaultExpression d)
+    {
+      Write("default(");
+      Write(GetTypeName(d.Type));
+      Write(")");
+      return d;
+    }
+
     /// <inheritdoc/>
     protected override ElementInit VisitElementInitializer(ElementInit initializer)
     {
@@ -452,7 +460,7 @@ protected override System.Collections.ObjectModel.ReadOnlyCollection<Expression>
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitInvocation(InvocationExpression i)
+    protected override InvocationExpression VisitInvocation(InvocationExpression i)
     {
       Write("Invoke(");
       WriteLine(IndentType.Inner);
@@ -467,7 +475,7 @@ protected override Expression VisitInvocation(InvocationExpression i)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitLambda(LambdaExpression l)
+    protected override LambdaExpression VisitLambda(LambdaExpression l)
     {
       if (l.Parameters.Count > 1) {
         Write("(");
@@ -493,7 +501,7 @@ protected override Expression VisitLambda(LambdaExpression l)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitListInit(ListInitExpression li)
+    protected override ListInitExpression VisitListInit(ListInitExpression li)
     {
       Visit(li.NewExpression);
       Write(" {");
@@ -505,7 +513,7 @@ protected override Expression VisitListInit(ListInitExpression li)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitMemberAccess(MemberExpression m)
+    protected override MemberExpression VisitMemberAccess(MemberExpression m)
     {
       Visit(m.Expression);
       Write(".");
@@ -523,7 +531,7 @@ protected override MemberAssignment VisitMemberAssignment(MemberAssignment ma)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitMemberInit(MemberInitExpression mi)
+    protected override MemberInitExpression VisitMemberInit(MemberInitExpression mi)
     {
       Visit(mi.NewExpression);
       Write(" {");
@@ -559,7 +567,7 @@ protected override MemberMemberBinding VisitMemberMemberBinding(MemberMemberBind
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitMethodCall(MethodCallExpression mc)
+    protected override MethodCallExpression VisitMethodCall(MethodCallExpression mc)
     {
       var arguments = mc.Arguments;
       if (mc.Object != null) {
@@ -584,7 +592,7 @@ protected override Expression VisitMethodCall(MethodCallExpression mc)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitNew(NewExpression n)
+    protected override NewExpression VisitNew(NewExpression n)
     {
       Write("new ");
       Write(GetTypeName(n.Type));
@@ -593,7 +601,7 @@ protected override Expression VisitNew(NewExpression n)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitNewArray(NewArrayExpression na)
+    protected override NewArrayExpression VisitNewArray(NewArrayExpression na)
     {
       Write("new ");
       Write(GetTypeName(SequenceHelper.GetElementType(na.Type)));
@@ -602,14 +610,14 @@ protected override Expression VisitNewArray(NewArrayExpression na)
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitParameter(ParameterExpression p)
+    protected override ParameterExpression VisitParameter(ParameterExpression p)
     {
       Write(p.Name);
       return p;
     }
 
     /// <inheritdoc/>
-    protected override Expression VisitTypeIs(TypeBinaryExpression tb)
+    protected override TypeBinaryExpression VisitTypeIs(TypeBinaryExpression tb)
     {
       Visit(tb.Expression);
       Write(" is ");

Orm/Xtensive.Orm/Linq/Internals/ExpressionHashCodeCalculator.cs

@@ -1,10 +1,11 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2008-2023 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Denis Krjuchkov
 // Created:    2009.05.06
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -60,6 +61,16 @@ protected override int VisitConstant(ConstantExpression c)
       return c.Value != null ? c.Value.GetHashCode() : NullHashCode;
     }
 
+    protected override int VisitDefault(DefaultExpression d)
+    {
+      if (d.Type.IsValueType) {
+        return d.GetDefaultValue().GetHashCode();
+      }
+      else {
+        return NullHashCode;
+      }
+    }
+
     protected override int VisitConditional(ConditionalExpression c)
     {
       return Visit(c.Test) ^ Visit(c.IfTrue) ^ Visit(c.IfFalse);