Code improvements

- nameofs instead of strings + no Resharper.UnusedMember
- update formatting
- get certain error messages when they needed

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Linq/Materialization/ExpressionMaterializer.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
@@ -90,8 +90,8 @@ protected override Expression VisitMarker(MarkerExpression expression)
     {
       var target = expression.Target;
       var processedTarget = Visit(target);
-      if (expression.MarkerType!=MarkerType.None && (expression.MarkerType & MarkerType.Default)==MarkerType.None) {
-        if (itemMaterializationContextParameter==null)
+      if (expression.MarkerType != MarkerType.None && (expression.MarkerType & MarkerType.Default) == MarkerType.None) {
+        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));
@@ -104,10 +104,8 @@ protected override Expression VisitMarker(MarkerExpression expression)
     protected override Expression VisitGroupingExpression(GroupingExpression groupingExpression)
     {
       // 1. Prepare subquery parameters.
-      Parameter<Tuple> parameterOfTuple;
-      Type elementType;
-      ProjectionExpression projection;
-      var translatedQuery = PrepareSubqueryParameters(groupingExpression, out parameterOfTuple, out elementType, out projection);
+      var translatedQuery = PrepareSubqueryParameters(groupingExpression,
+        out var parameterOfTuple, out var elementType, out var projection);
 
       // 2. Create constructor
       var keyType = groupingExpression.KeyExpression.Type;
@@ -198,7 +196,7 @@ protected override Expression VisitFieldExpression(FieldExpression expression)
       var tupleExpression = GetTupleExpression(expression);
 
       // Materialize non-owned field.
-      if (expression.Owner==null || expression.UnderlyingProperty == null) {
+      if (expression.Owner == null || expression.UnderlyingProperty == null) {
         if (expression.Field.IsEnum) {
           var underlyingType = Enum.GetUnderlyingType(expression.Type.StripNullable());
           if (expression.Field.IsNullable)
@@ -224,28 +222,27 @@ protected override Expression VisitFieldExpression(FieldExpression expression)
       return MaterializeThroughOwner(expression, tupleExpression);
     }
 
-    protected override Expression VisitLocalCollectionExpression(LocalCollectionExpression expression)
-    {
-      throw new NotSupportedException(String.Format(Strings.ExUnableToMaterializeBackLocalCollectionItem, expression.SourceExpression));
-    }
+    protected override Expression VisitLocalCollectionExpression(LocalCollectionExpression expression) =>
+      throw new NotSupportedException(
+        string.Format(Strings.ExUnableToMaterializeBackLocalCollectionItem, expression.SourceExpression));
 
     protected override Expression VisitStructureFieldExpression(StructureFieldExpression expression)
     {
       var tupleExpression = GetTupleExpression(expression);
 
       // Materialize non-owned structure.
-      if (expression.Owner==null) {
+      if (expression.Owner == null) {
         var typeInfo = expression.PersistentType;
         var tuplePrototype = typeInfo.TuplePrototype;
         var mappingInfo = expression.Fields
           .OfType<FieldExpression>()
-          .Where(f => f.ExtendedType==ExtendedExpressionType.Field)
+          .Where(f => f.ExtendedType == ExtendedExpressionType.Field)
           .OrderBy(f => f.Field.MappingInfo.Offset)
           .Select(f => new Pair<int>(f.Field.MappingInfo.Offset, f.Mapping.Offset))
           .Distinct()
           .ToArray();
 
-        int[] columnMap = MaterializationHelper.CreateSingleSourceMap(tuplePrototype.Count, mappingInfo);
+        var columnMap = MaterializationHelper.CreateSingleSourceMap(tuplePrototype.Count, mappingInfo);
 
         var persistentTupleExpression = (Expression) Expression.Call(
           BuildPersistentTupleMethod,
@@ -266,7 +263,7 @@ protected override Expression VisitStructureFieldExpression(StructureFieldExpres
 
     protected override Expression VisitConstructorExpression(ConstructorExpression expression)
     {
-      var newExpression = expression.Constructor==null
+      var newExpression = expression.Constructor == null
         ? Expression.New(expression.Type) // Value type with default ctor (expression.Constructor is null in that case)
         : Expression.New(expression.Constructor, expression.ConstructorArguments.Select(Visit));
 
@@ -275,9 +272,9 @@ protected override Expression VisitConstructorExpression(ConstructorExpression e
       return expression.NativeBindings.Count == 0 
         ? newExpression 
         : (Expression) Expression.MemberInit(newExpression, expression
-        .NativeBindings
-        .Where(item => Translator.FilterBindings(item.Key, item.Key.Name, item.Value.Type))
-        .Select(item => Expression.Bind(item.Key, Visit(item.Value))).Cast<MemberBinding>());
+          .NativeBindings
+          .Where(item => Translator.FilterBindings(item.Key, item.Key.Name, item.Value.Type))
+          .Select(item => Expression.Bind(item.Key, Visit(item.Value))).Cast<MemberBinding>());
     }
 
     protected override Expression VisitStructureExpression(StructureExpression expression)
@@ -288,13 +285,13 @@ protected override Expression VisitStructureExpression(StructureExpression expre
       var tuplePrototype = typeInfo.TuplePrototype;
       var mappingInfo = expression.Fields
         .OfType<FieldExpression>()
-        .Where(f => f.ExtendedType==ExtendedExpressionType.Field)
+        .Where(f => f.ExtendedType == ExtendedExpressionType.Field)
         .OrderBy(f => f.Field.MappingInfo.Offset)
         .Select(f => new Pair<int>(f.Field.MappingInfo.Offset, f.Mapping.Offset))
         .Distinct()
         .ToArray();
 
-      int[] columnMap = MaterializationHelper.CreateSingleSourceMap(tuplePrototype.Count, mappingInfo);
+      var columnMap = MaterializationHelper.CreateSingleSourceMap(tuplePrototype.Count, mappingInfo);
 
       var persistentTupleExpression = (Expression) Expression.Call(
         BuildPersistentTupleMethod,
@@ -337,21 +334,23 @@ protected override Expression VisitEntityExpression(EntityExpression expression)
     /// <exception cref="InvalidOperationException">Unable to materialize Entity.</exception>
     private Expression CreateEntity(IEntityExpression expression, Expression tupleExpression)
     {
-      int index;
-      if (!entityRegistry.TryGetValue(expression, out index)) {
+      if (!entityRegistry.TryGetValue(expression, out var index)) {
         index = entityRegistry.Count;
         entityRegistry.Add(expression, index);
       }
 
-      if (itemMaterializationContextParameter==null)
-        throw new InvalidOperationException(String.Format(Strings.ExUnableToTranslateLambdaExpressionXBecauseItRequiresToMaterializeEntityOfTypeX, context.Translator.state.CurrentLambda, expression.PersistentType.UnderlyingType.FullName));
+      if (itemMaterializationContextParameter == null)
+        throw new InvalidOperationException(
+          string.Format(Strings.ExUnableToTranslateLambdaExpressionXBecauseItRequiresToMaterializeEntityOfTypeX,
+            context.Translator.state.CurrentLambda,
+            expression.PersistentType.UnderlyingType.FullName));
 
-      var typeIdField = expression.Fields.SingleOrDefault(f => f.Name==WellKnown.TypeIdFieldName);
-      int typeIdIndex = typeIdField==null ? -1 : typeIdField.Mapping.Offset;
+      var typeIdField = expression.Fields.SingleOrDefault(f => f.Name == WellKnown.TypeIdFieldName);
+      var typeIdIndex = typeIdField == null ? -1 : typeIdField.Mapping.Offset;
 
       var mappingInfo = expression.Fields
         .OfType<FieldExpression>()
-        .Where(f => f.ExtendedType==ExtendedExpressionType.Field)
+        .Where(f => f.ExtendedType == ExtendedExpressionType.Field)
         .OrderBy(f => f.Field.MappingInfo.Offset)
         .Select(f => new Pair<int>(f.Field.MappingInfo.Offset, f.Mapping.Offset))
         .Distinct()
@@ -384,13 +383,13 @@ private Expression CreateEntity(IEntityExpression expression, Expression tupleEx
     /// <exception cref="InvalidOperationException"><c>InvalidOperationException</c>.</exception>
     protected override Expression VisitEntityFieldExpression(EntityFieldExpression expression)
     {
-      if (expression.Entity!=null)
+      if (expression.Entity != null)
         return Visit(expression.Entity);
 
       var tupleExpression = GetTupleExpression(expression);
-      if (itemMaterializationContextParameter==null)
-        return tupleExpression.MakeTupleAccess(expression.Type, expression.Mapping.Offset);
-      return CreateEntity(expression, tupleExpression);
+      return itemMaterializationContextParameter == null
+        ? tupleExpression.MakeTupleAccess(expression.Type, expression.Mapping.Offset)
+        : CreateEntity(expression, tupleExpression);
     }
 
     protected override Expression VisitEntitySetExpression(EntitySetExpression expression)
@@ -432,21 +431,18 @@ protected override Expression VisitUnary(UnaryExpression u)
           var index = tupleAccess.GetTupleAccessArgument();
           return tupleAccess.Object.MakeTupleAccess(u.Type, index);
         }
-        if (operand != u.Operand) {
-          return Expression.Convert(operand, u.Type);
-        }
-        return u;
+        return operand != u.Operand ? Expression.Convert(operand, u.Type) : u;
       }
       return base.VisitUnary(u);
     }
 
     protected override Expression VisitMemberAccess(MemberExpression m)
     {
-      if (m.Expression!=null) {
-        if ((ExtendedExpressionType) m.Expression.NodeType==ExtendedExpressionType.LocalCollection) {
+      if (m.Expression != null) {
+        if ((ExtendedExpressionType) m.Expression.NodeType == ExtendedExpressionType.LocalCollection) {
           return Visit((Expression) ((LocalCollectionExpression) m.Expression).Fields[m.Member]);
         }
-        if (itemMaterializationContextParameter!=null
+        if (itemMaterializationContextParameter != null
           && string.Equals(nameof(Parameter<object>.Value), m.Member.Name, StringComparison.Ordinal)
           && WellKnownOrmTypes.Parameter.IsAssignableFrom(m.Expression.Type)) {
           var parameterType = m.Expression.Type;
@@ -460,7 +456,7 @@ protected override Expression VisitMemberAccess(MemberExpression m)
       }
 
       var expression = Visit(m.Expression);
-      if (expression==m.Expression) {
+      if (expression == m.Expression) {
         return m;
       }
 
@@ -471,15 +467,12 @@ protected override Expression VisitMemberAccess(MemberExpression m)
 
     #region Private Methods
 
-    private Expression MaterializeThroughOwner(Expression target, Expression tuple)
-    {
-      return MaterializeThroughOwner(target, tuple, false);
-    }
+    private Expression MaterializeThroughOwner(Expression target, Expression tuple) =>
+      MaterializeThroughOwner(target, tuple, false);
 
     private Expression MaterializeThroughOwner(Expression target, Expression tuple, bool defaultIfEmpty)
     {
-      var field = target as FieldExpression;
-      if (field!=null) {
+      if (target is FieldExpression field) {
         defaultIfEmpty |= field.DefaultIfEmpty;
         var owner = field.Owner;
         var materializedOwner = MaterializeThroughOwner((Expression) owner, tuple, defaultIfEmpty);
@@ -492,20 +485,19 @@ private Expression MaterializeThroughOwner(Expression target, Expression tuple,
         }
         else
           fieldExpression = Expression.MakeMemberAccess(materializedOwner, field.Field.UnderlyingProperty);
-        if (defaultIfEmpty) {
-          return Expression.Condition(
-            Expression.Equal(materializedOwner, Expression.Constant(null, materializedOwner.Type)),
-            Expression.Call(MaterializationHelper.GetDefaultMethodInfo.MakeGenericMethod(field.Type)),
-            fieldExpression);
-        }
-        return fieldExpression;
+        return defaultIfEmpty
+          ? Expression.Condition(
+              Expression.Equal(materializedOwner, Expression.Constant(null, materializedOwner.Type)),
+              Expression.Call(MaterializationHelper.GetDefaultMethodInfo.MakeGenericMethod(field.Type)),
+              fieldExpression)
+          : fieldExpression;
       }
       return CreateEntity((EntityExpression) target, tuple);
     }
 
     private Expression GetTupleExpression(ParameterizedExpression expression)
     {
-      if (expression.OuterParameter==null)
+      if (expression.OuterParameter == null)
         return tupleParameter;
 
       var parameterOfTuple = context.GetTupleParameter(expression.OuterParameter);
@@ -517,7 +509,7 @@ private Expression GetTupleExpression(ParameterizedExpression expression)
       }
 
       // Use ApplyParameter for RecordSet predicates
-      if (itemMaterializationContextParameter==null) {
+      if (itemMaterializationContextParameter == null) {
         var projectionExpression = context.Bindings[expression.OuterParameter];
         var applyParameter = context.GetApplyParameter(projectionExpression);
         var applyParameterExpression = Expression.Constant(applyParameter);
@@ -527,21 +519,14 @@ private Expression GetTupleExpression(ParameterizedExpression expression)
       return tupleParameter;
     }
 
-    // ReSharper disable UnusedMember.Local
-
     private static Tuple BuildPersistentTuple(Tuple tuple, Tuple tuplePrototype, int[] mapping)
     {
       var result = tuplePrototype.CreateNew();
       tuple.CopyTo(result, mapping);
       return result;
     }
 
-    private static Tuple GetTupleSegment(Tuple tuple, in Segment<int> segment)
-    {
-      return tuple.GetSegment(segment).ToRegular();
-    }
-
-    // ReSharper restore UnusedMember.Local
+    private static Tuple GetTupleSegment(Tuple tuple, in Segment<int> segment) => tuple.GetSegment(segment).ToRegular();
 
     #endregion
 
@@ -561,12 +546,14 @@ private ExpressionMaterializer(ParameterExpression
 
     static ExpressionMaterializer()
     {
+      var thisType = typeof(ExpressionMaterializer);
+
       ParameterContextProperty =
         WellKnownOrmTypes.ItemMaterializationContext.GetProperty(nameof(ItemMaterializationContext.ParameterContext));
       GetParameterValueMethod = WellKnownOrmTypes.ParameterContext.GetMethod(nameof(ParameterContext.GetValue));
       GetTupleParameterValueMethod = GetParameterValueMethod.MakeGenericMethod(WellKnownOrmTypes.Tuple);
-      BuildPersistentTupleMethod = typeof (ExpressionMaterializer).GetMethod("BuildPersistentTuple", BindingFlags.NonPublic | BindingFlags.Static);
-      GetTupleSegmentMethod = typeof (ExpressionMaterializer).GetMethod("GetTupleSegment", BindingFlags.NonPublic | BindingFlags.Static);
+      BuildPersistentTupleMethod = thisType.GetMethod(nameof(BuildPersistentTuple), BindingFlags.NonPublic | BindingFlags.Static);
+      GetTupleSegmentMethod = thisType.GetMethod(nameof(GetTupleSegment), BindingFlags.NonPublic | BindingFlags.Static);
     }
   }
 }

Orm/Xtensive.Orm/Orm/Linq/Materialization/ItemMaterializationContext.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.
 
@@ -14,43 +14,34 @@ namespace Xtensive.Orm.Linq.Materialization
 {
   internal sealed class ItemMaterializationContext
   {
-    public ParameterContext ParameterContext { get; }
-    public static MethodInfo IsMaterializedMethodInfo { get; private set; }
-    public static MethodInfo GetEntityMethodInfo      { get; private set; }
-    public static MethodInfo MaterializeMethodInfo    { get; private set; }
-
-    public static System.Reflection.FieldInfo SessionFieldInfo { get; private set; }
+    public static readonly MethodInfo IsMaterializedMethodInfo;
+    public static readonly MethodInfo GetEntityMethodInfo;
+    public static readonly MethodInfo MaterializeMethodInfo;
+    public static readonly System.Reflection.FieldInfo SessionFieldInfo;
 
     public readonly Session Session;
     public readonly MaterializationContext MaterializationContext;
 
     private readonly TypeIdRegistry typeIdRegistry;
     private readonly Entity[] entities;
 
-    // ReSharper disable UnusedMember.Global
+    public ParameterContext ParameterContext { get; }
 
-    public bool IsMaterialized(int index)
-    {
-      return entities[index]!=null;
-    }
+    public bool IsMaterialized(int index) => entities[index] != null;
 
-    public Entity GetEntity(int index)
-    {
-      return entities[index];
-    }
+    public Entity GetEntity(int index) => entities[index];
 
     public Entity Materialize(int entityIndex, int typeIdIndex, TypeInfo type, Pair<int>[] entityColumns, Tuple tuple)
     {
       var result = entities[entityIndex];
-      if (result!=null)
+      if (result != null)
         return result;
 
-      TypeReferenceAccuracy accuracy;
-      int typeId = EntityDataReader.ExtractTypeId(type, typeIdRegistry, tuple, typeIdIndex, out accuracy);
-      if (typeId==TypeInfo.NoTypeId)
+      var typeId = EntityDataReader.ExtractTypeId(type, typeIdRegistry, tuple, typeIdIndex, out var accuracy);
+      if (typeId == TypeInfo.NoTypeId)
         return null;
 
-      bool canCache = accuracy==TypeReferenceAccuracy.ExactType;
+      var canCache = accuracy==TypeReferenceAccuracy.ExactType;
       var materializationInfo = MaterializationContext.GetTypeMapping(entityIndex, type, typeId, entityColumns);
       Key key;
       var keyIndexes = materializationInfo.KeyIndexes;
@@ -62,7 +53,7 @@ public Entity Materialize(int entityIndex, int typeIdIndex, TypeInfo type, Pair<
         var keyTuple = materializationInfo.KeyTransform.Apply(TupleTransformType.TransformedTuple, tuple);
         key = KeyFactory.Materialize(Session.Domain, Session.StorageNodeId, materializationInfo.Type, keyTuple, accuracy, canCache, null);
       }
-      if (accuracy==TypeReferenceAccuracy.ExactType) {
+      if (accuracy == TypeReferenceAccuracy.ExactType) {
         var entityTuple = materializationInfo.Transform.Apply(TupleTransformType.Tuple, tuple);
         var entityState = Session.Handler.UpdateState(key, entityTuple);
         result = entityState.Entity;
@@ -74,8 +65,6 @@ public Entity Materialize(int entityIndex, int typeIdIndex, TypeInfo type, Pair<
       return result;
     }
 
-    // ReSharper restore UnusedMember.Global
-
 
     // Constructors