Merge pull request #10926 from JohnHamby/MergeMicroupdateToFuturestabilization

Merge microupdate to futurestabilization

src/EditorFeatures/Test2/Diagnostics/DiagnosticServiceTests.vb

@@ -10,6 +10,7 @@ Imports Microsoft.CodeAnalysis.Diagnostics
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.Options
+Imports Microsoft.CodeAnalysis.Shared.Options
 Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.UnitTests.Diagnostics
@@ -1917,6 +1918,8 @@ class MyClass
                        </Workspace>
 
             Using workspace = TestWorkspace.CreateWorkspace(test)
+                workspace.Options = workspace.Options.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.CSharp, True)
+
                 Dim project = workspace.CurrentSolution.Projects.Single()
 
                 ' Add analyzer

src/Features/Core/Portable/Diagnostics/EngineV1/DiagnosticIncrementalAnalyzer.cs

@@ -143,7 +143,7 @@ private Task ClearOnlyDocumentStates(Document document)
         private bool CheckOptions(Project project, bool forceAnalysis)
         {
             var workspace = project.Solution.Workspace;
-            if (workspace.Options.GetOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, project.Language) &&
+            if (ServiceFeatureOnOffOptions.IsClosedFileDiagnosticsEnabled(workspace, project.Language) &&
                 workspace.Options.GetOption(RuntimeOptions.FullSolutionAnalysis))
             {
                 return true;

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs

@@ -320,7 +320,7 @@ private static async Task<bool> FullAnalysisEnabledAsync(Project project, Cancel
                 var workspace = project.Solution.Workspace;
                 var language = project.Language;
 
-                if (!workspace.Options.GetOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, language) ||
+                if (!ServiceFeatureOnOffOptions.IsClosedFileDiagnosticsEnabled(workspace, language) ||
                     !workspace.Options.GetOption(RuntimeOptions.FullSolutionAnalysis))
                 {
                     return false;

src/Features/Core/Portable/Shared/Options/ServiceFeatureOnOffOptions.cs

@@ -8,11 +8,33 @@ internal static class ServiceFeatureOnOffOptions
     {
         public const string OptionName = "ServiceFeaturesOnOff";
 
+        private const bool CSharpClosedFileDiagnosticsEnabledByDefault = false;
+        private const bool DefaultClosedFileDiagnosticsEnabledByDefault = true;
+
         /// <summary>
         /// this option is solely for performance. don't confused by option name. 
         /// this option doesn't mean we will show all diagnostics that belong to opened files when turned off,
         /// rather it means we will only show diagnostics that are cheap to calculate for small scope such as opened files.
         /// </summary>
-        public static readonly PerLanguageOption<bool> ClosedFileDiagnostic = new PerLanguageOption<bool>(OptionName, "Closed File Diagnostic", defaultValue: true);
+        public static readonly PerLanguageOption<bool?> ClosedFileDiagnostic = new PerLanguageOption<bool?>(OptionName, "Closed File Diagnostic", defaultValue: null);
+
+        public static bool IsClosedFileDiagnosticsEnabled(Workspace workspace, string language)
+        {
+            var optionsService = workspace.Services.GetService<IOptionService>();
+            return optionsService != null && IsClosedFileDiagnosticsEnabled(optionsService, language);
+        }
+
+        public static bool IsClosedFileDiagnosticsEnabled(IOptionService optionService, string language)
+        {
+            var option = optionService.GetOption(ClosedFileDiagnostic, language);
+            if (!option.HasValue)
+            {
+                return language == LanguageNames.CSharp ?
+                    CSharpClosedFileDiagnosticsEnabledByDefault :
+                    DefaultClosedFileDiagnosticsEnabledByDefault;
+            }
+
+            return option.Value;
+        }
     }
 }

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

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Runtime.InteropServices;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
@@ -38,7 +39,22 @@ public int BringUpOnIdentifier
             set { SetBooleanOption(CompletionOptions.TriggerOnTypingLetters, value); }
         }
 
+        [Obsolete("This SettingStore option has now been deprecated in favor of CSharpClosedFileDiagnostics")]
         public int ClosedFileDiagnostics
+        {
+            get { return GetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic); }
+            set
+            {
+                // Even though this option has been deprecated, we want to respect the setting if the user has explicitly turned off closed file diagnostics (which is the non-default value for 'ClosedFileDiagnostics').
+                // So, we invoke the setter only for value = 0.
+                if (value == 0)
+                {
+                    SetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, value);
+                }
+            }
+        }
+
+        public int CSharpClosedFileDiagnostics
         {
             get { return GetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic); }
             set { SetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, value); }
@@ -595,6 +611,25 @@ private void SetBooleanOption(PerLanguageOption<bool> key, int value)
             _optionService.SetOptions(optionSet);
         }
 
