Add external access APIs for O#

eng/Versions.props

@@ -21,7 +21,7 @@
     <!-- Versions used by several individual references below -->
     <RoslynDiagnosticsNugetPackageVersion>3.3.3-beta1.21105.3</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>6.0.0-rc1.21366.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
-    <MicrosoftCodeAnalysisTestingVersion>1.1.1-beta1.22081.4</MicrosoftCodeAnalysisTestingVersion>
+    <MicrosoftCodeAnalysisTestingVersion>1.1.2-beta1.22122.4</MicrosoftCodeAnalysisTestingVersion>
     <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.127-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
     <!-- CodeStyleAnalyzerVersion should we updated together with version of dotnet-format in dotnet-tools.json -->
     <CodeStyleAnalyzerVersion>4.0.1</CodeStyleAnalyzerVersion>

global.json

@@ -12,7 +12,7 @@
     "xcopy-msbuild": "16.10.0-preview2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22117.2",
-    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22117.2"
+    "Microsoft.DotNet.Arcade.Sdk": "7.0.0-beta.22080.1",
+    "Microsoft.DotNet.Helix.Sdk": "7.0.0-beta.22080.1"
   }
 }

src/Analyzers/CSharp/Analyzers/RemoveUnreachableCode/CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs

@@ -40,7 +40,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
         private void AnalyzeSemanticModel(SemanticModelAnalysisContext context)
         {
-            var fadeCode = context.GetIdeOptions().FadeOutUnreachableCode;
+            var fadeCode = context.Options.GetIdeOptions().FadeOutUnreachableCode;
             var semanticModel = context.SemanticModel;
             var cancellationToken = context.CancellationToken;
 

src/Analyzers/Core/Analyzers/Helpers/AnalyzerHelper.cs

@@ -14,46 +14,44 @@
 namespace Microsoft.CodeAnalysis.Diagnostics
 {
     internal readonly record struct IdeAnalyzerOptions(
-        bool FadeOutUnusedImports,
-        bool FadeOutUnreachableCode,
-        bool ReportInvalidPlaceholdersInStringDotFormatCalls,
-        bool ReportInvalidRegexPatterns)
+        bool FadeOutUnusedImports = true,
+        bool FadeOutUnreachableCode = true,
+        bool ReportInvalidPlaceholdersInStringDotFormatCalls = true,
+        bool ReportInvalidRegexPatterns = true)
     {
+        public IdeAnalyzerOptions()
+            : this(FadeOutUnusedImports: true)
+        {
+        }
+
+        public static readonly IdeAnalyzerOptions Default = new();
+
         public static readonly IdeAnalyzerOptions CodeStyleDefault = new(
             FadeOutUnusedImports: false,
             FadeOutUnreachableCode: false,
             ReportInvalidPlaceholdersInStringDotFormatCalls: true,
             ReportInvalidRegexPatterns: true);
-    }
-
-    internal static partial class AnalyzerHelper
-    {
-        public static IdeAnalyzerOptions GetIdeOptions(this SyntaxTreeAnalysisContext context)
-#if CODE_STYLE
-            => IdeAnalyzerOptions.CodeStyleDefault;
-#else
-            => (context.Options is WorkspaceAnalyzerOptions workspaceOptions) ? workspaceOptions.GetIdeOptions(context.Tree.Options.Language) : IdeAnalyzerOptions.CodeStyleDefault;
-#endif
 
-        public static IdeAnalyzerOptions GetIdeOptions(this OperationAnalysisContext context)
-#if CODE_STYLE
-            => IdeAnalyzerOptions.CodeStyleDefault;
-#else
-            => (context.Options is WorkspaceAnalyzerOptions workspaceOptions) ? workspaceOptions.GetIdeOptions(context.Operation.Language) : IdeAnalyzerOptions.CodeStyleDefault;
-#endif
+#if !CODE_STYLE
+        public static IdeAnalyzerOptions FromProject(Project project)
+            => From(project.Solution.Options, project.Language);
 
-        public static IdeAnalyzerOptions GetIdeOptions(this SyntaxNodeAnalysisContext context)
-#if CODE_STYLE
-            => IdeAnalyzerOptions.CodeStyleDefault;
-#else
-            => (context.Options is WorkspaceAnalyzerOptions workspaceOptions) ? workspaceOptions.GetIdeOptions(context.Node.Language) : IdeAnalyzerOptions.CodeStyleDefault;
+        public static IdeAnalyzerOptions From(OptionSet options, string language)
+            => new(
+                FadeOutUnusedImports: options.GetOption(Microsoft.CodeAnalysis.Fading.FadingOptions.Metadata.FadeOutUnusedImports, language),
+                FadeOutUnreachableCode: options.GetOption(Microsoft.CodeAnalysis.Fading.FadingOptions.Metadata.FadeOutUnreachableCode, language),
+                ReportInvalidPlaceholdersInStringDotFormatCalls: options.GetOption(Microsoft.CodeAnalysis.ValidateFormatString.ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, language),
+                ReportInvalidRegexPatterns: options.GetOption(Microsoft.CodeAnalysis.Features.EmbeddedLanguages.RegularExpressions.LanguageServices.RegularExpressionsOptions.ReportInvalidRegexPatterns, language));
 #endif
+    }
 
-        public static IdeAnalyzerOptions GetIdeOptions(this SemanticModelAnalysisContext context)
+    internal static partial class AnalyzerHelper
+    {
+        public static IdeAnalyzerOptions GetIdeOptions(this AnalyzerOptions options)
 #if CODE_STYLE
             => IdeAnalyzerOptions.CodeStyleDefault;
 #else
-            => (context.Options is WorkspaceAnalyzerOptions workspaceOptions) ? workspaceOptions.GetIdeOptions(context.SemanticModel.Language) : IdeAnalyzerOptions.CodeStyleDefault;
+            => (options is WorkspaceAnalyzerOptions workspaceOptions) ? workspaceOptions.IdeOptions : IdeAnalyzerOptions.CodeStyleDefault;
 #endif
 
         public static T GetOption<T>(this SemanticModelAnalysisContext context, Option2<T> option)

src/Analyzers/Core/Analyzers/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs

@@ -142,7 +142,7 @@ private void AnalyzeSemanticModel(SemanticModelAnalysisContext context)
                 // for us appropriately.
                 unnecessaryImports = MergeImports(unnecessaryImports);
 
-                var fadeOut = context.GetIdeOptions().FadeOutUnusedImports;
+                var fadeOut = context.Options.GetIdeOptions().FadeOutUnusedImports;
 
                 DiagnosticDescriptor descriptor;
                 if (GeneratedCodeUtilities.IsGeneratedCode(tree, IsRegularCommentOrDocComment, cancellationToken))

src/Analyzers/Core/Analyzers/ValidateFormatString/AbstractValidateFormatStringDiagnosticAnalyzer.cs

@@ -96,7 +96,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context, INamedTypeSymbol for
                 return;
             }
 
-            if (!context.GetIdeOptions().ReportInvalidPlaceholdersInStringDotFormatCalls)
+            if (!context.Options.GetIdeOptions().ReportInvalidPlaceholdersInStringDotFormatCalls)
             {
                 return;
             }

src/Analyzers/Core/Analyzers/ValidateFormatString/ValidateFormatStringOption.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.ValidateFormatString
@@ -12,7 +13,7 @@ internal class ValidateFormatStringOption
             new(
                 nameof(ValidateFormatStringOption),
                 nameof(ReportInvalidPlaceholdersInStringDotFormatCalls),
-                defaultValue: true,
+                IdeAnalyzerOptions.Default.ReportInvalidPlaceholdersInStringDotFormatCalls,
                 storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.WarnOnInvalidStringDotFormatCalls"));
     }
 }

