File: src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\RemoveUnreachableCodeHelpers.cs
Web Access
Project: Microsoft.CodeAnalysis.CSharp.CodeStyle.csproj (Microsoft.CodeAnalysis.CSharp.CodeStyle)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System.Collections.Immutable;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.PooledObjects;

namespace Microsoft.CodeAnalysis.CSharp.RemoveUnreachableCode;

internal static class RemoveUnreachableCodeHelpers
{
    public static ImmutableArray<ImmutableArray<StatementSyntax>> GetSubsequentUnreachableSections(StatementSyntax firstUnreachableStatement)
    {
        ImmutableArray<StatementSyntax> siblingStatements;
        switch (firstUnreachableStatement.Parent)
        {
            case BlockSyntax block:
                siblingStatements = [.. block.Statements];
                break;

            case SwitchSectionSyntax switchSection:
                siblingStatements = [.. switchSection.Statements];
                break;

            case GlobalStatementSyntax globalStatement:
                if (globalStatement.Parent is not CompilationUnitSyntax compilationUnit)
                {
                    return [];
                }

                {
                    // Can't use `SyntaxList<TNode>` here since the retrieving the added node will result
                    // in a different reference.
                    using var _ = ArrayBuilder<StatementSyntax>.GetInstance(out var builder);
                    foreach (var member in compilationUnit.Members)
                    {
                        if (member is not GlobalStatementSyntax currentGlobalStatement)
                        {
                            continue;
                        }

                        builder.Add(currentGlobalStatement.Statement);
                    }

                    siblingStatements = builder.ToImmutable();
                }

                break;

            default:
                // We're an embedded statement.  So the unreachable section is just us.
                return [];
        }

        var sections = ArrayBuilder<ImmutableArray<StatementSyntax>>.GetInstance();

        var currentSection = ArrayBuilder<StatementSyntax>.GetInstance();
        var firstUnreachableStatementIndex = siblingStatements.IndexOf(firstUnreachableStatement);

        for (int i = firstUnreachableStatementIndex + 1, n = siblingStatements.Length; i < n; i++)
        {
            var currentStatement = siblingStatements[i];
            if (currentStatement.IsKind(SyntaxKind.LabeledStatement))
            {
                // In the case of a subsequent labeled statement, we don't want to consider it 
                // unreachable as there may be a 'goto' somewhere else to that label.  If the 
                // compiler actually thinks that label is unreachable, it will give an diagnostic 
                // on that label itself  and we can use that diagnostic to handle it and any 
                // subsequent sections.
                break;
            }

            if (currentStatement.IsKind(SyntaxKind.LocalFunctionStatement))
            {
                // In the case of local functions, it is legal for a local function to be declared
                // in code that is otherwise unreachable.  It can still be called elsewhere.  If
                // the local function itself is not called, there will be a particular diagnostic
                // for that ("The variable XXX is declared but never used") and the user can choose
                // if they want to remove it or not. 
                var section = currentSection.ToImmutableAndFree();
                AddIfNonEmpty(sections, section);

                currentSection = ArrayBuilder<StatementSyntax>.GetInstance();
                continue;
            }

            currentSection.Add(currentStatement);
        }

        var lastSection = currentSection.ToImmutableAndFree();
        AddIfNonEmpty(sections, lastSection);

        return sections.ToImmutableAndFree();
    }

    private static void AddIfNonEmpty(ArrayBuilder<ImmutableArray<StatementSyntax>> sections, ImmutableArray<StatementSyntax> lastSection)
    {
        if (!lastSection.IsEmpty)
        {
            sections.Add(lastSection);
        }
    }
}