Fix property pattern indentation in positional patterns

When a property pattern appears inside a positional (tuple) pattern, it was being incorrectly dedented. The issue was that the alignment operation used the SubpatternSyntax's first token as the base, which is the same as the property pattern's opening brace, causing the operation to be skipped.

The fix navigates up to find the outer RecursivePattern's parent and uses that as the base, with an additional indentation delta of 1 to properly indent the property pattern relative to the tuple.

Co-authored-by: CyrusNajmabadi <4564579+CyrusNajmabadi@users.noreply.github.com>

Author: Copilot

src/Workspaces/CSharpTest/Formatting/FormattingTests_Patterns.cs

@@ -600,4 +600,58 @@ void M(string[][] ss)
                 }
             }
             """);
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/54288")]
+    public Task FormatPropertyPatternInPositionalPattern1()
+        => AssertFormatAsync("""
+            class C
+            {
+                void M(object former, object latter)
+                {
+                    if (
+                        (former, latter) is not (
+                            {
+                                Expression: IdentifierNameSyntax
+                                {
+                                    Identifier: { ValueText: var formerIdentifier }
+                                }
+                            },
+                            {
+                                Expression: IdentifierNameSyntax
+                                {
+                                    Identifier: { ValueText: var latterIdentifier }
+                                }
+                            }
+                        )
+                    )
+                    {
+                    }
+                }
+            }
+            """, """
+            class C
+            {
+                void M(object former, object latter)
+                {
+                    if (
+                        (former, latter) is not (
+              {
+                  Expression: IdentifierNameSyntax
+                  {
+                      Identifier: { ValueText: var formerIdentifier }
+                  }
+              },
+              {
+                  Expression: IdentifierNameSyntax
+                  {
+                      Identifier: { ValueText: var latterIdentifier }
+                  }
+              }
+                        )
+                    )
+                    {
+                    }
+                }
+            }
+            """);
 }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/IndentBlockFormattingRule.cs

@@ -184,17 +184,56 @@ private static void AddAlignmentBlockOperation(List<IndentBlockOperation> list,
                 SetAlignmentBlockOperation(list, withExpression.GetFirstToken(), withExpression.Initializer.OpenBraceToken, withExpression.Initializer.CloseBraceToken, IndentBlockOption.RelativeToFirstTokenOnBaseTokenLine);
                 return;
             case PropertyPatternClauseSyntax propertyPatternClause:
-                if (propertyPatternClause.Parent is RecursivePatternSyntax { Parent: { } recursivePatternParent })
+                if (propertyPatternClause.Parent is RecursivePatternSyntax recursivePattern)
                 {
-                    var baseTokenForAlignment = recursivePatternParent.GetFirstToken();
-                    if (baseTokenForAlignment == propertyPatternClause.OpenBraceToken)
+                    SyntaxNode? baseNode = null;
+                    IndentBlockOption options = IndentBlockOption.RelativeToFirstTokenOnBaseTokenLine | IndentBlockOption.IndentIfConditionOfAnchorToken;
+                    int indentationDelta = 0;
+
+                    // When the recursive pattern is part of a positional pattern (tuple pattern), we need to find
+                    // a base token that isn't the property pattern's own opening brace.
+                    if (recursivePattern.Parent is SubpatternSyntax subpattern)
+                    {
+                        // Walk up to find the PositionalPatternClause, then use its parent's parent as the base
+                        if (subpattern.Parent is PositionalPatternClauseSyntax positionalPattern &&
+                            positionalPattern.Parent is RecursivePatternSyntax outerPattern &&
+                            outerPattern.Parent != null)
+                        {
+                            baseNode = outerPattern.Parent;
+                            // For patterns inside positional patterns, add one level of indentation
+                            // relative to the first token on the base line
+                            options = IndentBlockOption.RelativeToFirstTokenOnBaseTokenLine;
+                            indentationDelta = 1;
+                        }
+                    }
+                    else if (recursivePattern.Parent != null)
                     {
-                        // It only makes sense to set the alignment for the '{' when it's on a separate line from
-                        // the base token for alignment. This is never the case when they are the same token.
-                        return;
+                        baseNode = recursivePattern.Parent;
                     }
 
-                    SetAlignmentBlockOperation(list, baseTokenForAlignment, propertyPatternClause.OpenBraceToken, propertyPatternClause.CloseBraceToken, IndentBlockOption.RelativeToFirstTokenOnBaseTokenLine | IndentBlockOption.IndentIfConditionOfAnchorToken);
+                    if (baseNode != null)
+                    {
+                        var baseTokenForAlignment = baseNode.GetFirstToken();
+                        if (baseTokenForAlignment != propertyPatternClause.OpenBraceToken)
+                        {
+                            // It only makes sense to set the alignment for the '{' when it's on a separate line from
+                            // the base token for alignment.
+                            if (indentationDelta != 0)
+                            {
+                                // Create the operation directly with the custom indentation delta
+                                list.Add(FormattingOperations.CreateRelativeIndentBlockOperation(
+                                    baseTokenForAlignment,
+                                    propertyPatternClause.OpenBraceToken,
+                                    propertyPatternClause.CloseBraceToken,
+                                    indentationDelta,
+                                    options));
+                            }
+                            else
+                            {
+                                SetAlignmentBlockOperation(list, baseTokenForAlignment, propertyPatternClause.OpenBraceToken, propertyPatternClause.CloseBraceToken, options);
+                            }
+                        }
+                    }
                 }
 
                 return;