Handle boolean for loop "To" expression - fixes #602

Author: GrahamTheCoder

CHANGELOG.md

@@ -27,6 +27,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 * Coercing enum to a string now correctly uses its numeric value [#590](https://github.com/icsharpcode/CodeConverter/issues/590)
 * Correct conversion for equality of overloaded types [#594](https://github.com/icsharpcode/CodeConverter/issues/594)
 * Correct conversion when for loop variable is a class member [#601](https://github.com/icsharpcode/CodeConverter/issues/601)
+* Correct conversion when for loop "To" expression is a boolean [#602](https://github.com/icsharpcode/CodeConverter/issues/602)
 
 ### C# -> VB
 

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -516,27 +516,31 @@ public override async Task<SyntaxList<StatementSyntax>> VisitForBlock(VBSyntax.F
                 }
             }
 
-            // In Visual Basic, the To expression is only evaluated once, but in C# will be evaluated every loop.
-            // If it could evaluate differently or has side effects, it must be extracted as a variable
+           
             var preLoopStatements = new List<SyntaxNode>();
             var csToValue = await stmt.ToValue.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
+            csToValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(stmt.ToValue, csToValue?.SkipIntoParens(), forceTargetType: controlVarType);
+
+            // In Visual Basic, the To expression is only evaluated once, but in C# will be evaluated every loop.
+            // If it could evaluate differently or has side effects, it must be extracted as a variable
             if (!_semanticModel.GetConstantValue(stmt.ToValue).HasValue) {
                 var loopToVariableName = GetUniqueVariableNameInScope(node, "loopTo");
                 var toValueType = _semanticModel.GetTypeInfo(stmt.ToValue).ConvertedType;
                 var toVariableId = SyntaxFactory.IdentifierName(loopToVariableName);
+
+                // If that variable has the same type as the loop variable, we can explicitly declare the type and it inline
                 if (controlVarType?.Equals(toValueType) == true && declaration != null) {
                     var loopToAssignment = CommonConversions.CreateVariableDeclarator(loopToVariableName, csToValue);
-                    declaration = declaration.AddVariables(loopToAssignment);
+                    declaration = declaration.AddVariables(loopToAssignment).WithType(CommonConversions.GetTypeSyntax(controlVarType));
                 } else {
-                    csToValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(stmt.ToValue, csToValue, forceTargetType: controlVarType);
                     var loopEndDeclaration = SyntaxFactory.LocalDeclarationStatement(
                         CommonConversions.CreateVariableDeclarationAndAssignment(loopToVariableName, csToValue));
                     // Does not do anything about porting newline trivia upwards to maintain spacing above the loop
                     preLoopStatements.Add(loopEndDeclaration);
                 }
 
                 csToValue = toVariableId;
-            };
+            }
 
             var (csCondition, csStep) = await ConvertConditionAndStepClauseAsync(stmt, id, csToValue, controlVarType);
 
@@ -562,7 +566,6 @@ public override async Task<SyntaxList<StatementSyntax>> VisitForBlock(VBSyntax.F
             // For an enum, you need to add on an integer for example:
             var forceStepType = controlVarType is INamedTypeSymbol nt && nt.IsEnumType() ? nt.EnumUnderlyingType : controlVarType;
             csStepValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(vbStepValue, csStepValue?.SkipIntoParens(), forceTargetType: forceStepType);
-            csToValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(stmt.ToValue, csToValue?.SkipIntoParens(), forceTargetType: controlVarType);
 
             var nonNegativeCondition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, csToValue);
             var negativeCondition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, csToValue);

Tests/CSharp/SpecialConversionTests.cs

@@ -243,6 +243,28 @@ public object GetItem(DataRow dr)
         const string 字 = ""字"";
         return default;
     }
+}");
+        }
+
+        [Fact]
+        public async Task UsingBoolInToExpressionAsync()
+        {
+            // Beware, this will never enter the loop, it's buggy input due to the "i <", but it compiles and runs, so the output should too (and do the same thing)
+            await TestConversionVisualBasicToCSharpAsync(@"Public Class C
+    Public Sub M(OldWords As String(), NewWords As String(), HTMLCode As String)
+        For i As Integer = 0 To i < OldWords.Length - 1
+            HTMLCode = HTMLCode.Replace(OldWords(i), NewWords(i))
+        Next i
+    End Sub
+End Class", @"using Microsoft.VisualBasic.CompilerServices; // Install-Package Microsoft.VisualBasic
+
+public partial class C
+{
+    public void M(string[] OldWords, string[] NewWords, string HTMLCode)
+    {
+        for (int i = 0, loopTo = Conversions.ToInteger(i < OldWords.Length - 1); i <= loopTo; i++)
+            HTMLCode = HTMLCode.Replace(OldWords[i], NewWords[i]);
+    }
 }");
         }
     }