Fixing multiline constructor argument formatting

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingObjectCreations.cs

@@ -6,6 +6,7 @@
     using System.Linq.Expressions;
     using System.Text;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
+    using NetStandardPolyfills;
 
     [TestClass]
     public class WhenTranslatingObjectCreations
@@ -268,6 +269,47 @@ public void ShouldTranslateAParameterConstructorParameter()
             Assert.AreEqual("new StringBuilder(str)", translated);
         }
 
+        [TestMethod]
+        public void ShouldTranslateMultilineConstructorParameters()
+        {
+            Expression<Func<int>> consoleRead = () => Console.Read();
+
+            var catchAll = Expression.Catch(typeof(Exception), Expression.Default(typeof(int)));
+            var tryReadInt = Expression.TryCatch(consoleRead.Body, catchAll);
+
+            var createStringBuilder = Expression.New(
+                typeof(StringBuilder).GetPublicInstanceConstructor(typeof(int), typeof(int)),
+                tryReadInt,
+                tryReadInt);
+
+            const string EXPECTED = @"
+new StringBuilder(
+    {
+        try
+        {
+            return Console.Read();
+        }
+        catch
+        {
+            return default(int);
+        }
+    },
+    {
+        try
+        {
+            return Console.Read();
+        }
+        catch
+        {
+            return default(int);
+        }
+    })";
+
+            var translated = createStringBuilder.ToReadableString();
+
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
+
         [TestMethod]
         public void ShouldTranslateAnAnonymousTypeCreation()
         {

ReadableExpressions/StringExtensions.cs

@@ -5,6 +5,7 @@ namespace AgileObjects.ReadableExpressions
     using System.Linq;
     using System.Linq.Expressions;
     using Extensions;
+    using static System.Environment;
 
     internal static class StringExtensions
     {
@@ -17,7 +18,7 @@ public static bool IsTerminated(this string codeLine)
                 return codeLine.EndsWithAny(_terminatingCharacters) || codeLine.IsComment();
             }
 
-            var lastNewLine = codeLine.LastIndexOf(Environment.NewLine, StringComparison.Ordinal);
+            var lastNewLine = codeLine.LastIndexOf(NewLine, StringComparison.Ordinal);
 
             if (lastNewLine == -1)
             {
@@ -66,7 +67,7 @@ public static string Unterminated(this string codeLine)
                 : codeLine;
         }
 
-        private static readonly string[] _newLines = { Environment.NewLine };
+        private static readonly string[] _newLines = { NewLine };
 
         public static string[] SplitToLines(this string line, StringSplitOptions splitOptions = StringSplitOptions.None)
         {
@@ -90,15 +91,15 @@ public static string Indented(this string line)
             if (line.IsMultiLine())
             {
                 return string.Join(
-                    Environment.NewLine,
+                    NewLine,
                     line.SplitToLines().Select(l => l.Indented()));
             }
 
             return IndentSpaces + line;
         }
 
         public static bool IsMultiLine(this string value)
-            => (value != Environment.NewLine) && value.Contains(Environment.NewLine);
+            => (value != NewLine) && value.Contains(NewLine);
 
         private const string UnindentPlaceholder = "*unindent*";
 
@@ -184,7 +185,7 @@ private static bool KeepSurroundingParentheses(Expression expression)
 
         public static bool StartsWithNewLine(this string value)
         {
-            return value.StartsWith(Environment.NewLine, StringComparison.Ordinal);
+            return value.StartsWith(NewLine, StringComparison.Ordinal);
         }
 
         public static bool StartsWith(this string value, char character)
@@ -213,7 +214,7 @@ public static string AsComment(this string text)
         {
             return CommentString + text
                 .Trim()
-                .Replace(Environment.NewLine, Environment.NewLine + CommentString);
+                .Replace(NewLine, NewLine + CommentString);
         }
 
         public static bool IsComment(this string codeLine)

ReadableExpressions/Translators/Formatting/FormattedCondition.cs

@@ -20,7 +20,7 @@ public FormattedCondition(
 
             if (test.IsMultiLine())
             {
-                if (test.StartsWith(Environment.NewLine + '{'))
+                if (test.StartsWith(Environment.NewLine + '{', StringComparison.Ordinal))
                 {
                     test = test.Indented();
                 }
@@ -33,19 +33,15 @@ public FormattedCondition(
             MultipleLineTranslationFactory = GetMultipleLineTranslation;
         }
 
-        private bool CheckExistingParentheses()
-        {
-            // ReSharper disable once UnusedVariable
-            return IsNotRelevantBinary(_condition, out BinaryExpression binary);
-        }
+        private bool CheckExistingParentheses() => IsNotRelevantBinary(_condition, out var _);
 
         protected override Func<string> SingleLineTranslationFactory => () => _singleLineTest;
 
         protected override Func<string> MultipleLineTranslationFactory { get; }
 
         private string GetMultipleLineTranslation()
         {
-            if (IsNotRelevantBinary(_condition, out BinaryExpression conditionBinary))
+            if (IsNotRelevantBinary(_condition, out var conditionBinary))
             {
                 return _singleLineTest;
             }

ReadableExpressions/Translators/Formatting/ParameterSet.cs

@@ -7,6 +7,7 @@
     using System.Reflection;
     using Extensions;
     using NetStandardPolyfills;
+    using static System.Environment;
 
     internal class ParameterSet : FormattableExpressionBase
     {
@@ -81,7 +82,7 @@ private static string FormatParamsArray(string array)
                 .SplitToLines(StringSplitOptions.RemoveEmptyEntries)
                 .Select(line => line.Trim(' '));
 
-            var arrayValuesString = string.Join(Environment.NewLine, arrayValues);
+            var arrayValuesString = string.Join(NewLine, arrayValues);
 
             return arrayValuesString;
         }
@@ -241,12 +242,22 @@ protected override Func<string> MultipleLineTranslationFactory
                        (_arguments[0].NodeType == ExpressionType.Quote);
 
                     var parameters = FormatParameters(
-                        "," + Environment.NewLine,
+                        "," + NewLine,
                         a =>
                         {
                             hasSingleBlockArgument = hasSingleBlockArgument && a.IsMultiLine();
 
-                            return hasSingleBlockArgument || compensateForQuotedLambda ? a : a.Indented();
+                            if (hasSingleBlockArgument || compensateForQuotedLambda)
+                            {
+                                return a;
+                            }
+
+                            if (a.StartsWithNewLine())
+                            {
+                                a = a.Substring(NewLine.Length);
+                            }
+
+                            return a.Indented();
                         });
 
                     if (hasSingleBlockArgument)
@@ -258,15 +269,15 @@ protected override Func<string> MultipleLineTranslationFactory
                     {
                         if (compensateForQuotedLambda)
                         {
-                            return Environment.NewLine + parameters
-                                .Substring(Environment.NewLine.Length)
-                                .Substring(parameters.IndexOf(Environment.NewLine, StringComparison.Ordinal));
+                            return NewLine + parameters
+                                .Substring(NewLine.Length)
+                                .Substring(parameters.IndexOf(NewLine, StringComparison.Ordinal));
                         }
 
                         return parameters.TrimStart();
                     }
 
-                    return Environment.NewLine + parameters;
+                    return NewLine + parameters;
                 };
             }
         }

ReadableExpressions/Translators/NewExpressionTranslator.cs

@@ -26,7 +26,7 @@ public override string Translate(Expression expression, TranslationContext conte
 
             return "new " + typeName + parameters;
         }
-        private string GetAnonymousTypeCreation(NewExpression newExpression, TranslationContext context)
+        private static string GetAnonymousTypeCreation(NewExpression newExpression, TranslationContext context)
         {
             var constructorParameters = newExpression.Constructor.GetParameters();