Improving detection of unterminated, multiple-line statements

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenFormattingCode.cs

@@ -422,7 +422,7 @@ public void ShouldVarAssignAVariableUsedInNestedConstructs()
             {
                 throw new NotSupportedException();
             }
-        }
+        };
     }
 
     var fileStream = stream as FileStream;
@@ -441,7 +441,7 @@ public void ShouldVarAssignAVariableUsedInNestedConstructs()
             {
                 throw new IOException();
             }
-        }
+        };
     }
 
     return 0L;

ReadableExpressions.UnitTests/WhenTranslatingAssignments.cs

@@ -528,8 +528,7 @@ public void ShouldTranslateANestedBlockAssignment()
         [TestMethod]
         public void ShouldTranslateMultiStatementValueBlockAssignments()
         {
-            ParameterExpression existingInts;
-            var valueConditional = GetReturnStatementBlock(out existingInts);
+            var valueConditional = GetReturnStatementBlock(out var existingInts);
 
             Expression<Action> consoleRead = () => Console.Read();
 
@@ -567,7 +566,7 @@ public void ShouldTranslateMultiStatementValueBlockAssignments()
             }
 
             return ints;
-        }
+        };
 }";
             Assert.AreEqual(EXPECTED.TrimStart(), translated);
         }
@@ -576,8 +575,7 @@ public void ShouldTranslateMultiStatementValueBlockAssignments()
         [TestMethod]
         public void ShouldTranslateSingleStatementValueBlockAssignments()
         {
-            ParameterExpression existingInts;
-            var valueConditional = GetReturnStatementBlock(out existingInts);
+            var valueConditional = GetReturnStatementBlock(out var existingInts);
 
             var singleStatementValueBlock = Expression.Block(
                 new[] { existingInts },
@@ -610,7 +608,7 @@ public void ShouldTranslateSingleStatementValueBlockAssignments()
             }
 
             return ints;
-        }
+        };
 }";
             Assert.AreEqual(EXPECTED.TrimStart(), translated);
         }

ReadableExpressions.UnitTests/WhenTranslatingBlocks.cs

@@ -281,6 +281,45 @@ public void ShouldNotTerminateMethodCallArguments()
             Assert.AreEqual("File.OpenText(((int)o).ToString())", translated);
         }
 
+        [TestMethod]
+        public void ShouldTerminateAMultipleLineMemberInitAssignment()
+        {
+            Expression<Action> writeWat = () => Console.WriteLine("Wat");
+            Expression<Func<long>> read = () => Console.Read();
+
+            var newMemoryStream = Expression.New(typeof(MemoryStream));
+            var positionProperty = newMemoryStream.Type.GetProperty("Position");
+            var valueBlock = Expression.Block(writeWat.Body, read.Body);
+            // ReSharper disable once AssignNullToNotNullAttribute
+            var positionInit = Expression.Bind(positionProperty, valueBlock);
+            var memoryStreamInit = Expression.MemberInit(newMemoryStream, positionInit);
+
+            var streamVariable = Expression.Variable(typeof(Stream), "stream");
+
+            var assignStream = Expression.Assign(streamVariable, memoryStreamInit);
+
+            var streamIsNull = Expression.Equal(streamVariable, Expression.Default(typeof(Stream)));
+
+            var ifNullAssign = Expression.IfThen(streamIsNull, assignStream);
+
+            var translated = ifNullAssign.ToReadableString();
+
+            const string EXPECTED = @"
+if (stream == null)
+{
+    stream = new MemoryStream
+    {
+        Position = 
+        {
+            Console.WriteLine(""Wat"");
+
+            return ((long)Console.Read());
+        }
+    };
+}";
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
+
         [TestMethod]
         public void ShouldTranslateASwitchWithMultipleVariableAssignments()
         {

ReadableExpressions.UnitTests/WhenTranslatingGotos.cs

@@ -189,7 +189,7 @@ public void ShouldTranslateAReturnStatementWithABlock()
     i = i + 2;
 
     return i;
-}";
+};";
 
             var translated = returnBlock.ToReadableString();
 

ReadableExpressions/StringExtensions.cs

@@ -19,19 +19,41 @@ public static bool IsTerminated(this string codeLine)
 
             var lastNewLine = codeLine.LastIndexOf(Environment.NewLine, StringComparison.Ordinal);
 
-            var index = (lastNewLine != -1)
-                ? lastNewLine + Environment.NewLine.Length
-                : 0;
+            if (lastNewLine == -1)
+            {
+                return false;
+            }
+
+            var codeLines = codeLine.SplitToLines();
 
-            for (var end = codeLine.Length - 1; index < end; ++index)
+            while (codeLines[0].StartsWith(IndentSpaces, StringComparison.Ordinal))
             {
-                if (codeLine[index] != ' ')
+                for (var i = 0; i < codeLines.Length; i++)
                 {
-                    return false;
+                    codeLines[i] = codeLines[i].Substring(IndentSpaces.Length);
                 }
             }
 
-            return true;
+            var lastNonIndentedCodeLine = codeLines
+                .Last(line => line.IsNonIndentedCodeLine());
+
+            if ((lastNonIndentedCodeLine == "catch") ||
+                 lastNonIndentedCodeLine.StartsWith("if ", StringComparison.Ordinal) ||
+                 lastNonIndentedCodeLine.StartsWith("while ", StringComparison.Ordinal) ||
+                (lastNonIndentedCodeLine == "finally") ||
+                 lastNonIndentedCodeLine.StartsWith("else if ", StringComparison.Ordinal) ||
+                (lastNonIndentedCodeLine == "else") ||
+                 lastNonIndentedCodeLine.StartsWith("switch ", StringComparison.Ordinal))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool IsNonIndentedCodeLine(this string line)
+        {
+            return line.IsNotIndented() && !line.StartsWith('{') && !line.StartsWith('}');
         }
 
         public static string Unterminated(this string codeLine)

ReadableExpressions/Translators/Formatting/CodeBlock.cs

@@ -34,7 +34,7 @@ public static bool IsSingleStatement(IList<string> blockLines)
 
             var numberOfNonIndentedLines = blockLines[0]
                 .SplitToLines()
-                .Count(RelevantNonIndentedLine);
+                .Count(line => line.IsNonIndentedCodeLine());
 
             return numberOfNonIndentedLines == 1;
         }
@@ -199,11 +199,6 @@ private void AddSemiColonIfRequired()
             }
         }
 
-        private static bool RelevantNonIndentedLine(string line)
-        {
-            return line.IsNotIndented() && !line.StartsWith('{') && !line.StartsWith('}');
-        }
-
         private class BlockInfo
         {
             private readonly string[] _blockLines;
@@ -217,7 +212,7 @@ public BlockInfo(string[] blockLines)
                 _lastNonIndentedStatement = blockLines.Last(line => line.IsNotIndented());
 
                 _lastStatementLines = _lastNonIndentedStatement.SplitToLines();
-                _lastNonIndentedLine = _lastStatementLines.Last(RelevantNonIndentedLine);
+                _lastNonIndentedLine = _lastStatementLines.Last(line => line.IsNonIndentedCodeLine());
             }
 
             public bool LastLineHasReturnKeyword =>