Translating assigned blocks into code blocks with curly braces

Author: SteveWilkes

ReadableExpressions.UnitTests/WhenTranslatingAssignments.cs

@@ -222,7 +222,7 @@ public void ShouldTranslateAnAssignmentResultAssignment()
 
             var translated = setVariableOneToAssignmentResult.ToReadableString();
 
-            Assert.AreEqual("i = (j = 1)", translated);
+            Assert.AreEqual("i = j = 1", translated);
         }
 
         [TestMethod]
@@ -263,13 +263,16 @@ public void ShouldAssignTheResultOfATryCatch()
             var translated = assignReadOrDefault.ToReadableString();
 
             const string EXPECTED = @"
-i = try
+i = 
 {
-    Console.Read();
-}
-catch (IOException)
-{
-    default(int);
+    try
+    {
+        Console.Read();
+    }
+    catch (IOException)
+    {
+        default(int);
+    }
 }";
 
             Assert.AreEqual(EXPECTED.TrimStart(), translated);

ReadableExpressions/TranslationContext.cs

@@ -29,6 +29,8 @@ public string GetTranslation(Expression expression)
             return _globalTranslator.Invoke(expression, this);
         }
 
+        public bool IsAssignedValue(Expression expression) => _analyzer.AssignedValues.Contains(expression);
+
         public bool IsNotJoinedAssignment(Expression expression)
         {
             return (expression.NodeType != ExpressionType.Assign) ||
@@ -49,6 +51,7 @@ private class ExpressionAnalysisVisitor : ExpressionVisitor
         {
             private readonly List<ParameterExpression> _accessedVariables;
             private readonly List<ParameterExpression> _assignedVariables;
+            private readonly List<Expression> _assignedValues;
             private readonly List<Expression> _assignedAssignments;
             private readonly List<BinaryExpression> _joinedAssignments;
             private readonly List<LabelTarget> _namedLabelTargets;
@@ -59,6 +62,7 @@ private ExpressionAnalysisVisitor()
             {
                 _accessedVariables = new List<ParameterExpression>();
                 _assignedVariables = new List<ParameterExpression>();
+                _assignedValues = new List<Expression>();
                 _assignedAssignments = new List<Expression>();
                 _joinedAssignments = new List<BinaryExpression>();
                 _namedLabelTargets = new List<LabelTarget>();
@@ -114,6 +118,8 @@ private static Expression GetCoreExpression(Expression expression)
 
             public IEnumerable<ParameterExpression> AssignedVariables => _assignedVariables;
 
+            public IEnumerable<Expression> AssignedValues => _assignedValues;
+
             public IEnumerable<BinaryExpression> JoinedAssignments => _joinedAssignments;
 
             public IEnumerable<LabelTarget> NamedLabelTargets => _namedLabelTargets;
@@ -139,22 +145,26 @@ protected override Expression VisitParameter(ParameterExpression variable)
 
             protected override Expression VisitBinary(BinaryExpression binaryExpression)
             {
-                if ((binaryExpression.NodeType == ExpressionType.Assign) &&
-                    (binaryExpression.Left.NodeType == ExpressionType.Parameter) &&
-                    ((_currentBlock == null) || _currentBlock.Expressions.Contains(binaryExpression)) &&
-                    !_assignedVariables.Contains(binaryExpression.Left) &&
-                    !_assignedAssignments.Contains(binaryExpression))
+                if (binaryExpression.NodeType == ExpressionType.Assign)
                 {
-                    var variable = (ParameterExpression)binaryExpression.Left;
+                    _assignedValues.Add(binaryExpression.Right);
 
-                    if (VariableHasNotYetBeenAccessed(variable))
+                    if ((binaryExpression.Left.NodeType == ExpressionType.Parameter) &&
+                        ((_currentBlock == null) || _currentBlock.Expressions.Contains(binaryExpression)) &&
+                        !_assignedVariables.Contains(binaryExpression.Left) &&
+                        !_assignedAssignments.Contains(binaryExpression))
                     {
-                        _joinedAssignments.Add(binaryExpression);
-                        _accessedVariables.Add(variable);
-                        _assignedVariables.Add(variable);
-                    }
+                        var variable = (ParameterExpression)binaryExpression.Left;
 
-                    AddAssignmentIfAppropriate(binaryExpression.Right);
+                        if (VariableHasNotYetBeenAccessed(variable))
+                        {
+                            _joinedAssignments.Add(binaryExpression);
+                            _accessedVariables.Add(variable);
+                            _assignedVariables.Add(variable);
+                        }
+
+                        AddAssignmentIfAppropriate(binaryExpression.Right);
+                    }
                 }
 
                 return base.VisitBinary(binaryExpression);

ReadableExpressions/Translators/AssignmentExpressionTranslator.cs

@@ -49,38 +49,29 @@ internal string GetAssignment(
             TranslationContext context)
         {
             var symbol = _symbolsByNodeType[assignmentType];
-            var valueString = GetValueTranslation(value, context);
 
-            switch (value.NodeType)
-            {
-                case ExpressionType.Assign:
-                case ExpressionType.Block:
-                    if (valueString.EndsWith(';'))
-                    {
-                        valueString = valueString.Substring(0, valueString.Length - 1);
-                    }
-
-                    if (!valueString.HasSurroundingParentheses())
-                    {
-                        valueString = valueString.WithSurroundingParentheses();
-                    }
-
-                    break;
-
-                default:
-                    valueString = valueString.WithoutSurroundingParentheses(value);
-                    break;
-
-            }
+            var valueString = (value.NodeType == ExpressionType.Default)
+                ? _defaultTranslator.Translate((DefaultExpression)value)
+                : GetValueTranslation(value, context);
 
             return $"{target} {symbol} {valueString}";
         }
 
         private string GetValueTranslation(Expression value, TranslationContext context)
         {
-            return (value.NodeType != ExpressionType.Default)
-                ? context.GetTranslation(value)
-                : _defaultTranslator.Translate((DefaultExpression)value);
+            var valueBlock = GetTranslatedExpressionBody(value, context);
+
+            if (valueBlock.IsASingleStatement)
+            {
+                return valueBlock.WithoutParentheses().Unterminated();
+            }
+
+            if (value.NodeType == ExpressionType.Lambda)
+            {
+                return valueBlock.WithoutParentheses();
+            }
+
+            return valueBlock.WithReturn().WithParentheses();
         }
     }
 }