+        private int GetBooleanOption(PerLanguageOption<bool?> key)
+        {
+            var option = _optionService.GetOption(key, LanguageNames.CSharp);
+            if (!option.HasValue)
+            {
+                return -1;
+            }
+
+            return option.Value ? 1 : 0;
+        }
+
+        private void SetBooleanOption(PerLanguageOption<bool?> key, int value)
+        {
+            bool? boolValue = (value < 0) ? (bool?)null : (value > 0);
+            var optionSet = _optionService.GetOptions();
+            optionSet = optionSet.WithChangedOption(key, LanguageNames.CSharp, boolValue);
+            _optionService.SetOptions(optionSet);
+        }
+
         private static string GetUseVarOption(SimpleCodeStyleOption option)
         {
             return option.ToXElement().ToString();

src/VisualStudio/CSharp/Impl/Options/CSharpSettingsManagerOptionSerializer.cs

@@ -100,6 +100,20 @@ private bool ShouldIncludeOnOffOption(FieldInfo fieldInfo)
 
         protected override string SettingStorageRoot { get { return "TextEditor.CSharp.Specific."; } }
 
+        protected override string GetStorageKeyForOption(IOption option)
+        {
+            var name = option.Name;
+            if (option == ServiceFeatureOnOffOptions.ClosedFileDiagnostic)
+            {
+                // ClosedFileDiagnostics has been deprecated in favor of CSharpClosedFileDiagnostics.
+                // ClosedFileDiagnostics had a default value of 'true', while CSharpClosedFileDiagnostics has a default value of 'false'.
+                // We want to ensure that we don't fetch the setting store value for the old flag, as that can cause the default value for this option to change.
+                name = nameof(AutomationObject.CSharpClosedFileDiagnostics);
+            }
+
+            return SettingStorageRoot + name;
+        }
+
         protected override bool SupportsOption(IOption option, string languageName)
         {
             if (option == OrganizerOptions.PlaceSystemNamespaceFirst ||

src/VisualStudio/Core/Def/Implementation/Diagnostics/MiscellaneousDiagnosticAnalyzerService.cs

@@ -152,7 +152,7 @@ public void RemoveProject(ProjectId projectId)
 
             private bool CheckOptions(Document document)
             {
-                if (_workspace.Options.GetOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, document.Project.Language) &&
+                if (ServiceFeatureOnOffOptions.IsClosedFileDiagnosticsEnabled(_workspace, document.Project.Language) &&
                     _workspace.Options.GetOption(RuntimeOptions.FullSolutionAnalysis))
                 {
                     return true;

src/VisualStudio/Core/Impl/Options/FullSolutionAnalysisOptionBinding.cs

@@ -11,7 +11,7 @@ internal class FullSolutionAnalysisOptionBinding
         private readonly string _languageName;
 
         private readonly Option<bool> _fullSolutionAnalysis;
-        private readonly PerLanguageOption<bool> _closedFileDiagnostics;
+        private readonly PerLanguageOption<bool?> _closedFileDiagnostics;
 
         public FullSolutionAnalysisOptionBinding(IOptionService optionService, string languageName)
         {
@@ -26,7 +26,7 @@ public bool Value
         {
             get
             {
-                return _optionService.GetOption(_closedFileDiagnostics, _languageName) &&
+                return ServiceFeatureOnOffOptions.IsClosedFileDiagnosticsEnabled(_optionService, _languageName) &&
                        _optionService.GetOption(_fullSolutionAnalysis);
             }
 

src/VisualStudio/VisualBasic/Impl/Options/AutomationObject.vb

@@ -44,11 +44,25 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             End Set
         End Property
 
+        <Obsolete("This SettingStore option has now been deprecated in favor of BasicClosedFileDiagnostics")>
         Public Property ClosedFileDiagnostics As Boolean
             Get
-                Return GetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic)
+                Return ServiceFeatureOnOffOptions.IsClosedFileDiagnosticsEnabled(_optionService, LanguageNames.VisualBasic)
             End Get
             Set(value As Boolean)
+                ' Even though this option has been deprecated, we want to respect the setting if the user has explicitly turned off closed file diagnostics (which is the non-default value for 'ClosedFileDiagnostics').
+                ' So, we invoke the setter only for value = False.
+                If Not value Then
+                    SetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, value:=0)
+                End If
+            End Set
+        End Property
+
+        Public Property BasicClosedFileDiagnostics As Integer
+            Get
+                Return GetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic)
+            End Get
+            Set(value As Integer)
                 SetBooleanOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, value)
             End Set
         End Property
@@ -198,5 +212,21 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
             optionSet = optionSet.WithChangedOption(key, LanguageNames.VisualBasic, value)
             _optionService.SetOptions(optionSet)
         End Sub
+
+        Private Function GetBooleanOption(key As PerLanguageOption(Of Boolean?)) As Integer
+            Dim [option] = _optionService.GetOption(key, LanguageNames.VisualBasic)
+            If Not [option].HasValue Then
+                Return -1
+            End If
+
+            Return If([option].Value, 1, 0)
+        End Function
+
+        Private Sub SetBooleanOption(key As PerLanguageOption(Of Boolean?), value As Integer)
+            Dim boolValue As Boolean? = If(value < 0, Nothing, value > 0)
+            Dim optionSet = _optionService.GetOptions()
+            optionSet = optionSet.WithChangedOption(key, LanguageNames.VisualBasic, boolValue)
+            _optionService.SetOptions(optionSet)
+        End Sub
     End Class
 End Namespace