Merge pull request #180 from servicetitan/upstream/ImmutableExpression

Optimization: allocate immutable Expression objects statically;

Author: alex-kulakov

Orm/Xtensive.Orm/Linq/ConstantExtractor.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 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
@@ -21,9 +21,10 @@ namespace Xtensive.Linq
   /// </summary>
   public sealed class ConstantExtractor : ExpressionVisitor
   {
+    private static readonly ParameterExpression ConstantParameter = Expression.Parameter(WellKnownTypes.ObjectArray, "constants");
+
     private readonly Func<ConstantExpression, bool> constantFilter;
     private readonly LambdaExpression lambda;
-    private readonly ParameterExpression constantParameter;
     private List<object> constantValues;
 
     /// <summary>
@@ -48,7 +49,7 @@ public LambdaExpression Process()
       if (constantValues != null)
         throw new InvalidOperationException();
       constantValues = new List<object>();
-      var parameters = EnumerableUtils.One(constantParameter).Concat(lambda.Parameters).ToArray();
+      var parameters = EnumerableUtils.One(ConstantParameter).Concat(lambda.Parameters).ToArray();
       var body = Visit(lambda.Body);
       // Preserve original delegate type because it may differ from types of parameters / return value
       return FastExpression.Lambda(FixDelegateType(lambda.Type), body, parameters);
@@ -60,7 +61,7 @@ protected override Expression VisitConstant(ConstantExpression c)
       if (!constantFilter.Invoke(c))
         return c;
       var result = Expression.Convert(
-        Expression.ArrayIndex(constantParameter, Expression.Constant(constantValues.Count)), c.Type);
+        Expression.ArrayIndex(ConstantParameter, Expression.Constant(constantValues.Count)), c.Type);
       constantValues.Add(c.Value);
       return result;
     }
@@ -70,7 +71,7 @@ protected override Expression VisitConstant(ConstantExpression c)
     private Type FixDelegateType(Type delegateType)
     {
       var signature = DelegateHelper.GetDelegateSignature(delegateType);
-      return DelegateHelper.MakeDelegateType(signature.First, signature.Second.Prepend(constantParameter.Type));
+      return DelegateHelper.MakeDelegateType(signature.First, signature.Second.Prepend(ConstantParameter.Type));
     }
 
     private static bool DefaultConstantFilter(ConstantExpression constant)
@@ -106,7 +107,6 @@ public ConstantExtractor(LambdaExpression lambda, Func<ConstantExpression, bool>
       ArgumentValidator.EnsureArgumentNotNull(lambda, "lambda");
       this.lambda = lambda;
       this.constantFilter = constantFilter ?? DefaultConstantFilter;
-      constantParameter = Expression.Parameter(WellKnownTypes.ObjectArray, "constants");
     }
   }
 }

Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2011-2020 Xtensive LLC.
+// Copyright (C) 2011-2021 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
@@ -25,21 +25,21 @@ namespace Xtensive.Orm.Building.Builders
 {
   internal class PartialIndexFilterBuilder : ExpressionVisitor
   {
+    private static readonly ParameterExpression Parameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "tuple");
+
     private readonly TypeInfo declaringType;
     private readonly TypeInfo reflectedType;
     private readonly IndexInfo index;
-    private readonly ParameterExpression parameter;
     private readonly List<FieldInfo> usedFields = new List<FieldInfo>();
     private readonly Dictionary<Expression, FieldInfo> entityAccessMap = new Dictionary<Expression, FieldInfo>();
 
     public static void BuildFilter(IndexInfo index)
     {
       ArgumentValidator.EnsureArgumentNotNull(index, "index");
-      var parameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "tuple");
-      var builder = new PartialIndexFilterBuilder(index, parameter);
+      var builder = new PartialIndexFilterBuilder(index);
       var body = builder.Visit(index.FilterExpression.Body);
       var filter = new PartialIndexFilterInfo {
-        Expression = FastExpression.Lambda(body, parameter),
+        Expression = FastExpression.Lambda(body, Parameter),
         Fields = builder.usedFields,
       };
       index.Filter = filter;
@@ -112,7 +112,7 @@ private Expression BuildFieldAccess(FieldInfo field, bool addNullability)
       var fieldIndex = usedFields.Count;
       var valueType = addNullability ? field.ValueType.ToNullable() : field.ValueType;
       usedFields.Add(field);
-      return Expression.Call(parameter,
+      return Expression.Call(Parameter,
         WellKnownMembers.Tuple.GenericAccessor.MakeGenericMethod(valueType),
         Expression.Constant(fieldIndex));
     }
@@ -174,10 +174,9 @@ private DomainBuilderException UnableToTranslate(Expression expression)
       return UnableToTranslate(expression, string.Format(Strings.ExpressionsOfTypeXAreNotSupported, expression.NodeType));
     }
 
