MethodBodyExecutableStatementVisitor.cs

using System.Collections;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Operations;
using static Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions;
using SyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
using Microsoft.CodeAnalysis.Text;
using ICSharpCode.CodeConverter.Util.FromRoslyn;
using ICSharpCode.CodeConverter.VB;
using ComparisonKind = ICSharpCode.CodeConverter.CSharp.VisualBasicEqualityComparison.ComparisonKind;

namespace ICSharpCode.CodeConverter.CSharp;

/// <summary>
/// Executable statements - which includes executable blocks such as if statements
/// Maintains state relevant to the called method-like object. A fresh one must be used for each method, and the same one must be reused for statements in the same method
/// </summary>
internal class MethodBodyExecutableStatementVisitor : VBasic.VisualBasicSyntaxVisitor<Task<SyntaxList<StatementSyntax>>>
{
    private readonly VBasic.VisualBasicSyntaxNode _methodNode;
    private readonly SemanticModel _semanticModel;
    private readonly CommentConvertingVisitorWrapper _expressionVisitor;
    private readonly VisualBasicEqualityComparison _visualBasicEqualityComparison;
    private readonly Stack<ExpressionSyntax> _withBlockLhs;
    private readonly HashSet<string> _extraUsingDirectives;
    private readonly HandledEventsAnalysis _handledEventsAnalysis;
    private readonly HashSet<string> _generatedNames = new();
    private readonly HashSet<ILocalSymbol> _localsToInlineInLoop;
    private readonly PerScopeState _perScopeState;

    public bool IsIterator { get; set; }
    public IdentifierNameSyntax ReturnVariable { get; set; }
    public bool HasReturnVariable => ReturnVariable != null;
    public VBasic.VisualBasicSyntaxVisitor<Task<SyntaxList<StatementSyntax>>> CommentConvertingVisitor { get; }

    private CommonConversions CommonConversions { get; }

    public static async Task<MethodBodyExecutableStatementVisitor> CreateAsync(VisualBasicSyntaxNode node, SemanticModel semanticModel,
        CommentConvertingVisitorWrapper triviaConvertingExpressionVisitor, CommonConversions commonConversions, VisualBasicEqualityComparison visualBasicEqualityComparison,
        Stack<ExpressionSyntax> withBlockLhs, HashSet<string> extraUsingDirectives,
        ITypeContext typeContext, bool isIterator, IdentifierNameSyntax csReturnVariable)
    {
        var solution = commonConversions.Document.Project.Solution;
        var declarationsToInlineInLoop = await solution.GetDescendantsToInlineInLoopAsync(semanticModel, node);
        return new MethodBodyExecutableStatementVisitor(node, semanticModel, triviaConvertingExpressionVisitor, commonConversions, visualBasicEqualityComparison, withBlockLhs, extraUsingDirectives, typeContext, declarationsToInlineInLoop) {
            IsIterator = isIterator,
            ReturnVariable = csReturnVariable,
        };
    }

    private MethodBodyExecutableStatementVisitor(VisualBasicSyntaxNode methodNode, SemanticModel semanticModel,
        CommentConvertingVisitorWrapper expressionVisitor, CommonConversions commonConversions,
        VisualBasicEqualityComparison visualBasicEqualityComparison,
        Stack<ExpressionSyntax> withBlockLhs, HashSet<string> extraUsingDirectives,
        ITypeContext typeContext, HashSet<ILocalSymbol> localsToInlineInLoop)
    {
        _methodNode = methodNode;
        _semanticModel = semanticModel;
        _expressionVisitor = expressionVisitor;
        _visualBasicEqualityComparison = visualBasicEqualityComparison;
        CommonConversions = commonConversions;
        _withBlockLhs = withBlockLhs;
        _extraUsingDirectives = extraUsingDirectives;
        _handledEventsAnalysis = typeContext.HandledEventsAnalysis;
        _perScopeState = typeContext.PerScopeState;
        var byRefParameterVisitor = new PerScopeStateVisitorDecorator(this, _perScopeState, semanticModel, _generatedNames);
        CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(byRefParameterVisitor);
        _localsToInlineInLoop = localsToInlineInLoop;
    }