src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs

@@ -5,6 +5,7 @@
 #nullable disable
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp;
@@ -1468,6 +1469,11 @@ class T : A
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementAbstractClass)]
         public async Task TestWithGroupingOff1()
         {
+            var options = CodeActionOptions.Default with
+            {
+                ImplementTypeOptions = new ImplementTypeOptions(InsertionBehavior: ImplementTypeInsertionBehavior.AtTheEnd)
+            };
+
             await TestInRegularAndScriptAsync(
 @"abstract class Base
 {
@@ -1488,7 +1494,7 @@ class Derived : Base
     void Goo() { }
 
     public override int Prop => throw new System.NotImplementedException();
-}", options: Option(ImplementTypeOptions.Metadata.InsertionBehavior, ImplementTypeInsertionBehavior.AtTheEnd));
+}", codeActionOptions: options);
         }
 
         [WorkItem(17274, "https://github.com/dotnet/roslyn/issues/17274")]
@@ -1641,6 +1647,11 @@ public override void M2<T>(T? i = null)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementAbstractClass)]
         public async Task TestAutoProperties()
         {
+            var options = CodeActionOptions.Default with
+            {
+                ImplementTypeOptions = new ImplementTypeOptions(PropertyGenerationBehavior: ImplementTypePropertyGenerationBehavior.PreferAutoProperties)
+            };
+
             await TestInRegularAndScript1Async(
 @"abstract class AbstractClass
 {
@@ -1664,9 +1675,7 @@ class C : AbstractClass
     public override int ReadOnlyProp { get; }
     public override int ReadWriteProp { get; set; }
     public override int WriteOnlyProp { set => throw new System.NotImplementedException(); }
-}", parameters: new TestParameters(options: Option(
-    ImplementTypeOptions.Metadata.PropertyGenerationBehavior,
-    ImplementTypePropertyGenerationBehavior.PreferAutoProperties)));
+}", parameters: new TestParameters(codeActionOptions: options));
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementAbstractClass)]

