related to #487: removing parens for the root expr in some cases; removing end ; from the ToCSharpString; add ; in PrintCSharp; avoid unnecessary ; after braced blocks; avoid double ;; at last block expr.

Maksim Volkau · Maksim Volkau · commit cbe93480e9c1 · 2026-02-26T10:54:40.000+01:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -33,6 +33,7 @@
         "Ldtoken",
         "Ldvirtftn",
         "Maksim",
+        "NETCOREAPP",
         "NETFRAMEWORK",
         "Newarr",
         "Newobj",
diff --git a/src/FastExpressionCompiler/FastExpressionCompiler.cs b/src/FastExpressionCompiler/FastExpressionCompiler.cs
@@ -8226,7 +8226,7 @@ public static string GetArithmeticBinaryOperatorMethodName(this ExpressionType n
         };
 
         [MethodImpl((MethodImplOptions)256)]
-        internal static bool IsBlockLike(this ExpressionType nodeType) =>
+        internal static bool IsBracedBlockLike(this ExpressionType nodeType) =>
             nodeType == ExpressionType.Try |
             nodeType == ExpressionType.Switch |
             nodeType == ExpressionType.Block |
@@ -8237,12 +8237,12 @@ internal static bool IsReturnable(this ExpressionType nodeType) =>
             nodeType != ExpressionType.Goto &
             nodeType != ExpressionType.Label &
             nodeType != ExpressionType.Throw &&
-            !IsBlockLike(nodeType);
+            !IsBracedBlockLike(nodeType);
 
         [MethodImpl((MethodImplOptions)256)]
         internal static bool IsBlockLikeOrConditional(this ExpressionType nodeType) =>
             nodeType == ExpressionType.Conditional | nodeType == ExpressionType.Coalesce ||
-            IsBlockLike(nodeType);
+            IsBracedBlockLike(nodeType);
 
         internal static Expression StripConvertRecursively(this Expression expr) =>
             expr is UnaryExpression convert && convert.NodeType == ExpressionType.Convert
@@ -9940,11 +9940,11 @@ public static class ToCSharpPrinter
     {
         /// <summary>Tries hard to convert the expression into the valid C# code. Avoids parens by default for the root expr.</summary>
         public static string ToCSharpString(this Expression expr, EnclosedIn enclosedIn = EnclosedIn.AvoidParens) =>
-            expr.ToCSharpString(new StringBuilder(1024), enclosedIn, stripNamespace: true).Append(';').ToString();
+            expr.ToCSharpString(new StringBuilder(1024), enclosedIn, stripNamespace: true).ToString();
 
         /// <summary>Tries hard to convert the expression into the valid C# code. Avoids parens by default for the root expr.</summary>
         public static string ToCSharpString(this Expression expr, ObjectToCode notRecognizedToCode, EnclosedIn enclosedIn = EnclosedIn.AvoidParens) =>
-            expr.ToCSharpString(new StringBuilder(1024), stripNamespace: true, notRecognizedToCode: notRecognizedToCode).Append(';').ToString();
+            expr.ToCSharpString(new StringBuilder(1024), stripNamespace: true, notRecognizedToCode: notRecognizedToCode).ToString();
 
         /// <summary>Tries hard to convert the expression into the valid C# code</summary>
         public static StringBuilder ToCSharpString(this Expression e, StringBuilder sb, EnclosedIn enclosedIn = EnclosedIn.ParensByDefault,
@@ -10421,7 +10421,7 @@ void PrintPart(Expression part, ref TNamed named)
                                     sb.Append("return ");
                                 part.ToCSharpString(sb, EnclosedIn.AvoidParens, ref named,
                                     incIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode);
-                                sb.AppendSemicolonOnce();
+                                sb.AppendSemicolonOnce(part);
                             }
                         }
 