-    private PartialIndexFilterBuilder(IndexInfo index, ParameterExpression parameter)
+    private PartialIndexFilterBuilder(IndexInfo index)
     {
       this.index = index;
-      this.parameter = parameter;
 
       declaringType = index.DeclaringType;
       reflectedType = index.ReflectedType;

Orm/Xtensive.Orm/Orm/EntitySet{T}.cs

@@ -62,6 +62,9 @@ public class EntitySet<TItem> : EntitySetBase,
     IQueryable<TItem>
     where TItem : IEntity
   {
+    private static readonly MemberExpression OwnerPropertyExpression = Expression.Property(Expression.Constant(ownerParameter), ownerParameter.GetType()
+      .GetProperty("Value", WellKnownOrmTypes.Entity));
+
     private Expression expression;
 
     /// <summary>
@@ -230,9 +233,7 @@ protected sealed override Func<QueryEndpoint,Int64> GetItemCountQueryDelegate(Fi
 
     private static IQueryable<TItem> GetItemsQuery(QueryEndpoint qe, FieldInfo field)
     {
-      var owner = Expression.Property(Expression.Constant(ownerParameter), ownerParameter.GetType()
-        .GetProperty("Value", WellKnownOrmTypes.Entity));
-      var queryExpression = QueryHelper.CreateEntitySetQuery(owner, field);
+      var queryExpression = QueryHelper.CreateEntitySetQuery(OwnerPropertyExpression, field);
       return qe.Provider.CreateQuery<TItem>(queryExpression);
     }
 

Orm/Xtensive.Orm/Orm/Linq/Expressions/Visitors/IncludeFilterMappingGatherer.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 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 Gamzov
@@ -34,7 +34,7 @@ public MappingEntry(LambdaExpression calculatedColumn)
       }
     }
 
-    private readonly ParameterExpression calculatedColumnParameter;
+    private static readonly ParameterExpression CalculatedColumnParameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "filteredRow");
 
     private readonly Expression filterDataTuple;
     private readonly ApplyParameter filteredTuple;
@@ -85,7 +85,7 @@ protected override Expression VisitMemberAccess(MemberExpression m)
       }
 
       if (target.NodeType == ExpressionType.Constant && ((ConstantExpression) target).Value == filteredTuple) {
-        return calculatedColumnParameter;
+        return CalculatedColumnParameter;
       }
       return base.VisitMemberAccess(m);
     }
@@ -96,14 +96,12 @@ private MappingEntry CreateMappingEntry(Expression expression)
       if (tupleAccess != null) {
         return new MappingEntry(tupleAccess.GetTupleAccessArgument());
       }
-      expression = ExpressionReplacer.Replace(expression, filterDataTuple, calculatedColumnParameter);
-      return new MappingEntry(FastExpression.Lambda(expression, calculatedColumnParameter));
+      expression = ExpressionReplacer.Replace(expression, filterDataTuple, CalculatedColumnParameter);
+      return new MappingEntry(FastExpression.Lambda(expression, CalculatedColumnParameter));
     }
 
     private IncludeFilterMappingGatherer(Expression filterDataTuple, ApplyParameter filteredTuple, MappingEntry[] resultMapping)
     {
-      calculatedColumnParameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "filteredRow");
-
       this.filterDataTuple = filterDataTuple;
       this.filteredTuple = filteredTuple;
       this.resultMapping = resultMapping;

