﻿// 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;
using System.Collections.Immutable;
using System.Composition;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Formatting;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Simplification;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp.CodeRefactorings.UseRecursivePatterns
{
    using static SyntaxFactory;
    using static SyntaxKind;

    [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.UseRecursivePatterns), Shared]
    internal sealed class UseRecursivePatternsCodeRefactoringProvider : SyntaxEditorBasedCodeRefactoringProvider
    {
        private static readonly PatternSyntax s_trueConstantPattern = ConstantPattern(LiteralExpression(TrueLiteralExpression));
        private static readonly PatternSyntax s_falseConstantPattern = ConstantPattern(LiteralExpression(FalseLiteralExpression));

        [ImportingConstructor]
        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
        public UseRecursivePatternsCodeRefactoringProvider()
        {
        }

        protected override ImmutableArray<FixAllScope> SupportedFixAllScopes => AllFixAllScopes;

        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
        {
            var (document, textSpan, cancellationToken) = context;
            if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)
                return;

            if (textSpan.Length > 0)
                return;

            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            if (root.SyntaxTree.Options.LanguageVersion() < LanguageVersion.CSharp9)
                return;

            var model = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
            var node = root.FindToken(textSpan.Start).Parent;
            var replacementFunc = GetReplacementFunc(node, model);
            if (replacementFunc is null)
                return;

            context.RegisterRefactoring(
                CodeAction.Create(
                    CSharpFeaturesResources.Use_recursive_patterns,
                    _ => Task.FromResult(document.WithSyntaxRoot(replacementFunc(root))),
                    nameof(CSharpFeaturesResources.Use_recursive_patterns)));
        }

        private static Func<SyntaxNode, SyntaxNode>? GetReplacementFunc(SyntaxNode? node, SemanticModel model)
            => node switch
            {
                BinaryExpressionSyntax(LogicalAndExpression) logicalAnd => CombineLogicalAndOperands(logicalAnd, model),
                CasePatternSwitchLabelSyntax { WhenClause: { } whenClause } switchLabel => CombineWhenClauseCondition(switchLabel.Pattern, whenClause.Condition, model),
                SwitchExpressionArmSyntax { WhenClause: { } whenClause } switchArm => CombineWhenClauseCondition(switchArm.Pattern, whenClause.Condition, model),
                WhenClauseSyntax { Parent: CasePatternSwitchLabelSyntax switchLabel } whenClause => CombineWhenClauseCondition(switchLabel.Pattern, whenClause.Condition, model),
                WhenClauseSyntax { Parent: SwitchExpressionArmSyntax switchArm } whenClause => CombineWhenClauseCondition(switchArm.Pattern, whenClause.Condition, model),
                _ => null
            };

        private static bool IsFixableNode(SyntaxNode node)
            => node switch
            {
                BinaryExpressionSyntax(LogicalAndExpression) => true,
                CasePatternSwitchLabelSyntax { WhenClause: { } whenClause } => true,
                SwitchExpressionArmSyntax { WhenClause: { } whenClause } => true,
                WhenClauseSyntax { Parent: CasePatternSwitchLabelSyntax } => true,
                WhenClauseSyntax { Parent: SwitchExpressionArmSyntax } => true,
                _ => false
            };

        private static Func<SyntaxNode, SyntaxNode>? CombineLogicalAndOperands(BinaryExpressionSyntax logicalAnd, SemanticModel model)
        {
            if (TryDetermineReceiver(logicalAnd.Left, model) is not var (leftReceiver, leftTarget, leftFlipped) ||
                TryDetermineReceiver(logicalAnd.Right, model) is not var (rightReceiver, rightTarget, rightFlipped))
            {
                return null;
            }

            // If we have an is-expression on the left, first we check if there is a variable designation that's been used on the right-hand-side,
            // in which case, we'll convert and move the check inside the existing pattern, if possible.
            // For instance, `e is C c && c.p == 0` is converted to `e is C { p: 0 } c`
            if (leftTarget.Parent is IsPatternExpressionSyntax isPatternExpression &&
                TryFindVariableDesignation(isPatternExpression.Pattern, rightReceiver, model) is var (containingPattern, rightNamesOpt))
            {
                Debug.Assert(leftTarget == isPatternExpression.Pattern);
                Debug.Assert(leftReceiver == isPatternExpression.Expression);
                return root =>
                {
                    var rightPattern = CreatePattern(rightReceiver, rightTarget, rightFlipped);
                    var rewrittenPattern = RewriteContainingPattern(containingPattern, rightPattern, rightNamesOpt);
                    var replacement = isPatternExpression.ReplaceNode(containingPattern, rewrittenPattern);
                    return root.ReplaceNode(logicalAnd, AdjustBinaryExpressionOperands(logicalAnd, replacement));
                };
            }

            if (TryGetCommonReceiver(leftReceiver, rightReceiver, model) is var (commonReceiver, leftNames, rightNames))
            {
                return root =>
                {
                    var leftSubpattern = CreateSubpattern(leftNames, CreatePattern(leftReceiver, leftTarget, leftFlipped));
                    var rightSubpattern = CreateSubpattern(rightNames, CreatePattern(rightReceiver, rightTarget, rightFlipped));
                    var replacement = IsPatternExpression(commonReceiver, RecursivePattern(leftSubpattern, rightSubpattern));
                    return root.ReplaceNode(logicalAnd, AdjustBinaryExpressionOperands(logicalAnd, replacement));
                };
            }

            return null;

            static SyntaxNode AdjustBinaryExpressionOperands(BinaryExpressionSyntax logicalAnd, ExpressionSyntax replacement)
            {
                // If there's a `&&` on the left, we have picked the right-hand-side for the combination.
                // In which case, we should replace that instead of the whole `&&` operator in a chain.
                // For instance, `expr && a.b == 1 && a.c == 2` is converted to `expr && a is { b: 1, c: 2 }`
                if (logicalAnd.Left is BinaryExpressionSyntax(LogicalAndExpression) leftExpression)
                    replacement = leftExpression.WithRight(replacement);
                return replacement.ConvertToSingleLine().WithAdditionalAnnotations(Formatter.Annotation);
            }
        }

        private static Func<SyntaxNode, SyntaxNode>? CombineWhenClauseCondition(PatternSyntax switchPattern, ExpressionSyntax condition, SemanticModel model)
        {
            if (TryDetermineReceiver(condition, model, inWhenClause: true) is not var (receiver, target, flipped) ||
                TryFindVariableDesignation(switchPattern, receiver, model) is not var (containingPattern, namesOpt))
            {
                return null;
            }

            return root =>
            {
                var editor = new SyntaxEditor(root, CSharpSyntaxGenerator.Instance);
                switch (receiver.GetRequiredParent().Parent)
                {
                    // This is the leftmost `&&` operand in a when-clause. Remove the left-hand-side which we've just morphed in the switch pattern.
                    // For instance, `case { p: var v } when v.q == 1 && expr:` would be converted to `case { p: { q: 1 } } v when expr:`
                    case BinaryExpressionSyntax(LogicalAndExpression) logicalAnd:
                        editor.ReplaceNode(logicalAnd, logicalAnd.Right);
                        break;
                    // If we reach here, there's no other expression left in the when-clause. Remove.
                    // For instance, `case { p: var v } when v.q == 1:` would be converted to `case { p: { q: 1 } v }:`
                    case WhenClauseSyntax whenClause:
                        editor.RemoveNode(whenClause, SyntaxRemoveOptions.AddElasticMarker);
                        break;
                    case var v:
                        throw ExceptionUtilities.UnexpectedValue(v);
                }

                var generatedPattern = CreatePattern(receiver, target, flipped);
                var rewrittenPattern = RewriteContainingPattern(containingPattern, generatedPattern, namesOpt);
                editor.ReplaceNode(containingPattern, rewrittenPattern);
                return editor.GetChangedRoot();
            };
        }

        private static PatternSyntax RewriteContainingPattern(
            PatternSyntax containingPattern,
            PatternSyntax generatedPattern,
            ImmutableArray<IdentifierNameSyntax> namesOpt)
        {
            // This is a variable designation match. We'll try to combine the generated
            // pattern from the right-hand-side into the containing pattern of this designation.
            var rewrittenPattern = namesOpt.IsDefault
                // If there's no name, we will combine the pattern itself.
                ? Combine(containingPattern, generatedPattern)
                // Otherwise, we generate a subpattern per each name and rewrite as a recursive pattern.
                : AddSubpattern(containingPattern, CreateSubpattern(namesOpt, generatedPattern));

            return rewrittenPattern.ConvertToSingleLine().WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);

            static PatternSyntax Combine(PatternSyntax containingPattern, PatternSyntax generatedPattern)
            {
                // We know we have a var-pattern, declaration-pattern or a recursive-pattern on the left as the containing node of the variable designation.
                // Depending on the generated pattern off of the expression on the right, we can give a better result by morphing it into the existing match.
                return (containingPattern, generatedPattern) switch
                {
                    // e.g. `e is var x && x is { p: 1 }` => `e is { p: 1 } x`
                    (VarPatternSyntax var, RecursivePatternSyntax { Designation: null } recursive)
                        => recursive.WithDesignation(var.Designation),

                    // e.g. `e is C x && x is { p: 1 }` => `is C { p: 1 } x`
                    (DeclarationPatternSyntax decl, RecursivePatternSyntax { Type: null, Designation: null } recursive)
                        => recursive.WithType(decl.Type).WithDesignation(decl.Designation),

                    // e.g. `e is { p: 1 } x && x is C` => `is C { p: 1 } x`
                    (RecursivePatternSyntax { Type: null } recursive, TypePatternSyntax type)
                        => recursive.WithType(type.Type),

                    // e.g. `e is { p: 1 } x && x is { q: 2 }` => `e is { p: 1, q: 2 } x`
                    (RecursivePatternSyntax recursive, RecursivePatternSyntax { Type: null, Designation: null } other)
                        when recursive.PositionalPatternClause is null || other.PositionalPatternClause is null
                        => recursive
                            .WithPositionalPatternClause(recursive.PositionalPatternClause ?? other.PositionalPatternClause)
                            .WithPropertyPatternClause(Concat(recursive.PropertyPatternClause, other.PropertyPatternClause)),

                    // In any other case, we fallback to an `and` pattern.
                    // UNDONE: This may result in a few unused variables which should be removed in a later pass.
                    _ => BinaryPattern(AndPattern, containingPattern.Parenthesize(), generatedPattern.Parenthesize()),
                };
            }

            static PatternSyntax AddSubpattern(PatternSyntax containingPattern, SubpatternSyntax subpattern)
            {
                return containingPattern switch
                {
                    // e.g. `case var x when x.p is 1` => `case { p: 1 } x`
                    VarPatternSyntax p => RecursivePattern(type: null, subpattern, p.Designation),

                    // e.g. `case Type x when x.p is 1` => `case Type { p: 1 } x`
                    DeclarationPatternSyntax p => RecursivePattern(p.Type, subpattern, p.Designation),

                    // e.g. `case { p: 1 } x when x.q is 2` => `case { p: 1, q: 2 } x`
                    RecursivePatternSyntax p => p.AddPropertyPatternClauseSubpatterns(subpattern),

                    // We've already checked that the designation is contained in any of the above pattern forms.
                    var p => throw ExceptionUtilities.UnexpectedValue(p)
                };
            }

            static PropertyPatternClauseSyntax? Concat(PropertyPatternClauseSyntax? left, PropertyPatternClauseSyntax? right)
            {
                if (left is null || right is null)
                    return left ?? right;
                return left.WithSubpatterns(left.Subpatterns.AddRange(right.Subpatterns));
            }
        }

        private static PatternSyntax CreatePattern(ExpressionSyntax originalReceiver, ExpressionOrPatternSyntax target, bool flipped)
        {
            return target switch
            {
                // A pattern come from an `is` expression on either side of `&&`
                PatternSyntax pattern => pattern,
                TypeSyntax type when originalReceiver.IsParentKind(IsExpression) => TypePattern(type),
                // Otherwise, this is a constant. Depending on the original receiver, we create an appropriate pattern.
                ExpressionSyntax constant => originalReceiver.Parent switch
                {
                    BinaryExpressionSyntax(EqualsExpression) => ConstantPattern(constant),
                    BinaryExpressionSyntax(NotEqualsExpression) => UnaryPattern(ConstantPattern(constant)),
                    BinaryExpressionSyntax(GreaterThanExpression or
                                           GreaterThanOrEqualExpression or
                                           LessThanOrEqualExpression or
                                           LessThanExpression) e
                        => RelationalPattern(flipped ? Flip(e.OperatorToken) : e.OperatorToken, constant),
                    var v => throw ExceptionUtilities.UnexpectedValue(v),
                },
                var v => throw ExceptionUtilities.UnexpectedValue(v),
            };

            static SyntaxToken Flip(SyntaxToken token)
            {
                return Token(token.Kind() switch
                {
                    LessThanToken => GreaterThanToken,
                    LessThanEqualsToken => GreaterThanEqualsToken,
                    GreaterThanEqualsToken => LessThanEqualsToken,
                    GreaterThanToken => LessThanToken,
                    var v => throw ExceptionUtilities.UnexpectedValue(v)
                });
            }
        }

        private static (PatternSyntax ContainingPattern, ImmutableArray<IdentifierNameSyntax> NamesOpt)? TryFindVariableDesignation(
            PatternSyntax leftPattern,
            ExpressionSyntax rightReceiver,
            SemanticModel model)
        {
            using var _ = ArrayBuilder<IdentifierNameSyntax>.GetInstance(out var names);
            if (GetInnermostReceiver(rightReceiver, names, model) is not IdentifierNameSyntax identifierName)
                return null;

            var designation = leftPattern.DescendantNodes()
                .OfType<SingleVariableDesignationSyntax>()
                .Where(d => d.Identifier.ValueText == identifierName.Identifier.ValueText)
                .FirstOrDefault();

            // Excluding list patterns because those cannot be combined with a recursive pattern.
            if (designation is not { Parent: PatternSyntax(not SyntaxKind.ListPattern) containingPattern })
                return null;

            // Only the following patterns can directly contain a variable designation.
            // Note: While a parenthesized designation can also contain other variables,
            // it is not a pattern, so it would not get past the PatternSyntax test above.
            Debug.Assert(containingPattern.Kind() is SyntaxKind.VarPattern or SyntaxKind.DeclarationPattern or SyntaxKind.RecursivePattern);
            return (containingPattern, names.ToImmutableOrNull());
        }

        private static (ExpressionSyntax Receiver, ExpressionOrPatternSyntax Target, bool Flipped)? TryDetermineReceiver(
            ExpressionSyntax node,
            SemanticModel model,
            bool inWhenClause = false)
        {
            return node switch
            {
                // For comparison operators, after we have determined the
                // constant operand, we rewrite it as a constant or relational pattern.
                BinaryExpressionSyntax(EqualsExpression or
                                       NotEqualsExpression or
                                       GreaterThanExpression or
                                       GreaterThanOrEqualExpression or
                                       LessThanOrEqualExpression or
                                       LessThanExpression) expr
                    => TryDetermineConstant(expr, model),

                // If we found a `&&` here, there's two possibilities:
                //
                //  1) If we're in a when-clause, we look for the leftmost expression
                //     which we will try to combine with the switch arm/label pattern.
                //     For instance, we return `a` if we have `case <pat> when a && b && c`.
                //
                //  2) Otherwise, we will return the operand that *appears* to be on the left in the source.
                //     For instance, we return `a` if we have `x && a && b` with the cursor on the second operator.
                //     Since `&&` is left-associative, it's guaranteed to be the expression that we want.
                //     For simplicity, we won't descend into any parenthesized expression here.
                //
                BinaryExpressionSyntax(LogicalAndExpression) expr => TryDetermineReceiver(inWhenClause ? expr.Left : expr.Right, model, inWhenClause),

                // If we have an `is` operator, we'll try to combine the existing pattern/type with the other operand.
                BinaryExpressionSyntax(IsExpression) { Right: NullableTypeSyntax type } expr => (expr.Left, type.ElementType, Flipped: false),
                BinaryExpressionSyntax(IsExpression) { Right: TypeSyntax type } expr => (expr.Left, type, Flipped: false),
                IsPatternExpressionSyntax expr => (expr.Expression, expr.Pattern, Flipped: false),

                // We treat any other expression as if they were compared to true/false.
                // For instance, `a.b && !a.c` will be converted to `a is { b: true, c: false }`
                PrefixUnaryExpressionSyntax(LogicalNotExpression) expr => (expr.Operand, s_falseConstantPattern, Flipped: false),
                var expr => (expr, s_trueConstantPattern, Flipped: false),
            };

            static (ExpressionSyntax Expression, ExpressionSyntax Constant, bool Flipped)? TryDetermineConstant(BinaryExpressionSyntax node, SemanticModel model)
            {
                return (node.Left, node.Right) switch
                {
                    var (left, right) when model.GetConstantValue(left).HasValue => (right, left, Flipped: true),
                    var (left, right) when model.GetConstantValue(right).HasValue => (left, right, Flipped: false),
                    _ => null
                };
            }
        }

        private static SubpatternSyntax CreateSubpattern(ImmutableArray<IdentifierNameSyntax> names, PatternSyntax pattern)
        {
            Debug.Assert(!names.IsDefaultOrEmpty);

            if (names.Length > 1 && names[0].SyntaxTree.Options.LanguageVersion() >= LanguageVersion.CSharp10)
            {
                ExpressionSyntax expression = names[^1];
                for (var i = names.Length - 2; i >= 0; i--)
                    expression = MemberAccessExpression(SimpleMemberAccessExpression, expression, names[i]);
                return SyntaxFactory.Subpattern(ExpressionColon(expression, Token(ColonToken)), pattern);
            }
            else
            {
                var subpattern = Subpattern(names[0], pattern);
                for (var i = 1; i < names.Length; i++)
                    subpattern = Subpattern(names[i], RecursivePattern(subpattern));
                return subpattern;
            }
        }

        private static SubpatternSyntax Subpattern(IdentifierNameSyntax name, PatternSyntax pattern)
            => SyntaxFactory.Subpattern(NameColon(name), pattern);

        private static RecursivePatternSyntax RecursivePattern(params SubpatternSyntax[] subpatterns)
            => SyntaxFactory.RecursivePattern(type: null, positionalPatternClause: null, PropertyPatternClause(SeparatedList(subpatterns)), designation: null);

        private static RecursivePatternSyntax RecursivePattern(TypeSyntax? type, SubpatternSyntax subpattern, VariableDesignationSyntax? designation)
            => SyntaxFactory.RecursivePattern(type, positionalPatternClause: null, PropertyPatternClause(SingletonSeparatedList(subpattern)), designation);

        private static RecursivePatternSyntax RecursivePattern(SubpatternSyntax subpattern)
            => RecursivePattern(type: null, subpattern, designation: null);

        /// <summary>
        /// Obtain the outermost common receiver between two expressions.  This can succeed with a null 'CommonReceiver'
        /// in the case that the common receiver is the 'implicit this'.
        /// </summary>
        private static (ExpressionSyntax CommonReceiver, ImmutableArray<IdentifierNameSyntax> LeftNames, ImmutableArray<IdentifierNameSyntax> RightNames)? TryGetCommonReceiver(
            ExpressionSyntax left,
            ExpressionSyntax right,
            SemanticModel model)
        {
            using var _1 = ArrayBuilder<IdentifierNameSyntax>.GetInstance(out var leftNames);
            using var _2 = ArrayBuilder<IdentifierNameSyntax>.GetInstance(out var rightNames);

            if (!TryGetInnermostReceiver(left, leftNames, out var leftReceiver, model) ||
                !TryGetInnermostReceiver(right, rightNames, out var rightReceiver, model) ||
                !AreEquivalent(leftReceiver, rightReceiver)) // We must have a common starting point to proceed.
            {
                return null;
            }

            var commonReceiver = leftReceiver;

            // To reduce noise on superfluous subpatterns and avoid duplicates, skip any common name in the path.
            var lastName = SkipCommonNames(leftNames, rightNames);
            if (lastName is not null)
            {
                // If there were some common names in the path, we rewrite the receiver to include those.
                // For instance, in `a.b.c && a.b.d`, we have `b` as the last common name in the path,
                // So we want `a.b` as the receiver so that we convert it to `a.b is { c: true, d: true }`.
                commonReceiver = GetInnermostReceiver(left, lastName, static (identifierName, lastName) => identifierName != lastName);
            }

            // If the common receiver is null, it's an implicit `this` reference in source.
            // For instance, `prop == 1 && field == 2` would be converted to `this is { prop: 1, field: 2 }`
            return (commonReceiver ?? ThisExpression(), leftNames.ToImmutable(), rightNames.ToImmutable());

            static bool TryGetInnermostReceiver(ExpressionSyntax node, ArrayBuilder<IdentifierNameSyntax> builder, [NotNullWhen(true)] out ExpressionSyntax? receiver, SemanticModel model)
            {
                receiver = GetInnermostReceiver(node, builder, model);
                return builder.Any();
            }

            static IdentifierNameSyntax? SkipCommonNames(ArrayBuilder<IdentifierNameSyntax> leftNames, ArrayBuilder<IdentifierNameSyntax> rightNames)
            {
                IdentifierNameSyntax? lastName = null;
                int leftIndex, rightIndex;
                // Note: we don't want to skip the first name to still be able to convert to a subpattern, hence checking `> 0` below.
                for (leftIndex = leftNames.Count - 1, rightIndex = rightNames.Count - 1; leftIndex > 0 && rightIndex > 0; leftIndex--, rightIndex--)
                {
                    var leftName = leftNames[leftIndex];
                    var rightName = rightNames[rightIndex];
                    if (!AreEquivalent(leftName, rightName))
                        break;
                    lastName = leftName;
                }

                leftNames.Clip(leftIndex + 1);
                rightNames.Clip(rightIndex + 1);
                return lastName;
            }
        }

        private static ExpressionSyntax? GetInnermostReceiver(ExpressionSyntax node, ArrayBuilder<IdentifierNameSyntax> builder, SemanticModel model)
        {
            return GetInnermostReceiver(node, model, CanConvertToSubpattern, builder);

            static bool CanConvertToSubpattern(IdentifierNameSyntax name, SemanticModel model)
            {
                return model.GetSymbolInfo(name).Symbol is
                {
                    IsStatic: false,
                    Kind: SymbolKind.Property or SymbolKind.Field,
                    ContainingType: not { SpecialType: SpecialType.System_Nullable_T }
                };
            }
        }

        private static ExpressionSyntax? GetInnermostReceiver<TArg>(
            ExpressionSyntax node, TArg arg,
            Func<IdentifierNameSyntax, TArg, bool> canConvertToSubpattern,
            ArrayBuilder<IdentifierNameSyntax>? builder = null)
        {
            return GetInnermostReceiver(node);

            ExpressionSyntax? GetInnermostReceiver(ExpressionSyntax node)
            {
                switch (node)
                {

                    case IdentifierNameSyntax name
                            when canConvertToSubpattern(name, arg):
                        builder?.Add(name);
                        // This is a member reference with an implicit `this` receiver.
                        // We know this is true because we already checked canConvertToSubpattern.
                        // Any other name outside the receiver position is captured in the cases below.
                        return null;

                    case MemberBindingExpressionSyntax { Name: IdentifierNameSyntax name }
                            when canConvertToSubpattern(name, arg):
                        builder?.Add(name);
                        // We only reach here from a parent conditional-access.
                        // Returning null here means that all the names on the right were convertible to a property pattern.
                        return null;

                    case MemberAccessExpressionSyntax(SimpleMemberAccessExpression) { Name: IdentifierNameSyntax name } memberAccess
                            when canConvertToSubpattern(name, arg) && !memberAccess.Expression.IsKind(SyntaxKind.BaseExpression):
                        builder?.Add(name);
                        // For a simple member access we simply record the name and descend into the expression on the left-hand-side.
                        return GetInnermostReceiver(memberAccess.Expression);

                    case ConditionalAccessExpressionSyntax conditionalAccess:
                        // For a conditional access, first we need to verify the right-hand-side is convertible to a property pattern.
                        var right = GetInnermostReceiver(conditionalAccess.WhenNotNull);
                        if (right is not null)
                        {
                            // If it has it's own receiver other than a member-binding expression, we return this node as the receiver.
                            // For instance, if we had `a?.M().b`, the name `b` is already captured, so we need to return `a?.M()` as the innermost receiver.
                            // If there was no name, this call returns itself, e.g. in `a?.M()` the receiver is the entire existing conditional access.
                            return conditionalAccess.WithWhenNotNull(right);
                        }
                        // Otherwise, descend into the the expression on the left-hand-side.
                        return GetInnermostReceiver(conditionalAccess.Expression);

                    default:
                        return node;
                }
            }
        }

        protected override async Task FixAllAsync(
            Document document,
            ImmutableArray<TextSpan> fixAllSpans,
            SyntaxEditor editor,
            CodeActionOptionsProvider optionsProvider,
            string? equivalenceKey,
            CancellationToken cancellationToken)
        {
            // Get all the descendant nodes to refactor.
            // NOTE: We need to realize the nodes with 'ToArray' call here
            // to ensure we strongly hold onto the nodes so that 'TrackNodes'
            // invoked below, which does tracking based off a ConditionalWeakTable,
            // tracks the nodes for the entire duration of this method.
            var nodes = editor.OriginalRoot.DescendantNodes().Where(IsFixableNode).ToArray();

            // We're going to be continually editing this tree. Track all the nodes we
            // care about so we can find them across each edit.
            document = document.WithSyntaxRoot(editor.OriginalRoot.TrackNodes(nodes));

            // Process all nodes to refactor in reverse to ensure nested nodes
            // are processed before the outer nodes to refactor.
            foreach (var originalNode in nodes.Reverse())
            {
                // Only process nodes fully within a fixAllSpan
                if (!fixAllSpans.Any(fixAllSpan => fixAllSpan.Contains(originalNode.Span)))
                    continue;

                // Get current root, current node to refactor and semantic model.
                var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
                var currentNode = root.GetCurrentNodes(originalNode).SingleOrDefault();
                var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

                var replacementFunc = GetReplacementFunc(currentNode, semanticModel);
                if (replacementFunc == null)
                    continue;

                document = document.WithSyntaxRoot(replacementFunc(root));
            }

            var updatedRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            editor.ReplaceNode(editor.OriginalRoot, updatedRoot);
        }
    }
}