    public override async Task<SyntaxList<StatementSyntax>> DefaultVisit(SyntaxNode node)
    {
        throw new NotImplementedException($"Conversion for {VBasic.VisualBasicExtensions.Kind(node)} not implemented, please report this issue")
            .WithNodeInformation(node);
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitStopOrEndStatement(VBSyntax.StopOrEndStatementSyntax node)
    {
        return SingleStatement(SyntaxFactory.ParseStatement(ConvertStopOrEndToCSharpStatementText(node)));
    }

    private string ConvertStopOrEndToCSharpStatementText(VBSyntax.StopOrEndStatementSyntax node)
    {
        switch (VBasic.VisualBasicExtensions.Kind(node.StopOrEndKeyword)) {
            case VBasic.SyntaxKind.StopKeyword:
                _extraUsingDirectives.Add("System.Diagnostics");
                return "Debugger.Break();";
            case VBasic.SyntaxKind.EndKeyword:
                _extraUsingDirectives.Add("System");
                return "Environment.Exit(0);";
            default:
                throw new NotImplementedException(VBasic.VisualBasicExtensions.Kind(node.StopOrEndKeyword) + " not implemented!");
        }
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitLocalDeclarationStatement(VBSyntax.LocalDeclarationStatementSyntax node)
    {  
        var modifiers = CommonConversions.ConvertModifiers(node.Declarators[0].Names[0], node.Modifiers, TokenContext.Local);
        var isConst = modifiers.Any(a => a.IsKind(SyntaxKind.ConstKeyword));
        var isVBStatic = node.Modifiers.Any(a => a.IsKind(VBasic.SyntaxKind.StaticKeyword));

        var declarations = new List<StatementSyntax>();

        foreach (var declarator in node.Declarators) {
            var (variables, methods) = await SplitVariableDeclarationsAsync(declarator, preferExplicitType: isConst || isVBStatic);
            var localDeclarationStatementSyntaxs = variables.Select(declAndType => SyntaxFactory.LocalDeclarationStatement(modifiers, declAndType.Decl));
            if (isVBStatic) {
                foreach (var decl in localDeclarationStatementSyntaxs) {
                    var variable = decl.Declaration.Variables.Single();
                    var initializeValue = variable.Initializer?.Value;
                    string methodName;
                    SyntaxTokenList methodModifiers;

                    MethodKind parentAccessorKind = MethodKind.Ordinary;
                    if (_methodNode is VBSyntax.MethodBlockSyntax methodBlock) {
                        var methodStatement = methodBlock.BlockStatement as VBSyntax.MethodStatementSyntax;
                        methodModifiers = methodStatement.Modifiers;
                        methodName = methodStatement.Identifier.Text;
                    } else if (_methodNode is VBSyntax.ConstructorBlockSyntax constructorBlock) {
                        methodModifiers = constructorBlock.BlockStatement.Modifiers;
                        methodName = null;
                    } else if (_methodNode is VBSyntax.AccessorBlockSyntax accessorBlock) {
                        var propertyBlock = accessorBlock.Parent as VBSyntax.PropertyBlockSyntax;
                        methodName = propertyBlock.PropertyStatement.Identifier.Text;
                        parentAccessorKind = accessorBlock.IsKind(VBasic.SyntaxKind.GetAccessorBlock) ? MethodKind.PropertyGet : MethodKind.PropertySet;
                        methodModifiers = propertyBlock.PropertyStatement.Modifiers;
                    } else {
                        throw new NotImplementedException(_methodNode.GetType() + " not implemented!");
                    }

                    var isVbShared = methodModifiers.Any(a => a.IsKind(VBasic.SyntaxKind.SharedKeyword));
                    _perScopeState.HoistToTopLevel(new HoistedFieldFromVbStaticVariable(methodName, variable.Identifier.Text, parentAccessorKind, initializeValue, decl.Declaration.Type, isVbShared));
                }
            } else {
                var shouldPullVariablesBeforeLoop = _perScopeState.IsInsideLoop() && declarator.Initializer is null && declarator.AsClause is not VBSyntax.AsNewClauseSyntax;
                if (shouldPullVariablesBeforeLoop) {
                    localDeclarationStatementSyntaxs = HoistVariablesBeforeLoopWhenNeeded(variables)
                        .Select(variableDecl => SyntaxFactory.LocalDeclarationStatement(modifiers, variableDecl));
                }

                declarations.AddRange(localDeclarationStatementSyntaxs);
            }
            var localFunctions = methods.Cast<LocalFunctionStatementSyntax>();
            declarations.AddRange(localFunctions);
        }

        return SyntaxFactory.List(declarations);
    }

    private IEnumerable<VariableDeclarationSyntax> HoistVariablesBeforeLoopWhenNeeded(IEnumerable<CommonConversions.VariablesDeclaration> variablesDeclarations)
    {
        foreach (var variablesDecl in variablesDeclarations) {
            var variablesToRemove = new List<CSSyntax.VariableDeclaratorSyntax>();
            foreach (var (csVariable, vbVariable) in variablesDecl.Variables) {
                var symbol = _semanticModel.GetDeclaredSymbol(vbVariable);
                var assignedBeforeRead = _semanticModel.IsDefinitelyAssignedBeforeRead(symbol, vbVariable);
                if (!assignedBeforeRead) {
                    _perScopeState.Hoist(new HoistedDefaultInitializedLoopVariable(
                        csVariable.Identifier.Text,
                        // e.g. "b As Boolean" has no initializer but can turn into "var b = default(bool)"
                        csVariable.Initializer?.Value,
                        variablesDecl.Decl.Type,
                        _perScopeState.IsInsideNestedLoop()));
                    variablesToRemove.Add(csVariable);
                }
            }

            var variablesToDeclareLocally = variablesDecl.Variables.Select(t => t.CsVar).Except(variablesToRemove).ToArray();
            if(variablesToDeclareLocally.Any()) {
                yield return variablesDecl.Decl.WithVariables(SyntaxFactory.SeparatedList(variablesToDeclareLocally));
            }
        }
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitAddRemoveHandlerStatement(VBSyntax.AddRemoveHandlerStatementSyntax node)
    {
        var syntaxKind = ConvertAddRemoveHandlerToCSharpSyntaxKind(node);
        return SingleStatement(SyntaxFactory.AssignmentExpression(syntaxKind,
            await node.EventExpression.AcceptAsync<ExpressionSyntax>(_expressionVisitor),
            await node.DelegateExpression.AcceptAsync<ExpressionSyntax>(_expressionVisitor)));
    }

    private static SyntaxKind ConvertAddRemoveHandlerToCSharpSyntaxKind(VBSyntax.AddRemoveHandlerStatementSyntax node)
    {
        switch (node.Kind()) {
            case VBasic.SyntaxKind.AddHandlerStatement:
                return SyntaxKind.AddAssignmentExpression;
            case VBasic.SyntaxKind.RemoveHandlerStatement:
                return SyntaxKind.SubtractAssignmentExpression;
            default:
                throw new NotImplementedException(node.Kind() + " not implemented!");
        }
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitExpressionStatement(VBSyntax.ExpressionStatementSyntax node)
    {
        if (node.Expression is VBSyntax.InvocationExpressionSyntax invoke && invoke.Expression is VBSyntax.MemberAccessExpressionSyntax access && access.Expression is VBSyntax.MyBaseExpressionSyntax && access.Name.Identifier.ValueText.Equals("Finalize", StringComparison.OrdinalIgnoreCase)) {
            return new SyntaxList<StatementSyntax>();
        }

        return SingleStatement(await node.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitAssignmentStatement(VBSyntax.AssignmentStatementSyntax node)
    {
        if (node.IsKind(VBasic.SyntaxKind.MidAssignmentStatement) && node.Left is VBSyntax.MidExpressionSyntax mes) {
            return await ConvertMidAssignmentAsync(node, mes);
        }

        var lhs = await node.Left.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        var lOperation = _semanticModel.GetOperation(node.Left);

        var (parameterizedPropertyAccessMethod, _) = await CommonConversions.GetParameterizedPropertyAccessMethodAsync(lOperation);

        // If it's a simple assignment, we can return early as it's already handled by ConvertInvocationExpression
        if (parameterizedPropertyAccessMethod != null && node.IsKind(VBasic.SyntaxKind.SimpleAssignmentStatement)) {
            return SingleStatement(lhs);
        }

        // For compound assignments, we want to expand it to the setter, but parameterizedPropertyAccessMethod above
        // returned 'get_Item' or 'set_Item' depending on operation context.
        // We know for sure the left-hand side is a getter invocation for compound assignments (e.g. this.get_Item(0) += 2),
        // but we need the setter name to build the final expression.
        string setMethodName = null;
        if (lOperation is IPropertyReferenceOperation pro && pro.Arguments.Any() && !Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions.IsDefault(pro.Property)) {
            setMethodName = pro.Property.SetMethod?.Name;
        }

        var rhs = await node.Right.AcceptAsync<ExpressionSyntax>(_expressionVisitor);

        if (node.Left is VBSyntax.IdentifierNameSyntax id &&
            _methodNode is VBSyntax.MethodBlockSyntax mb &&
            HasReturnVariable &&
            id.Identifier.ValueText.Equals(mb.SubOrFunctionStatement.Identifier.ValueText, StringComparison.OrdinalIgnoreCase)) {
            lhs = ReturnVariable;
        }

        if (node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) {
            rhs = SyntaxFactory.InvocationExpression(
                ValidSyntaxFactory.MemberAccess(nameof(Math), nameof(Math.Pow)),
                ExpressionSyntaxExtensions.CreateArgList(lhs, rhs));
        }
        var kind = node.Kind().ConvertToken();

            
        var lhsTypeInfo = _semanticModel.GetTypeInfo(node.Left);
        var rhsTypeInfo = _semanticModel.GetTypeInfo(node.Right);
            
        var typeConvertedRhs = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, rhs);

        // Split out compound operator if type conversion needed on result
        if (TypeConversionAnalyzer.GetNonCompoundOrNull(kind) is {} nonCompound) {
                
            var nonCompoundRhs = SyntaxFactory.BinaryExpression(nonCompound, lhs, typeConvertedRhs);
            var typeConvertedNonCompoundRhs = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, nonCompoundRhs, forceSourceType: rhsTypeInfo.ConvertedType, forceTargetType: lhsTypeInfo.Type);
            if (nonCompoundRhs != typeConvertedNonCompoundRhs || setMethodName != null) {
                kind = SyntaxKind.SimpleAssignmentExpression;
                typeConvertedRhs = typeConvertedNonCompoundRhs;
            }
        } else if (setMethodName != null && node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) {
            // ExponentiateAssignmentStatement evaluates to Math.Pow invocation which might need casting back to lhsType
            var typeConvertedNonCompoundRhs = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, typeConvertedRhs, forceSourceType: _semanticModel.Compilation.GetTypeByMetadataName("System.Double"), forceTargetType: lhsTypeInfo.Type);
            kind = SyntaxKind.SimpleAssignmentExpression;
            typeConvertedRhs = typeConvertedNonCompoundRhs;
        }

        rhs = typeConvertedRhs;

        if (setMethodName != null) {
            if (lhs is InvocationExpressionSyntax ies) {
                ExpressionSyntax exprToReplace = ies.Expression;
                if (exprToReplace is MemberAccessExpressionSyntax maes) {
                    var newName = SyntaxFactory.IdentifierName(setMethodName).WithTriviaFrom(maes.Name);
                    var stripThis = maes.Expression is ThisExpressionSyntax
                        && node.Left.SkipIntoParens() is not VBSyntax.MemberAccessExpressionSyntax {
                            Expression: not (VBSyntax.MeExpressionSyntax or VBSyntax.MyClassExpressionSyntax)
                        };
                    exprToReplace = stripThis ? newName.WithTriviaFrom(maes) : maes.WithName(newName);
                } else if (exprToReplace is IdentifierNameSyntax) {
                    exprToReplace = SyntaxFactory.IdentifierName(setMethodName).WithTriviaFrom(exprToReplace);
                }
                var newArgList = ies.ArgumentList.AddArguments(SyntaxFactory.Argument(rhs));
                var newLhs = ies.WithExpression(exprToReplace).WithArgumentList(newArgList);
                var postAssign = GetPostAssignmentStatements(node);
                return postAssign.Insert(0, SyntaxFactory.ExpressionStatement(newLhs));
            }
            return SingleStatement(lhs);
        }

        var assignment = SyntaxFactory.AssignmentExpression(kind, lhs, rhs);
        var postAssignment = GetPostAssignmentStatements(node);
        return postAssignment.Insert(0, SyntaxFactory.ExpressionStatement(assignment));
    }

    private async Task<SyntaxList<StatementSyntax>> ConvertMidAssignmentAsync(VBSyntax.AssignmentStatementSyntax node, VBSyntax.MidExpressionSyntax mes)
    {
        _extraUsingDirectives.Add("Microsoft.VisualBasic.CompilerServices");
        var midFunction = ValidSyntaxFactory.MemberAccess("StringType", "MidStmtStr");
        var midArgList = await mes.ArgumentList.AcceptAsync<ArgumentListSyntax>(_expressionVisitor);
        var (reusable, statements, _) = await GetExpressionWithoutSideEffectsAsync(node.Right, "midTmp");
        if (midArgList.Arguments.Count == 2) {
            var length = ValidSyntaxFactory.MemberAccess(reusable, "Length");
            midArgList = midArgList.AddArguments(SyntaxFactory.Argument(length));
        }
        midArgList = midArgList.AddArguments(SyntaxFactory.Argument(reusable));
        var invokeMid = SyntaxFactory.InvocationExpression(midFunction, midArgList);
        return statements.Add(SyntaxFactory.ExpressionStatement(invokeMid));
    }

    /// <remarks>
    /// <see cref="CommonConversions.ConvertIdentifier"/> ensures we convert the property access to a field access
    /// </remarks>
    private SyntaxList<StatementSyntax> GetPostAssignmentStatements(VBSyntax.AssignmentStatementSyntax node)
    {
        var potentialPropertySymbol = _semanticModel.GetSymbolInfo(node.Left).ExtractBestMatch<ISymbol>();
        return GetPostAssignmentStatements(node, potentialPropertySymbol);
    }

    /// <summary>
    /// Make winforms designer work: https://github.com/icsharpcode/CodeConverter/issues/321
    /// </summary>
    public SyntaxList<StatementSyntax> GetPostAssignmentStatements(Microsoft.CodeAnalysis.VisualBasic.Syntax.AssignmentStatementSyntax node, ISymbol potentialPropertySymbol)
    {
        if (CommonConversions.WinformsConversions.MayNeedToInlinePropertyAccess(node, potentialPropertySymbol)) {
            return _handledEventsAnalysis.GetPostAssignmentStatements(potentialPropertySymbol);
        }

        return SyntaxFactory.List<StatementSyntax>();
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitEraseStatement(VBSyntax.EraseStatementSyntax node)
    {
        var eraseStatements = await node.Expressions.SelectAsync<VBSyntax.ExpressionSyntax, StatementSyntax>(async arrayExpression => {
            var lhs = await arrayExpression.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
            var rhs = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
            var assignmentExpressionSyntax =
                SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, lhs,
                    rhs);
            return SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax);
        });
        return SyntaxFactory.List(eraseStatements);
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitReDimStatement(VBSyntax.ReDimStatementSyntax node)
    {
        return SyntaxFactory.List(await node.Clauses.SelectManyAsync(async arrayExpression => (IEnumerable<StatementSyntax>) await ConvertRedimClauseAsync(arrayExpression)));
    }

    /// <remarks>
    /// RedimClauseSyntax isn't an executable statement, therefore this isn't a "Visit" method.
    /// Since it returns multiple statements it's easiest for it to be here in the current architecture.
    /// </remarks>
    private async Task<SyntaxList<StatementSyntax>> ConvertRedimClauseAsync(VBSyntax.RedimClauseSyntax node)
    {
        bool preserve = node.Parent is VBSyntax.ReDimStatementSyntax rdss && rdss.PreserveKeyword.IsKind(VBasic.SyntaxKind.PreserveKeyword);

        var csTargetArrayExpression = await node.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        var convertedBounds = (await CommonConversions.ConvertArrayBoundsAsync(node.ArrayBounds)).Sizes.ToList();
        if (preserve && convertedBounds.Count == 1) {
            bool isProperty = _semanticModel.GetSymbolInfo(node.Expression).Symbol?.IsKind(SymbolKind.Property) == true;
            var arrayToResize = isProperty ? CreateLocalVariableWithUniqueName(node.Expression, "arg" + csTargetArrayExpression.ToString().Split('.').Last(), csTargetArrayExpression) : default;
            var resizeArg = isProperty ? (ExpressionSyntax)arrayToResize.Reference : csTargetArrayExpression;

            var argumentList = new[] { resizeArg, convertedBounds.Single() }.CreateCsArgList(SyntaxKind.RefKeyword);
            var arrayResize = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(Array), nameof(Array.Resize)), argumentList);

            if (isProperty) {
                var assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, csTargetArrayExpression, arrayToResize.Reference);
                return SyntaxFactory.List(new StatementSyntax[] { arrayToResize.Declaration, SyntaxFactory.ExpressionStatement(arrayResize), SyntaxFactory.ExpressionStatement(assignment) });
            }

            return SingleStatement(arrayResize);
        }
        var newArrayAssignment = CreateNewArrayAssignment(node.Expression, csTargetArrayExpression, convertedBounds);
        if (!preserve) return SingleStatement(newArrayAssignment);

        var lastIdentifierText = node.Expression.DescendantNodesAndSelf().OfType<VBSyntax.IdentifierNameSyntax>().Last().Identifier.Text;
        string variableNameBase = "old" + lastIdentifierText.ToPascalCase();
        var expr = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, csTargetArrayExpression);
        var (stmt, oldTargetExpression) = CreateLocalVariableWithUniqueName(node.Expression, variableNameBase, expr);
            
