Removing local variable use where possible

Author: SteveWilkes

AgileMapper/Extensions/EnumerableExtensions.cs

@@ -3,9 +3,18 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Linq.Expressions;
 
     internal static class EnumerableExtensions
     {
+        public static void AddUnlessNullOrEmpty(this ICollection<Expression> items, Expression item)
+        {
+            if ((item != null) && (item != Constants.EmptyExpression))
+            {
+                items.Add(item);
+            }
+        }
+
         public static bool Any<T>(this ICollection<T> items) => items.Count > 0;
 
         public static bool None<T>(this ICollection<T> items) => items.Count == 0;

AgileMapper/ObjectPopulation/ComplexTypeMappingExpressionFactory.cs

@@ -74,13 +74,13 @@ protected override Expression GetTypeTests(IObjectMappingData mappingData)
         protected override IEnumerable<Expression> GetObjectPopulation(IObjectMappingData mappingData)
         {
             var mapperData = mappingData.MapperData;
-            var preCreationCallback = GetCreationCallbackOrEmpty(CallbackPosition.Before, mapperData);
-            var postCreationCallback = GetCreationCallbackOrEmpty(CallbackPosition.After, mapperData);
+            var preCreationCallback = GetCreationCallbackOrNull(CallbackPosition.Before, mapperData);
+            var postCreationCallback = GetCreationCallbackOrNull(CallbackPosition.After, mapperData);
             var populationsAndCallbacks = GetPopulationsAndCallbacks(mappingData).ToArray();
 
             yield return preCreationCallback;
 
-            var instanceVariableValue = GetObjectResolution(mappingData, postCreationCallback != Constants.EmptyExpression);
+            var instanceVariableValue = GetObjectResolution(mappingData, postCreationCallback != null);
             var instanceVariableAssignment = Expression.Assign(mapperData.InstanceVariable, instanceVariableValue);
             yield return instanceVariableAssignment;
 
@@ -98,8 +98,8 @@ protected override IEnumerable<Expression> GetObjectPopulation(IObjectMappingDat
             }
         }
 
-        private static Expression GetCreationCallbackOrEmpty(CallbackPosition callbackPosition, IMemberMapperData mapperData)
-            => GetCallbackOrEmpty(c => c.GetCreationCallbackOrNull(callbackPosition, mapperData), mapperData);
+        private static Expression GetCreationCallbackOrNull(CallbackPosition callbackPosition, IMemberMapperData mapperData)
+            => mapperData.MapperContext.UserConfigurations.GetCreationCallbackOrNull(callbackPosition, mapperData);
 
         private Expression GetObjectResolution(IObjectMappingData mappingData, bool postCreationCallbackExists)
         {
@@ -202,9 +202,7 @@ private static Expression GetPopulationCallbackOrEmpty(
             IMemberPopulation memberPopulation,
             IObjectMappingData mappingData)
         {
-            return GetCallbackOrEmpty(
-                c => c.GetCallbackOrNull(position, memberPopulation.MapperData, mappingData.MapperData),
-                mappingData.MapperData);
+            return GetMappingCallbackOrNull(position, memberPopulation.MapperData, mappingData.MapperData);
         }
 
         private static void CreateSourceMemberTypeTesterIfRequired(

AgileMapper/ObjectPopulation/MappingExpressionFactoryBase.cs

@@ -2,11 +2,12 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq;
     using System.Linq.Expressions;
+    using Extensions;
 #if NET_STANDARD
     using System.Reflection;
 #endif
-    using Configuration;
     using Members;
     using NetStandardPolyfills;
     using ReadableExpressions;
@@ -32,13 +33,12 @@ public Expression Create(IObjectMappingData mappingData)
             var basicMapperData = mapperData.WithNoTargetMember();
 
             mappingExpressions.AddRange(GetShortCircuitReturns(returnNull, mapperData));
-            mappingExpressions.Add(GetTypeTests(mappingData));
-            mappingExpressions.Add(GetMappingCallback(CallbackPosition.Before, basicMapperData, mapperData));
-            mappingExpressions.AddRange(GetObjectPopulation(mappingData));
-            mappingExpressions.Add(GetMappingCallback(CallbackPosition.After, basicMapperData, mapperData));
-            mappingExpressions.Add(Expression.Label(mapperData.ReturnLabelTarget, GetReturnValue(mapperData)));
+            mappingExpressions.AddUnlessNullOrEmpty(GetTypeTests(mappingData));
+            mappingExpressions.AddUnlessNullOrEmpty(GetMappingCallbackOrNull(CallbackPosition.Before, basicMapperData, mapperData));
+            mappingExpressions.AddRange(GetObjectPopulation(mappingData).WhereNotNull());
+            mappingExpressions.AddUnlessNullOrEmpty(GetMappingCallbackOrNull(CallbackPosition.After, basicMapperData, mapperData));
 
-            var mappingBlock = Expression.Block(new[] { mapperData.InstanceVariable }, mappingExpressions);
+            var mappingBlock = GetMappingBlock(mappingExpressions.WhereNotNull().ToList(), mapperData);
             var mappingBlockWithTryCatch = WrapInTryCatch(mappingBlock, mapperData);
 
             return mappingBlockWithTryCatch;
@@ -56,21 +56,50 @@ protected abstract IEnumerable<Expression> GetShortCircuitReturns(
 
         protected abstract Expression GetTypeTests(IObjectMappingData mappingData);
 
-        private static Expression GetMappingCallback(
+        protected static Expression GetMappingCallbackOrNull(
             CallbackPosition callbackPosition,
             IBasicMapperData basicData,
             IMemberMapperData mapperData)
         {
-            return GetCallbackOrEmpty(c => c.GetCallbackOrNull(callbackPosition, basicData, mapperData), mapperData);
+            return mapperData.MapperContext.UserConfigurations.GetCallbackOrNull(callbackPosition, basicData, mapperData);
         }
 
-        protected static Expression GetCallbackOrEmpty(
-            Func<UserConfigurationSet, Expression> callbackFactory,
-            IMemberMapperData mapperData)
-            => callbackFactory.Invoke(mapperData.MapperContext.UserConfigurations) ?? Constants.EmptyExpression;
-
         protected abstract IEnumerable<Expression> GetObjectPopulation(IObjectMappingData mappingData);
 
+        private Expression GetMappingBlock(IList<Expression> mappingExpressions, ObjectMapperData mapperData)
+        {
+            if (mappingExpressions[0].NodeType != ExpressionType.Block)
+            {
+                var objectAssignment = mappingExpressions.First(exp => exp.NodeType == ExpressionType.Assign);
+
+                if (mappingExpressions.Last() == objectAssignment)
+                {
+                    var assignment = (BinaryExpression)objectAssignment;
+                    var assignedValue = assignment.Right;
+
+                    if (assignedValue.NodeType == ExpressionType.Invoke)
+                    {
+                        assignedValue = assignedValue.Replace(mapperData.InstanceVariable, mapperData.TargetObject);
+                    }
+
+                    if (mappingExpressions.Count == 1)
+                    {
+                        return Expression.Block(assignedValue);
+                    }
+
+                    mappingExpressions[mappingExpressions.Count - 1] = assignedValue;
+
+                    return Expression.Block(mappingExpressions);
+                }
+            }
+
+            mappingExpressions.Add(Expression.Label(mapperData.ReturnLabelTarget, GetReturnValue(mapperData)));
+
+            var mappingBlock = Expression.Block(new[] { mapperData.InstanceVariable }, mappingExpressions);
+
+            return mappingBlock;
+        }
+
         protected abstract Expression GetReturnValue(ObjectMapperData mapperData);
 
         private static Expression WrapInTryCatch(Expression mappingBlock, IMemberMapperData mapperData)