Orm/Xtensive.Orm/Orm/Linq/ItemToTupleConverter{TItem}.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 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 Gamzov
@@ -52,6 +52,9 @@ public void AddRange(IReadOnlyCollection<Type> newTypes)
       }
     }
 
+    private static readonly ParameterExpression ParamContext = Expression.Parameter(WellKnownOrmTypes.ParameterContext, "context");
+    private static readonly MethodInfo SelectMethod = WellKnownMembers.Enumerable.Select.MakeGenericMethod(typeof(TItem), WellKnownOrmTypes.Tuple);
+
     private readonly Func<ParameterContext, IEnumerable<TItem>> enumerableFunc;
     private readonly DomainModel model;
     private Func<TItem, Tuple> converter;
@@ -61,11 +64,9 @@ public void AddRange(IReadOnlyCollection<Type> newTypes)
 
     public override Expression<Func<ParameterContext, IEnumerable<Tuple>>> GetEnumerable()
     {
-      var paramContext = Expression.Parameter(WellKnownOrmTypes.ParameterContext, "context");
-      var call = Expression.Call(Expression.Constant(enumerableFunc.Target), enumerableFunc.Method, paramContext);
-      var selectMethod = WellKnownMembers.Enumerable.Select.MakeGenericMethod(typeof (TItem), WellKnownOrmTypes.Tuple);
-      var select = Expression.Call(selectMethod, call, Expression.Constant(converter));
-      return FastExpression.Lambda<Func<ParameterContext, IEnumerable<Tuple>>>(select, paramContext);
+      var call = Expression.Call(Expression.Constant(enumerableFunc.Target), enumerableFunc.Method, ParamContext);
+      var select = Expression.Call(SelectMethod, call, Expression.Constant(converter));
+      return FastExpression.Lambda<Func<ParameterContext, IEnumerable<Tuple>>>(select, ParamContext);
     }
 
 

Orm/Xtensive.Orm/Orm/Linq/Materialization/ExpressionMaterializer.cs

@@ -33,9 +33,11 @@ internal class ExpressionMaterializer : PersistentExpressionVisitor
     private static readonly MethodInfo GetParameterValueMethod;
     private static readonly PropertyInfo ParameterContextProperty;
     private static readonly MethodInfo GetTupleParameterValueMethod;
+    private static readonly ParameterExpression TupleParameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "tuple");
+    private static readonly ParameterExpression MaterializationContextParameter = Expression.Parameter(WellKnownOrmTypes.ItemMaterializationContext, "mc");
+    private static readonly ConstantExpression TypeReferenceAccuracyConstantExpression = Expression.Constant(TypeReferenceAccuracy.BaseType);
 
     private readonly TranslatorContext context;
-    private readonly ParameterExpression tupleParameter;
     private readonly ParameterExpression itemMaterializationContextParameter;
     private readonly Dictionary<IEntityExpression, int> entityRegistry = new Dictionary<IEntityExpression, int>();
     private readonly HashSet<Parameter<Tuple>> tupleParameters;
@@ -52,19 +54,16 @@ internal class ExpressionMaterializer : PersistentExpressionVisitor
 
     public static LambdaExpression MakeLambda(Expression expression, TranslatorContext context)
     {
-      var tupleParameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "tuple");
-      var visitor = new ExpressionMaterializer(tupleParameter, context, null, EnumerableUtils<Parameter<Tuple>>.Empty);
+      var visitor = new ExpressionMaterializer(context, null, Enumerable.Empty<Parameter<Tuple>>());
       var processedExpression = OwnerRemover.RemoveOwner(expression);
