Keeping surrounding parenthesis in assignments of chained method calls starting with a cast

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenFormattingCode.cs

@@ -391,6 +391,20 @@ public void ShouldOnlyRemoveParenthesesIfNecessary()
             Assert.AreEqual("(i == 1) ? string.Empty : ((int)o).ToString()", translated);
         }
 
+        [TestMethod]
+        public void ShouldNotRemoveParenthesesFromACastObjectChainedMethodCall()
+        {
+            Expression<Func<IList<int>, string[]>> intArrayConverter =
+                ints => ((int[])ints).ToString().Split(',');
+
+            var stringArrayVariable = Expression.Variable(typeof(string[]), "strings");
+            var assignment = Expression.Assign(stringArrayVariable, intArrayConverter.Body);
+
+            var translated = assignment.ToReadableString();
+
+            Assert.AreEqual("strings = ((int[])ints).ToString().Split(',')", translated);
+        }
+
         [TestMethod]
         public void ShouldUseMethodGroupsForStaticMethods()
         {

ReadableExpressions/Extensions/PublicExpressionExtensions.cs

@@ -22,5 +22,24 @@ public static Expression GetSubject(this MethodCallExpression methodCall)
             return methodCall.Method.IsExtensionMethod()
                 ? methodCall.Arguments.First() : methodCall.Object;
         }
+
+        /// <summary>
+        /// Gets the parent Expression for the given <paramref name="expression"/>.
+        /// </summary>
+        /// <param name="expression">The Expression for which to retrieve the parent.</param>
+        /// <returns>The given <paramref name="expression"/>'s parent Expression.</returns>
+        public static Expression GetParentOrNull(this Expression expression)
+        {
+            switch (expression.NodeType)
+            {
+                case ExpressionType.Call:
+                    return ((MethodCallExpression)expression).GetSubject();
+
+                case ExpressionType.MemberAccess:
+                    return ((MemberExpression)expression).Expression;
+            }
+
+            return null;
+        }
     }
 }

ReadableExpressions/StringExtensions.cs

@@ -109,7 +109,14 @@ private static bool KeepSurroundingParentheses(Expression expression)
                     return true;
 
                 case ExpressionType.Call:
-                    return ((MethodCallExpression)expression).Object?.NodeType == ExpressionType.Convert;
+                    var parentExpression = expression.GetParentOrNull();
+                    while (parentExpression != null)
+                    {
+                        expression = parentExpression;
+                        parentExpression = expression.GetParentOrNull();
+                    }
+
+                    return (expression.NodeType == ExpressionType.Convert);
             }
 
             return false;