Merge pull request #320 from servicetitan/upstream/OptimizeVisitors

alex-kulakov · web-flow · commit 3091198e2ff9 · 2023-09-02T05:28:06.000-04:00
Optimize Visitors
diff --git a/Extensions/Xtensive.Orm.BulkOperations/Internals/ExpressionVisitor.cs b/Extensions/Xtensive.Orm.BulkOperations/Internals/ExpressionVisitor.cs
@@ -30,7 +30,7 @@ public static Expression Visit(Expression exp, Func<T, Expression> visitor)
 
     protected override Expression Visit(Expression exp)
     {
-      if (exp is T && visitor!=null)
+      if (exp is T && visitor != null)
         exp = visitor((T) exp);
 
       return base.Visit(exp);
@@ -54,7 +54,7 @@ internal abstract class ExpressionVisitor
 
     protected virtual Expression Visit(Expression exp)
     {
-      if (exp==null)
+      if (exp == null)
         return null;
       switch (exp.NodeType) {
         case ExpressionType.Negate:
@@ -127,8 +127,8 @@ private Expression VisitBinary(BinaryExpression b)
       Expression left = Visit(b.Left);
       Expression right = Visit(b.Right);
       Expression conversion = Visit(b.Conversion);
-      if (left!=b.Left || right!=b.Right || conversion!=b.Conversion) {
-        if (b.NodeType==ExpressionType.Coalesce)
+      if (left != b.Left || right != b.Right || conversion != b.Conversion) {
+        if (b.NodeType == ExpressionType.Coalesce)
           return Expression.Coalesce(left, right, conversion as LambdaExpression);
         return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);
       }
@@ -154,16 +154,16 @@ private IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBin
       List<MemberBinding> list = null;
       for (int i = 0, n = original.Count; i < n; i++) {
         MemberBinding b = VisitBinding(original[i]);
-        if (list!=null)
+        if (list != null)
           list.Add(b);
-        else if (b!=original[i]) {
+        else if (b != original[i]) {
           list = new List<MemberBinding>(n);
           for (int j = 0; j < i; j++)
             list.Add(original[j]);
           list.Add(b);
         }
       }
-      if (list!=null)
+      if (list != null)
         return list;
       return original;
     }
@@ -173,7 +173,7 @@ private Expression VisitConditional(ConditionalExpression c)
       Expression test = Visit(c.Test);
       Expression ifTrue = Visit(c.IfTrue);
       Expression ifFalse = Visit(c.IfFalse);
-      if (test!=c.Test || ifTrue!=c.IfTrue || ifFalse!=c.IfFalse)
+      if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)
         return Expression.Condition(test, ifTrue, ifFalse);
       return c;
     }
@@ -191,7 +191,7 @@ private Expression VisitDefault(DefaultExpression d)
     private ElementInit VisitElementInitializer(ElementInit initializer)
     {
       IEnumerable<Expression> arguments = VisitExpressionList(initializer.Arguments);
-      if (arguments!=initializer.Arguments)
+      if (arguments != initializer.Arguments)
         return Expression.ElementInit(initializer.AddMethod, arguments);
       return initializer;
     }
@@ -201,16 +201,16 @@ private IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<
       List<ElementInit> list = null;
       for (int i = 0, n = original.Count; i < n; i++) {
         ElementInit init = VisitElementInitializer(original[i]);
-        if (list!=null)
+        if (list != null)
           list.Add(init);
-        else if (init!=original[i]) {
+        else if (init != original[i]) {
           list = new List<ElementInit>(n);
           for (int j = 0; j < i; j++)
             list.Add(original[j]);
           list.Add(init);
         }
       }
-      if (list!=null)
+      if (list != null)
         return list;
       return original;
     }
@@ -220,16 +220,16 @@ private IEnumerable<Expression> VisitExpressionList(ReadOnlyCollection<Expressio
       List<Expression> list = null;
       for (int i = 0, n = original.Count; i < n; i++) {
         var p = Visit(original[i]);
-        if (list!=null)
+        if (list != null)
           list.Add(p);
-        else if (p!=original[i]) {
+        else if (p != original[i]) {
           list = new List<Expression>(n);
           for (int j = 0; j < i; j++)
             list.Add(original[j]);
           list.Add(p);
         }
       }
-      if (list!=null)
+      if (list != null)
         return list.AsReadOnly();
       return original;
     }
@@ -238,15 +238,15 @@ private Expression VisitInvocation(InvocationExpression iv)
     {
       IEnumerable<Expression> args = VisitExpressionList(iv.Arguments);
       Expression expr = Visit(iv.Expression);
-      if (args!=iv.Arguments || expr!=iv.Expression)
+      if (args != iv.Arguments || expr != iv.Expression)
         return Expression.Invoke(expr, args);
       return iv;
     }
 
     private Expression VisitLambda(LambdaExpression lambda)
     {
       Expression body = Visit(lambda.Body);
-      if (body!=lambda.Body)
+      if (body != lambda.Body)
         return FastExpression.Lambda(lambda.Type, body, lambda.Parameters);
       return lambda;
     }
@@ -255,23 +255,24 @@ private Expression VisitListInit(ListInitExpression init)
     {
       NewExpression n = VisitNew(init.NewExpression);
       IEnumerable<ElementInit> initializers = VisitElementInitializerList(init.Initializers);
-      if (n!=init.NewExpression || initializers!=init.Initializers)
+      if (n != init.NewExpression || initializers != init.Initializers)
         return Expression.ListInit(n, initializers);
       return init;
     }
 
     private Expression VisitMemberAccess(MemberExpression m)
     {
-      Expression exp = Visit(m.Expression);
-      if (exp!=m.Expression)
+      var originalExpression = m.Expression;
+      Expression exp = Visit(originalExpression);
+      if (exp != originalExpression)
         return Expression.MakeMemberAccess(exp, m.Member);
       return m;
     }
 
     private MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
     {
       Expression e = Visit(assignment.Expression);
-      if (e!=assignment.Expression)
+      if (e != assignment.Expression)
         return Expression.Bind(assignment.Member, e);
       return assignment;
     }
@@ -280,23 +281,23 @@ private Expression VisitMemberInit(MemberInitExpression init)
     {
       NewExpression n = VisitNew(init.NewExpression);
       IEnumerable<MemberBinding> bindings = VisitBindingList(init.Bindings);
-      if (n!=init.NewExpression || bindings!=init.Bindings)
+      if (n != init.NewExpression || bindings != init.Bindings)
         return Expression.MemberInit(n, bindings);
       return init;
     }
 
     private MemberListBinding VisitMemberListBinding(MemberListBinding binding)
     {
       IEnumerable<ElementInit> initializers = VisitElementInitializerList(binding.Initializers);
-      if (initializers!=binding.Initializers)
+      if (initializers != binding.Initializers)
         return Expression.ListBind(binding.Member, initializers);
       return binding;
     }
 
     private MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
     {
       IEnumerable<MemberBinding> bindings = VisitBindingList(binding.Bindings);
-      if (bindings!=binding.Bindings)
+      if (bindings != binding.Bindings)
         return Expression.MemberBind(binding.Member, bindings);
       return binding;
     }
@@ -305,24 +306,24 @@ private Expression VisitMethodCall(MethodCallExpression m)
     {
       Expression obj = Visit(m.Object);
       IEnumerable<Expression> args = VisitExpressionList(m.Arguments);
-      if (obj!=m.Object || args!=m.Arguments)
+      if (obj != m.Object || args != m.Arguments)
         return Expression.Call(obj, m.Method, args);
       return m;
     }
 
     private NewExpression VisitNew(NewExpression nex)
     {
       IEnumerable<Expression> args = VisitExpressionList(nex.Arguments);
-      if (args!=nex.Arguments)
+      if (args != nex.Arguments)
         return Expression.New(nex.Constructor, args, nex.Members);
       return nex;
     }
 
     private Expression VisitNewArray(NewArrayExpression na)
     {
       IEnumerable<Expression> exprs = VisitExpressionList(na.Expressions);
-      if (exprs!=na.Expressions) {
-        if (na.NodeType==ExpressionType.NewArrayInit)
+      if (exprs != na.Expressions) {
+        if (na.NodeType == ExpressionType.NewArrayInit)
           return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
         return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
       }
@@ -337,15 +338,15 @@ private Expression VisitParameter(ParameterExpression p)
     private Expression VisitTypeIs(TypeBinaryExpression b)
     {
       Expression expr = Visit(b.Expression);
-      if (expr!=b.Expression)
+      if (expr != b.Expression)
         return Expression.TypeIs(expr, b.TypeOperand);
       return b;
     }
 
     private Expression VisitUnary(UnaryExpression u)
     {
       Expression operand = Visit(u.Operand);
-      if (operand!=u.Operand)
+      if (operand != u.Operand)
         return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);
       return u;
     }
diff --git a/Orm/Xtensive.Orm.Tests/Linq/QueryDumper.cs b/Orm/Xtensive.Orm.Tests/Linq/QueryDumper.cs
@@ -228,7 +228,7 @@ private void CreateNodeTree(List<object> values, ref XmlDocument document, strin
         var depth = 1;
         XmlNode itemNode = document.CreateElement("Item" + itemIndex);
 
-        if (value==null || !value.GetType().IsGenericType || (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition()!=typeof (Grouping<,>))) {
+        if (value == null || !value.GetType().IsGenericType || (value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition() != typeof(Grouping<,>))) {
           itemNode = document.CreateElement("Item" + itemIndex);
           itemIndex++;
           parentNode.AppendChild(itemNode);
@@ -299,8 +299,8 @@ private int AddNode(object value, PropertyInfo property, ref XmlDocument documen
 
       else {
         if (property.PropertyType.IsGenericType &&
-          (property.PropertyType.GetGenericTypeDefinition()==typeof (IQueryable<>)
-            || (property.PropertyType.GetGenericTypeDefinition()==typeof (IEnumerable<>)))) {
+          (property.PropertyType.GetGenericTypeDefinition() == typeof(IQueryable<>)
+            || (property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))) {
           var enumerable = (IEnumerable) property.GetValue(value, property.GetIndexParameters());
           var list = new List<object>();
           foreach (var o in enumerable)
@@ -556,13 +556,18 @@ private string KeyToString(object key)
     private static void EnumerateAll(IEnumerable enumerable)
     {
       foreach (var o in enumerable)
-        if (o!=null) {
-          if (o.GetType().IsGenericType && (o.GetType().GetGenericTypeDefinition()==typeof (IQueryable<>)
-            || o.GetType().GetGenericTypeDefinition()==typeof (IEnumerable<>)
-            || o.GetType().GetGenericTypeDefinition()==typeof (SubQuery<>)
-            || o.GetType().GetGenericTypeDefinition()==typeof (Grouping<,>)))
-            EnumerateAll((IEnumerable) o);
-          var properties = o.GetType().GetProperties();
+        if (o != null) {
+          var type = o.GetType();
+          if (type.IsGenericType) {
+            var genericTypeDefinition = type.GetGenericTypeDefinition();
+            if (genericTypeDefinition == typeof(IQueryable<>)
+                || genericTypeDefinition == typeof(IEnumerable<>)
+                || genericTypeDefinition == typeof(SubQuery<>)
+              || genericTypeDefinition == typeof(Grouping<,>)) {
+              EnumerateAll((IEnumerable) o);
+            }
+          }
+          var properties = type.GetProperties();
           foreach (var info in properties) {
             if (info.PropertyType.IsGenericType && 
               (info.PropertyType.GetGenericTypeDefinition()==typeof (IQueryable<>)
diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/ValueTypeBuilder.cs b/Orm/Xtensive.Orm/Orm/Building/Builders/ValueTypeBuilder.cs
@@ -61,14 +61,16 @@ private static object AdjustValue(string fieldName, Type fieldType, object value
 #if NET6_0_OR_GREATER
 
       if (valueType == WellKnownTypes.TimeOnly) {
-        if (value is string timeOnlyString && !TimeOnly.TryParse(timeOnlyString, out var timeOnly)) {
+        TimeOnly timeOnly = default;
+        if (value is string timeOnlyString && !TimeOnly.TryParse(timeOnlyString, out timeOnly)) {
           throw FailToParseValue(fieldName, timeOnlyString);
         }
         return timeOnly;
       }
 
       if (valueType == WellKnownTypes.DateOnly) {
-        if (value is string dateOnlyString && !DateOnly.TryParse(dateOnlyString, out var dateOnly)) {
+        DateOnly dateOnly = default;
+        if (value is string dateOnlyString && !DateOnly.TryParse(dateOnlyString, out dateOnly)) {
           throw FailToParseValue(fieldName, dateOnlyString);
         }
         return dateOnly;
diff --git a/Orm/Xtensive.Orm/Orm/Linq/ExpressionExtensions.cs b/Orm/Xtensive.Orm/Orm/Linq/ExpressionExtensions.cs
@@ -134,8 +134,9 @@ public static bool IsEntitySetExpression(this Expression expression)
     }
 
     public static bool IsEntitySet(this Expression expression) =>
-      expression.Type.IsGenericType
-      && expression.Type.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT;
+      expression.Type switch {
+        var type => type.IsGenericType && type.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT
+      };
 
     public static Expression StripMarkers(this Expression e)
     {
diff --git a/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs b/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs
@@ -313,28 +313,23 @@ private static CompilerKey GetCompilerKey(MemberInfo member)
 
       var targetType = canonicalMember.ReflectedType;
       if (targetType.IsGenericType) {
-        targetType = targetType.GetGenericTypeDefinition();
-        if (canonicalMember is FieldInfo)
-          canonicalMember = targetType.GetField(canonicalMember.Name);
-        else if (canonicalMember is MethodInfo methodInfo) {
-          canonicalMember = GetCanonicalMethod(methodInfo, targetType.GetMethods());
+        if (!targetType.IsGenericTypeDefinition) {
+          targetType = targetType.GetGenericTypeDefinition();
         }
-        else if (canonicalMember is ConstructorInfo constructorInfo)
-          canonicalMember = GetCanonicalMethod(constructorInfo, targetType.GetConstructors());
-        else
-          canonicalMember = null;
+        canonicalMember = canonicalMember switch {
+          FieldInfo _ => targetType.GetField(canonicalMember.Name),
+          MethodInfo methodInfo => GetCanonicalMethod(methodInfo, targetType.GetMethods()),
+          ConstructorInfo constructorInfo => GetCanonicalMethod(constructorInfo, targetType.GetConstructors()),
+          _ => null
+        };
       }
 
       if (canonicalMember == null) {
         return default;
       }
 
       if (targetType.IsEnum) {
-        var declaringType = canonicalMember.DeclaringType;
-        if (targetType != declaringType)
-          canonicalMember = GetCanonicalMethod((MethodInfo) canonicalMember, declaringType.GetMethods());
-        else
-          canonicalMember = GetCanonicalMethod((MethodInfo) canonicalMember, targetType.GetMethods());
+        canonicalMember = GetCanonicalMethod((MethodInfo) canonicalMember, canonicalMember.DeclaringType.GetMethods());
       }
 
       return new CompilerKey(canonicalMember);
diff --git a/Orm/Xtensive.Orm/Orm/Linq/QueryHelper.cs b/Orm/Xtensive.Orm/Orm/Linq/QueryHelper.cs
@@ -74,9 +74,9 @@ public static bool IsDirectEntitySetQuery(Expression entitySet)
       if (owner.NodeType!=ExpressionType.MemberAccess)
         return false;
       var wrapper = ((MemberExpression) owner).Expression;
-      return wrapper.NodeType==ExpressionType.Constant
+      return wrapper.NodeType == ExpressionType.Constant
         && wrapper.Type.IsGenericType
-        && wrapper.Type.GetGenericTypeDefinition()==typeof (OwnerWrapper<>);
+        && wrapper.Type.GetGenericTypeDefinition() == typeof(OwnerWrapper<>);
     }
 
     public static Expression CreateDirectEntitySetQuery(EntitySetBase entitySet)
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs
diff --git a/Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs b/Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public static Expression Visit(Expression exp, Func<T, Expression> visitor)`
`30`	`30`
`31`	`31`	`protected override Expression Visit(Expression exp)`
`32`	`32`	`{`
`33`		`- if (exp is T && visitor!=null)`
	`33`	`+ if (exp is T && visitor != null)`
`34`	`34`	`exp = visitor((T) exp);`
`35`	`35`
`36`	`36`	`return base.Visit(exp);`
`@@ -54,7 +54,7 @@ internal abstract class ExpressionVisitor`
`54`	`54`
`55`	`55`	`protected virtual Expression Visit(Expression exp)`
`56`	`56`	`{`
`57`		`- if (exp==null)`
	`57`	`+ if (exp == null)`
`58`	`58`	`return null;`
`59`	`59`	`switch (exp.NodeType) {`
`60`	`60`	`case ExpressionType.Negate:`
`@@ -127,8 +127,8 @@ private Expression VisitBinary(BinaryExpression b)`
`127`	`127`	`Expression left = Visit(b.Left);`
`128`	`128`	`Expression right = Visit(b.Right);`
`129`	`129`	`Expression conversion = Visit(b.Conversion);`
`130`		`- if (left!=b.Left \|\| right!=b.Right \|\| conversion!=b.Conversion) {`
`131`		`- if (b.NodeType==ExpressionType.Coalesce)`
	`130`	`+ if (left != b.Left \|\| right != b.Right \|\| conversion != b.Conversion) {`
	`131`	`+ if (b.NodeType == ExpressionType.Coalesce)`
`132`	`132`	`return Expression.Coalesce(left, right, conversion as LambdaExpression);`
`133`	`133`	`return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);`
`134`	`134`	`}`
`@@ -154,16 +154,16 @@ private IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBin`
`154`	`154`	`List<MemberBinding> list = null;`
`155`	`155`	`for (int i = 0, n = original.Count; i < n; i++) {`
`156`	`156`	`MemberBinding b = VisitBinding(original[i]);`
`157`		`- if (list!=null)`
	`157`	`+ if (list != null)`
`158`	`158`	`list.Add(b);`
`159`		`- else if (b!=original[i]) {`
	`159`	`+ else if (b != original[i]) {`
`160`	`160`	`list = new List<MemberBinding>(n);`
`161`	`161`	`for (int j = 0; j < i; j++)`
`162`	`162`	`list.Add(original[j]);`
`163`	`163`	`list.Add(b);`
`164`	`164`	`}`
`165`	`165`	`}`
`166`		`- if (list!=null)`
	`166`	`+ if (list != null)`
`167`	`167`	`return list;`
`168`	`168`	`return original;`
`169`	`169`	`}`
`@@ -173,7 +173,7 @@ private Expression VisitConditional(ConditionalExpression c)`
`173`	`173`	`Expression test = Visit(c.Test);`
`174`	`174`	`Expression ifTrue = Visit(c.IfTrue);`
`175`	`175`	`Expression ifFalse = Visit(c.IfFalse);`
`176`		`- if (test!=c.Test \|\| ifTrue!=c.IfTrue \|\| ifFalse!=c.IfFalse)`
	`176`	`+ if (test != c.Test \|\| ifTrue != c.IfTrue \|\| ifFalse != c.IfFalse)`
`177`	`177`	`return Expression.Condition(test, ifTrue, ifFalse);`
`178`	`178`	`return c;`
`179`	`179`	`}`
`@@ -191,7 +191,7 @@ private Expression VisitDefault(DefaultExpression d)`
`191`	`191`	`private ElementInit VisitElementInitializer(ElementInit initializer)`
`192`	`192`	`{`
`193`	`193`	`IEnumerable<Expression> arguments = VisitExpressionList(initializer.Arguments);`
`194`		`- if (arguments!=initializer.Arguments)`
	`194`	`+ if (arguments != initializer.Arguments)`
`195`	`195`	`return Expression.ElementInit(initializer.AddMethod, arguments);`
`196`	`196`	`return initializer;`
`197`	`197`	`}`
`@@ -201,16 +201,16 @@ private IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<`
`201`	`201`	`List<ElementInit> list = null;`
`202`	`202`	`for (int i = 0, n = original.Count; i < n; i++) {`
`203`	`203`	`ElementInit init = VisitElementInitializer(original[i]);`
`204`		`- if (list!=null)`
	`204`	`+ if (list != null)`
`205`	`205`	`list.Add(init);`
`206`		`- else if (init!=original[i]) {`
	`206`	`+ else if (init != original[i]) {`
`207`	`207`	`list = new List<ElementInit>(n);`
`208`	`208`	`for (int j = 0; j < i; j++)`
`209`	`209`	`list.Add(original[j]);`
`210`	`210`	`list.Add(init);`
`211`	`211`	`}`
`212`	`212`	`}`
`213`		`- if (list!=null)`
	`213`	`+ if (list != null)`
`214`	`214`	`return list;`
`215`	`215`	`return original;`
`216`	`216`	`}`
`@@ -220,16 +220,16 @@ private IEnumerable<Expression> VisitExpressionList(ReadOnlyCollection<Expressio`
`220`	`220`	`List<Expression> list = null;`
`221`	`221`	`for (int i = 0, n = original.Count; i < n; i++) {`
`222`	`222`	`var p = Visit(original[i]);`
`223`		`- if (list!=null)`
	`223`	`+ if (list != null)`
`224`	`224`	`list.Add(p);`
`225`		`- else if (p!=original[i]) {`
	`225`	`+ else if (p != original[i]) {`
`226`	`226`	`list = new List<Expression>(n);`
`227`	`227`	`for (int j = 0; j < i; j++)`
`228`	`228`	`list.Add(original[j]);`
`229`	`229`	`list.Add(p);`
`230`	`230`	`}`
`231`	`231`	`}`
`232`		`- if (list!=null)`
	`232`	`+ if (list != null)`
`233`	`233`	`return list.AsReadOnly();`
`234`	`234`	`return original;`
`235`	`235`	`}`
`@@ -238,15 +238,15 @@ private Expression VisitInvocation(InvocationExpression iv)`
`238`	`238`	`{`
`239`	`239`	`IEnumerable<Expression> args = VisitExpressionList(iv.Arguments);`
`240`	`240`	`Expression expr = Visit(iv.Expression);`
`241`		`- if (args!=iv.Arguments \|\| expr!=iv.Expression)`
	`241`	`+ if (args != iv.Arguments \|\| expr != iv.Expression)`
`242`	`242`	`return Expression.Invoke(expr, args);`
`243`	`243`	`return iv;`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`private Expression VisitLambda(LambdaExpression lambda)`
`247`	`247`	`{`
`248`	`248`	`Expression body = Visit(lambda.Body);`
`249`		`- if (body!=lambda.Body)`
	`249`	`+ if (body != lambda.Body)`
`250`	`250`	`return FastExpression.Lambda(lambda.Type, body, lambda.Parameters);`
`251`	`251`	`return lambda;`
`252`	`252`	`}`
`@@ -255,23 +255,24 @@ private Expression VisitListInit(ListInitExpression init)`
`255`	`255`	`{`
`256`	`256`	`NewExpression n = VisitNew(init.NewExpression);`
`257`	`257`	`IEnumerable<ElementInit> initializers = VisitElementInitializerList(init.Initializers);`
`258`		`- if (n!=init.NewExpression \|\| initializers!=init.Initializers)`
	`258`	`+ if (n != init.NewExpression \|\| initializers != init.Initializers)`
`259`	`259`	`return Expression.ListInit(n, initializers);`
`260`	`260`	`return init;`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`private Expression VisitMemberAccess(MemberExpression m)`
`264`	`264`	`{`
`265`		`- Expression exp = Visit(m.Expression);`
`266`		`- if (exp!=m.Expression)`
	`265`	`+ var originalExpression = m.Expression;`
	`266`	`+ Expression exp = Visit(originalExpression);`
	`267`	`+ if (exp != originalExpression)`
`267`	`268`	`return Expression.MakeMemberAccess(exp, m.Member);`
`268`	`269`	`return m;`
`269`	`270`	`}`
`270`	`271`
`271`	`272`	`private MemberAssignment VisitMemberAssignment(MemberAssignment assignment)`
`272`	`273`	`{`
`273`	`274`	`Expression e = Visit(assignment.Expression);`
`274`		`- if (e!=assignment.Expression)`
	`275`	`+ if (e != assignment.Expression)`
`275`	`276`	`return Expression.Bind(assignment.Member, e);`
`276`	`277`	`return assignment;`
`277`	`278`	`}`
`@@ -280,23 +281,23 @@ private Expression VisitMemberInit(MemberInitExpression init)`
`280`	`281`	`{`
`281`	`282`	`NewExpression n = VisitNew(init.NewExpression);`
`282`	`283`	`IEnumerable<MemberBinding> bindings = VisitBindingList(init.Bindings);`
`283`		`- if (n!=init.NewExpression \|\| bindings!=init.Bindings)`
	`284`	`+ if (n != init.NewExpression \|\| bindings != init.Bindings)`
`284`	`285`	`return Expression.MemberInit(n, bindings);`
`285`	`286`	`return init;`
`286`	`287`	`}`
`287`	`288`
`288`	`289`	`private MemberListBinding VisitMemberListBinding(MemberListBinding binding)`
`289`	`290`	`{`
`290`	`291`	`IEnumerable<ElementInit> initializers = VisitElementInitializerList(binding.Initializers);`
`291`		`- if (initializers!=binding.Initializers)`
	`292`	`+ if (initializers != binding.Initializers)`
`292`	`293`	`return Expression.ListBind(binding.Member, initializers);`
`293`	`294`	`return binding;`
`294`	`295`	`}`
`295`	`296`
`296`	`297`	`private MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)`
`297`	`298`	`{`
`298`	`299`	`IEnumerable<MemberBinding> bindings = VisitBindingList(binding.Bindings);`
`299`		`- if (bindings!=binding.Bindings)`
	`300`	`+ if (bindings != binding.Bindings)`
`300`	`301`	`return Expression.MemberBind(binding.Member, bindings);`
`301`	`302`	`return binding;`
`302`	`303`	`}`
`@@ -305,24 +306,24 @@ private Expression VisitMethodCall(MethodCallExpression m)`
`305`	`306`	`{`
`306`	`307`	`Expression obj = Visit(m.Object);`
`307`	`308`	`IEnumerable<Expression> args = VisitExpressionList(m.Arguments);`
`308`		`- if (obj!=m.Object \|\| args!=m.Arguments)`
	`309`	`+ if (obj != m.Object \|\| args != m.Arguments)`
`309`	`310`	`return Expression.Call(obj, m.Method, args);`
`310`	`311`	`return m;`
`311`	`312`	`}`
`312`	`313`
`313`	`314`	`private NewExpression VisitNew(NewExpression nex)`
`314`	`315`	`{`
`315`	`316`	`IEnumerable<Expression> args = VisitExpressionList(nex.Arguments);`
`316`		`- if (args!=nex.Arguments)`
	`317`	`+ if (args != nex.Arguments)`
`317`	`318`	`return Expression.New(nex.Constructor, args, nex.Members);`
`318`	`319`	`return nex;`
`319`	`320`	`}`
`320`	`321`
`321`	`322`	`private Expression VisitNewArray(NewArrayExpression na)`
`322`	`323`	`{`
`323`	`324`	`IEnumerable<Expression> exprs = VisitExpressionList(na.Expressions);`
`324`		`- if (exprs!=na.Expressions) {`
`325`		`- if (na.NodeType==ExpressionType.NewArrayInit)`
	`325`	`+ if (exprs != na.Expressions) {`
	`326`	`+ if (na.NodeType == ExpressionType.NewArrayInit)`
`326`	`327`	`return Expression.NewArrayInit(na.Type.GetElementType(), exprs);`
`327`	`328`	`return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);`
`328`	`329`	`}`
`@@ -337,15 +338,15 @@ private Expression VisitParameter(ParameterExpression p)`
`337`	`338`	`private Expression VisitTypeIs(TypeBinaryExpression b)`
`338`	`339`	`{`
`339`	`340`	`Expression expr = Visit(b.Expression);`
`340`		`- if (expr!=b.Expression)`
	`341`	`+ if (expr != b.Expression)`
`341`	`342`	`return Expression.TypeIs(expr, b.TypeOperand);`
`342`	`343`	`return b;`
`343`	`344`	`}`
`344`	`345`
`345`	`346`	`private Expression VisitUnary(UnaryExpression u)`
`346`	`347`	`{`
`347`	`348`	`Expression operand = Visit(u.Operand);`
`348`		`- if (operand!=u.Operand)`
	`349`	`+ if (operand != u.Operand)`
`349`	`350`	`return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);`
`350`	`351`	`return u;`
`351`	`352`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,14 +61,16 @@ private static object AdjustValue(string fieldName, Type fieldType, object value`
`61`	`61`	`#if NET6_0_OR_GREATER`
`62`	`62`
`63`	`63`	`if (valueType == WellKnownTypes.TimeOnly) {`
`64`		`- if (value is string timeOnlyString && !TimeOnly.TryParse(timeOnlyString, out var timeOnly)) {`
	`64`	`+ TimeOnly timeOnly = default;`
	`65`	`+ if (value is string timeOnlyString && !TimeOnly.TryParse(timeOnlyString, out timeOnly)) {`
`65`	`66`	`throw FailToParseValue(fieldName, timeOnlyString);`
`66`	`67`	`}`
`67`	`68`	`return timeOnly;`
`68`	`69`	`}`
`69`	`70`
`70`	`71`	`if (valueType == WellKnownTypes.DateOnly) {`
`71`		`- if (value is string dateOnlyString && !DateOnly.TryParse(dateOnlyString, out var dateOnly)) {`
	`72`	`+ DateOnly dateOnly = default;`
	`73`	`+ if (value is string dateOnlyString && !DateOnly.TryParse(dateOnlyString, out dateOnly)) {`
`72`	`74`	`throw FailToParseValue(fieldName, dateOnlyString);`
`73`	`75`	`}`
`74`	`76`	`return dateOnly;`
Original file line number	Diff line number	Diff line change
`@@ -134,8 +134,9 @@ public static bool IsEntitySetExpression(this Expression expression)`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`public static bool IsEntitySet(this Expression expression) =>`
`137`		`- expression.Type.IsGenericType`
`138`		`- && expression.Type.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT;`
	`137`	`+ expression.Type switch {`
	`138`	`+ var type => type.IsGenericType && type.GetGenericTypeDefinition() == WellKnownOrmTypes.EntitySetOfT`
	`139`	`+ };`
`139`	`140`
`140`	`141`	`public static Expression StripMarkers(this Expression e)`
`141`	`142`	`{`