Fix Issue #803: Use relational patterns in switch statements

- Modifies `MethodBodyExecutableStatementVisitor` to generate `RelationalPatternSyntax` instead of `VarPattern` with a `when` clause for VB `RelationalCaseClauseSyntax`.
- Adds helper `GetRelationalTokenKind` to map VB syntax kinds to the appropriate C# relational operators.
- Added corresponding unit test demonstrating the new output.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: GrahamTheCoder

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -844,11 +844,16 @@ public override async Task<SyntaxList<StatementSyntax>> VisitSelectBlock(VBSynta
                         caseSwitchLabelSyntax = WrapInCasePatternSwitchLabelSyntax(node, relational.Value, csRelationalValue, false, operatorKind);
                     }
                     else {
-                        var varName = CommonConversions.CsEscapedIdentifier(GetUniqueVariableNameInScope(node, "case"));
-                        ExpressionSyntax csLeft = ValidSyntaxFactory.IdentifierName(varName);
                         csRelationalValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(relational.Value, csRelationalValue);
-                        var binaryExp = SyntaxFactory.BinaryExpression(operatorKind.ConvertToken(), csLeft, csRelationalValue);
-                        caseSwitchLabelSyntax = VarWhen(varName, binaryExp);
+                        PatternSyntax pattern;
+                        if (operatorKind == VBasic.SyntaxKind.CaseEqualsClause) {
+                            pattern = SyntaxFactory.ConstantPattern(csRelationalValue);
+                        } else if (operatorKind == VBasic.SyntaxKind.CaseNotEqualsClause) {
+                            pattern = SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), SyntaxFactory.ConstantPattern(csRelationalValue));
+                        } else {
+                            pattern = SyntaxFactory.RelationalPattern(SyntaxFactory.Token(GetRelationalTokenKind(operatorKind)), csRelationalValue);
+                        }
+                        caseSwitchLabelSyntax = SyntaxFactory.CasePatternSwitchLabel(pattern, null, SyntaxFactory.Token(SyntaxKind.ColonToken));
                     }
                     labels.Add(caseSwitchLabelSyntax);
                 } else if (c is VBSyntax.RangeCaseClauseSyntax range) {
@@ -1201,4 +1206,12 @@ private static SyntaxList<StatementSyntax> SingleStatement(ExpressionSyntax expr
     {
         return SyntaxFactory.SingletonList<StatementSyntax>(SyntaxFactory.ExpressionStatement(expression));
     }
+
+    private static SyntaxKind GetRelationalTokenKind(VBasic.SyntaxKind caseClauseKind) => caseClauseKind switch {
+        VBasic.SyntaxKind.CaseLessThanClause => SyntaxKind.LessThanToken,
+        VBasic.SyntaxKind.CaseLessThanOrEqualClause => SyntaxKind.LessThanEqualsToken,
+        VBasic.SyntaxKind.CaseGreaterThanOrEqualClause => SyntaxKind.GreaterThanEqualsToken,
+        VBasic.SyntaxKind.CaseGreaterThanClause => SyntaxKind.GreaterThanToken,
+        _ => throw new ArgumentOutOfRangeException(nameof(caseClauseKind), caseClauseKind, null)
+    };
 }

Tests/CSharp/StatementTests/MethodStatementTests_803.cs

@@ -0,0 +1,68 @@
+using System.Threading.Tasks;
+using ICSharpCode.CodeConverter.Tests.TestRunners;
+using Xunit;
+
+namespace ICSharpCode.CodeConverter.Tests.CSharp.StatementTests;
+
+public class MethodStatementTests_803 : ConverterTestBase
+{
+    [Fact]
+    public async Task Issue803_SelectCaseWithRelationalPatternAsync()
+    {
+        await TestConversionVisualBasicToCSharpAsync(@"Class TestClass
+    Private Sub TestMethod(ByVal Breite As Integer)
+        Dim Rollo_FederUmdrehungen_Berechnen As Integer
+        Select Case Breite
+          Case Is < 1000
+            Rollo_FederUmdrehungen_Berechnen = 12
+          Case Is < 1200
+            Rollo_FederUmdrehungen_Berechnen = 15
+          Case Is < 1600
+            Rollo_FederUmdrehungen_Berechnen = 19
+          Case Is < 1800
+            Rollo_FederUmdrehungen_Berechnen = 25
+          Case Else
+            Rollo_FederUmdrehungen_Berechnen = 28
+        End Select
+    End Sub
+End Class", @"internal partial class TestClass
+{
+    private void TestMethod(int Breite)
+    {
+        int Rollo_FederUmdrehungen_Berechnen;
+        switch (Breite)
+        {
+            case < 1000:
+                {
+                    Rollo_FederUmdrehungen_Berechnen = 12;
+                    break;
+                }
+
+            case < 1200:
+                {
+                    Rollo_FederUmdrehungen_Berechnen = 15;
+                    break;
+                }
+
+            case < 1600:
+                {
+                    Rollo_FederUmdrehungen_Berechnen = 19;
+                    break;
+                }
+
+            case < 1800:
+                {
+                    Rollo_FederUmdrehungen_Berechnen = 25;
+                    break;
+                }
+
+            default:
+                {
+                    Rollo_FederUmdrehungen_Berechnen = 28;
+                    break;
+                }
+        }
+    }
+}");
+    }
+}