Including return keywords in code blocks which end with new, new array or array init statements / Correctly terminating init statement lines

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingBlocks.cs

@@ -343,7 +343,7 @@ public void ShouldIgnoreABlankLabelTargetLine()
         }
 
         [TestMethod]
-        public void ShouldIncludeAReturnStatementForACoalesce()
+        public void ShouldIncludeAReturnKeywordForACoalesce()
         {
             var stringVariable1 = Expression.Variable(typeof(string), "myString");
             var stringVariable2 = Expression.Variable(typeof(string), "yourString");
@@ -363,5 +363,82 @@ public void ShouldIncludeAReturnStatementForACoalesce()
 
             Assert.AreEqual(EXPECTED.TrimStart(), translated);
         }
+
+        [TestMethod]
+        public void ShouldIncludeAReturnKeywordForANewObjectStatement()
+        {
+            var exception = Expression.Variable(typeof(Exception), "ex");
+            var newList = Expression.New(typeof(List<string>).GetConstructors().First());
+            var rethrow = Expression.Rethrow(newList.Type);
+            var globalCatchAndRethrow = Expression.Catch(exception, rethrow);
+            var tryCatch = Expression.TryCatch(newList, globalCatchAndRethrow);
+
+            var tryCatchBlock = Expression.Block(tryCatch);
+
+            var translated = tryCatchBlock.ToReadableString();
+
+            const string EXPECTED = @"
+try
+{
+    return new List<string>();
+}
+catch
+{
+    throw;
+}";
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
+
+        [TestMethod]
+        public void ShouldIncludeAReturnKeywordForANewArrayStatement()
+        {
+            var exception = Expression.Variable(typeof(Exception), "ex");
+            var zero = Expression.Constant(0, typeof(int));
+            var newArray = Expression.NewArrayBounds(typeof(int), zero);
+            var rethrow = Expression.Rethrow(newArray.Type);
+            var globalCatchAndRethrow = Expression.Catch(exception, rethrow);
+            var tryCatch = Expression.TryCatch(newArray, globalCatchAndRethrow);
+
+            var tryCatchBlock = Expression.Block(tryCatch);
+
+            var translated = tryCatchBlock.ToReadableString();
+
+            const string EXPECTED = @"
+try
+{
+    return new int[0];
+}
+catch
+{
+    throw;
+}";
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
+
+        [TestMethod]
+        public void ShouldIncludeAReturnKeywordForANewArrayInitStatement()
+        {
+            var exception = Expression.Variable(typeof(Exception), "ex");
+            var zero = Expression.Constant(0, typeof(int));
+            var newArray = Expression.NewArrayInit(typeof(int), zero);
+            var rethrow = Expression.Rethrow(newArray.Type);
+            var globalCatchAndRethrow = Expression.Catch(exception, rethrow);
+            var tryCatch = Expression.TryCatch(newArray, globalCatchAndRethrow);
+
+            var tryCatchBlock = Expression.Block(tryCatch);
+
+            var translated = tryCatchBlock.ToReadableString();
+
+            const string EXPECTED = @"
+try
+{
+    return new[] { 0 };
+}
+catch
+{
+    throw;
+}";
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
+        }
     }
 }

ReadableExpressions/Extensions/InternalExpressionExtensions.cs

@@ -35,6 +35,9 @@ public static bool IsReturnable(this Expression expression)
                 case ExpressionType.MemberAccess:
                 case ExpressionType.Multiply:
                 case ExpressionType.MultiplyChecked:
+                case ExpressionType.New:
+                case ExpressionType.NewArrayBounds:
+                case ExpressionType.NewArrayInit:
                 case ExpressionType.Parameter:
                 case ExpressionType.Subtract:
                 case ExpressionType.SubtractChecked:

ReadableExpressions/StringExtensions.cs

@@ -8,11 +8,30 @@ namespace AgileObjects.ReadableExpressions
 
     internal static class StringExtensions
     {
-        private static readonly char[] _terminatingCharacters = { ';', '}', ':', ',' };
+        private static readonly char[] _terminatingCharacters = { ';', ':', ',' };
 
         public static bool IsTerminated(this string codeLine)
         {
-            return codeLine.EndsWithAny(_terminatingCharacters) || codeLine.IsComment();
+            if (!codeLine.EndsWith('}'))
+            {
+                return codeLine.EndsWithAny(_terminatingCharacters) || codeLine.IsComment();
+            }
+
+            var lastNewLine = codeLine.LastIndexOf(Environment.NewLine, StringComparison.Ordinal);
+
+            var index = (lastNewLine != -1)
+                ? lastNewLine + Environment.NewLine.Length
+                : 0;
+
+            for (var end = codeLine.Length - 1; index < end; ++index)
+            {
+                if (codeLine[index] != ' ')
+                {
+                    return false;
+                }
+            }
+
+            return true;
         }
 
         public static string Unterminated(this string codeLine)
@@ -149,17 +168,17 @@ public static bool StartsWith(this string value, char character)
 
         public static bool EndsWith(this string value, char character)
         {
-            if (value == string.Empty)
-            {
-                return false;
-            }
-
-            return value[value.Length - 1] == character;
+            return (value != string.Empty) && value.EndsWithNoEmptyCheck(character);
         }
 
         private static bool EndsWithAny(this string value, IEnumerable<char> characters)
         {
-            return characters.Any(value.EndsWith);
+            return (value != string.Empty) && characters.Any(value.EndsWithNoEmptyCheck);
+        }
+
+        private static bool EndsWithNoEmptyCheck(this string value, char character)
+        {
+            return value[value.Length - 1] == character;
         }
 
         private const string CommentString = "// ";