Include wrapping options in editorconfig formatting options

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

src/Features/VisualBasicTest/Wrapping/AbstractParameterWrappingTests.vb

@@ -7,6 +7,7 @@ Imports Microsoft.CodeAnalysis.CodeActions
 Imports Microsoft.CodeAnalysis.CodeRefactorings
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
 Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
+Imports Microsoft.CodeAnalysis.Formatting
 Imports Microsoft.CodeAnalysis.VisualBasic.Wrapping
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Wrapping
@@ -22,7 +23,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Wrapping
         End Function
 
         Private Protected Function GetIndentionColumn(column As Integer) As TestParameters
-            Return New TestParameters(globalOptions:=[Option](CodeActionOptionsStorage.WrappingColumn, column))
+            Return New TestParameters(options:=[Option](FormattingOptions2.WrappingColumn, column))
         End Function
 
         Protected Function TestAllWrappingCasesAsync(

src/LanguageServer/Protocol/Features/Options/CodeActionOptionsStorage.cs

@@ -17,9 +17,6 @@ namespace Microsoft.CodeAnalysis.CodeActions
 {
     internal static class CodeActionOptionsStorage
     {
-        public static readonly PerLanguageOption2<int> WrappingColumn =
-            new("FormattingOptions_WrappingColumn", CodeActionOptions.DefaultWrappingColumn);
-
         public static CodeActionOptions GetCodeActionOptions(this IGlobalOptionService globalOptions, LanguageServices languageServices)
             => new()
             {
@@ -30,21 +27,12 @@ public static CodeActionOptions GetCodeActionOptions(this IGlobalOptionService g
                 ImplementTypeOptions = globalOptions.GetImplementTypeOptions(languageServices.Language),
                 ExtractMethodOptions = globalOptions.GetExtractMethodOptions(languageServices.Language),
                 HideAdvancedMembers = globalOptions.GetOption(CompletionOptionsStorage.HideAdvancedMembers, languageServices.Language),
-                WrappingColumn = globalOptions.GetOption(WrappingColumn, languageServices.Language),
-                ConditionalExpressionWrappingLength = globalOptions.GetOption(ConditionalExpressionWrappingLength, languageServices.Language),
-                CollectionExpressionWrappingLength = globalOptions.GetOption(CollectionExpressionWrappingLength, languageServices.Language),
             };
 
         internal static CodeActionOptionsProvider GetCodeActionOptionsProvider(this IGlobalOptionService globalOptions)
         {
             var cache = ImmutableDictionary<string, CodeActionOptions>.Empty;
             return new DelegatingCodeActionOptionsProvider(languageService => ImmutableInterlocked.GetOrAdd(ref cache, languageService.Language, (_, options) => GetCodeActionOptions(options, languageService), globalOptions));
         }
-
-        public static readonly PerLanguageOption2<int> ConditionalExpressionWrappingLength = new(
-            "dotnet_conditional_expression_wrapping_length", CodeActionOptions.DefaultConditionalExpressionWrappingLength);
-
-        public static readonly PerLanguageOption2<int> CollectionExpressionWrappingLength = new(
-            "dotnet_collection_expression_wrapping_length", CodeActionOptions.DefaultCollectionExpressionWrappingLength);
     }
 }