@@ -10546,13 +10546,13 @@ void PrintPart(Expression part, ref TNamed named)
                                 {
                                     var bodyIn = caseBody.Type != typeof(void) ? EnclosedIn.Return : EnclosedIn.AvoidParens;
                                     caseBody.ToCSharpString(bodyIn == EnclosedIn.Return ? sb.Append("return ") : sb, bodyIn, ref named,
-                                        caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();
+                                        caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(caseBody);
                                 }
                             }
                             else
                             {
                                 caseBody.ToCSharpString(sb, enclosedIn, ref named,
-                                    caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();
+                                    caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(caseBody);
                                 sb.NewLineIndent(caseBodyIndent).Append("break;");
                             }
                         }
@@ -10571,13 +10571,13 @@ void PrintPart(Expression part, ref TNamed named)
                                 {
                                     var bodyIn = defaultBody.Type != typeof(void) ? EnclosedIn.Return : EnclosedIn.AvoidParens;
                                     defaultBody.ToCSharpString(bodyIn == EnclosedIn.Return ? sb.Append("return ") : sb, bodyIn, ref named,
-                                        caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();
+                                        caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(defaultBody);
                                 }
                             }
                             else
                             {
                                 defaultBody.ToCSharpString(sb, enclosedIn, ref named,
-                                    caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();
+                                    caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(defaultBody);
                                 sb.NewLineIndent(caseBodyIndent).Append("break;");
                             }
                         }
@@ -10831,7 +10831,7 @@ private static StringBuilder ToCSharpBlock<TNamed>(this Expression expr, StringB
                 sb.NewLineIndent(lineIndent + indentSpaces);
                 sb = expr?.ToCSharpString(sb, EnclosedIn.ParensByDefault, ref named,
                     lineIndent + indentSpaces, stripNamespace, printType, indentSpaces, notRecognizedToCode) ?? sb.Append("null");
-                sb.AppendSemicolonOnce();
+                sb.AppendSemicolonOnce(expr);
             }
             return sb.NewLineIndent(lineIndent).Append('}');
         }