        var arrayCopyIfNotNull = CreateConditionalArrayCopy(node, oldTargetExpression, csTargetArrayExpression, convertedBounds);

        return SyntaxFactory.List(new[] { stmt, newArrayAssignment, arrayCopyIfNotNull});
    }

    /// <summary>
    /// Cut down version of Microsoft.VisualBasic.CompilerServices.Utils.CopyArray
    /// </summary>
    private IfStatementSyntax CreateConditionalArrayCopy(VBasic.VisualBasicSyntaxNode originalVbNode,
        IdentifierNameSyntax sourceArrayExpression,
        ExpressionSyntax targetArrayExpression,
        List<ExpressionSyntax> convertedBounds)
    {
        var sourceLength = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, sourceArrayExpression, ValidSyntaxFactory.IdentifierName("Length"));
        var arrayCopyStatement = convertedBounds.Count == 1
            ? CreateArrayCopyWithMinOfLengths(sourceArrayExpression, sourceLength, targetArrayExpression, convertedBounds.Single())
            : CreateArrayCopy(originalVbNode, sourceArrayExpression, sourceLength, targetArrayExpression, convertedBounds);

        var oldTargetNotEqualToNull = CommonConversions.NotNothingComparison(sourceArrayExpression, true);
        return SyntaxFactory.IfStatement(oldTargetNotEqualToNull, arrayCopyStatement);
    }

    /// <summary>
    /// Array copy for multiple array dimensions represented by <paramref name="convertedBounds"/>
    /// </summary>
    /// <remarks>
    /// Exception cases will sometimes silently succeed in the converted code,
    ///  but existing VB code relying on the exception thrown from a multidimensional redim preserve on
    ///  different rank arrays is hopefully rare enough that it's worth saving a few lines of code
    /// </remarks>
    private StatementSyntax CreateArrayCopy(VBasic.VisualBasicSyntaxNode originalVbNode,
        IdentifierNameSyntax sourceArrayExpression,
        MemberAccessExpressionSyntax sourceLength,
        ExpressionSyntax targetArrayExpression, ICollection convertedBounds)
    {
        var lastSourceLengthArgs = ExpressionSyntaxExtensions.CreateArgList(CommonConversions.Literal(convertedBounds.Count - 1));
        var sourceLastRankLength = SyntaxFactory.InvocationExpression(
            SyntaxFactory.ParseExpression($"{sourceArrayExpression.Identifier}.GetLength"), lastSourceLengthArgs);
        var targetLastRankLength =
            SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression($"{targetArrayExpression}.GetLength"),
                lastSourceLengthArgs);
        var length = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Math.Min"), ExpressionSyntaxExtensions.CreateArgList(sourceLastRankLength, targetLastRankLength));

        var loopVariableName = GetUniqueVariableNameInScope(originalVbNode, "i");
        var loopVariableIdentifier = ValidSyntaxFactory.IdentifierName(loopVariableName);
        var sourceStartForThisIteration =
            SyntaxFactory.BinaryExpression(SyntaxKind.MultiplyExpression, loopVariableIdentifier, sourceLastRankLength);
        var targetStartForThisIteration =
            SyntaxFactory.BinaryExpression(SyntaxKind.MultiplyExpression, loopVariableIdentifier, targetLastRankLength);

        var arrayCopy = CreateArrayCopyWithStartingPoints(sourceArrayExpression, sourceStartForThisIteration, targetArrayExpression,
            targetStartForThisIteration, length);

        var sourceArrayCount = SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression,
            SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, sourceLength, sourceLastRankLength), CommonConversions.Literal(1));

        return CreateForZeroToValueLoop(loopVariableIdentifier, arrayCopy, sourceArrayCount);
    }

    private static ForStatementSyntax CreateForZeroToValueLoop(SimpleNameSyntax loopVariableIdentifier, StatementSyntax loopStatement, ExpressionSyntax inclusiveLoopUpperBound)
    {
        var loopVariableAssignment = CommonConversions.CreateVariableDeclarationAndAssignment(loopVariableIdentifier.Identifier.Text, CommonConversions.Literal(0));
        var lessThanSourceBounds = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression,
            loopVariableIdentifier, inclusiveLoopUpperBound);
        var incrementors = SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
            SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, loopVariableIdentifier));
        var forStatementSyntax = SyntaxFactory.ForStatement(loopVariableAssignment,
            SyntaxFactory.SeparatedList<ExpressionSyntax>(),
            lessThanSourceBounds, incrementors, loopStatement);
        return forStatementSyntax;
    }

    private static ExpressionStatementSyntax CreateArrayCopyWithMinOfLengths(
        IdentifierNameSyntax sourceExpression, ExpressionSyntax sourceLength,
        ExpressionSyntax targetExpression, ExpressionSyntax targetLength)
    {
        var minLength = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Math.Min"), ExpressionSyntaxExtensions.CreateArgList(targetLength, sourceLength));
        var copyArgList = ExpressionSyntaxExtensions.CreateArgList(sourceExpression, targetExpression, minLength);
        var arrayCopy = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Array.Copy"), copyArgList);
        return SyntaxFactory.ExpressionStatement(arrayCopy);
    }

    private static ExpressionStatementSyntax CreateArrayCopyWithStartingPoints(
        IdentifierNameSyntax sourceExpression, ExpressionSyntax sourceStart,
        ExpressionSyntax targetExpression, ExpressionSyntax targetStart, ExpressionSyntax length)
    {
        var copyArgList = ExpressionSyntaxExtensions.CreateArgList(sourceExpression, sourceStart, targetExpression, targetStart, length);
        var arrayCopy = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Array.Copy"), copyArgList);
        return SyntaxFactory.ExpressionStatement(arrayCopy);
    }

    private ExpressionStatementSyntax CreateNewArrayAssignment(VBSyntax.ExpressionSyntax vbArrayExpression,
        ExpressionSyntax csArrayExpression, List<ExpressionSyntax> convertedBounds)
    {
        var convertedType = (IArrayTypeSymbol) _semanticModel.GetTypeInfo(vbArrayExpression).ConvertedType;
        var arrayRankSpecifierSyntax = SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(convertedBounds));
        var rankSpecifiers = SyntaxFactory.SingletonList(arrayRankSpecifierSyntax);
        while (convertedType.ElementType is IArrayTypeSymbol ats) {
            convertedType = ats;
            rankSpecifiers = rankSpecifiers.Add(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())));
        };
        var typeSyntax = CommonConversions.GetTypeSyntax(convertedType.ElementType);
        var arrayCreation =
            SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(typeSyntax, rankSpecifiers));
        var assignmentExpressionSyntax =
            SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, csArrayExpression, arrayCreation);
        var newArrayAssignment = SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax);
        return newArrayAssignment;
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitThrowStatement(VBSyntax.ThrowStatementSyntax node)
    {
        return SingleStatement(SyntaxFactory.ThrowStatement(await node.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor)));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitReturnStatement(VBSyntax.ReturnStatementSyntax node)
    {
        if (IsIterator)
            return SingleStatement(SyntaxFactory.YieldStatement(SyntaxKind.YieldBreakStatement));

        var csExpression = await node.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        csExpression = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, csExpression);
        return SingleStatement(SyntaxFactory.ReturnStatement(csExpression));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitContinueStatement(VBSyntax.ContinueStatementSyntax node)
    {
        var vbBlockKeywordKind = VBasic.VisualBasicExtensions.Kind(node.BlockKeyword);
        return SyntaxFactory.List(_perScopeState.ConvertContinue(vbBlockKeywordKind));
    }

    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 = typeContainer switch {
                    VBSyntax.LambdaExpressionSyntax e => _semanticModel.GetSymbolInfo(e).Symbol,
                    VBSyntax.MethodBlockSyntax e => _semanticModel.GetDeclaredSymbol(e.SubOrFunctionStatement),
                    VBSyntax.AccessorBlockSyntax e => _semanticModel.GetDeclaredSymbol(e.AccessorStatement),
                    _ => null
                } 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));
        }
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitRaiseEventStatement(VBSyntax.RaiseEventStatementSyntax node)
    {
        var argumentListSyntax = await node.ArgumentList.AcceptAsync<ArgumentListSyntax>(_expressionVisitor) ?? SyntaxFactory.ArgumentList();

        var symbolInfo = _semanticModel.GetSymbolInfo(node.Name).ExtractBestMatch<IEventSymbol>();
        if (symbolInfo?.RaiseMethod != null) {
            return SingleStatement(SyntaxFactory.InvocationExpression(
                ValidSyntaxFactory.IdentifierName($"On{symbolInfo.Name}"),
                argumentListSyntax));
        }

        var memberBindingExpressionSyntax = SyntaxFactory.MemberBindingExpression(ValidSyntaxFactory.IdentifierName("Invoke"));
        var conditionalAccessExpressionSyntax = SyntaxFactory.ConditionalAccessExpression(
            await node.Name.AcceptAsync<NameSyntax>(_expressionVisitor),
            SyntaxFactory.InvocationExpression(memberBindingExpressionSyntax, argumentListSyntax)
        );
        return SingleStatement(
            conditionalAccessExpressionSyntax
        );
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitSingleLineIfStatement(VBSyntax.SingleLineIfStatementSyntax node)
    {
        var condition = await node.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        condition = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Condition, condition, forceTargetType: CommonConversions.KnownTypes.Boolean);
        var block = SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements));
        ElseClauseSyntax elseClause = null;

        if (node.ElseClause != null) {
            var elseBlock = SyntaxFactory.Block(await ConvertStatementsAsync(node.ElseClause.Statements));
            elseClause = SyntaxFactory.ElseClause(elseBlock.UnpackNonNestedBlock());
        }
        return SingleStatement(SyntaxFactory.IfStatement(condition, block.UnpackNonNestedBlock(), elseClause));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitMultiLineIfBlock(VBSyntax.MultiLineIfBlockSyntax node)
    {
        var condition = await node.IfStatement.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        condition = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.IfStatement.Condition, condition, forceTargetType: CommonConversions.KnownTypes.Boolean);
        var block = SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements));

        var elseClause = await ConvertElseClauseAsync(node.ElseBlock);
        elseClause = elseClause.WithVbSourceMappingFrom(node.ElseBlock); //Special case where explicit mapping is needed since block becomes clause so cannot be easily visited

        var elseIfBlocks = await node.ElseIfBlocks.SelectAsync(async elseIf => await ConvertElseIfAsync(elseIf));
        foreach (var elseIf in Enumerable.Reverse(elseIfBlocks)) {
            var ifStmt = SyntaxFactory.IfStatement(elseIf.ElseIfCondition, elseIf.ElseBlock, elseClause);
            elseClause = SyntaxFactory.ElseClause(ifStmt);
        }

        return SingleStatement(SyntaxFactory.IfStatement(condition, block, elseClause));
    }

    private async Task<(ExpressionSyntax ElseIfCondition, BlockSyntax ElseBlock)> ConvertElseIfAsync(VBSyntax.ElseIfBlockSyntax elseIf)
    {
        var elseBlock = SyntaxFactory.Block(await ConvertStatementsAsync(elseIf.Statements));
        var elseIfCondition = await elseIf.ElseIfStatement.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        elseIfCondition = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(elseIf.ElseIfStatement.Condition, elseIfCondition, forceTargetType: CommonConversions.KnownTypes.Boolean);
        return (elseIfCondition, elseBlock);
    }

    private async Task<ElseClauseSyntax> ConvertElseClauseAsync(VBSyntax.ElseBlockSyntax elseBlock)
    {
        if (elseBlock == null) return null;

        var csStatements = await ConvertStatementsAsync(elseBlock.Statements);
        if (csStatements.TryUnpackSingleStatement(out var stmt) && stmt.IsKind(SyntaxKind.IfStatement)) {
            // so that you get a neat "else if" at the end
            return SyntaxFactory.ElseClause(stmt);
        }

        return SyntaxFactory.ElseClause(SyntaxFactory.Block(csStatements));
    }

    private async Task<StatementSyntax[]> ConvertStatementsAsync(SyntaxList<VBSyntax.StatementSyntax> statementSyntaxs)
    {
        return await statementSyntaxs.SelectManyAsync(async s => (IEnumerable<StatementSyntax>)await s.Accept(CommentConvertingVisitor));
    }

    /// <summary>
    /// See https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/for-next-statement#BKMK_Counter
    /// </summary>
    public override async Task<SyntaxList<StatementSyntax>> VisitForBlock(VBSyntax.ForBlockSyntax node)
    {
        var stmt = node.ForStatement;
        VariableDeclarationSyntax declaration = null;
        ExpressionSyntax id;
        var controlVarSymbol  = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol ?? (_semanticModel.GetOperation(stmt.ControlVariable) as IVariableDeclaratorOperation)?.Symbol;
            
        // If missing semantic info, the compiler just guesses object, let's try to improve on that guess:
        var controlVarType = controlVarSymbol?.GetSymbolType().Yield().Concat(
            new SyntaxNode[] {stmt.ControlVariable, stmt.FromValue, stmt.ToValue, stmt.StepClause?.StepValue}
                .Select(exp => _semanticModel.GetTypeInfo(exp).Type)
        ).FirstOrDefault(t => t != null && t.SpecialType != SpecialType.System_Object);
        var startValue = await stmt.FromValue.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        startValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(stmt.FromValue, startValue?.SkipIntoParens(), forceTargetType: controlVarType);
            
        var initializers = new List<ExpressionSyntax>();
        var controlVarTypeSyntax = CommonConversions.GetTypeSyntax(controlVarType);
        if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax v) {
            declaration = (await SplitVariableDeclarationsAsync(v)).Variables.Single().Decl;
            declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
            id = ValidSyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
        } else {
            id = await stmt.ControlVariable.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
                
            if (controlVarSymbol != null && controlVarSymbol.DeclaringSyntaxReferences.Any(r => r.Span.OverlapsWith(stmt.ControlVariable.Span))) {
                declaration = CommonConversions.CreateVariableDeclarationAndAssignment(controlVarSymbol.Name, startValue, controlVarTypeSyntax);
            } else {
                startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue);
                initializers.Add(startValue);
            }
        }

           
        var preLoopStatements = new List<StatementSyntax>();
        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 toVariableId = ValidSyntaxFactory.IdentifierName(loopToVariableName);

            var loopToAssignment = CommonConversions.CreateVariableDeclarator(loopToVariableName, csToValue);
            if (initializers.Any()) {
                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);
            } else {
                declaration = declaration == null
                    ? SyntaxFactory.VariableDeclaration(controlVarTypeSyntax,
                        SyntaxFactory.SingletonSeparatedList(loopToAssignment))
                    : declaration.AddVariables(loopToAssignment).WithType(controlVarTypeSyntax);
            }

            csToValue = toVariableId;
        }

        var (csCondition, csStep) = await ConvertConditionAndStepClauseAsync(stmt, id, csToValue, controlVarType);

        var block = SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements));
        var forStatementSyntax = SyntaxFactory.ForStatement(
            declaration,
            SyntaxFactory.SeparatedList(initializers),
            csCondition,
            SyntaxFactory.SingletonSeparatedList(csStep),
            block.UnpackNonNestedBlock());
        return SyntaxFactory.List(preLoopStatements.Concat(new[] { forStatementSyntax }));
    }

    private async Task<(IReadOnlyCollection<CommonConversions.VariablesDeclaration> Variables, IReadOnlyCollection<CSharpSyntaxNode> Methods)> SplitVariableDeclarationsAsync(VBSyntax.VariableDeclaratorSyntax v, bool preferExplicitType = false)
    {
        return await CommonConversions.SplitVariableDeclarationsAsync(v, _localsToInlineInLoop, preferExplicitType);
    }

    private async Task<(ExpressionSyntax, ExpressionSyntax)> ConvertConditionAndStepClauseAsync(VBSyntax.ForStatementSyntax stmt, ExpressionSyntax id, ExpressionSyntax csToValue, ITypeSymbol controlVarType)
    {
        var vbStepValue = stmt.StepClause?.StepValue;
        var csStepValue = await (stmt.StepClause?.StepValue).AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        // 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);

        var nonNegativeCondition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, csToValue);
        var negativeCondition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, csToValue);
        if (csStepValue == null) {
            return (nonNegativeCondition, SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id));
        }

        ExpressionSyntax csCondition;
        ExpressionSyntax csStep = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, csStepValue);
        var vbStepConstValue = _semanticModel.GetConstantValue(vbStepValue);
        var constValue = !vbStepConstValue.HasValue ? null : (dynamic)vbStepConstValue.Value;
        if (constValue == null) {
            var ifStepNonNegative = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, csStepValue, CommonConversions.Literal(0));
            csCondition = SyntaxFactory.ConditionalExpression(ifStepNonNegative, nonNegativeCondition, negativeCondition);
        } else if (constValue < 0) {
            csCondition = negativeCondition;
            if (csStepValue is PrefixUnaryExpressionSyntax pues && pues.OperatorToken.IsKind(SyntaxKind.MinusToken)) {
                csStep = SyntaxFactory.AssignmentExpression(SyntaxKind.SubtractAssignmentExpression, id, pues.Operand);
            }
        } else {
            csCondition = nonNegativeCondition;
        }

        return (csCondition, csStep);
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitForEachBlock(VBSyntax.ForEachBlockSyntax node)
    {
        var stmt = node.ForEachStatement;

        TypeSyntax type;
        SyntaxToken id;
        List<StatementSyntax> statements = new List<StatementSyntax>();
        if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax vds) {
            var declaration = (await SplitVariableDeclarationsAsync(vds)).Variables.Single().Decl;
            type = declaration.Type;
            id = declaration.Variables.Single().Identifier;
        } else if (_semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol is { } varSymbol) {
            var variableType = varSymbol.GetSymbolType();
            var explicitCastWouldHaveNoEffect = variableType?.SpecialType == SpecialType.System_Object || _semanticModel.GetTypeInfo(stmt.Expression).ConvertedType.IsEnumerableOfExactType(variableType);
            type = CommonConversions.GetTypeSyntax(varSymbol.GetSymbolType(), explicitCastWouldHaveNoEffect);
            var v = await stmt.ControlVariable.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
            if (_localsToInlineInLoop.Contains(varSymbol, SymbolEqualityComparer.IncludeNullability) && v is IdentifierNameSyntax vId) {
                id = vId.Identifier;
            } else {
                id = CommonConversions.CsEscapedIdentifier(GetUniqueVariableNameInScope(node, "current" + varSymbol.Name.ToPascalCase()));
                statements.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, v, ValidSyntaxFactory.IdentifierName(id))));
            }
        } else {
            var v = await stmt.ControlVariable.AcceptAsync<IdentifierNameSyntax>(_expressionVisitor);
            id = v.Identifier;
            type = ValidSyntaxFactory.VarType;
        }

        var block = SyntaxFactory.Block(statements.Concat(await ConvertStatementsAsync(node.Statements)));
        var csExpression = await stmt.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        return SingleStatement(SyntaxFactory.ForEachStatement(
            type,
            id,
            CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(stmt.Expression, csExpression),
            block.UnpackNonNestedBlock()
        ));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitLabelStatement(VBSyntax.LabelStatementSyntax node)
    {
        return SingleStatement(SyntaxFactory.LabeledStatement(CommonConversions.CsEscapedIdentifier(node.LabelToken.Text), SyntaxFactory.EmptyStatement()));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitGoToStatement(VBSyntax.GoToStatementSyntax node)
    {
        return SingleStatement(SyntaxFactory.GotoStatement(SyntaxKind.GotoStatement,
            ValidSyntaxFactory.IdentifierName((node.Label.LabelToken.Text))));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitSelectBlock(VBSyntax.SelectBlockSyntax node)
    {
        var vbExpr = node.SelectStatement.Expression;
        var vbEquality = CommonConversions.VisualBasicEqualityComparison;

        var csSwitchExpr = await vbExpr.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        csSwitchExpr = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(vbExpr, csSwitchExpr);
        var switchExprTypeInfo = _semanticModel.GetTypeInfo(vbExpr);
        var isObjectComparison = switchExprTypeInfo.ConvertedType.SpecialType == SpecialType.System_Object;
        var isStringComparison = !isObjectComparison && 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);
        }

        var usedConstantValues = new HashSet<object>();
        var sections = new List<SwitchSectionSyntax>();
        foreach (var block in node.CaseBlocks) {
            var labels = new List<SwitchLabelSyntax>();
            foreach (var c in block.CaseStatement.Cases) {
                if (c is VBSyntax.SimpleCaseClauseSyntax s) {
                    var originalExpressionSyntax = await s.Value.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
                    var caseTypeInfo = _semanticModel.GetTypeInfo(s.Value);
                    var typeConversionKind = CommonConversions.TypeConversionAnalyzer.AnalyzeConversion(s.Value);
                    var correctTypeExpressionSyntax = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(s.Value, originalExpressionSyntax, typeConversionKind, true, true);
                    var constantValue = _semanticModel.GetConstantValue(s.Value);
                    var notAlreadyUsed = !constantValue.HasValue || usedConstantValues.Add(constantValue.Value);

                    // Pass both halves in case we can optimize away the check based on the switch expr
                    var wrapForStringComparison = isStringComparison && (caseInsensitiveStringComparison ||
                                                                         vbEquality.VbCoerceToNonNullString(vbExpr, csSwitchExpr, switchExprTypeInfo, true, s.Value, originalExpressionSyntax, caseTypeInfo, false).rhs != originalExpressionSyntax);

                    // CSharp requires an explicit cast from the base type (e.g. int) in most cases switching on an enum
                    var isBooleanCase = caseTypeInfo.Type?.SpecialType == SpecialType.System_Boolean;
                    bool enumRelated = IsEnumOrNullableEnum(switchExprTypeInfo.ConvertedType) || IsEnumOrNullableEnum(caseTypeInfo.Type);
                    bool convertingEnum = IsEnumOrNullableEnum(switchExprTypeInfo.ConvertedType) ^ IsEnumOrNullableEnum(caseTypeInfo.Type);
                    var csExpressionToUse = !isObjectComparison && !isBooleanCase && (convertingEnum || !enumRelated && correctTypeExpressionSyntax.IsConst)
                        ? correctTypeExpressionSyntax.Expr
                        : originalExpressionSyntax;

                    var caseSwitchLabelSyntax = !isObjectComparison && !wrapForStringComparison && correctTypeExpressionSyntax.IsConst && notAlreadyUsed
                        ? (SwitchLabelSyntax)SyntaxFactory.CaseSwitchLabel(csExpressionToUse)
                        : WrapInCasePatternSwitchLabelSyntax(node, s.Value, csExpressionToUse, isBooleanCase);
                    labels.Add(caseSwitchLabelSyntax);
                } else if (c is VBSyntax.ElseCaseClauseSyntax) {
                    labels.Add(SyntaxFactory.DefaultSwitchLabel());
                } else if (c is VBSyntax.RelationalCaseClauseSyntax relational) {

                    var operatorKind = VBasic.VisualBasicExtensions.Kind(relational);
                    var csRelationalValue = await relational.Value.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
                    CasePatternSwitchLabelSyntax caseSwitchLabelSyntax;
                    if (isObjectComparison) {
                        caseSwitchLabelSyntax = WrapInCasePatternSwitchLabelSyntax(node, relational.Value, csRelationalValue, false, operatorKind);
                    }
                    else {
                        csRelationalValue = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(relational.Value, csRelationalValue);
                        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) {
                    var varName = CommonConversions.CsEscapedIdentifier(GetUniqueVariableNameInScope(node, "case"));
                    ExpressionSyntax csCaseVar = ValidSyntaxFactory.IdentifierName(varName);
                    var lowerBound = await range.LowerBound.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
                    ExpressionSyntax lowerBoundCheck;
                    if (isObjectComparison) {
                        var caseTypeInfo = _semanticModel.GetTypeInfo(range.LowerBound);
                        lowerBoundCheck = ComparisonAdjustedForStringComparison(node, range.LowerBound, caseTypeInfo, lowerBound, csCaseVar, switchExprTypeInfo, ComparisonKind.LessThanOrEqual);
                    } else {
                        lowerBound = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(range.LowerBound, lowerBound);
                        lowerBoundCheck = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, lowerBound, csCaseVar);
                    }
                    var upperBound = await range.UpperBound.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
                    ExpressionSyntax upperBoundCheck;
                    if (isObjectComparison) {
                        var caseTypeInfo = _semanticModel.GetTypeInfo(range.UpperBound);
                        upperBoundCheck = ComparisonAdjustedForStringComparison(node, range.UpperBound, switchExprTypeInfo, csCaseVar, upperBound, caseTypeInfo, ComparisonKind.LessThanOrEqual);
                    } else {
                        upperBound = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(range.UpperBound, upperBound);
                        upperBoundCheck = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, csCaseVar, upperBound);
                    }
                    var withinBounds = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalAndExpression, lowerBoundCheck, upperBoundCheck);
                    labels.Add(VarWhen(varName, withinBounds));
                } else {
                    throw new NotSupportedException(c.Kind().ToString());
                }
            }

            var csBlockStatements = (await ConvertStatementsAsync(block.Statements)).ToList();
            if (!DefinitelyExits(csBlockStatements.LastOrDefault())) {
                csBlockStatements.Add(SyntaxFactory.BreakStatement());
            }
            var list = SingleStatement(SyntaxFactory.Block(csBlockStatements));
            sections.Add(SyntaxFactory.SwitchSection(SyntaxFactory.List(labels), list));
        }

        var switchStatementSyntax = ValidSyntaxFactory.SwitchStatement(csSwitchExpr, sections);
        return SingleStatement(switchStatementSyntax);
    }

    private static bool DefinitelyExits(StatementSyntax statement)
    {
        if (statement == null) {
            return false;
        }

        StatementSyntax GetLastStatement(StatementSyntax node) => node is BlockSyntax block ? block.Statements.LastOrDefault() : node;
        bool IsExitStatement(StatementSyntax node)
        {
            node = GetLastStatement(node);
            return node != null && node.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.BreakStatement, SyntaxKind.ThrowStatement, SyntaxKind.ContinueStatement);
        }

        if (IsExitStatement(statement)) {
            return true;
        }

        if (statement is not IfStatementSyntax ifStatement) {
            return false;
        }

        while(ifStatement.Else != null) {
            if (!IsExitStatement(ifStatement.Statement)) {
                return false;
            }

            if (ifStatement.Else.Statement is IfStatementSyntax x) {
                ifStatement = x;
            } else {
                return IsExitStatement(ifStatement.Else.Statement);
            }
        }

        return false;
    }

    private static bool IsEnumOrNullableEnum(ITypeSymbol convertedType) =>
        convertedType?.IsEnumType() == true || convertedType?.GetNullableUnderlyingType()?.IsEnumType() == true;

    private static CasePatternSwitchLabelSyntax VarWhen(SyntaxToken varName, ExpressionSyntax binaryExp)
    {
        var patternMatch = ValidSyntaxFactory.VarPattern(varName);
        return SyntaxFactory.CasePatternSwitchLabel(patternMatch,
            SyntaxFactory.WhenClause(binaryExp), SyntaxFactory.Token(SyntaxKind.ColonToken));
    }

    private async Task<(ExpressionSyntax Reusable, SyntaxList<StatementSyntax> Statements, ExpressionSyntax SingleUse)> GetExpressionWithoutSideEffectsAsync(VBSyntax.ExpressionSyntax vbExpr, string variableNameBase)
    {
        var expr = await vbExpr.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        expr = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(vbExpr, expr);
        SyntaxList<StatementSyntax> stmts = SyntaxFactory.List<StatementSyntax>();
        ExpressionSyntax exprWithoutSideEffects;
        ExpressionSyntax reusableExprWithoutSideEffects;
        if (IsReusableReadOnlyLocalKind(_semanticModel.GetSymbolInfo(vbExpr).Symbol) || await CanEvaluateMultipleTimesAsync(vbExpr)) {
            exprWithoutSideEffects = expr;
            reusableExprWithoutSideEffects = expr.WithoutSourceMapping();
        } else {
            TypeSyntax forceType = null;
            if (_semanticModel.GetOperation(vbExpr.SkipIntoParens()).IsAssignableExpression()) {
                forceType = SyntaxFactory.RefType(ValidSyntaxFactory.VarType);
                expr = SyntaxFactory.RefExpression(expr);
            }

            var (stmt, id) = CreateLocalVariableWithUniqueName(vbExpr, variableNameBase, expr, forceType);
            stmts = stmts.Add(stmt);
            reusableExprWithoutSideEffects = exprWithoutSideEffects = id;
        }

        return (reusableExprWithoutSideEffects, stmts, exprWithoutSideEffects);
    }

    private static bool IsReusableReadOnlyLocalKind(ISymbol symbol) => symbol is ILocalSymbol ls && (VBasic.VisualBasicExtensions.IsForEach(ls) || ls.IsUsing);

    private (StatementSyntax Declaration, IdentifierNameSyntax Reference) CreateLocalVariableWithUniqueName(VBSyntax.ExpressionSyntax vbExpr, string variableNameBase, ExpressionSyntax expr, TypeSyntax forceType = null)
    {
        var contextNode = vbExpr.GetAncestor<VBSyntax.MethodBlockBaseSyntax>() ?? (VBasic.VisualBasicSyntaxNode) vbExpr.Parent;
        return CreateLocalVariableWithUniqueName(contextNode, variableNameBase, expr, forceType);
    }

    private (StatementSyntax Declaration, IdentifierNameSyntax Reference) CreateLocalVariableWithUniqueName(VisualBasicSyntaxNode contextNode, string variableNameBase, ExpressionSyntax expr, TypeSyntax forceType = null)
    {
        var varName = GetUniqueVariableNameInScope(contextNode, variableNameBase);
        var stmt = CommonConversions.CreateLocalVariableDeclarationAndAssignment(varName, expr, forceType);
        return (stmt, ValidSyntaxFactory.IdentifierName(varName));
    }

    private async Task<bool> CanEvaluateMultipleTimesAsync(VBSyntax.ExpressionSyntax vbExpr)
    {
        return _semanticModel.GetConstantValue(vbExpr).HasValue || vbExpr.IsKind(VBasic.SyntaxKind.MeExpression) || vbExpr.SkipIntoParens() is VBSyntax.NameSyntax ns && await IsNeverMutatedAsync(ns);
    }

    private async Task<bool> IsNeverMutatedAsync(VBSyntax.NameSyntax ns)
    {
        var allowedLocation = Location.Create(ns.SyntaxTree, TextSpan.FromBounds(ns.GetAncestor<VBSyntax.MethodBlockBaseSyntax>().SpanStart, ns.Span.End));
        var symbol = _semanticModel.GetSymbolInfo(ns).Symbol;
        //Perf optimization: Looking across the whole solution is expensive, so assume non-local symbols are written somewhere
        return symbol.MatchesKind(SymbolKind.Parameter, SymbolKind.Local) && await CommonConversions.Document.Project.Solution.IsNeverWrittenAsync(symbol, allowedLocation);
    }

    private CasePatternSwitchLabelSyntax WrapInCasePatternSwitchLabelSyntax(VBSyntax.SelectBlockSyntax node, VBSyntax.ExpressionSyntax vbCase, ExpressionSyntax expression, bool treatAsBoolean = false, VBasic.SyntaxKind caseClauseKind = VBasic.SyntaxKind.CaseEqualsClause)
    {
        var typeInfo = _semanticModel.GetTypeInfo(node.SelectStatement.Expression);

        DeclarationPatternSyntax patternMatch;
        if (typeInfo.ConvertedType.SpecialType == SpecialType.System_Boolean || treatAsBoolean) {
            patternMatch = SyntaxFactory.DeclarationPattern(
                SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)),
                SyntaxFactory.DiscardDesignation());
        } else {
            var varName = CommonConversions.CsEscapedIdentifier(GetUniqueVariableNameInScope(node, "case"));
            patternMatch = ValidSyntaxFactory.VarPattern(varName);
            ExpressionSyntax csLeft = ValidSyntaxFactory.IdentifierName(varName), csRight = expression;
            var caseTypeInfo = _semanticModel.GetTypeInfo(vbCase);
            expression = ComparisonAdjustedForStringComparison(node, vbCase, typeInfo, csLeft, csRight, caseTypeInfo, GetComparisonKind(caseClauseKind));
        }

        var colonToken = SyntaxFactory.Token(SyntaxKind.ColonToken);
        return SyntaxFactory.CasePatternSwitchLabel(patternMatch, SyntaxFactory.WhenClause(expression), colonToken);
    }

    private ComparisonKind GetComparisonKind(VBasic.SyntaxKind caseClauseKind) => caseClauseKind switch {
        VBasic.SyntaxKind.CaseLessThanClause => ComparisonKind.LessThan,
        VBasic.SyntaxKind.CaseLessThanOrEqualClause => ComparisonKind.LessThanOrEqual,
        VBasic.SyntaxKind.CaseEqualsClause => ComparisonKind.Equals,
        VBasic.SyntaxKind.CaseNotEqualsClause => ComparisonKind.NotEquals,
        VBasic.SyntaxKind.CaseGreaterThanOrEqualClause => ComparisonKind.GreaterThanOrEqual,
        VBasic.SyntaxKind.CaseGreaterThanClause => ComparisonKind.GreaterThan,
        _ => throw new ArgumentOutOfRangeException(nameof(caseClauseKind), caseClauseKind, null)
    };

    private ExpressionSyntax ComparisonAdjustedForStringComparison(VBSyntax.SelectBlockSyntax node, VBSyntax.ExpressionSyntax vbCase, TypeInfo lhsTypeInfo, ExpressionSyntax csLeft, ExpressionSyntax csRight, TypeInfo rhsTypeInfo, ComparisonKind comparisonKind)
    {
        var vbEquality = CommonConversions.VisualBasicEqualityComparison;
        switch (_visualBasicEqualityComparison.GetObjectEqualityType(lhsTypeInfo, rhsTypeInfo)) {
            case VisualBasicEqualityComparison.RequiredType.Object:
                return vbEquality.GetFullExpressionForVbObjectComparison(csLeft, csRight, comparisonKind);
            case VisualBasicEqualityComparison.RequiredType.StringOnly:
                // We know lhs isn't null, because we always coalesce it in the switch expression
                (csLeft, csRight) = vbEquality
                    .AdjustForVbStringComparison(node.SelectStatement.Expression, csLeft, lhsTypeInfo, true, vbCase, csRight, rhsTypeInfo, false);
                break;
        }
        return SyntaxFactory.BinaryExpression(GetSyntaxKind(comparisonKind), csLeft, csRight);
    }

    private CS.SyntaxKind GetSyntaxKind(ComparisonKind comparisonKind) => comparisonKind switch {
        ComparisonKind.LessThan => CS.SyntaxKind.LessThanExpression,
        ComparisonKind.LessThanOrEqual => CS.SyntaxKind.LessThanOrEqualExpression,
        ComparisonKind.Equals => CS.SyntaxKind.EqualsExpression,
        ComparisonKind.NotEquals => CS.SyntaxKind.NotEqualsExpression,
        ComparisonKind.GreaterThanOrEqual => CS.SyntaxKind.GreaterThanOrEqualExpression,
        ComparisonKind.GreaterThan => CS.SyntaxKind.GreaterThanExpression,
        _ => throw new ArgumentOutOfRangeException(nameof(comparisonKind), comparisonKind, null)
    };

    public override async Task<SyntaxList<StatementSyntax>> VisitWithBlock(VBSyntax.WithBlockSyntax node)
    {
        var (lhsExpression, prefixDeclarations, _) = await GetExpressionWithoutSideEffectsAsync(node.WithStatement.Expression, "withBlock");

        _withBlockLhs.Push(lhsExpression);
        try {
            var statements = await ConvertStatementsAsync(node.Statements);

            var statementSyntaxs = SyntaxFactory.List(prefixDeclarations.Concat(statements));
            return prefixDeclarations.Any()
                ? SingleStatement(SyntaxFactory.Block(statementSyntaxs))
                : statementSyntaxs;
        } finally {
            _withBlockLhs.Pop();
        }
    }

    private string GetUniqueVariableNameInScope(VBasic.VisualBasicSyntaxNode node, string variableNameBase)
    {
        return NameGenerator.CS.GetUniqueVariableNameInScope(_semanticModel, _generatedNames, node, variableNameBase);
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitTryBlock(VBSyntax.TryBlockSyntax node)
    {
        var block = SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements));
        return SingleStatement(
            SyntaxFactory.TryStatement(
                block,
                SyntaxFactory.List(await node.CatchBlocks.SelectAsync(async c => await ConvertCatchBlockAsync(c))),
                await ConvertFinallyBlockAsync(node.FinallyBlock)
            )
        );

        async Task<CatchClauseSyntax> ConvertCatchBlockAsync(VBasic.Syntax.CatchBlockSyntax node)
        {
            var stmt = node.CatchStatement;
            CatchDeclarationSyntax catcher = null;
            if (stmt.AsClause != null) {
                catcher = SyntaxFactory.CatchDeclaration(
                    ConvertTypeSyntax(stmt.AsClause.Type),
                    CommonConversions.ConvertIdentifier(stmt.IdentifierName.Identifier)
                );
            }

            var filter = await ConvertCatchFilterClauseAsync(stmt.WhenClause);
            var stmts = await node.Statements.SelectManyAsync(async s => (IEnumerable<StatementSyntax>)await s.Accept(CommentConvertingVisitor));
            return SyntaxFactory.CatchClause(
                catcher,
                filter,
                SyntaxFactory.Block(stmts)
            );
        }

        async Task<CatchFilterClauseSyntax> ConvertCatchFilterClauseAsync(VBasic.Syntax.CatchFilterClauseSyntax node)
        {
            if (node == null) return null;
            return SyntaxFactory.CatchFilterClause(await node.Filter.AcceptAsync<ExpressionSyntax>(_expressionVisitor));
        }

        async Task<FinallyClauseSyntax> ConvertFinallyBlockAsync(VBasic.Syntax.FinallyBlockSyntax node)
        {
            if (node == null) return null;
            var stmts = await node.Statements.SelectManyAsync(async s => (IEnumerable<StatementSyntax>)await s.Accept(CommentConvertingVisitor));
            return SyntaxFactory.FinallyClause(SyntaxFactory.Block(stmts));
        }
    }

    private TypeSyntax ConvertTypeSyntax(VBSyntax.TypeSyntax vbType)
    {
        if (_semanticModel.GetSymbolInfo(vbType).Symbol is ITypeSymbol typeSymbol)
            return CommonConversions.GetTypeSyntax(typeSymbol);
        return SyntaxFactory.ParseTypeName(vbType.ToString());
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitSyncLockBlock(VBSyntax.SyncLockBlockSyntax node)
    {
        return SingleStatement(SyntaxFactory.LockStatement(
            await node.SyncLockStatement.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor),
            SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements)).UnpackNonNestedBlock()
        ));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitUsingBlock(VBSyntax.UsingBlockSyntax node)
    {
        var statementSyntax = SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements));
        if (node.UsingStatement.Expression == null) {
            StatementSyntax stmt = statementSyntax;
            foreach (var v in node.UsingStatement.Variables.Reverse())
            foreach (var declaration in (await SplitVariableDeclarationsAsync(v)).Variables.Reverse())
                stmt = SyntaxFactory.UsingStatement(declaration.Decl, null, stmt);
            return SingleStatement(stmt);
        }

        var expr = await node.UsingStatement.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
        var unpackPossiblyNestedBlock = statementSyntax.UnpackPossiblyNestedBlock(); // Allow reduced indentation for multiple usings in a row
        return SingleStatement(SyntaxFactory.UsingStatement(null, expr, unpackPossiblyNestedBlock));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitWhileBlock(VBSyntax.WhileBlockSyntax node)
    {
        return SingleStatement(SyntaxFactory.WhileStatement(
            await node.WhileStatement.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor),
            SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements)).UnpackNonNestedBlock()
        ));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitDoLoopBlock(VBSyntax.DoLoopBlockSyntax node)
    {
        var statements = SyntaxFactory.Block(await ConvertStatementsAsync(node.Statements)).UnpackNonNestedBlock();

        if (node.DoStatement.WhileOrUntilClause != null) {
            var stmt = node.DoStatement.WhileOrUntilClause;
            if (stmt.WhileOrUntilKeyword.IsKind(VBasic.SyntaxKind.WhileKeyword))
                return SingleStatement(SyntaxFactory.WhileStatement(
                    await stmt.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor),
                    statements
                ));
            return SingleStatement(SyntaxFactory.WhileStatement(
                (await stmt.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor)).InvertCondition(),
                statements
            ));
        }

        var whileOrUntilStmt = node.LoopStatement.WhileOrUntilClause;
        ExpressionSyntax conditionExpression;
        bool isUntilStmt;
        if (whileOrUntilStmt != null) {
            conditionExpression = await whileOrUntilStmt.Condition.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
            isUntilStmt = whileOrUntilStmt.WhileOrUntilKeyword.IsKind(VBasic.SyntaxKind.UntilKeyword);
        } else {
            conditionExpression = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression);
            isUntilStmt = false;
        }

        if (isUntilStmt) {
            conditionExpression = conditionExpression.InvertCondition();
        }

        return SingleStatement(SyntaxFactory.DoStatement(statements, conditionExpression));
    }

    public override async Task<SyntaxList<StatementSyntax>> VisitCallStatement(VBSyntax.CallStatementSyntax node)
    {
        return SingleStatement(await node.Invocation.AcceptAsync<ExpressionSyntax>(_expressionVisitor));
    }

    private static SyntaxList<StatementSyntax> SingleStatement(StatementSyntax statement)
    {
        return SyntaxFactory.SingletonList(statement);
    }

    private static SyntaxList<StatementSyntax> SingleStatement(ExpressionSyntax expression)
    {
        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)
    };
}