Include wrapping options in editorconfig formatting options (#73938)

Author: tmat

src/Analyzers/CSharp/CodeFixes/UseCollectionExpression/CSharpCollectionExpressionRewriter.cs

@@ -10,6 +10,7 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Indentation;
@@ -47,20 +48,15 @@ public static async Task<CollectionExpressionSyntax> CreateCollectionExpressionA
         var document = await ParsedDocument.CreateAsync(workspaceDocument, cancellationToken).ConfigureAwait(false);
 
 #if CODE_STYLE
-        var formattingOptions = SyntaxFormattingOptions.CommonDefaults;
+        var formattingOptions = CSharpSyntaxFormattingOptions.Default;
 #else
-        var formattingOptions = await workspaceDocument.GetSyntaxFormattingOptionsAsync(
+        var formattingOptions = (CSharpSyntaxFormattingOptions)await workspaceDocument.GetSyntaxFormattingOptionsAsync(
             fallbackOptions, cancellationToken).ConfigureAwait(false);
 #endif
 
         var indentationOptions = new IndentationOptions(formattingOptions);
 
-        // the option is currently not an editorconfig option, so not available in code style layer
-#if CODE_STYLE
-        var wrappingLength = CodeActionOptions.DefaultCollectionExpressionWrappingLength;
-#else
-        var wrappingLength = fallbackOptions.GetOptions(document.LanguageServices).CollectionExpressionWrappingLength;
-#endif
+        var wrappingLength = formattingOptions.CollectionExpressionWrappingLength;
 
         var initializer = getInitializer(expressionToReplace);
         var endOfLine = DetermineEndOfLine(document, expressionToReplace, formattingOptions);

src/Analyzers/Core/CodeFixes/UseConditionalExpression/AbstractUseConditionalExpressionCodeFixProvider.cs

@@ -47,14 +47,22 @@ internal abstract class AbstractUseConditionalExpressionCodeFixProvider<
 
     protected abstract Task FixOneAsync(
         Document document, Diagnostic diagnostic,
-        SyntaxEditor editor, CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken);
+        SyntaxEditor editor, SyntaxFormattingOptions formattingOptions, CancellationToken cancellationToken);
 
     protected override async Task FixAllAsync(
         Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor,
         CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken)
     {
         var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
+#if CODE_STYLE
+        var provider = GetSyntaxFormatting();
+#else
+        var provider = document.Project.Solution.Services;
+#endif
+        var options = await document.GetCodeFixOptionsAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
+        var formattingOptions = options.GetFormattingOptions(GetSyntaxFormatting());
+
         // Defer to our callback to actually make the edits for each diagnostic. In turn, it
         // will return 'true' if it made a multi-line conditional expression. In that case,
         // we'll need to explicitly format this node so we can get our special multi-line
@@ -63,7 +71,7 @@ protected override async Task FixAllAsync(
         foreach (var diagnostic in diagnostics)
         {
             await FixOneAsync(
-                document, diagnostic, nestedEditor, fallbackOptions, cancellationToken).ConfigureAwait(false);
+                document, diagnostic, nestedEditor, formattingOptions, cancellationToken).ConfigureAwait(false);
         }
 
         var changedRoot = nestedEditor.GetChangedRoot();
@@ -74,13 +82,6 @@ await FixOneAsync(
         // annotation on it.
         var rules = ImmutableArray.Create(GetMultiLineFormattingRule());
 
-#if CODE_STYLE
-        var provider = GetSyntaxFormatting();
-#else
-        var provider = document.Project.Solution.Services;
-#endif
-        var options = await document.GetCodeFixOptionsAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
-        var formattingOptions = options.GetFormattingOptions(GetSyntaxFormatting());
         var formattedRoot = Formatter.Format(changedRoot, SpecializedFormattingAnnotation, provider, formattingOptions, rules, cancellationToken);
 
         changedRoot = formattedRoot;
@@ -98,7 +99,7 @@ protected async Task<TExpressionSyntax> CreateConditionalExpressionAsync(
         Document document, IConditionalOperation ifOperation,
         IOperation trueStatement, IOperation falseStatement,
         IOperation trueValue, IOperation falseValue,
-        bool isRef, CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken)
+        bool isRef, SyntaxFormattingOptions formattingOptions, CancellationToken cancellationToken)
     {
         var generator = SyntaxGenerator.GetGenerator(document);
         var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();
@@ -125,7 +126,7 @@ protected async Task<TExpressionSyntax> CreateConditionalExpressionAsync(
         conditionalExpression = conditionalExpression.WithAdditionalAnnotations(Simplifier.Annotation);
         var makeMultiLine = await MakeMultiLineAsync(
             document, condition,
-            trueValue.Syntax, falseValue.Syntax, fallbackOptions, cancellationToken).ConfigureAwait(false);
+            trueValue.Syntax, falseValue.Syntax, formattingOptions, cancellationToken).ConfigureAwait(false);
         if (makeMultiLine)
         {
             conditionalExpression = conditionalExpression.WithAdditionalAnnotations(
@@ -148,7 +149,7 @@ private static TExpressionSyntax MakeRef(SyntaxGeneratorInternal generator, bool
     /// Checks if we should wrap the conditional expression over multiple lines.
     /// </summary>
     private static async Task<bool> MakeMultiLineAsync(
-        Document document, SyntaxNode condition, SyntaxNode trueSyntax, SyntaxNode falseSyntax, CodeActionOptionsProvider fallbackOptions,
+        Document document, SyntaxNode condition, SyntaxNode trueSyntax, SyntaxNode falseSyntax, SyntaxFormattingOptions formattingOptions,
         CancellationToken cancellationToken)
     {
         var sourceText = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
@@ -159,14 +160,7 @@ private static async Task<bool> MakeMultiLineAsync(
             return true;
         }
 
-        // the option is currently not an editorconfig option, so not available in code style layer
-        var wrappingLength =
-#if !CODE_STYLE
-            fallbackOptions.GetOptions(document.Project.Services)?.ConditionalExpressionWrappingLength ??
-#endif
-            CodeActionOptions.DefaultConditionalExpressionWrappingLength;
-
-        if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > wrappingLength)
+        if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > formattingOptions.ConditionalExpressionWrappingLength)
         {
             return true;
         }

src/Analyzers/Core/CodeFixes/UseConditionalExpression/ForAssignment/AbstractUseConditionalExpressionForAssignmentCodeFixProvider.cs

@@ -2,22 +2,20 @@
 // 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.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Roslyn.Utilities;
-using static Microsoft.CodeAnalysis.UseConditionalExpression.UseConditionalExpressionHelpers;
 using static Microsoft.CodeAnalysis.UseConditionalExpression.UseConditionalExpressionCodeFixHelpers;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.CodeAnalysis.UseConditionalExpression;
 
@@ -59,7 +57,7 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
     /// </summary>
     protected override async Task FixOneAsync(
         Document document, Diagnostic diagnostic,
-        SyntaxEditor editor, CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken)
+        SyntaxEditor editor, SyntaxFormattingOptions formattingOptions, CancellationToken cancellationToken)
     {
         var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
         var ifStatement = diagnostic.AdditionalLocations[0].FindNode(cancellationToken);
@@ -81,7 +79,7 @@ protected override async Task FixOneAsync(
             trueAssignment?.Value ?? trueStatement,
             falseAssignment?.Value ?? falseStatement,
             isRef,
-            fallbackOptions,
+            formattingOptions,
             cancellationToken).ConfigureAwait(false);
 
         // See if we're assigning to a variable declared directly above the if statement. If so,

src/Analyzers/Core/CodeFixes/UseConditionalExpression/ForReturn/AbstractUseConditionalExpressionForReturnCodeFixProvider.cs

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -45,7 +46,7 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
 
     protected override async Task FixOneAsync(
         Document document, Diagnostic diagnostic,
-        SyntaxEditor editor, CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken)
+        SyntaxEditor editor, SyntaxFormattingOptions formattingOptions, CancellationToken cancellationToken)
     {
         var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
         var ifStatement = (TIfStatementSyntax)diagnostic.AdditionalLocations[0].FindNode(cancellationToken);
@@ -69,7 +70,7 @@ protected override async Task FixOneAsync(
             trueReturn?.ReturnedValue ?? trueStatement,
             falseReturn?.ReturnedValue ?? falseStatement,
             isRef,
-            fallbackOptions,
+            formattingOptions,
             cancellationToken).ConfigureAwait(false);
 
         var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();

src/EditorFeatures/TestUtilities/Utilities/VisualBasicCodeActionOptions.cs

@@ -24,9 +24,6 @@ internal static class VisualBasicCodeActionOptions
         CodeStyleOptions = VisualBasicIdeCodeStyleOptions.Default
     };
 
-    public static CodeActionOptions WithWrappingColumn(this CodeActionOptions options, int value)
-        => options with { WrappingColumn = value };
-
     public static CodeActionOptions With(this CodeActionOptions options, VisualBasicSyntaxFormattingOptions value)
         => options with { CleanupOptions = options.CleanupOptions with { FormattingOptions = value } };
 

src/Features/CSharp/Portable/Wrapping/CSharpSyntaxWrappingOptions.cs

@@ -12,9 +12,8 @@ namespace Microsoft.CodeAnalysis.CSharp.Wrapping;
 
 internal sealed class CSharpSyntaxWrappingOptions(
     CSharpSyntaxFormattingOptions formattingOptions,
-    int wrappingColumn,
     OperatorPlacementWhenWrappingPreference operatorPlacement,
-    bool newLinesForBracesInObjectCollectionArrayInitializers) : SyntaxWrappingOptions(formattingOptions, wrappingColumn, operatorPlacement)
+    bool newLinesForBracesInObjectCollectionArrayInitializers) : SyntaxWrappingOptions(formattingOptions, operatorPlacement)
 {
     public readonly bool NewLinesForBracesInObjectCollectionArrayInitializers = newLinesForBracesInObjectCollectionArrayInitializers;
 }
@@ -28,7 +27,6 @@ public static CSharpSyntaxWrappingOptions GetCSharpSyntaxWrappingOptions(this IO
         return new(
             new CSharpSyntaxFormattingOptions(options, (CSharpSyntaxFormattingOptions)fallbackOptions.CleanupOptions.FormattingOptions),
             operatorPlacement: options.GetOption(CodeStyleOptions2.OperatorPlacementWhenWrapping, fallbackOptions.CodeStyleOptions.OperatorPlacementWhenWrapping),
-            wrappingColumn: fallbackOptions.WrappingColumn,
             newLinesForBracesInObjectCollectionArrayInitializers: options.GetOption(CSharpFormattingOptions2.NewLineBeforeOpenBrace, newLineBeforeOpenBraceDefault).HasFlag(NewLineBeforeOpenBracePlacement.ObjectCollectionArrayInitializers));
     }
 }

src/Features/CSharpTest/Wrapping/AbstractWrappingTests.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CSharp.Wrapping;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
+using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Test.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Wrapping;
@@ -23,7 +24,7 @@ protected sealed override ImmutableArray<CodeAction> MassageActions(ImmutableArr
         => FlattenActions(actions);
 
     private protected TestParameters GetIndentionColumn(int column)
-        => new(globalOptions: Option(CodeActionOptionsStorage.WrappingColumn, column));
+        => new(options: Option(FormattingOptions2.WrappingColumn, column));
 
     protected Task TestAllWrappingCasesAsync(
         string input,

src/Features/Core/Portable/Wrapping/SyntaxWrappingOptions.cs

@@ -10,20 +10,18 @@ namespace Microsoft.CodeAnalysis.Wrapping;
 internal abstract class SyntaxWrappingOptions
 {
     public readonly SyntaxFormattingOptions FormattingOptions;
-    public readonly int WrappingColumn;
     public readonly OperatorPlacementWhenWrappingPreference OperatorPlacement;
 
     protected SyntaxWrappingOptions(
         SyntaxFormattingOptions formattingOptions,
-        int wrappingColumn,
         OperatorPlacementWhenWrappingPreference operatorPlacement)
     {
         FormattingOptions = formattingOptions;
-        WrappingColumn = wrappingColumn;
         OperatorPlacement = operatorPlacement;
     }
 
     public bool UseTabs => FormattingOptions.UseTabs;
     public int TabSize => FormattingOptions.TabSize;
     public string NewLine => FormattingOptions.NewLine;
+    public int WrappingColumn => FormattingOptions.WrappingColumn;
 }

src/Features/DiagnosticsTestUtilities/CodeActionsLegacy/AbstractCodeActionTest_NoEditor.cs

@@ -106,10 +106,7 @@ internal async Task<CodeRefactoring> GetCodeRefactoringAsync(
 
             using var _ = ArrayBuilder<(CodeAction, TextSpan?)>.GetInstance(out var actions);
 
-            var codeActionOptionsProvider = parameters.globalOptions?.IsEmpty() == false
-                ? CodeActionOptionsStorage.GetCodeActionOptionsProvider(workspace.GlobalOptions)
-                : CodeActionOptions.DefaultProvider;
-
+            var codeActionOptionsProvider = CodeActionOptions.DefaultProvider;
             var context = new CodeRefactoringContext(document, selectedOrAnnotatedSpan, (a, t) => actions.Add((a, t)), codeActionOptionsProvider, CancellationToken.None);
             await provider.ComputeRefactoringsAsync(context);
             var result = actions.Count > 0 ? new CodeRefactoring(provider, actions.ToImmutable(), FixAllProviderInfo.Create(provider), codeActionOptionsProvider) : null;

src/Features/VisualBasic/Portable/Wrapping/VisualBasicSyntaxWrappingOptions.vb

@@ -16,17 +16,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Wrapping
 
         Public Sub New(
             formattingOptions As VisualBasicSyntaxFormattingOptions,
-            wrappingColumn As Integer,
             operatorPlacement As OperatorPlacementWhenWrappingPreference)
 
-            MyBase.New(formattingOptions, wrappingColumn, operatorPlacement)
+            MyBase.New(formattingOptions, operatorPlacement)
         End Sub
 
         Public Shared Function Create(options As IOptionsReader, fallbackOptions As CodeActionOptions) As VisualBasicSyntaxWrappingOptions
             Return New VisualBasicSyntaxWrappingOptions(
                 formattingOptions:=New VisualBasicSyntaxFormattingOptions(options, DirectCast(fallbackOptions.CleanupOptions.FormattingOptions, VisualBasicSyntaxFormattingOptions)),
-                operatorPlacement:=options.GetOption(CodeStyleOptions2.OperatorPlacementWhenWrapping, fallbackOptions.CodeStyleOptions.OperatorPlacementWhenWrapping),
-                wrappingColumn:=fallbackOptions.WrappingColumn)
+                operatorPlacement:=options.GetOption(CodeStyleOptions2.OperatorPlacementWhenWrapping, fallbackOptions.CodeStyleOptions.OperatorPlacementWhenWrapping))
         End Function
     End Class
 End Namespace