ToCsharpCode: format block inside expression in {}

It's not valid C# code, but neither was it valid before this change.
This makes the code eaiser to read (IMHO), since the block scope
is clearly visible.

Author: exyi

Diff for: src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -6760,7 +6760,7 @@ internal static StringBuilder ToCSharpString(this Expression e, StringBuilder sb
                     {
                         var x = (ConstantExpression)e;
                         if (x.Value == null)
-                            return x.Type != null
+                            return x.Type != null && x.Type.IsValueType
                                 ? sb.Append("default(").Append(x.Type.ToCode(stripNamespace, printType)).Append(')')
                                 : sb.Append("null");
 
@@ -6948,7 +6948,8 @@ internal static StringBuilder ToCSharpString(this Expression e, StringBuilder sb
                             sb.NewLineIdentCs(body, EnclosedIn.LambdaBody, lineIdent + identSpaces, stripNamespace, printType, identSpaces, notRecognizedToCode);
                         else
                         {
-                            sb.NewLine(lineIdent, identSpaces).Append('{');
+                            sb.NewLineIdent(lineIdent).Append('{');
+
                             // Body handles `;` itself
                             if (body is BlockExpression bb)
                                 bb.BlockToCSharpString(sb, lineIdent + identSpaces, stripNamespace, printType, identSpaces, notRecognizedToCode,
@@ -6959,7 +6960,7 @@ internal static StringBuilder ToCSharpString(this Expression e, StringBuilder sb
                                 if (isBodyExpression)
                                     sb.AddSemicolonIfFits();
                             }
-                            sb.NewLine(lineIdent, identSpaces).Append('}');
+                            sb.NewLineIdent(lineIdent).Append('}');
                         }
                         return sb.Append(')');
                     }
@@ -7011,7 +7012,14 @@ internal static StringBuilder ToCSharpString(this Expression e, StringBuilder sb
                     }
                 case ExpressionType.Block:
                     {
-                        return BlockToCSharpString((BlockExpression)e, sb, lineIdent, stripNamespace, printType, identSpaces, notRecognizedToCode: notRecognizedToCode);
+                        if (enclosedIn == EnclosedIn.Block)
+                            return BlockToCSharpString((BlockExpression)e, sb, lineIdent, stripNamespace, printType, identSpaces, notRecognizedToCode: notRecognizedToCode);
+                        else
+                        {
+                            sb.Append('{');
+                            BlockToCSharpString((BlockExpression)e, sb, lineIdent + identSpaces, stripNamespace, printType, identSpaces, notRecognizedToCode: notRecognizedToCode);
+                            return sb.AddSemicolonIfFits().NewLineIdent(lineIdent).Append('}');
+                        }
                     }
                 case ExpressionType.Loop:
                     {
@@ -7162,11 +7170,12 @@ void PrintPart(Expression part)
                     }
                 case ExpressionType.Default:
                     {
-                        return e.Type == typeof(void) ? sb // `default(void)` does not make sense in the C#
-                            : sb.Append("default(").Append(e.Type.ToCode(stripNamespace, printType)).Append(')');
+                        return e.Type == typeof(void) ? sb : // `default(void)` does not make sense in the C#
+                            !e.Type.IsValueType && !e.Type.IsGenericParameter ? sb.Append("null") :
+                            sb.Append("default(").Append(e.Type.ToCode(stripNamespace, printType)).Append(')');
                     }
                 case ExpressionType.TypeIs:
-                case ExpressionType.TypeEqual:
+                case ExpressionType.TypeEqual: // TODO: type equal
                     {
                         var x = (TypeBinaryExpression)e;
                         sb.Append('(');
@@ -8118,3 +8127,4 @@ public RequiresUnreferencedCodeAttribute(string message)
     }
 }
 #endif
+}

Diff for: test/FastExpressionCompiler.UnitTests/FastExpressionCompiler.UnitTests.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <TargetFrameworks>net472;net7.0</TargetFrameworks>
+        <TargetFrameworks>net472;net6.0</TargetFrameworks>
     </PropertyGroup>
 
     <ItemGroup>

Diff for: test/FastExpressionCompiler.UnitTests/ToCSharpStringTests.cs

@@ -31,6 +31,35 @@ public void Outputs_closed_generic_type_constant_correctly()
             Assert.AreEqual(typeof(A<string>), f());
         }
 
+        [Test]
+        public void Outputs_default_reference_type_is_just_null()
+        {
+            var cs = Default(typeof(string)).ToCSharpString();
+            Assert.AreEqual("null;", cs);
+
+            cs = Default(typeof(System.Collections.Generic.List<string>)).ToCSharpString();
+            Assert.AreEqual("null;", cs);
+        }
+
+        [Test]
+        public void Somehow_handles_block_in_expression()
+        {
+            // it's probably not possible to output compilable C# for expressions like this, but at least it can be easy to read
+            var variable = Parameter(typeof(int), "variable");
+            var cs = Add(Constant(1), Block(new [] { variable },
+                Assign(variable, Constant(2)),
+                variable
+            )).ToCSharpString();
+            Assert.AreEqual("""
+                    (1 + {
+                        int variable;
+                        variable = 2;
+                        variable;
+                    });
+                    """, cs);
+        }
+
+
         class A<X> {}
     }
-}
+}