-      return FastExpression.Lambda(visitor.Visit(processedExpression), tupleParameter);
+      return FastExpression.Lambda(visitor.Visit(processedExpression), TupleParameter);
     }
 
-    public static MaterializationInfo MakeMaterialization(ItemProjectorExpression projector, TranslatorContext context, 
+    public static MaterializationInfo MakeMaterialization(ItemProjectorExpression projector, TranslatorContext context,
       IEnumerable<Parameter<Tuple>> tupleParameters)
     {
-      var tupleParameter = Expression.Parameter(WellKnownOrmTypes.Tuple, "tuple");
-      var materializationContextParameter = Expression.Parameter(WellKnownOrmTypes.ItemMaterializationContext, "mc");
-      var visitor = new ExpressionMaterializer(tupleParameter, context, materializationContextParameter, tupleParameters);
-      var lambda = FastExpression.Lambda(visitor.Visit(projector.Item), tupleParameter, materializationContextParameter);
+      var visitor = new ExpressionMaterializer(context, MaterializationContextParameter, tupleParameters);
+      var lambda = FastExpression.Lambda(visitor.Visit(projector.Item), TupleParameter, MaterializationContextParameter);
       var count = visitor.entityRegistry.Count;
       return new MaterializationInfo(count, lambda);
     }
@@ -96,7 +95,7 @@ protected override Expression VisitMarker(MarkerExpression expression)
         if (itemMaterializationContextParameter == null)
           return processedTarget;
         var columns = ColumnGatherer.GetColumns(target, ColumnExtractionModes.Distinct | ColumnExtractionModes.Ordered).ToArray();
-        var sequenceCheck = Expression.Call(MaterializationHelper.IsNullMethodInfo, tupleParameter, Expression.Constant(columns));
+        var sequenceCheck = Expression.Call(MaterializationHelper.IsNullMethodInfo, TupleParameter, Expression.Constant(columns));
         var throwException = Expression.Convert(Expression.Call(MaterializationHelper.ThrowEmptySequenceExceptionMethodInfo), target.Type);
         return Expression.Condition(sequenceCheck, throwException, processedTarget);
       }
@@ -129,7 +128,7 @@ protected override Expression VisitGroupingExpression(GroupingExpression groupin
         Expression.Constant(projection),
         Expression.Constant(translatedQuery),
         Expression.Constant(parameterOfTuple),
-        tupleParameter,
+        TupleParameter,
         keyMaterializer,
         itemMaterializationContextParameter);
 
@@ -154,7 +153,7 @@ protected override Expression VisitSubQueryExpression(SubQueryExpression subQuer
         Expression.Constant(projection),
         Expression.Constant(translatedQuery),
         Expression.Constant(parameterOfTuple),
-        tupleParameter,
+        TupleParameter,
         itemMaterializationContextParameter);
 
       return Expression.Convert(resultExpression, subQueryExpression.Type);
