Deal with as many combinations of cases as possible

Author: GrahamTheCoder

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -733,7 +733,7 @@ public override async Task<CSharpSyntaxNode> VisitBinaryExpression(VBasic.Syntax
                     omitConversion = true; // Already handled within for the appropriate types (rhs can become int in comparison)
                     break;
                 case VisualBasicEqualityComparison.RequiredType.Object:
-                    return _visualBasicEqualityComparison.GetFullExpressionForVbObjectComparison(node, lhs, rhs);
+                    return _visualBasicEqualityComparison.GetFullExpressionForVbObjectComparison(lhs, rhs, node.IsKind(VBasic.SyntaxKind.NotEqualsExpression));
             }
 
             omitConversion |= lhsTypeInfo.Type != null && rhsTypeInfo.Type != null &&

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -642,14 +642,14 @@ public override async Task<SyntaxList<StatementSyntax>> VisitSelectBlock(VBSynta
         {
             var vbExpr = node.SelectStatement.Expression;
             var vbEquality = CommonConversions.VisualBasicEqualityComparison;
-            var (csSwitchExpr, stmts, csExprToReuse) = await GetExpressionWithoutSideEffectsAsync(vbExpr, "switchExpr");
+            var (csExprToReuse, stmts, csSwitchExpr) = await GetExpressionWithoutSideEffectsAsync(vbExpr, "switchExpr");
             var switchExprTypeInfo = _semanticModel.GetTypeInfo(vbExpr);
-            var isStringComparison = switchExprTypeInfo.ConvertedType?.SpecialType == SpecialType.System_String;
+            var isStringComparison = switchExprTypeInfo.ConvertedType?.SpecialType == SpecialType.System_String || switchExprTypeInfo.ConvertedType?.IsArrayOf(SpecialType.System_Char) == true;
             var caseInsensitiveStringComparison = vbEquality.OptionCompareTextCaseInsensitive &&
                 isStringComparison;
             if (isStringComparison) {
-                csSwitchExpr = vbEquality.VbCoerceToNonNullString(vbExpr, csSwitchExpr, switchExprTypeInfo);
                 csExprToReuse = vbEquality.VbCoerceToNonNullString(vbExpr, csExprToReuse, switchExprTypeInfo);
+                csSwitchExpr = vbEquality.VbCoerceToNonNullString(vbExpr, csSwitchExpr, switchExprTypeInfo);
             }
 
             var usedConstantValues = new HashSet<object>();
@@ -665,15 +665,16 @@ public override async Task<SyntaxList<StatementSyntax>> VisitSelectBlock(VBSynta
                         var constantValue = _semanticModel.GetConstantValue(s.Value);
                         var caseTypeInfo = _semanticModel.GetTypeInfo(s.Value);
                         var notAlreadyUsed = !constantValue.HasValue || usedConstantValues.Add(constantValue.Value);
-                        var csCase = correctTypeExpressionSyntax.Expr;
 
                         // Pass both halves in case we can optimize away the check based on the switch expr
-                        if (isStringComparison && !caseInsensitiveStringComparison) {
-                            csCase = vbEquality.VbCoerceToNonNullString(vbExpr, csExprToReuse, switchExprTypeInfo, true, s.Value, correctTypeExpressionSyntax.Expr, caseTypeInfo, false).rhs;
-                        }
-                        var caseSwitchLabelSyntax = !caseInsensitiveStringComparison && correctTypeExpressionSyntax.IsConst && notAlreadyUsed
-                            ? (SwitchLabelSyntax)SyntaxFactory.CaseSwitchLabel(csCase)
-                            : WrapInCasePatternSwitchLabelSyntax(node, s.Value, csCase, caseInsensitiveStringComparison);
+                        var wrapForStringComparison = isStringComparison && (caseInsensitiveStringComparison ||
+                            vbEquality.VbCoerceToNonNullString(vbExpr, csExprToReuse, switchExprTypeInfo, true, s.Value, originalExpressionSyntax, caseTypeInfo, false).rhs != originalExpressionSyntax);
+
+                        var csExpressionToUse = wrapForStringComparison ? originalExpressionSyntax : correctTypeExpressionSyntax.Expr;
+
+                        var caseSwitchLabelSyntax = !wrapForStringComparison && correctTypeExpressionSyntax.IsConst && notAlreadyUsed
+                            ? (SwitchLabelSyntax)SyntaxFactory.CaseSwitchLabel(csExpressionToUse)
+                            : WrapInCasePatternSwitchLabelSyntax(node, s.Value, csExpressionToUse, caseInsensitiveStringComparison);
                         labels.Add(caseSwitchLabelSyntax);
                     } else if (c is VBSyntax.ElseCaseClauseSyntax) {
                         labels.Add(SyntaxFactory.DefaultSwitchLabel());
@@ -753,13 +754,16 @@ private CasePatternSwitchLabelSyntax WrapInCasePatternSwitchLabelSyntax(VBSyntax
                 patternMatch = SyntaxFactory.DeclarationPattern(
                     ValidSyntaxFactory.VarType, SyntaxFactory.SingleVariableDesignation(varName));
                 ExpressionSyntax csLeft = SyntaxFactory.IdentifierName(varName), csRight = expression;
-                if (caseInsensitiveTextComparison) {
+                var caseTypeInfo = _semanticModel.GetTypeInfo(vbCase);
+                var vbEquality = CommonConversions.VisualBasicEqualityComparison;
+                if (vbEquality.GetObjectEqualityType(typeInfo, caseTypeInfo) == VisualBasicEqualityComparison.RequiredType.Object) {
+                    expression = vbEquality.GetFullExpressionForVbObjectComparison(csLeft, csRight);
+                } else {
                     // We know lhs isn't null, because we always coalesce it in the switch expression
-                    (csLeft, csRight) = CommonConversions.VisualBasicEqualityComparison
-                        .AdjustForVbStringComparison(node.SelectStatement.Expression, csLeft, typeInfo, true, vbCase, csRight, _semanticModel.GetTypeInfo(vbCase), false);
+                    (csLeft, csRight) = vbEquality
+                        .AdjustForVbStringComparison(node.SelectStatement.Expression, csLeft, typeInfo, true, vbCase, csRight, caseTypeInfo, false);
+                    expression = SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, csLeft, csRight);
                 }
-                expression = SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, csLeft, csRight);
-                
             }
 
             var casePatternSwitchLabelSyntax = SyntaxFactory.CasePatternSwitchLabel(patternMatch,

CodeConverter/CSharp/VisualBasicEqualityComparison.cs

@@ -54,11 +54,15 @@ public LiteralExpressionSyntax OptionCompareTextCaseInsensitiveBoolExpression {
 
         public RequiredType GetObjectEqualityType(VBSyntax.BinaryExpressionSyntax node, TypeInfo leftType, TypeInfo rightType)
         {
-            var typeInfos = new[] {leftType, rightType};
+            var typeInfos = new[] { leftType, rightType };
             if (!node.IsKind(VBasic.SyntaxKind.EqualsExpression, VBasic.SyntaxKind.NotEqualsExpression)) {
                 return RequiredType.None;
             }
+            return GetObjectEqualityType(typeInfos);
+        }
 
+        public RequiredType GetObjectEqualityType(params TypeInfo[] typeInfos)
+        {
             bool requiresVbEqualityCheck = typeInfos.Any(t => t.Type?.SpecialType == SpecialType.System_Object);
 
             if (typeInfos.All(t => t.Type != null) && typeInfos.All(
@@ -71,7 +75,6 @@ public RequiredType GetObjectEqualityType(VBSyntax.BinaryExpressionSyntax node,
         }
 
 
-
         public (ExpressionSyntax lhs, ExpressionSyntax rhs) VbCoerceToNonNullString(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, bool leftKnownNotNull, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo, bool rightKnownNotNull)
         {
             if (IsNonEmptyStringLiteral(vbLeft) || IsNonEmptyStringLiteral(vbRight)) {
@@ -198,9 +201,14 @@ private static bool IsEmptyString(VBSyntax.LiteralExpressionSyntax les)
 
         private static ExpressionSyntax NegateIfNeeded(VBSyntax.BinaryExpressionSyntax node, InvocationExpressionSyntax positiveExpression)
         {
-            return node.IsKind(VBasic.SyntaxKind.EqualsExpression)
-                ? (ExpressionSyntax) positiveExpression
-                : SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, positiveExpression);
+            return node.IsKind(VBasic.SyntaxKind.NotEqualsExpression)
+               ? Negate(positiveExpression)
+               : (ExpressionSyntax)positiveExpression;
+        }
+
+        private static PrefixUnaryExpressionSyntax Negate(InvocationExpressionSyntax positiveExpression)
+        {
+            return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, positiveExpression);
         }
 
         public (ExpressionSyntax csLeft, ExpressionSyntax csRight) AdjustForVbStringComparison(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, bool leftKnownNotNull, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo, bool rightKnownNotNull)
@@ -222,14 +230,14 @@ private static ExpressionSyntax NegateIfNeeded(VBSyntax.BinaryExpressionSyntax n
             return (csLeft, csRight);
         }
 
-        public ExpressionSyntax GetFullExpressionForVbObjectComparison(VBSyntax.BinaryExpressionSyntax node, ExpressionSyntax lhs, ExpressionSyntax rhs)
+        public ExpressionSyntax GetFullExpressionForVbObjectComparison(ExpressionSyntax lhs, ExpressionSyntax rhs, bool negate = false)
         {
                 ExtraUsingDirectives.Add("Microsoft.VisualBasic.CompilerServices");
                 var optionCompareTextCaseInsensitive = SyntaxFactory.Argument(OptionCompareTextCaseInsensitiveBoolExpression);
                 var compareObject = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(Operators), nameof(Operators.ConditionalCompareObjectEqual)),
                     SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[]
                         {SyntaxFactory.Argument(lhs), SyntaxFactory.Argument(rhs), optionCompareTextCaseInsensitive})));
-                return NegateIfNeeded(node, compareObject);
+                return negate ? (ExpressionSyntax)Negate(compareObject) : compareObject;
         }
 
         private static BinaryExpressionSyntax GetCompareTextCaseInsensitiveCompareOptions()

Tests/CSharp/StatementTests/StatementTests.cs

@@ -1765,7 +1765,7 @@ public int Add(int x)
         public async Task Issue579SelectCaseWithCaseInsensitiveTextCompareAsync()
         {
             await TestConversionVisualBasicToCSharpAsync(@"
-Option Compare Text
+Option Compare Text ' Comments lost
 
 Class Issue579SelectCaseWithCaseInsensitiveTextCompare
 Private Function Test(astr_Temp As String) As Nullable(Of Boolean)