Fix layering of C# formatting options

src/Features/ExternalAccess/OmniSharp.CSharp/Formatting/OmniSharpSyntaxFormattingOptionsFactory.cs

@@ -108,7 +108,7 @@ public static OmniSharpSyntaxFormattingOptionsWrapper Create(
                 (spaceBeforeComma ? SpacePlacement.BeforeComma : 0) |
                 (spaceAfterDot ? SpacePlacement.AfterDot : 0) |
                 (spaceBeforeDot ? SpacePlacement.BeforeDot : 0),
-            SpacingAroundBinaryOperator = (BinaryOperatorSpacingOptions)spacingAroundBinaryOperator,
+            SpacingAroundBinaryOperator = (BinaryOperatorSpacingOptionsInternal)spacingAroundBinaryOperator,
             NewLines =
                 (newLineForMembersInObjectInit ? NewLinePlacement.BeforeMembersInObjectInitializers : 0) |
                 (newLineForMembersInAnonymousTypes ? NewLinePlacement.BeforeMembersInAnonymousTypes : 0) |
@@ -125,7 +125,7 @@ public static OmniSharpSyntaxFormattingOptionsWrapper Create(
                 (newLinesForBracesInLambdaExpressionBody ? NewLinePlacement.BeforeOpenBraceInLambdaExpressionBody : 0) |
                 (newLinesForBracesInControlBlocks ? NewLinePlacement.BeforeOpenBraceInControlBlocks : 0) |
                 (newLineForClausesInQuery ? NewLinePlacement.BetweenQueryExpressionClauses : 0),
-            LabelPositioning = (LabelPositionOptions)labelPositioning,
+            LabelPositioning = (LabelPositionOptionsInternal)labelPositioning,
             Indentation =
                 (indentBraces ? IndentationPlacement.Braces : 0) |
                 (indentBlock ? IndentationPlacement.BlockContents : 0) |

src/Tools/ExternalAccess/Razor/Features/RazorCSharpSyntaxFormattingOptions.cs

@@ -49,9 +49,9 @@ public CSharpSyntaxFormattingOptions ToCSharpSyntaxFormattingOptions()
             => new()
             {
                 Spacing = (SpacePlacement)Spacing,
-                SpacingAroundBinaryOperator = (BinaryOperatorSpacingOptions)SpacingAroundBinaryOperator,
+                SpacingAroundBinaryOperator = (BinaryOperatorSpacingOptionsInternal)SpacingAroundBinaryOperator,
                 NewLines = (NewLinePlacement)NewLines,
-                LabelPositioning = (LabelPositionOptions)LabelPositioning,
+                LabelPositioning = (LabelPositionOptionsInternal)LabelPositioning,
                 Indentation = (IndentationPlacement)Indentation,
                 WrappingKeepStatementsOnSingleLine = WrappingKeepStatementsOnSingleLine,
                 WrappingPreserveSingleLine = WrappingPreserveSingleLine,

src/VisualStudio/CSharp/Impl/Options/AutomationObject/AutomationObject.Formatting.cs

@@ -42,13 +42,13 @@ public int Indent_CaseLabels
     public int Indent_FlushLabelsLeft
     {
         get { return (int)GetOption(CSharpFormattingOptions2.LabelPositioning); }
-        set { SetOption(CSharpFormattingOptions2.LabelPositioning, (LabelPositionOptions)value); }
+        set { SetOption(CSharpFormattingOptions2.LabelPositioning, (LabelPositionOptionsInternal)value); }
     }
 
     public int Indent_UnindentLabels
     {
         get { return (int)GetOption(CSharpFormattingOptions2.LabelPositioning); }
-        set { SetOption(CSharpFormattingOptions2.LabelPositioning, (LabelPositionOptions)value); }
+        set { SetOption(CSharpFormattingOptions2.LabelPositioning, (LabelPositionOptionsInternal)value); }
     }
 
     public int NewLines_AnonymousTypeInitializer_EachMember
@@ -186,7 +186,7 @@ public int Space_AfterSemicolonsInForStatement
     public int Space_AroundBinaryOperator
     {
         get { return (int)GetOption(CSharpFormattingOptions2.SpacingAroundBinaryOperator); }
-        set { SetOption(CSharpFormattingOptions2.SpacingAroundBinaryOperator, (BinaryOperatorSpacingOptions)value); }
+        set { SetOption(CSharpFormattingOptions2.SpacingAroundBinaryOperator, (BinaryOperatorSpacingOptionsInternal)value); }
     }
 
     public int Space_BeforeBasesColon
@@ -282,7 +282,7 @@ public int Space_WithinSquares
     public int Wrapping_IgnoreSpacesAroundBinaryOperators
     {
         get { return (int)GetOption(CSharpFormattingOptions2.SpacingAroundBinaryOperator); }
-        set { SetOption(CSharpFormattingOptions2.SpacingAroundBinaryOperator, (BinaryOperatorSpacingOptions)value); }
+        set { SetOption(CSharpFormattingOptions2.SpacingAroundBinaryOperator, (BinaryOperatorSpacingOptionsInternal)value); }
     }
 
     public int Wrapping_IgnoreSpacesAroundVariableDeclaration

src/VisualStudio/CSharp/Impl/Options/Formatting/IndentationViewModel.cs

@@ -86,8 +86,8 @@ public IndentationViewModel(OptionStore optionStore, IServiceProvider servicePro
 
         Items.Add(new TextBlock() { Text = CSharpVSResources.Label_Indentation });
 
-        Items.Add(new RadioButtonViewModel<LabelPositionOptions>(CSharpVSResources.Place_goto_labels_in_leftmost_column, GotoLabelPreview, "goto", LabelPositionOptions.LeftMost, CSharpFormattingOptions2.LabelPositioning, this, optionStore));
-        Items.Add(new RadioButtonViewModel<LabelPositionOptions>(CSharpVSResources.Indent_labels_normally, GotoLabelPreview, "goto", LabelPositionOptions.NoIndent, CSharpFormattingOptions2.LabelPositioning, this, optionStore));
-        Items.Add(new RadioButtonViewModel<LabelPositionOptions>(CSharpVSResources.Place_goto_labels_one_indent_less_than_current, GotoLabelPreview, "goto", LabelPositionOptions.OneLess, CSharpFormattingOptions2.LabelPositioning, this, optionStore));
+        Items.Add(new RadioButtonViewModel<LabelPositionOptionsInternal>(CSharpVSResources.Place_goto_labels_in_leftmost_column, GotoLabelPreview, "goto", LabelPositionOptionsInternal.LeftMost, CSharpFormattingOptions2.LabelPositioning, this, optionStore));
+        Items.Add(new RadioButtonViewModel<LabelPositionOptionsInternal>(CSharpVSResources.Indent_labels_normally, GotoLabelPreview, "goto", LabelPositionOptionsInternal.NoIndent, CSharpFormattingOptions2.LabelPositioning, this, optionStore));
+        Items.Add(new RadioButtonViewModel<LabelPositionOptionsInternal>(CSharpVSResources.Place_goto_labels_one_indent_less_than_current, GotoLabelPreview, "goto", LabelPositionOptionsInternal.OneLess, CSharpFormattingOptions2.LabelPositioning, this, optionStore));
     }
 }

src/VisualStudio/CSharp/Impl/Options/Formatting/SpacingViewModel.cs

@@ -150,8 +150,8 @@ public SpacingViewModel(OptionStore optionStore, IServiceProvider serviceProvide
 
         Items.Add(new HeaderItemViewModel() { Header = CSharpVSResources.Set_spacing_for_operators });
 
-        Items.Add(new RadioButtonViewModel<BinaryOperatorSpacingOptions>(CSharpVSResources.Ignore_spaces_around_binary_operators, s_expressionSpacingPreview, "binary", BinaryOperatorSpacingOptions.Ignore, CSharpFormattingOptions2.SpacingAroundBinaryOperator, this, OptionStore));
-        Items.Add(new RadioButtonViewModel<BinaryOperatorSpacingOptions>(CSharpVSResources.Remove_spaces_before_and_after_binary_operators, s_expressionSpacingPreview, "binary", BinaryOperatorSpacingOptions.Remove, CSharpFormattingOptions2.SpacingAroundBinaryOperator, this, OptionStore));
-        Items.Add(new RadioButtonViewModel<BinaryOperatorSpacingOptions>(CSharpVSResources.Insert_space_before_and_after_binary_operators, s_expressionSpacingPreview, "binary", BinaryOperatorSpacingOptions.Single, CSharpFormattingOptions2.SpacingAroundBinaryOperator, this, OptionStore));
+        Items.Add(new RadioButtonViewModel<BinaryOperatorSpacingOptionsInternal>(CSharpVSResources.Ignore_spaces_around_binary_operators, s_expressionSpacingPreview, "binary", BinaryOperatorSpacingOptionsInternal.Ignore, CSharpFormattingOptions2.SpacingAroundBinaryOperator, this, OptionStore));
+        Items.Add(new RadioButtonViewModel<BinaryOperatorSpacingOptionsInternal>(CSharpVSResources.Remove_spaces_before_and_after_binary_operators, s_expressionSpacingPreview, "binary", BinaryOperatorSpacingOptionsInternal.Remove, CSharpFormattingOptions2.SpacingAroundBinaryOperator, this, OptionStore));
+        Items.Add(new RadioButtonViewModel<BinaryOperatorSpacingOptionsInternal>(CSharpVSResources.Insert_space_before_and_after_binary_operators, s_expressionSpacingPreview, "binary", BinaryOperatorSpacingOptionsInternal.Single, CSharpFormattingOptions2.SpacingAroundBinaryOperator, this, OptionStore));
     }
 }

src/Workspaces/CSharp/Portable/Formatting/CSharpFormattingOptions.cs

@@ -4,6 +4,8 @@
 
 #pragma warning disable RS0030 // Do not used banned APIs
 
+using System;
+using System.Runtime.CompilerServices;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
 
@@ -133,7 +135,7 @@ public SpacePlacementInternalStorageMapping(IOption2 internalOption, SpacePlacem
     public static Option<bool> SpaceBeforeSemicolonsInForStatement { get; } = CSharpFormattingOptions2.SpaceBeforeSemicolonsInForStatement.ToPublicOption();
 
     /// <inheritdoc cref="CSharpFormattingOptions2.SpacingAroundBinaryOperator"/>
-    public static Option<BinaryOperatorSpacingOptions> SpacingAroundBinaryOperator { get; } = CSharpFormattingOptions2.SpacingAroundBinaryOperator.ToPublicOption();
+    public static Option<BinaryOperatorSpacingOptions> SpacingAroundBinaryOperator { get; } = OptionUtilities.ConvertEnumOption<BinaryOperatorSpacingOptionsInternal, BinaryOperatorSpacingOptions, int>(CSharpFormattingOptions2.SpacingAroundBinaryOperator.ToPublicOption());
 
     /// <inheritdoc cref="CSharpFormattingOptions2.IndentBraces"/>
     public static Option<bool> IndentBraces { get; } = CSharpFormattingOptions2.IndentBraces.ToPublicOption();
@@ -151,7 +153,7 @@ public SpacePlacementInternalStorageMapping(IOption2 internalOption, SpacePlacem
     public static Option<bool> IndentSwitchCaseSectionWhenBlock { get; } = CSharpFormattingOptions2.IndentSwitchCaseSectionWhenBlock.ToPublicOption();
 
     /// <inheritdoc cref="CSharpFormattingOptions2.LabelPositioning"/>
-    public static Option<LabelPositionOptions> LabelPositioning { get; } = CSharpFormattingOptions2.LabelPositioning.ToPublicOption();
+    public static Option<LabelPositionOptions> LabelPositioning { get; } = OptionUtilities.ConvertEnumOption<LabelPositionOptionsInternal, LabelPositionOptions, int>(CSharpFormattingOptions2.LabelPositioning.ToPublicOption());
 
     /// <inheritdoc cref="CSharpFormattingOptions2.WrappingPreserveSingleLine"/>
     public static Option<bool> WrappingPreserveSingleLine { get; } = CSharpFormattingOptions2.WrappingPreserveSingleLine.ToPublicOption();
@@ -187,3 +189,27 @@ public SpacePlacementInternalStorageMapping(IOption2 internalOption, SpacePlacem
     /// <inheritdoc cref="CSharpFormattingOptions2.NewLineForClausesInQuery"/>
     public static Option<bool> NewLineForClausesInQuery { get; } = CSharpFormattingOptions2.NewLineForClausesInQuery.ToPublicOption();
 }
+
+public enum LabelPositionOptions
+{
+    /// Placed in the Zeroth column of the text editor
+    LeftMost = LabelPositionOptionsInternal.LeftMost,
+
+    /// Placed at one less indent to the current context
+    OneLess = LabelPositionOptionsInternal.OneLess,
+
+    /// Placed at the same indent as the current context
+    NoIndent = LabelPositionOptionsInternal.NoIndent,
+}
+
+public enum BinaryOperatorSpacingOptions
+{
+    /// Single Spacing
+    Single = BinaryOperatorSpacingOptionsInternal.Single,
+
+    /// Ignore Formatting
+    Ignore = BinaryOperatorSpacingOptionsInternal.Ignore,
+
+    /// Remove Spacing
+    Remove = BinaryOperatorSpacingOptionsInternal.Remove,
+}

src/Workspaces/CSharpTest/CodeStyle/CSharpEditorConfigCodeStyleParserTests.cs

@@ -25,7 +25,7 @@ public sealed class CSharpEditorConfigCodeStyleParserTests
     [InlineData(" none ", BinaryOperatorSpacingOptions.Remove)]
     [InlineData(" before_and_after ", BinaryOperatorSpacingOptions.Single)]
     public void TestParseSpacingAroundBinaryOperator(string rawValue, BinaryOperatorSpacingOptions parsedValue)
-        => Assert.Equal(parsedValue, CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(rawValue));
+        => Assert.Equal(parsedValue, (BinaryOperatorSpacingOptions)CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(rawValue));
 
     [Theory]
     [InlineData("flush_left", LabelPositionOptions.LeftMost)]
@@ -37,7 +37,7 @@ public void TestParseSpacingAroundBinaryOperator(string rawValue, BinaryOperator
     [InlineData(" no_change ", LabelPositionOptions.NoIndent)]
     [InlineData(" one_less_than_current ", LabelPositionOptions.OneLess)]
     public void TestParseLabelPositioning(string rawValue, LabelPositionOptions parsedValue)
-        => Assert.Equal(parsedValue, CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(rawValue));
+        => Assert.Equal(parsedValue, (LabelPositionOptions)CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(rawValue));
 
     [Theory]
     [InlineData("false:none", (int)ExpressionBodyPreference.Never, ReportDiagnostic.Suppress)]

src/Workspaces/CSharpTest/Formatting/EditorConfigOptionParserTests.cs

@@ -37,7 +37,7 @@ internal void TestParseSpacingWithinParenthesesList(string list, SpacePlacementW
     InlineData("before_and_after", BinaryOperatorSpacingOptions.Single)]
     public void TestParseEditorConfigSpacingAroundBinaryOperatorTrue(string value, BinaryOperatorSpacingOptions expectedResult)
     {
-        Assert.True(CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(value) == expectedResult,
+        Assert.True(CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(value) == (BinaryOperatorSpacingOptionsInternal)expectedResult,
                     $"Expected option {value} to be parsed as set.");
     }
 
@@ -47,7 +47,7 @@ public void TestParseEditorConfigSpacingAroundBinaryOperatorTrue(string value, B
     InlineData("before_and_after,ignore")]
     public void TestParseEditorConfigSpacingAroundBinaryOperatorFalse(string value)
     {
-        Assert.True(CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(value) == BinaryOperatorSpacingOptions.Single,
+        Assert.True(CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(value) == BinaryOperatorSpacingOptionsInternal.Single,
                     $"Expected option {value} to be parsed as default option.");
     }
 
@@ -57,7 +57,7 @@ public void TestParseEditorConfigSpacingAroundBinaryOperatorFalse(string value)
     InlineData("one_less_than_current", LabelPositionOptions.OneLess)]
     public void TestParseEditorConfigLabelPositioningTrue(string value, LabelPositionOptions expectedValue)
     {
-        Assert.True(CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(value) == expectedValue,
+        Assert.True(CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(value) == (LabelPositionOptionsInternal)expectedValue,
                     $"Expected option {value} to be parsed as set.");
     }
 
@@ -67,7 +67,7 @@ public void TestParseEditorConfigLabelPositioningTrue(string value, LabelPositio
     InlineData("one_less_thancurrent")]
     public void TestParseEditorConfigLabelPositioningFalse(string value)
     {
-        Assert.True(CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(value) == LabelPositionOptions.NoIndent,
+        Assert.True(CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(value) == LabelPositionOptionsInternal.NoIndent,
                     $"Expected option {value} to be parsed default");
     }
 

src/Workspaces/Core/Portable/Options/Option.cs

@@ -14,17 +14,17 @@ namespace Microsoft.CodeAnalysis.Options;
 /// <inheritdoc cref="Option2{T}"/>
 public class Option<T> : IPublicOption
 {
-    private readonly OptionDefinition _optionDefinition;
+    internal readonly OptionDefinition<T> OptionDefinition;
 
     public string Feature { get; }
 
-    internal OptionGroup Group => _optionDefinition.Group;
+    internal OptionGroup Group => OptionDefinition.Group;
 
     public string Name { get; }
 
-    public T DefaultValue => (T)_optionDefinition.DefaultValue!;
+    public T DefaultValue => (T)OptionDefinition.DefaultValue!;
 
-    public Type Type => _optionDefinition.Type;
+    public Type Type => OptionDefinition.Type;
 
     public ImmutableArray<OptionStorageLocation> StorageLocations { get; }
 
@@ -71,11 +71,11 @@ internal Option(
     {
     }
 
-    internal Option(OptionDefinition optionDefinition, string feature, string name, ImmutableArray<OptionStorageLocation> storageLocations)
+    internal Option(OptionDefinition<T> optionDefinition, string feature, string name, ImmutableArray<OptionStorageLocation> storageLocations)
     {
         Feature = feature;
         Name = name;
-        _optionDefinition = optionDefinition;
+        OptionDefinition = optionDefinition;
         StorageLocations = storageLocations;
     }
 
@@ -85,13 +85,13 @@ internal Option(OptionDefinition optionDefinition, string feature, string name,
 
     IPublicOption? IOption2.PublicOption => null;
 
-    OptionDefinition IOption2.Definition => _optionDefinition;
+    OptionDefinition IOption2.Definition => OptionDefinition;
 
     bool IEquatable<IOption2?>.Equals(IOption2? other) => Equals(other);
 
     public override string ToString() => this.PublicOptionDefinitionToString();
 
-    public override int GetHashCode() => _optionDefinition.GetHashCode();
+    public override int GetHashCode() => OptionDefinition.GetHashCode();
 
     public override bool Equals(object? obj) => Equals(obj as IOption2);
 

src/Workspaces/Core/Portable/Options/OptionUtilities.cs

@@ -0,0 +1,66 @@
+// 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.
+
+#pragma warning disable RS0030 // Do not used banned APIs: Option<T>
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.CodeAnalysis.Options;
+
+internal static class OptionUtilities
+{
+    /// <summary>
+    /// Allows an option of one enum type to be converted to another enum type, provided that both enums share the same underlying type.
+    /// Useful for some cases in Roslyn where we have an existing shipped public option in the Workspace layer, and an internal option
+    /// in the CodeStyle layer, and we want to map between them.
+    /// </summary>
+    public static Option<TToEnum> ConvertEnumOption<TFromEnum, TToEnum, TUnderlyingEnumType>(Option<TFromEnum> option)
+        where TFromEnum : struct, Enum
+        where TToEnum : struct, Enum
+        where TUnderlyingEnumType : struct
+    {
+        // Ensure that this is only called for enums that are actually compatible with each other.
+        Contract.ThrowIfTrue(typeof(TFromEnum).GetEnumUnderlyingType() != typeof(TUnderlyingEnumType));
+        Contract.ThrowIfTrue(typeof(TToEnum).GetEnumUnderlyingType() != typeof(TUnderlyingEnumType));
+
+        var definition = option.OptionDefinition;
+        var newDefaultValue = ConvertEnum<TFromEnum, TToEnum, TUnderlyingEnumType>(definition.DefaultValue);
+        var newSerializer = ConvertEnumSerializer<TFromEnum, TToEnum, TUnderlyingEnumType>(definition.Serializer);
+
+        var newDefinition = new OptionDefinition<TToEnum>(
+            defaultValue: newDefaultValue, newSerializer, definition.Group, definition.ConfigName, definition.StorageMapping, definition.IsEditorConfigOption);
+
+        return new(newDefinition, option.Feature, option.Name, option.StorageLocations);
+    }
+
+    private static EditorConfigValueSerializer<TToEnum>? ConvertEnumSerializer<TFromEnum, TToEnum, TUnderlyingEnumType>(EditorConfigValueSerializer<TFromEnum> serializer)
+        where TFromEnum : struct
+        where TToEnum : struct
+        where TUnderlyingEnumType : struct
+    {
+        return new(
+            value => ConvertEnum<TFromEnum, TToEnum, TUnderlyingEnumType>(serializer.ParseValue(value)),
+            value => serializer.SerializeValue(ConvertEnum<TToEnum, TFromEnum, TUnderlyingEnumType>(value)));
+    }
+
+    private static Optional<TToEnum> ConvertEnum<TFromEnum, TToEnum, TUnderlyingEnumType>(Optional<TFromEnum> optional)
+        where TFromEnum : struct
+        where TToEnum : struct
+        where TUnderlyingEnumType : struct
+    {
+        if (!optional.HasValue)
+            return default;
+
+        return ConvertEnum<TFromEnum, TToEnum, TUnderlyingEnumType>(optional.Value);
+    }
+
+    private static TToEnum ConvertEnum<TFromEnum, TToEnum, TUnderlyingEnumType>(TFromEnum value)
+        where TFromEnum : struct
+        where TToEnum : struct
+        where TUnderlyingEnumType : struct
+    {
+        return Unsafe.As<TUnderlyingEnumType, TToEnum>(ref Unsafe.As<TFromEnum, TUnderlyingEnumType>(ref value));
+    }
+}