@@ -184,15 +183,15 @@ private TranslatedQuery PrepareSubqueryParameters(SubQueryExpression subQueryExp
       var itemProjector = new ItemProjectorExpression(newItemProjectorBody, newDataSource, subQueryExpression.ProjectionExpression.ItemProjector.Context);
       parameterOfTuple = context.GetTupleParameter(subQueryExpression.OuterParameter);
 
-      // 2. Add only parameter<tuple>. Tuple value will be assigned 
+      // 2. Add only parameter<tuple>. Tuple value will be assigned
       // at the moment of materialization in SubQuery constructor
       projection = new ProjectionExpression(
         subQueryExpression.ProjectionExpression.Type,
         itemProjector,
         subQueryExpression.ProjectionExpression.TupleParameterBindings,
         subQueryExpression.ProjectionExpression.ResultAccessMethod);
 
-      // 3. Make translation 
+      // 3. Make translation
       elementType = subQueryExpression.ProjectionExpression.ItemProjector.Item.Type;
       var translateMethod = Translator.TranslateMethod;
       return (TranslatedQuery) translateMethod.Invoke(
@@ -278,8 +277,8 @@ protected override Expression VisitConstructorExpression(ConstructorExpression e
 
       var realBindings = expression.NativeBindings;
 
-      return expression.NativeBindings.Count == 0 
-        ? newExpression 
+      return expression.NativeBindings.Count == 0
+        ? newExpression
         : (Expression) Expression.MemberInit(newExpression, expression
           .NativeBindings
           .Where(item => Translator.FilterBindings(item.Key, item.Key.Name, item.Value.Type))
@@ -330,7 +329,7 @@ protected override Expression VisitKeyExpression(KeyExpression expression)
           Expression.Field(itemMaterializationContextParameter, ItemMaterializationContext.SessionFieldInfo),
           WellKnownMembers.SessionNodeId),
         Expression.Constant(expression.EntityType),
-        Expression.Constant(TypeReferenceAccuracy.BaseType),
+        TypeReferenceAccuracyConstantExpression,
         tupleExpression);
     }
 
@@ -507,7 +506,7 @@ private Expression MaterializeThroughOwner(Expression target, Expression tuple,
     private Expression GetTupleExpression(ParameterizedExpression expression)
     {
       if (expression.OuterParameter == null)
-        return tupleParameter;
+        return TupleParameter;
 
       var parameterOfTuple = context.GetTupleParameter(expression.OuterParameter);
       if (tupleParameters.Contains(parameterOfTuple)) {
@@ -525,7 +524,7 @@ private Expression GetTupleExpression(ParameterizedExpression expression)
         return Expression.Property(applyParameterExpression, WellKnownMembers.ApplyParameterValue);
       }
 
-      return tupleParameter;
+      return TupleParameter;
     }
 
     private static Tuple BuildPersistentTuple(Tuple tuple, Tuple tuplePrototype, int[] mapping)
@@ -541,14 +540,12 @@ private static Tuple BuildPersistentTuple(Tuple tuple, Tuple tuplePrototype, int
 
     // Constructors
 
-    private ExpressionMaterializer(ParameterExpression
-      tupleParameter,
+    private ExpressionMaterializer(
       TranslatorContext context,
       ParameterExpression itemMaterializationContextParameter,
       IEnumerable<Parameter<Tuple>> tupleParameters)
     {
       this.itemMaterializationContextParameter = itemMaterializationContextParameter;
-      this.tupleParameter = tupleParameter;
       this.context = context;
       this.tupleParameters = new HashSet<Parameter<Tuple>>(tupleParameters);
     }

Orm/Xtensive.Orm/Orm/Linq/ParameterAccessorFactory.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Xtensive LLC.
+// Copyright (C) 2020-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -18,6 +18,8 @@ internal static class ParameterAccessorFactory
     private static readonly MethodInfo GetParameterValueMethod =
       WellKnownOrmTypes.ParameterContext.GetMethod(nameof(ParameterContext.GetValue));
 
+    private static readonly ParameterExpression ParameterContextArgument = Expression.Parameter(WellKnownOrmTypes.ParameterContext, "context");
+
     private class ParameterAccessorFactoryImpl<T>: ExpressionVisitor
     {
       private readonly ParameterExpression parameterContextArgument;
@@ -55,8 +57,7 @@ public ParameterAccessorFactoryImpl(ParameterExpression parameterContextArgument
 
     public static Expression<Func<ParameterContext, T>> CreateAccessorExpression<T>(Expression parameterExpression)
     {
-      var parameterContextArgument = Expression.Parameter(WellKnownOrmTypes.ParameterContext, "context");
-      return new ParameterAccessorFactoryImpl<T>(parameterContextArgument).BindToParameterContext(parameterExpression);
+      return new ParameterAccessorFactoryImpl<T>(ParameterContextArgument).BindToParameterContext(parameterExpression);
     }
   }
 }