Test coverage for multiple line checked maths operations / Analyzing all expression types before translating

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingMathsOperations.cs

@@ -96,20 +96,38 @@ public void ShouldTranslateAMultiplicationExpression()
         [TestMethod]
         public void ShouldTranslateACheckedMultiplicationExpression()
         {
-            var intParameter1 = Expression.Parameter(typeof(int), "a");
-            var intParameter2 = Expression.Parameter(typeof(int), "b");
-            var checkedMultiplication = Expression.MultiplyChecked(intParameter1, intParameter2);
+            Expression<Action> consoleRead = () => Console.Read();
 
-            var checkedMultiplicationLambda = Expression.Lambda<Func<int, int, int>>(
-                checkedMultiplication,
-                intParameter1,
-                intParameter2);
+            var variableOne = Expression.Variable(typeof(int), "one");
+            var variableTwo = Expression.Variable(typeof(int), "two");
+
+            var variableOneAssignment = Expression.Assign(variableOne, consoleRead.Body);
+            var variableTwoAssignment = Expression.Assign(variableTwo, consoleRead.Body);
 
-            //Expression<Func<int, int, int>> ass = (a, b) => checked(a * b);
+            var variableOnePlusTwo = Expression.Add(variableOne, variableTwo);
 
-            var translated = checkedMultiplicationLambda.ToReadableString();
+            var valueOneBlock = Expression.Block(
+                new[] { variableOne, variableTwo },
+                variableOneAssignment,
+                variableTwoAssignment,
+                variableOnePlusTwo);
+
+            var intVariable = Expression.Parameter(typeof(int), "i");
+            var checkedMultiplication = Expression.MultiplyChecked(valueOneBlock, intVariable);
+
+            var translated = checkedMultiplication.ToReadableString();
+
+            const string EXPECTED = @"
+checked
+{
+    {
+        var one = Console.Read();
+        var two = Console.Read();
+        return (one + two);
+    } * i
+}";
 
-            Assert.AreEqual("(a, b) => checked(a * b)", translated);
+            Assert.AreEqual(EXPECTED.TrimStart(), translated);
         }
 
         [TestMethod]

ReadableExpressions/TranslationContext.cs

@@ -73,21 +73,7 @@ public static ExpressionAnalysisVisitor Analyse(Expression expression)
 
                 var coreExpression = GetCoreExpression(expression);
 
-                if (coreExpression.IsAssignment())
-                {
-                    analyzer.Visit(coreExpression);
-                    return analyzer;
-                }
-
-                switch (coreExpression.NodeType)
-                {
-                    case ExpressionType.Block:
-                    case ExpressionType.Call:
-                    case ExpressionType.Conditional:
-                        analyzer.Visit(coreExpression);
-                        break;
-                }
-
+                analyzer.Visit(coreExpression);
                 return analyzer;
             }
 

ReadableExpressions/Translators/BinaryExpressionTranslator.cs

@@ -67,24 +67,31 @@ public override string Translate(Expression expression, TranslationContext conte
                 : Translate(binary, context);
         }
 
-        private static string Translate(BinaryExpression binary, TranslationContext context)
+        private string Translate(BinaryExpression binary, TranslationContext context)
         {
-            var left = GetTranslation(binary.Left, context);
+            var left = TranslateOperand(binary.Left, context);
             var @operator = _operatorsByNodeType[binary.NodeType];
-            var right = GetTranslation(binary.Right, context);
+            var right = TranslateOperand(binary.Right, context);
 
             var operation = $"{left} {@operator} {right}";
 
             return AdjustForCheckedOperatorIfAppropriate(binary.NodeType, operation);
         }
 
-        private static string GetTranslation(Expression expression, TranslationContext context)
+        private string TranslateOperand(Expression expression, TranslationContext context)
         {
+            var operand = GetTranslatedExpressionBody(expression, context);
+
+            if (!operand.IsASingleStatement)
+            {
+                return operand.WithCurlyBraces();
+            }
+
             var translation = context.GetTranslation(expression);
 
             if (expression.IsAssignment() && !translation.HasSurroundingParentheses())
             {
-                translation = translation.WithSurroundingParentheses();
+                return translation.WithSurroundingParentheses();
             }
 
             return translation;
@@ -104,14 +111,14 @@ private static string AdjustForCheckedOperatorIfAppropriate(
                 return $@"
 checked
 {{
-{operation.Indent()}
+{operation.TrimStart().Indent()}
 }}".TrimStart();
             }
 
             return $"checked({operation})";
         }
 
-        private static string TranslateAddition(BinaryExpression binary, TranslationContext context)
+        private string TranslateAddition(BinaryExpression binary, TranslationContext context)
         {
             if ((binary.Left.Type != typeof(string)) && (binary.Right.Type != typeof(string)))
             {
@@ -157,7 +164,7 @@ private static bool IsBooleanConstant(Expression expression)
         private string Translate(StandaloneBoolean standalone, TranslationContext context)
         {
             return standalone.IsComparisonToTrue
-                ? GetTranslation(standalone.Boolean, context)
+                ? TranslateOperand(standalone.Boolean, context)
                 : _negationTranslator.TranslateNot(standalone.Boolean, context);
         }