src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
@@ -7286,10 +7287,10 @@ void M() { }
 
     public int Prop => throw new System.NotImplementedException();
 }",
-                Options =
+                CodeActionOptions = CodeActionOptions.Default with
                 {
-                    { ImplementTypeOptions.Metadata.InsertionBehavior, ImplementTypeInsertionBehavior.AtTheEnd },
-                },
+                    ImplementTypeOptions = new ImplementTypeOptions(InsertionBehavior: ImplementTypeInsertionBehavior.AtTheEnd)
+                }
             }.RunAsync();
         }
 
@@ -7461,10 +7462,10 @@ class Class : IInterface
     public int ReadWriteProp { get; set; }
     public int WriteOnlyProp { set => throw new System.NotImplementedException(); }
 }",
-                Options =
+                CodeActionOptions = CodeActionOptions.Default with
                 {
-                    { ImplementTypeOptions.Metadata.PropertyGenerationBehavior, ImplementTypePropertyGenerationBehavior.PreferAutoProperties },
-                },
+                    ImplementTypeOptions = new ImplementTypeOptions(PropertyGenerationBehavior: ImplementTypePropertyGenerationBehavior.PreferAutoProperties)
+                }
             }.RunAsync();
         }
 

src/EditorFeatures/CSharpTest/Wrapping/AbstractWrappingTests.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.ImplementType;
 using Microsoft.CodeAnalysis.SymbolSearch;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Wrapping