@@ -10841,7 +10841,7 @@ private static StringBuilder ToCSharpExpression<TNamed>(this Expression expr,
             bool newLineExpr, int lineIndent, bool stripNamespace, Func<Type, string, string> printType, int indentSpaces, ObjectToCode notRecognizedToCode)
             where TNamed : struct, ISmallList<NamedWithIndex>
         {
-            if (!expr.NodeType.IsBlockLike())
+            if (!expr.NodeType.IsBracedBlockLike())
             {
                 if (!newLineExpr)
                     return expr.ToCSharpString(sb, enclosedIn, ref named,
@@ -10870,8 +10870,8 @@ private static StringBuilder ToCSharpExpression<TNamed>(this Expression expr,
             return sb.NewLineIndent(lineIndent).Append("})");
         }
 
-        internal static StringBuilder AppendSemicolonOnce(this StringBuilder sb) =>
-            sb[sb.Length - 1] != ';' ? sb.Append(";") : sb;
+        internal static StringBuilder AppendSemicolonOnce(this StringBuilder sb, Expression expr = null) =>
+            expr?.NodeType.IsBracedBlockLike() == true ? sb : sb[sb.Length - 1] != ';' ? sb.Append(";") : sb;
 
         internal static StringBuilder AppendNewLineOnce(this StringBuilder sb)
         {
@@ -11099,7 +11099,7 @@ private static StringBuilder BlockToCSharpString<TNamed>(this BlockExpression b,
                 }
             }
 
-            if (lastExpr.NodeType.IsBlockLike() ||
+            if (lastExpr.NodeType.IsBracedBlockLike() ||
                 lastExpr is DefaultExpression d && d.Type == typeof(void))
             {
                 lastExpr.ToCSharpString(sb, EnclosedIn.Block, ref named,
diff --git a/src/FastExpressionCompiler/TestTools.cs b/src/FastExpressionCompiler/TestTools.cs
@@ -90,7 +90,7 @@ public static void PrintExpression(this IDelegateDebugInfo debugInfo, bool compl
         [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "") =>
         PrintExpression(debugInfo.Expression, completeTypeNames, caller, filePath);
 
-    public static void PrintCSharp(this Expression expr, bool completeTypeNames = false,
+    public static void PrintCSharp(this Expression expr, bool completeTypeNames = false, bool stripNamespace = true,
         [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "")
     {
         if (!AllowPrintIL) return;
@@ -107,45 +107,51 @@ public static void PrintCSharp(this Expression expr, bool completeTypeNames = fa
         sb.Append("var @cs = ");
         sb = expr.ToCSharpString(sb,
             lineIndent: 0,
-            stripNamespace: true,
+            stripNamespace: stripNamespace,
             printType: completeTypeNames ? null : CodePrinter.PrintTypeStripOuterClasses,
             indentSpaces: 4);
-        sb.Append(';');
+        sb.AppendSemicolonOnce();
         Console.WriteLine(sb.ToString());
     }
 
-    public static void PrintCSharp(this Expression expr, Func<string, string> transform,
+    public static void PrintCSharp(this Expression expr, Func<string, string> transform, bool stripNamespace = true,
         [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "")
     {
         if (!AllowPrintCS) return;
         Console.WriteLine();
         Console.WriteLine($"//{Path.GetFileNameWithoutExtension(filePath)}.{caller}");
-        Console.WriteLine(transform(expr.ToCSharpString()));
+        var sb = expr.ToCSharpString(new StringBuilder(1024), ToCSharpPrinter.EnclosedIn.AvoidParens, stripNamespace: stripNamespace).AppendSemicolonOnce();
+        var str = transform(sb.ToString());
+        Console.WriteLine(str);
     }
 
-    public static void PrintCSharp(this Expression expr, CodePrinter.ObjectToCode objectToCode,
+    public static void PrintCSharp(this Expression expr, CodePrinter.ObjectToCode objectToCode, bool stripNamespace = true,
         [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "")
     {
         if (!AllowPrintCS) return;
 
         Console.WriteLine();
         Console.WriteLine($"//{Path.GetFileNameWithoutExtension(filePath)}.{caller}");
-        Console.WriteLine(expr.ToCSharpString(objectToCode));
+        var sb = expr.ToCSharpString(new StringBuilder(1024), ToCSharpPrinter.EnclosedIn.AvoidParens, notRecognizedToCode: objectToCode, stripNamespace: stripNamespace).AppendSemicolonOnce();
+        var str = sb.ToString();
+        Console.WriteLine(str);
     }
 
-    public static void PrintCSharp(this Expression expr, ref string result)
+    public static void PrintCSharp(this Expression expr, ref string result, bool stripNamespace = true)
     {
         if (!AllowPrintCS) return;
-        Console.WriteLine(result = expr.ToCSharpString());
+        var sb = expr.ToCSharpString(new StringBuilder(1024), ToCSharpPrinter.EnclosedIn.AvoidParens, stripNamespace: stripNamespace).AppendSemicolonOnce();
+        result = sb.ToString();
+        Console.WriteLine(result);
     }
 
     /// <summary>The method outputs the whole code of the expression including the code of the nested lambdas.
     /// In case of nested lambda represented in the expression of the Constant Delegate, 
     /// and the Delegate.Target being IDelegateDebugInfo, you may call `IDelegateDebugInfo.EnumerateNestedLambdas()`
     /// and output C# for each nested lambda</summary>
-    public static void PrintCSharp(this IDelegateDebugInfo debugInfo, bool completeTypeNames = false,
+    public static void PrintCSharp(this IDelegateDebugInfo debugInfo, bool completeTypeNames = false, bool stripNamespace = true,
         [CallerMemberName] string caller = "", [CallerFilePath] string filePath = "") =>
-        debugInfo.Expression.PrintCSharp(completeTypeNames, caller, filePath);
+        debugInfo.Expression.PrintCSharp(completeTypeNames, stripNamespace, caller, filePath);
 
     public static void PrintIL(this Delegate dlg, [CallerMemberName] string tag = null, ILFormat format = ILFormat.Default)
     {
diff --git a/test/FastExpressionCompiler.IssueTests/Issue458_Support_TryFault.cs b/test/FastExpressionCompiler.IssueTests/Issue458_Support_TryFault.cs
@@ -67,6 +67,7 @@ public void Original_case2()
         );
 
         expr.PrintCSharp();
+
         // outputs
         var @cs = (Func<int>)(() => //int
         {
@@ -87,7 +88,6 @@ public void Original_case2()
                         x = 2;
                     }
                 }
-                ;
             }
             catch (Exception)
             {
diff --git a/test/FastExpressionCompiler.IssueTests/Issue487_Fix_ToCSharpString_output_for_boolean_equality_expressions.cs b/test/FastExpressionCompiler.IssueTests/Issue487_Fix_ToCSharpString_output_for_boolean_equality_expressions.cs
@@ -30,20 +30,17 @@ public class TestClass
     public void Original_case(TestContext t)
     {
         var input = new TestClass() { MyTestBool = true };
-        var parameter = Expression.Parameter(input.GetType(), "x");
-        var property = Expression.Property(parameter, nameof(TestClass.MyTestBool));
-        var expr = Expression.Equal(property, Expression.Constant(true));
+        var parameter = Parameter(input.GetType(), "x");
+        var property = Property(parameter, nameof(TestClass.MyTestBool));
+        var expr = Equal(property, Constant(true));
 
-        var str = expr.ToString(); // => (x.MyTestBool == True)
-        var cs = expr.ToCSharpString(); // => (x.MyTestBool;
+        var str = expr.ToString();
+        t.AreEqual("(x.MyTestBool == True)", str);
 
-        expr.PrintCSharp();
-
-        // var fs = expr.CompileSys();
-        // fs.PrintIL(format: ILDecoder.ILFormat.AssertOpCodes);
+        var cs = expr.ToCSharpString();
+        t.AreEqual("x.MyTestBool", cs);
 
-        // var ff = expr.CompileFast(false);
-        // ff.PrintIL(format: ILDecoder.ILFormat.AssertOpCodes);
+        expr.PrintCSharp();
     }
 }
 #endif
diff --git a/test/FastExpressionCompiler.TestsRunner/Program.cs b/test/FastExpressionCompiler.TestsRunner/Program.cs
@@ -14,8 +14,9 @@ public static void Main()
             // ILGeneratorTools.DisableILGeneratorPooling = true;
             // LightExpression.ILGeneratorTools.DisableILGeneratorPooling = true;
 
-            // new Issue127_Switch_is_supported().Run();
+            new Issue458_Support_TryFault().Run();
 
+            // new Issue127_Switch_is_supported().Run();
             // new Issue316_in_parameter().Run();
             // new LightExpression.IssueTests.Issue347_InvalidProgramException_on_compiling_an_expression_that_returns_a_record_which_implements_IList().Run();
             // new LightExpression.UnitTests.NestedLambdasSharedToExpressionCodeStringTest().Run();
diff --git a/test/FastExpressionCompiler.UnitTests/ToCSharpStringTests.cs b/test/FastExpressionCompiler.UnitTests/ToCSharpStringTests.cs
@@ -42,22 +42,22 @@ public void Outputs_type_equals()
             var eArray = TypeEqual(p, typeof(object[]));
             var eOpen = TypeEqual(p, typeof(System.Collections.Generic.List<string>));
 
-            Asserts.AreEqual("(p is string);", eSealed.ToCSharpString());
-            Asserts.AreEqual("(p is int);", eStruct.ToCSharpString());
-            Asserts.AreEqual("(p.GetType() == typeof(object[]));", eArray.ToCSharpString());
-            Asserts.AreEqual("(p.GetType() == typeof(List<string>));", eOpen.ToCSharpString());
+            Asserts.AreEqual("(p is string)", eSealed.ToCSharpString());
+            Asserts.AreEqual("(p is int)", eStruct.ToCSharpString());
+            Asserts.AreEqual("(p.GetType() == typeof(object[]))", eArray.ToCSharpString());
+            Asserts.AreEqual("(p.GetType() == typeof(List<string>))", eOpen.ToCSharpString());
         }
 
         public void Outputs_default_null_for_reference_types()
         {
-            Asserts.AreEqual("(string)null;", Constant(null, typeof(string)).ToCSharpString());
-            Asserts.AreEqual("(string)null;", Default(typeof(string)).ToCSharpString());
-            Asserts.AreEqual("(List<string>)null;", Constant(null, typeof(System.Collections.Generic.List<string>)).ToCSharpString());
-            Asserts.AreEqual("(List<string>)null;", Default(typeof(System.Collections.Generic.List<string>)).ToCSharpString());
-            Asserts.AreEqual("(int?)null;", Constant(null, typeof(int?)).ToCSharpString());
-            Asserts.AreEqual("(int?)null;", Default(typeof(int?)).ToCSharpString());
+            Asserts.AreEqual("(string)null", Constant(null, typeof(string)).ToCSharpString());
+            Asserts.AreEqual("(string)null", Default(typeof(string)).ToCSharpString());
+            Asserts.AreEqual("(List<string>)null", Constant(null, typeof(System.Collections.Generic.List<string>)).ToCSharpString());
+            Asserts.AreEqual("(List<string>)null", Default(typeof(System.Collections.Generic.List<string>)).ToCSharpString());
+            Asserts.AreEqual("(int?)null", Constant(null, typeof(int?)).ToCSharpString());
+            Asserts.AreEqual("(int?)null", Default(typeof(int?)).ToCSharpString());
 
-            Asserts.AreEqual("default(int);", Default(typeof(int)).ToCSharpString());
+            Asserts.AreEqual("default(int)", Default(typeof(int)).ToCSharpString());
 
             var e = Block(
                 new[] { Variable(typeof(int), "integer"), Variable(typeof(int?), "maybe_integer"), Variable(typeof(string), "str") },
@@ -67,7 +67,7 @@ public void Outputs_default_null_for_reference_types()
             Asserts.AreEqual(
                 "int integer = default;" + Environment.NewLine +
                 "int? maybe_integer = null;" + Environment.NewLine +
-                "string str = null;;",
+                "string str = null;",
                 e.ToCSharpString().Trim());
         }
 

Original file line number	Diff line number	Diff line change
`@@ -8226,7 +8226,7 @@ public static string GetArithmeticBinaryOperatorMethodName(this ExpressionType n`
`8226`	`8226`	`};`
`8227`	`8227`
`8228`	`8228`	`[MethodImpl((MethodImplOptions)256)]`
`8229`		`- internal static bool IsBlockLike(this ExpressionType nodeType) =>`
	`8229`	`+ internal static bool IsBracedBlockLike(this ExpressionType nodeType) =>`
`8230`	`8230`	`nodeType == ExpressionType.Try \|`
`8231`	`8231`	`nodeType == ExpressionType.Switch \|`
`8232`	`8232`	`nodeType == ExpressionType.Block \|`
`@@ -8237,12 +8237,12 @@ internal static bool IsReturnable(this ExpressionType nodeType) =>`
`8237`	`8237`	`nodeType != ExpressionType.Goto &`
`8238`	`8238`	`nodeType != ExpressionType.Label &`
`8239`	`8239`	`nodeType != ExpressionType.Throw &&`
`8240`		`- !IsBlockLike(nodeType);`
	`8240`	`+ !IsBracedBlockLike(nodeType);`
`8241`	`8241`
`8242`	`8242`	`[MethodImpl((MethodImplOptions)256)]`
`8243`	`8243`	`internal static bool IsBlockLikeOrConditional(this ExpressionType nodeType) =>`
`8244`	`8244`	`nodeType == ExpressionType.Conditional \| nodeType == ExpressionType.Coalesce \|\|`
`8245`		`- IsBlockLike(nodeType);`
	`8245`	`+ IsBracedBlockLike(nodeType);`
`8246`	`8246`
`8247`	`8247`	`internal static Expression StripConvertRecursively(this Expression expr) =>`
`8248`	`8248`	`expr is UnaryExpression convert && convert.NodeType == ExpressionType.Convert`
`@@ -9940,11 +9940,11 @@ public static class ToCSharpPrinter`
`9940`	`9940`	`{`
`9941`	`9941`	`/// <summary>Tries hard to convert the expression into the valid C# code. Avoids parens by default for the root expr.</summary>`
`9942`	`9942`	`public static string ToCSharpString(this Expression expr, EnclosedIn enclosedIn = EnclosedIn.AvoidParens) =>`
`9943`		`- expr.ToCSharpString(new StringBuilder(1024), enclosedIn, stripNamespace: true).Append(';').ToString();`
	`9943`	`+ expr.ToCSharpString(new StringBuilder(1024), enclosedIn, stripNamespace: true).ToString();`
`9944`	`9944`
`9945`	`9945`	`/// <summary>Tries hard to convert the expression into the valid C# code. Avoids parens by default for the root expr.</summary>`
`9946`	`9946`	`public static string ToCSharpString(this Expression expr, ObjectToCode notRecognizedToCode, EnclosedIn enclosedIn = EnclosedIn.AvoidParens) =>`
`9947`		`- expr.ToCSharpString(new StringBuilder(1024), stripNamespace: true, notRecognizedToCode: notRecognizedToCode).Append(';').ToString();`
	`9947`	`+ expr.ToCSharpString(new StringBuilder(1024), stripNamespace: true, notRecognizedToCode: notRecognizedToCode).ToString();`
`9948`	`9948`
`9949`	`9949`	`/// <summary>Tries hard to convert the expression into the valid C# code</summary>`
`9950`	`9950`	`public static StringBuilder ToCSharpString(this Expression e, StringBuilder sb, EnclosedIn enclosedIn = EnclosedIn.ParensByDefault,`
`@@ -10421,7 +10421,7 @@ void PrintPart(Expression part, ref TNamed named)`
`10421`	`10421`	`sb.Append("return ");`
`10422`	`10422`	`part.ToCSharpString(sb, EnclosedIn.AvoidParens, ref named,`
`10423`	`10423`	`incIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode);`
`10424`		`- sb.AppendSemicolonOnce();`
	`10424`	`+ sb.AppendSemicolonOnce(part);`
`10425`	`10425`	`}`
`10426`	`10426`	`}`
`10427`	`10427`
`@@ -10546,13 +10546,13 @@ void PrintPart(Expression part, ref TNamed named)`
`10546`	`10546`	`{`
`10547`	`10547`	`var bodyIn = caseBody.Type != typeof(void) ? EnclosedIn.Return : EnclosedIn.AvoidParens;`
`10548`	`10548`	`caseBody.ToCSharpString(bodyIn == EnclosedIn.Return ? sb.Append("return ") : sb, bodyIn, ref named,`
`10549`		`- caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();`
	`10549`	`+ caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(caseBody);`
`10550`	`10550`	`}`
`10551`	`10551`	`}`
`10552`	`10552`	`else`
`10553`	`10553`	`{`
`10554`	`10554`	`caseBody.ToCSharpString(sb, enclosedIn, ref named,`
`10555`		`- caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();`
	`10555`	`+ caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(caseBody);`
`10556`	`10556`	`sb.NewLineIndent(caseBodyIndent).Append("break;");`
`10557`	`10557`	`}`
`10558`	`10558`	`}`
`@@ -10571,13 +10571,13 @@ void PrintPart(Expression part, ref TNamed named)`
`10571`	`10571`	`{`
`10572`	`10572`	`var bodyIn = defaultBody.Type != typeof(void) ? EnclosedIn.Return : EnclosedIn.AvoidParens;`
`10573`	`10573`	`defaultBody.ToCSharpString(bodyIn == EnclosedIn.Return ? sb.Append("return ") : sb, bodyIn, ref named,`
`10574`		`- caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();`
	`10574`	`+ caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(defaultBody);`
`10575`	`10575`	`}`
`10576`	`10576`	`}`
`10577`	`10577`	`else`
`10578`	`10578`	`{`
`10579`	`10579`	`defaultBody.ToCSharpString(sb, enclosedIn, ref named,`
`10580`		`- caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce();`
	`10580`	`+ caseBodyIndent, stripNamespace, printType, indentSpaces, notRecognizedToCode).AppendSemicolonOnce(defaultBody);`
`10581`	`10581`	`sb.NewLineIndent(caseBodyIndent).Append("break;");`
`10582`	`10582`	`}`
`10583`	`10583`	`}`
`@@ -10831,7 +10831,7 @@ private static StringBuilder ToCSharpBlock<TNamed>(this Expression expr, StringB`
`10831`	`10831`	`sb.NewLineIndent(lineIndent + indentSpaces);`
`10832`	`10832`	`sb = expr?.ToCSharpString(sb, EnclosedIn.ParensByDefault, ref named,`
`10833`	`10833`	`lineIndent + indentSpaces, stripNamespace, printType, indentSpaces, notRecognizedToCode) ?? sb.Append("null");`
`10834`		`- sb.AppendSemicolonOnce();`
	`10834`	`+ sb.AppendSemicolonOnce(expr);`
`10835`	`10835`	`}`
`10836`	`10836`	`return sb.NewLineIndent(lineIndent).Append('}');`
`10837`	`10837`	`}`
`@@ -10841,7 +10841,7 @@ private static StringBuilder ToCSharpExpression<TNamed>(this Expression expr,`
`10841`	`10841`	`bool newLineExpr, int lineIndent, bool stripNamespace, Func<Type, string, string> printType, int indentSpaces, ObjectToCode notRecognizedToCode)`
`10842`	`10842`	`where TNamed : struct, ISmallList<NamedWithIndex>`
`10843`	`10843`	`{`
`10844`		`- if (!expr.NodeType.IsBlockLike())`
	`10844`	`+ if (!expr.NodeType.IsBracedBlockLike())`
`10845`	`10845`	`{`
`10846`	`10846`	`if (!newLineExpr)`
`10847`	`10847`	`return expr.ToCSharpString(sb, enclosedIn, ref named,`
`@@ -10870,8 +10870,8 @@ private static StringBuilder ToCSharpExpression<TNamed>(this Expression expr,`
`10870`	`10870`	`return sb.NewLineIndent(lineIndent).Append("})");`
`10871`	`10871`	`}`
`10872`	`10872`
`10873`		`- internal static StringBuilder AppendSemicolonOnce(this StringBuilder sb) =>`
`10874`		`- sb[sb.Length - 1] != ';' ? sb.Append(";") : sb;`
	`10873`	`+ internal static StringBuilder AppendSemicolonOnce(this StringBuilder sb, Expression expr = null) =>`
	`10874`	`+ expr?.NodeType.IsBracedBlockLike() == true ? sb : sb[sb.Length - 1] != ';' ? sb.Append(";") : sb;`
`10875`	`10875`
`10876`	`10876`	`internal static StringBuilder AppendNewLineOnce(this StringBuilder sb)`
`10877`	`10877`	`{`
`@@ -11099,7 +11099,7 @@ private static StringBuilder BlockToCSharpString<TNamed>(this BlockExpression b,`
`11099`	`11099`	`}`
`11100`	`11100`	`}`
`11101`	`11101`
`11102`		`- if (lastExpr.NodeType.IsBlockLike() \|\|`
	`11102`	`+ if (lastExpr.NodeType.IsBracedBlockLike() \|\|`
`11103`	`11103`	`lastExpr is DefaultExpression d && d.Type == typeof(void))`
`11104`	`11104`	`{`
`11105`	`11105`	`lastExpr.ToCSharpString(sb, EnclosedIn.Block, ref named,`
Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,7 @@ public void Original_case2()`
`67`	`67`	`);`
`68`	`68`
`69`	`69`	`expr.PrintCSharp();`
	`70`	`+`
`70`	`71`	`// outputs`
`71`	`72`	`var @cs = (Func<int>)(() => //int`
`72`	`73`	`{`
`@@ -87,7 +88,6 @@ public void Original_case2()`
`87`	`88`	`x = 2;`
`88`	`89`	`}`
`89`	`90`	`}`
`90`		`- ;`
`91`	`91`	`}`
`92`	`92`	`catch (Exception)`
`93`	`93`	`{`