VB -> C#: Infinite While loop inside For loop

[Korfu]

VB.Net input code

For Each appRole In accessingUnit.Role.ApplicationRoles
    Dim objectUnit = Company.GetInstance(appRole.ObjectId.Value)
    While objectUnit IsNot Nothing
        If CBool(unit.UnitType And HrUnitTypeEnum.CanHaveEmployment) Then
            If unit.Id = objectUnit.Id Then
                Return True
            Else
                Continue For
            End If
        End IF
        objectUnit = objectUnit.ParentCompany
    End While
Next

Erroneous output

Converter tool would translate `Continue For` into `continue`.

Expected output

Converter tool should translate `Continue For` into `break`. It should exit the outer `for loop` and instead it was endleslly starting over and over again the `inner while loop`.

Details

• The inner while loop has become an infinite loop.
• We converted gigantic monolith (1.3 million lines of code) and were stuck with this issue for a couple of days. Caused serious performance issues.

[GrahamTheCoder]

Thanks for the clear report. Should be straightforward to fix since the logic needed in VisitContinueStatement can likely mimic the default case in VisitExitStatement:

CodeConverter/CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

Lines 434 to 472 in c5e6405

	public override async Task<SyntaxList<StatementSyntax>> VisitContinueStatement(VBSyntax.ContinueStatementSyntax node)
	{
	return SingleStatement(SyntaxFactory.ContinueStatement());
	}
	public override async Task<SyntaxList<StatementSyntax>> VisitYieldStatement(VBSyntax.YieldStatementSyntax node)
	{
	return SingleStatement(SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, await node.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor)));
	}
	public override async Task<SyntaxList<StatementSyntax>> VisitExitStatement(VBSyntax.ExitStatementSyntax node)
	{
	var vbBlockKeywordKind = VBasic.VisualBasicExtensions.Kind(node.BlockKeyword);
	switch (vbBlockKeywordKind) {
	case VBasic.SyntaxKind.SubKeyword:
	case VBasic.SyntaxKind.PropertyKeyword when node.GetAncestor<VBSyntax.AccessorBlockSyntax>()?.IsKind(VBasic.SyntaxKind.GetAccessorBlock) != true:
	return SingleStatement(SyntaxFactory.ReturnStatement());
	case VBasic.SyntaxKind.FunctionKeyword:
	case VBasic.SyntaxKind.PropertyKeyword when node.GetAncestor<VBSyntax.AccessorBlockSyntax>()?.IsKind(VBasic.SyntaxKind.GetAccessorBlock) == true:
	VBasic.VisualBasicSyntaxNode typeContainer = node.GetAncestor<VBSyntax.LambdaExpressionSyntax>()
	?? (VBasic.VisualBasicSyntaxNode)node.GetAncestor<VBSyntax.MethodBlockSyntax>()
	?? node.GetAncestor<VBSyntax.AccessorBlockSyntax>();
	var enclosingMethodInfo = await typeContainer.TypeSwitch(
	async (VBSyntax.LambdaExpressionSyntax e) => _semanticModel.GetSymbolInfo(e).Symbol,
	async (VBSyntax.MethodBlockSyntax e) => _semanticModel.GetDeclaredSymbol(e),
	async (VBSyntax.AccessorBlockSyntax e) => _semanticModel.GetDeclaredSymbol(e)) as IMethodSymbol;
	if (IsIterator) return SingleStatement(SyntaxFactory.YieldStatement(SyntaxKind.YieldBreakStatement));
	if (!enclosingMethodInfo.ReturnsVoidOrAsyncTask()) {
	ExpressionSyntax expr = HasReturnVariable ? ReturnVariable : SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
	return SingleStatement(SyntaxFactory.ReturnStatement(expr));
	}
	return SingleStatement(SyntaxFactory.ReturnStatement());
	default:
	return SyntaxFactory.List(_perScopeState.ConvertExit(vbBlockKeywordKind));
	}
	}

CodeConverter/CodeConverter/CSharp/PerScopeState.cs

Lines 192 to 205 in c5e6405

	public IEnumerable<StatementSyntax> ConvertExit(VBasic.SyntaxKind vbBlockKeywordKind)
	{
	var scopesToExit = _hoistedNodesPerScope.Where(x => x.ExitableKind != VBasic.SyntaxKind.None).TakeWhile(x => x.ExitableKind != vbBlockKeywordKind && x.IsBreakableInCs).ToArray();
	var assignmentExpression = CommonConversions.Literal(true);
	foreach (var scope in scopesToExit) {
	var exitScopeVar = new AdditionalDeclaration("exit" + VBasic.SyntaxFactory.Token(vbBlockKeywordKind), CommonConversions.Literal(false), SyntaxFactory.ParseTypeName("bool"));
	var ifTrueBreak = new IfTrueBreak(exitScopeVar.IdentifierName);
	scope.HoistedNodes.Add(exitScopeVar);
	scope.HoistedNodes.Add(ifTrueBreak);
	assignmentExpression = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, exitScopeVar.IdentifierName, assignmentExpression);
	}
	if (scopesToExit.Any()) yield return SyntaxFactory.ExpressionStatement(assignmentExpression);
	yield return SyntaxFactory.BreakStatement();
	}

Tests here: https://github.com/icsharpcode/CodeConverter/blob/da720fa0549dc7e121fe6d3dcb0eb19f8d756d16/Tests/CSharp/StatementTests/ExitableMethodExecutableStatementTests.cs