Leaving blank lines before if and switch statements

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenFormattingCode.cs

@@ -406,6 +406,7 @@ public void ShouldVarAssignAVariableUsedInNestedConstructs()
 try
 {
     var memoryStream = stream as MemoryStream;
+
     if (memoryStream != null)
     {
         return 
@@ -423,6 +424,7 @@ public void ShouldVarAssignAVariableUsedInNestedConstructs()
     }
 
     var fileStream = stream as FileStream;
+
     if (fileStream != null)
     {
         return 
@@ -775,6 +777,29 @@ public void ShouldLeaveABlankLineAfterAMultipleLineExpression()
             Assert.AreEqual(EXPECTED.TrimStart(), translated);
         }
 
+        [TestMethod]
+        public void ShouldLeaveABlankLineBeforeAnIfStatement()
+        {
+            var intVariable = Expression.Variable(typeof(int), "i");
+            var zero = Expression.Constant(0);
+            var intVariableEqualsZero = Expression.Equal(intVariable, zero);
+            var doNothing = Expression.Default(typeof(void));
+            var ifIntEqualsZeroDoNothing = Expression.IfThen(intVariableEqualsZero, doNothing);
+
+            var block = Expression.Block(new[] { intVariable }, ifIntEqualsZeroDoNothing);
+
+            const string EXPECTED = @"
+int i;
+
+if (i == 0)
+{
+}";
+
+            var translated = block.ToReadableString();
+
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
+
         [TestMethod]
         public void ShouldTranslateMultilineBlockSingleMethodArguments()
         {

ReadableExpressions.UnitTests/WhenTranslatingBlocks.cs

@@ -217,6 +217,7 @@ public void ShouldTranslateAVariableAssignmentWithinACondition()
             const string EXPECTED = @"() =>
 {
     int count;
+
     if ((count = 5) < 10)
     {
     }
@@ -300,6 +301,7 @@ public void ShouldTranslateASwitchWithMultipleVariableAssignments()
 
             const string EXPECTED = @"
 int count;
+
 switch (i)
 {
     case 1:

ReadableExpressions/Translators/BlockExpressionTranslator.cs

@@ -22,16 +22,15 @@ public override string Translate(Expression expression, TranslationContext conte
             var block = (BlockExpression)expression;
 
             var variables = GetVariableDeclarations(block, context);
-            var lines = GetBlockLines(block, context);
-
-            lines = ProcessBlockContents(lines.ToArray(), block);
+            var statements = GetBlockStatements(block, context).ToArray();
+            var separator = GetStatementsSeparator(variables, statements);
 
-            var blockContents = variables.Concat(lines);
+            var blockContents = variables.Concat(separator).Concat(statements);
 
             return string.Join(Environment.NewLine, blockContents);
         }
 
-        private IEnumerable<string> GetVariableDeclarations(
+        private IList<string> GetVariableDeclarations(
             BlockExpression block,
             TranslationContext context)
         {
@@ -44,10 +43,66 @@ private IEnumerable<string> GetVariableDeclarations(
                     TypeName = vGrp.Key.GetFriendlyName(),
                     VariableNames = vGrp.Select(varName => _variableNameTranslator.Translate(varName))
                 })
-                .Select(varData => $"{varData.TypeName} {string.Join(", ", varData.VariableNames)};");
+                .Select(varData => $"{varData.TypeName} {string.Join(", ", varData.VariableNames)};")
+                .ToArray();
         }
 
-        private static IEnumerable<string> GetBlockLines(BlockExpression block, TranslationContext context)
+        private static IEnumerable<string> GetStatementsSeparator(
+            ICollection<string> variables,
+            IList<string> statements)
+        {
+            if ((variables.Count > 0) && LeaveBlankLineBefore(statements[0]))
+            {
+                yield return string.Empty;
+            }
+        }
+
+        private static IEnumerable<string> GetBlockStatements(
+            BlockExpression block,
+            TranslationContext context)
+        {
+            var lines = GetBlockLines(block, context);
+
+            var finalLineIndex = lines.Count - 1;
+
+            for (var i = 0; i < lines.Count; i++)
+            {
+                var line = lines[i];
+
+                if ((i > 0) && LeaveBlankLineBefore(line))
+                {
+                    yield return string.Empty;
+                }
+
+                if (i != finalLineIndex)
+                {
+                    yield return line;
+
+                    if (LeaveBlankLineAfter(line, lines[i + 1]))
+                    {
+                        yield return string.Empty;
+                    }
+
+                    continue;
+                }
+
+                if (DoNotAddReturnStatement(block, lines))
+                {
+                    yield return line;
+                    yield break;
+                }
+
+                if (CodeBlock.IsSingleStatement(line.SplitToLines()))
+                {
+                    yield return "return " + line;
+                    yield break;
+                }
+
+                yield return CodeBlock.InsertReturnKeyword(line);
+            }
+        }
+
+        private static IList<string> GetBlockLines(BlockExpression block, TranslationContext context)
         {
             return block
                 .Expressions
@@ -58,7 +113,8 @@ private static IEnumerable<string> GetBlockLines(BlockExpression block, Translat
                     Translation = GetTerminatedStatementOrNull(exp, context)
                 })
                 .Where(d => d.Translation != null)
-                .Select(d => d.Translation);
+                .Select(d => d.Translation)
+                .ToArray();
         }
 
         private static bool Include(Expression expression)
@@ -135,40 +191,9 @@ private static bool UseFullTypeName(BinaryExpression assignment)
             return conditional.IfTrue.Type != conditional.IfFalse.Type;
         }
 
-        private static IEnumerable<string> ProcessBlockContents(IList<string> lines, BlockExpression block)
+        private static bool LeaveBlankLineBefore(string line)
         {
-            var finalLineIndex = lines.Count - 1;
-
-            for (var i = 0; i < lines.Count; i++)
-            {
-                var line = lines[i];
-
-                if (i != finalLineIndex)
-                {
-                    yield return line;
-
-                    if (LeaveBlankLineAfter(line, lines[i + 1]))
-                    {
-                        yield return string.Empty;
-                    }
-
-                    continue;
-                }
-
-                if (DoNotAddReturnStatement(block, lines))
-                {
-                    yield return line;
-                    yield break;
-                }
-
-                if (CodeBlock.IsSingleStatement(line.SplitToLines()))
-                {
-                    yield return "return " + line;
-                    yield break;
-                }
-
-                yield return CodeBlock.InsertReturnKeyword(line);
-            }
+            return line.StartsWith("if (") || line.StartsWith("switch ");
         }
 
         private static bool LeaveBlankLineAfter(string line, string nextLine)
@@ -179,12 +204,7 @@ private static bool LeaveBlankLineAfter(string line, string nextLine)
 
         private static bool IsMultiLineStatement(string line)
         {
-            if (!line.Contains(Environment.NewLine))
-            {
-                return false;
-            }
-
-            return line
+            return line.IsMultiLine() && line
                 .SplitToLines(StringSplitOptions.RemoveEmptyEntries)
                 .Any(l => !l.IsTerminated());
         }