Translating checked operators using checked() or checked {}

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingMathsOperations.cs

@@ -31,7 +31,7 @@ public void ShouldTranslateACheckedAdditionExpression()
 
             var translated = checkedAdditionLambda.ToReadableString();
 
-            Assert.AreEqual("(a, b) => a + b", translated);
+            Assert.AreEqual("(a, b) => checked(a + b)", translated);
         }
 
         [TestMethod]
@@ -58,7 +58,7 @@ public void ShouldTranslateACheckedSubtractionExpression()
 
             var translated = checkedSubtractionLambda.ToReadableString();
 
-            Assert.AreEqual("(a, b) => a - b", translated);
+            Assert.AreEqual("(a, b) => checked(a - b)", translated);
         }
 
         [TestMethod]
@@ -105,9 +105,11 @@ public void ShouldTranslateACheckedMultiplicationExpression()
                 intParameter1,
                 intParameter2);
 
+            //Expression<Func<int, int, int>> ass = (a, b) => checked(a * b);
+
             var translated = checkedMultiplicationLambda.ToReadableString();
 
-            Assert.AreEqual("(a, b) => a * b", translated);
+            Assert.AreEqual("(a, b) => checked(a * b)", translated);
         }
 
         [TestMethod]

ReadableExpressions/Extensions/InternalExpressionExtensions.cs

@@ -1,5 +1,7 @@
 namespace AgileObjects.ReadableExpressions.Extensions
 {
+    using System;
+    using System.Collections.Generic;
     using System.Linq;
     using System.Linq.Expressions;
 
@@ -80,5 +82,13 @@ public static bool IsAssignment(this Expression expression)
 
             return false;
         }
+
+        public static ExpressionType[] GetCheckedExpressionTypes(this Dictionary<ExpressionType, string> valuesByExpressionTypes)
+        {
+            return valuesByExpressionTypes
+               .Keys
+               .Where(nt => nt.ToString().EndsWith("Checked", StringComparison.Ordinal))
+               .ToArray();
+        }
     }
 }

ReadableExpressions/Translators/AssignmentExpressionTranslator.cs

@@ -1,9 +1,9 @@
 namespace AgileObjects.ReadableExpressions.Translators
 {
-    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Linq.Expressions;
+    using Extensions;
 
     internal class AssignmentExpressionTranslator : ExpressionTranslatorBase
     {
@@ -27,10 +27,8 @@ internal class AssignmentExpressionTranslator : ExpressionTranslatorBase
                 [ExpressionType.SubtractAssignChecked] = "-="
             };
 
-        private static readonly ExpressionType[] _checkedAssignmentTypes = _symbolsByNodeType
-            .Keys
-            .Where(nt => nt.ToString().EndsWith("Checked", StringComparison.Ordinal))
-            .ToArray();
+        private static readonly ExpressionType[] _checkedAssignmentTypes =
+            _symbolsByNodeType.GetCheckedExpressionTypes();
 
         private readonly DefaultExpressionTranslator _defaultTranslator;
 
@@ -62,7 +60,7 @@ internal string GetAssignment(
 
             var assignment = $"{target} {symbol} {valueString}";
 
-            assignment = AdjustForCheckedAssignmentIfAppropriate(assignment, assignmentType);
+            assignment = AdjustForCheckedAssignmentIfAppropriate(assignmentType, assignment);
 
             return assignment;
         }
@@ -85,8 +83,8 @@ private string GetValueTranslation(Expression value, TranslationContext context)
         }
 
         private static string AdjustForCheckedAssignmentIfAppropriate(
-            string assignment,
-            ExpressionType assignmentType)
+            ExpressionType assignmentType,
+            string assignment)
         {
             if (!_checkedAssignmentTypes.Contains(assignmentType))
             {

ReadableExpressions/Translators/BinaryExpressionTranslator.cs

@@ -37,6 +37,9 @@ internal class BinaryExpressionTranslator : ExpressionTranslatorBase
                 [ExpressionType.SubtractChecked] = "-"
             };
 
+        private static readonly ExpressionType[] _checkedOperatorTypes =
+            _operatorsByNodeType.GetCheckedExpressionTypes();
+
         private readonly NegationExpressionTranslator _negationTranslator;
         private readonly Dictionary<ExpressionType, BinaryTranslator> _translatorsByNodeType;
 
@@ -70,7 +73,9 @@ private static string Translate(BinaryExpression binary, TranslationContext cont
             var @operator = _operatorsByNodeType[binary.NodeType];
             var right = GetTranslation(binary.Right, context);
 
-            return $"({left} {@operator} {right})";
+            var operation = $"{left} {@operator} {right}";
+
+            return AdjustForCheckedOperatorIfAppropriate(binary.NodeType, operation);
         }
 
         private static string GetTranslation(Expression expression, TranslationContext context)
@@ -85,6 +90,27 @@ private static string GetTranslation(Expression expression, TranslationContext c
             return translation;
         }
 
+        private static string AdjustForCheckedOperatorIfAppropriate(
+            ExpressionType operatorType,
+            string operation)
+        {
+            if (!_checkedOperatorTypes.Contains(operatorType))
+            {
+                return operation.WithSurroundingParentheses();
+            }
+
+            if (operation.IsMultiLine())
+            {
+                return $@"
+checked
+{{
+{operation.Indent()}
+}}".TrimStart();
+            }
+
+            return $"checked({operation})";
+        }
+
         private static string TranslateAddition(BinaryExpression binary, TranslationContext context)
         {
             if ((binary.Left.Type != typeof(string)) && (binary.Right.Type != typeof(string)))