Improving translation of method calls with a single, multi-line code block parameter

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenFormattingCode.cs

@@ -637,6 +637,55 @@ public void ShouldLeaveABlankLineAfterAMultipleLineExpression()
 
             Assert.AreEqual(EXPECTED.TrimStart(), translated);
         }
+
+        [TestMethod]
+        public void ShouldTranslateMultilineBlockSingleMethodArguments()
+        {
+            var intVariable = Expression.Variable(typeof(int), "i");
+            var variableInit = Expression.Assign(intVariable, Expression.Constant(3));
+            var variableMultiplyFive = Expression.Multiply(intVariable, Expression.Constant(5));
+            var variableAdditionOne = Expression.Assign(intVariable, variableMultiplyFive);
+            var variableDivideThree = Expression.Divide(intVariable, Expression.Constant(3));
+            var variableAdditionTwo = Expression.Assign(intVariable, variableDivideThree);
+
+            var argumentBlock = Expression.Block(
+                new[] { intVariable },
+                variableInit,
+                variableAdditionOne,
+                variableAdditionTwo,
+                intVariable);
+
+            var catchBlock = Expression.Catch(
+                typeof(Exception),
+                Expression.Block(ReadableExpression.Comment("So what!"), Expression.Constant(0)));
+
+            var tryCatch = Expression.TryCatch(argumentBlock, catchBlock);
+
+            var collectionVariable = Expression.Variable(typeof(ICollection<int>), "ints");
+            var addMethod = collectionVariable.Type.GetMethod("Add");
+            var addMethodCall = Expression.Call(collectionVariable, addMethod, tryCatch);
+
+            const string EXPECTED = @"
+ints.Add(
+{
+    try
+    {
+        var i = 3;
+        i = i * 5;
+        i = i / 3;
+        return i;
+    }
+    catch
+    {
+        // So what!
+        return 0;
+    }
+})";
+
+            var translated = addMethodCall.ToReadableString();
+
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
     }
 
     #region Helper Classes

ReadableExpressions/Translators/Formatting/ParameterSet.cs

@@ -211,29 +211,59 @@ protected override Func<string> MultipleLineTranslationFactory
             {
                 return () =>
                 {
-                    var hasSingleLambdaArgument = HasSingleLambdaArgument();
-                    var prefix = hasSingleLambdaArgument ? null : Environment.NewLine;
+                    bool hasSingleBlockArgument, hasSingleLambdaArgument;
 
-                    var parameters = FormatParameters("," + Environment.NewLine, a => a.Indented());
+                    if (_arguments.Length == 1)
+                    {
+                        hasSingleBlockArgument = IsSingleArgumentABlock();
+                        hasSingleLambdaArgument = !hasSingleBlockArgument && IsSingleArgumentALambda();
+                    }
+                    else
+                    {
+                        hasSingleBlockArgument = hasSingleLambdaArgument = false;
+                    }
+
+                    var parameters = FormatParameters(
+                        "," + Environment.NewLine,
+                        a =>
+                        {
+                            hasSingleBlockArgument = hasSingleBlockArgument && a.IsMultiLine();
+
+                            return hasSingleBlockArgument ? a : a.Indented();
+                        });
+
+                    if (hasSingleBlockArgument)
+                    {
+                        return parameters;
+                    }
 
                     if (hasSingleLambdaArgument)
                     {
-                        parameters = parameters.TrimStart();
+                        return parameters.TrimStart();
                     }
 
-                    return prefix + parameters;
+                    return Environment.NewLine + parameters;
                 };
             }
         }
 
-        private bool HasSingleLambdaArgument()
+        private bool IsSingleArgumentABlock()
         {
-            if (_arguments.Length != 1)
+            switch (_arguments[0].NodeType)
             {
-                return false;
+                case ExpressionType.Block:
+                case ExpressionType.Switch:
+                case ExpressionType.Conditional:
+                case ExpressionType.Try:
+                    return true;
             }
 
-            var argument = _arguments.First();
+            return false;
+        }
+
+        private bool IsSingleArgumentALambda()
+        {
+            var argument = _arguments[0];
 
             if (argument.NodeType != ExpressionType.Lambda)
             {