Fix indentation of if statement after else on separate line (#81178)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: CyrusNajmabadi <4564579+CyrusNajmabadi@users.noreply.github.com>
Co-authored-by: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>

Author: Copilot

src/Workspaces/CSharpTest/Formatting/FormattingTests.cs

@@ -171,6 +171,82 @@ void Method()
             }
             """);
 
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16328")]
+    public Task FormatElseIfOnSeparateLines()
+        => AssertFormatAsync("""
+            void Method()
+            {
+                if (true) { }
+                else
+                    if (false) { }
+            }
+            """, """
+            void Method()
+            {
+                if (true) { }
+                else
+            if (false) { }
+            }
+            """);
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16328")]
+    public Task FormatElseReturnOnSeparateLines()
+        => AssertFormatAsync("""
+            void Method()
+            {
+                if (true) { }
+                else
+                    return;
+            }
+            """, """
+            void Method()
+            {
+                if (true) { }
+                else
+            return;
+            }
+            """);
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16328")]
+    public Task FormatElseWhileOnSeparateLines()
+        => AssertFormatAsync("""
+            void Method()
+            {
+                if (true) { }
+                else
+                    while (true) { }
+            }
+            """, """
+            void Method()
+            {
+                if (true) { }
+                else
+            while (true) { }
+            }
+            """);
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16328")]
+    public Task FormatElseIfOnSameLineWithExtraSpaces()
+        => AssertFormatAsync("""
+            class A
+            {
+                void Method()
+                {
+                    if (true) { }
+                    else if (false) { }
+                }
+            }
+            """, """
+            class A
+            {
+                void Method()
+                {
+                    if (true) { }
+                    else     if (false) { }
+                }
+            }
+            """);
+
     [Fact]
     public Task Format10()
         => AssertFormatAsync("""

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -531,4 +532,12 @@ public static bool IsCommaInTupleExpression(this SyntaxToken currentToken)
 
     public static bool IsCommaInCollectionExpression(this SyntaxToken token)
         => token.Kind() == SyntaxKind.CommaToken && token.Parent.IsKind(SyntaxKind.CollectionExpression);
+
+    public static bool AreOnSameLine(SyntaxToken previousToken, SyntaxToken currentToken)
+    {
+        Debug.Assert(previousToken != default);
+        Debug.Assert(currentToken != default);
+        Debug.Assert(previousToken.FullSpan.End == currentToken.FullSpan.Start);
+        return !previousToken.TrailingTrivia.Any(SyntaxKind.EndOfLineTrivia) && !currentToken.LeadingTrivia.Any(SyntaxKind.EndOfLineTrivia);
+    }
 }

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

@@ -292,29 +292,38 @@ private static void AddAlignmentBlockOperationRelativeToFirstTokenOnBaseTokenLin
 
     private static void AddEmbeddedStatementsIndentationOperation(List<IndentBlockOperation> list, SyntaxNode node)
     {
-        // increase indentation - embedded statement cases
-        var statement = node switch
+        // An else-if on the same line should not cause an extra indentation.  Instead, the indentation will be
+        // controlled entirely by the IfStatement.
+        if (node is ElseClauseSyntax { ElseKeyword: var elseKeyword, Statement: IfStatementSyntax { IfKeyword: var ifKeyword } } &&
+            FormattingHelpers.AreOnSameLine(elseKeyword, ifKeyword))
         {
-            // Basic cases that want to unilaterally indent their embedded statements (unless they are blocks) 
-            IfStatementSyntax ifStatement => ifStatement.Statement,
-            WhileStatementSyntax whileStatement => whileStatement.Statement,
-            ForStatementSyntax forStatement => forStatement.Statement,
-            CommonForEachStatementSyntax foreachStatement => foreachStatement.Statement,
-            DoStatementSyntax doStatement => doStatement.Statement,
-            LockStatementSyntax lockStatement => lockStatement.Statement,
-            // A few special cases where if we see certain nesting of statements, we don't want to double indent.
-            ElseClauseSyntax { Statement: not IfStatementSyntax } elseClause => elseClause.Statement,
-            UsingStatementSyntax { Statement: not UsingStatementSyntax } usingStatement => usingStatement.Statement,
-            FixedStatementSyntax { Statement: not FixedStatementSyntax } fixedStatement => fixedStatement.Statement,
-            _ => null,
-        };
-
-        // We never want to indent a block.  It is its own indentation region.
-        if (statement is null or BlockSyntax)
+            return;
+        }
+
+        // Handle common idiom in C# of nested usings (or nested fixed-statements) not getting extra indentation.
+        if (node is UsingStatementSyntax { Statement: UsingStatementSyntax } ||
+            node is FixedStatementSyntax { Statement: FixedStatementSyntax })
+        {
+            return;
+        }
+
+        // Labels don't increase indent.  Instead, the label itself is placed normally at a higher level and the content
+        // stays at the same level as the label's container.
+        if (node is LabeledStatementSyntax)
+            return;
+
+        var embeddedStatement = node.GetEmbeddedStatement();
+
+        // If it's not a construct that has embedded statements, we def don't want to increase the indent.
+        if (embeddedStatement is null)
+            return;
+
+        // We also never want to indent if the embedded statement is a block.  It is its own indentation region.
+        if (embeddedStatement is BlockSyntax)
             return;
 
-        var firstToken = statement.GetFirstToken(includeZeroWidth: true);
-        var lastToken = statement.GetLastToken(includeZeroWidth: true);
+        var firstToken = embeddedStatement.GetFirstToken(includeZeroWidth: true);
+        var lastToken = embeddedStatement.GetLastToken(includeZeroWidth: true);
 
         if (lastToken.IsMissing)
         {

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

@@ -137,10 +137,12 @@ public override AbstractFormattingRule WithOptions(SyntaxFormattingOptions optio
             return CreateAdjustNewLinesOperation(0, AdjustNewLinesOption.PreserveLines);
         }
 
-        // else * except else if case
-        if (previousToken.Kind() == SyntaxKind.ElseKeyword && currentToken.Kind() != SyntaxKind.IfKeyword)
+        // else * except `else if` case on the same line.
+        if (previousToken.Kind() == SyntaxKind.ElseKeyword)
         {
-            return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
+            var isElseIfOnSameLine = currentToken.Kind() == SyntaxKind.IfKeyword && FormattingHelpers.AreOnSameLine(previousToken, currentToken);
+            if (!isElseIfOnSameLine)
+                return CreateAdjustNewLinesOperation(1, AdjustNewLinesOption.PreserveLines);
         }
 
         // , * in enum declarations