@@ -19,7 +20,9 @@ protected sealed override ImmutableArray<CodeAction> MassageActions(ImmutableArr
             => FlattenActions(actions);
 
         private protected static CodeActionOptions GetIndentionColumn(int column)
-            => new(SymbolSearchOptions.Default, WrappingColumn: column);
+            => new(SymbolSearchOptions.Default,
+                   ImplementTypeOptions.Default,
+                   WrappingColumn: column);
 
         protected Task TestAllWrappingCasesAsync(
             string input,

src/EditorFeatures/Core/ImplementType/ImplementTypeOptionsStorage.cs

@@ -0,0 +1,30 @@
+// 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.
+
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.ImplementType
+{
+    internal static class ImplementTypeOptionsStorage
+    {
+        public static ImplementTypeOptions GetImplementTypeOptions(this IGlobalOptionService globalOptions, string language)
+          => new(
+              InsertionBehavior: globalOptions.GetOption(InsertionBehavior, language),
+              PropertyGenerationBehavior: globalOptions.GetOption(PropertyGenerationBehavior, language));
+
+        private const string FeatureName = "ImplementTypeOptions";
+
+        public static readonly PerLanguageOption2<ImplementTypeInsertionBehavior> InsertionBehavior =
+            new(FeatureName,
+                "InsertionBehavior",
+                defaultValue: ImplementTypeOptions.Default.InsertionBehavior,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.ImplementTypeOptions.InsertionBehavior"));
+
+        public static readonly PerLanguageOption2<ImplementTypePropertyGenerationBehavior> PropertyGenerationBehavior =
+            new(FeatureName,
+                "PropertyGenerationBehavior",
+                defaultValue: ImplementTypeOptions.Default.PropertyGenerationBehavior,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.ImplementTypeOptions.PropertyGenerationBehavior"));
+    }
+}

src/EditorFeatures/Core/Implementation/CodeActions/CodeActionOptionsStorage.cs

@@ -4,6 +4,7 @@
 
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.ImplementType;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.SymbolSearch;
 
@@ -20,6 +21,7 @@ internal static CodeActionOptions GetBlockingCodeActionOptions(this IGlobalOptio
         private static CodeActionOptions GetCodeActionOptions(this IGlobalOptionService globalOptions, string language, bool isBlocking)
             => new(
                 SearchOptions: globalOptions.GetSymbolSearchOptions(language),
+                ImplementTypeOptions: globalOptions.GetImplementTypeOptions(language),
                 HideAdvancedMembers: globalOptions.GetOption(CompletionOptionsStorage.HideAdvancedMembers, language),
                 IsBlocking: isBlocking);
 

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs

@@ -376,14 +376,15 @@ internal Task TestInRegularAndScriptAsync(
             CodeActionPriority? priority = null,
             CompilationOptions compilationOptions = null,
             OptionsCollection options = null,
+            CodeActionOptions? codeActionOptions = null,
             object fixProviderData = null,
             ParseOptions parseOptions = null,
             string title = null,
             TestHost testHost = TestHost.InProcess)
         {
             return TestInRegularAndScript1Async(
                 initialMarkup, expectedMarkup, index,
-                new TestParameters(parseOptions, compilationOptions, options, CodeActionOptions.Default, fixProviderData, index, priority, title: title, testHost: testHost));
+                new TestParameters(parseOptions, compilationOptions, options, codeActionOptions ?? CodeActionOptions.Default, fixProviderData, index, priority, title: title, testHost: testHost));
         }
 
         internal Task TestInRegularAndScript1Async(

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs

@@ -16,6 +16,8 @@
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Text;
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Shared.Utilities;
 
 #if !CODE_STYLE
 using Roslyn.Utilities;
@@ -73,6 +75,13 @@ public Test()
             /// <inheritdoc cref="SharedVerifierState.Options"/>
             internal OptionsCollection Options => _sharedState.Options;
 
+#if !CODE_STYLE
+            internal CodeActionOptions CodeActionOptions
+            {
+                get => _sharedState.CodeActionOptions;
+                set => _sharedState.CodeActionOptions = value;
+            }
+#endif
             /// <inheritdoc cref="SharedVerifierState.EditorConfig"/>
             public string? EditorConfig
             {
@@ -97,7 +106,31 @@ protected override async Task RunImplAsync(CancellationToken cancellationToken =
 
 #if !CODE_STYLE
             protected override AnalyzerOptions GetAnalyzerOptions(Project project)
-                => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project.Solution);
+                => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project);
+
+            protected override CodeFixContext CreateCodeFixContext(Document document, TextSpan span, ImmutableArray<Diagnostic> diagnostics, Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix, CancellationToken cancellationToken)
+                => new(document, span, diagnostics, registerCodeFix, _sharedState.CodeActionOptions, cancellationToken);
+
+            protected override FixAllContext CreateFixAllContext(
+                Document? document,
+                Project project,
+                CodeFixProvider codeFixProvider,
+                FixAllScope scope,
+                string? codeActionEquivalenceKey,
+                IEnumerable<string> diagnosticIds,
+                FixAllContext.DiagnosticProvider fixAllDiagnosticProvider,
+                CancellationToken cancellationToken)
+                => new(new FixAllState(
+                    fixAllProvider: null,
+                    document,
+                    project,
+                    codeFixProvider,
+                    scope,
+                    codeActionEquivalenceKey,
+                    diagnosticIds,
+                    fixAllDiagnosticProvider,
+                    _ => _sharedState.CodeActionOptions),
+                  new ProgressTracker(), cancellationToken);
 #endif
 
             protected override Diagnostic? TrySelectDiagnosticToFix(ImmutableArray<Diagnostic> fixableDiagnostics)

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs

@@ -102,7 +102,7 @@ protected override ImmutableArray<CodeAction> FilterCodeActions(ImmutableArray<C
 
 #if !CODE_STYLE
             protected override AnalyzerOptions GetAnalyzerOptions(Project project)
-                => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project.Solution);
+                => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project);
 
             /// <summary>
             /// The <see cref="TestHost"/> we want this test to run in.  Defaults to <see cref="TestHost.InProcess"/> if unspecified.

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/SharedVerifierState.cs

@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.Testing.Verifiers;
 
 #if !CODE_STYLE
+using Microsoft.CodeAnalysis.CodeActions;
 using Roslyn.Utilities;
 #endif
 
@@ -45,6 +46,9 @@ public SharedVerifierState(AnalyzerTest<XUnitVerifier> test, string defaultFileE
         /// </summary>
         internal OptionsCollection Options { get; }
 
+#if !CODE_STYLE
+        internal CodeActionOptions CodeActionOptions { get; set; }
+#endif
         internal void Apply()
         {
             var (analyzerConfigSource, remainingOptions) = CodeFixVerifierHelper.ConvertOptionsToAnalyzerConfig(_defaultFileExt, EditorConfig, Options);

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeFixVerifier`2+Test.cs

@@ -88,7 +88,7 @@ protected override async Task RunImplAsync(CancellationToken cancellationToken =
 
 #if !CODE_STYLE
             protected override AnalyzerOptions GetAnalyzerOptions(Project project)
-                => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project.Solution);
+                => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project);
 #endif
 
             protected override Diagnostic? TrySelectDiagnosticToFix(ImmutableArray<Diagnostic> fixableDiagnostics)