Merge remote-tracking branch 'upstream/main' into initializeFieldOrProp

Author: CyrusNajmabadi

src/Analyzers/CSharp/Tests/AddObsoleteAttribute/AddObsoleteAttributeTests.cs

@@ -3,14 +3,18 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.AddObsoleteAttribute;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.Testing;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
-    Microsoft.CodeAnalysis.Testing.EmptyDiagnosticAnalyzer,
-    Microsoft.CodeAnalysis.CSharp.AddObsoleteAttribute.CSharpAddObsoleteAttributeCodeFixProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.AddObsoleteAttribute;
 
+using VerifyCS = CSharpCodeFixVerifier<
+    EmptyDiagnosticAnalyzer,
+    CSharpAddObsoleteAttributeCodeFixProvider>;
+
 [Trait(Traits.Feature, Traits.Features.CodeActionsAddObsoleteAttribute)]
 public sealed class AddObsoleteAttributeTests
 {

src/Analyzers/CSharp/Tests/FileHeaders/FileHeaderTests.cs

@@ -3,16 +3,19 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.FileHeaders;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
-    Microsoft.CodeAnalysis.CSharp.FileHeaders.CSharpFileHeaderDiagnosticAnalyzer,
-    Microsoft.CodeAnalysis.CSharp.FileHeaders.CSharpFileHeaderCodeFixProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.FileHeaders;
 
+using VerifyCS = CSharpCodeFixVerifier<
+    CSharpFileHeaderDiagnosticAnalyzer,
+    CSharpFileHeaderCodeFixProvider>;
+
 public sealed class FileHeaderTests
 {
     private const string TestSettings = """

src/Analyzers/CSharp/Tests/RemoveUnnecessarySuppressions/RemoveUnnecessaryAttributeSuppressionsTests.cs

@@ -3,17 +3,19 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessarySuppressions;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.RemoveUnnecessarySuppressions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
-    Microsoft.CodeAnalysis.CSharp.RemoveUnnecessarySuppressions.CSharpRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer,
-    Microsoft.CodeAnalysis.RemoveUnnecessarySuppressions.RemoveUnnecessaryAttributeSuppressionsCodeFixProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.RemoveUnnecessarySuppressions;
 
+using VerifyCS = CSharpCodeFixVerifier<
+    CSharpRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer,
+    RemoveUnnecessaryAttributeSuppressionsCodeFixProvider>;
+
 [Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessarySuppressions)]
 [WorkItem("https://github.com/dotnet/roslyn/issues/44176")]
 public sealed class RemoveUnnecessaryAttributeSuppressionsTests

src/Analyzers/CSharp/Tests/UpdateLegacySuppressions/UpdateLegacySuppressionsTests.cs

@@ -3,17 +3,20 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.RemoveUnnecessarySuppressions;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.RemoveUnnecessarySuppressions;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.UpdateLegacySuppressions;
 using Roslyn.Test.Utilities;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
-    Microsoft.CodeAnalysis.CSharp.RemoveUnnecessarySuppressions.CSharpRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer,
-    Microsoft.CodeAnalysis.UpdateLegacySuppressions.UpdateLegacySuppressionsCodeFixProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UpdateLegacySuppressions;
 
+using VerifyCS = CSharpCodeFixVerifier<
+    CSharpRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer,
+    UpdateLegacySuppressionsCodeFixProvider>;
+
 [Trait(Traits.Feature, Traits.Features.CodeActionsUpdateLegacySuppressions)]
 [WorkItem("https://github.com/dotnet/roslyn/issues/44362")]
 public sealed class UpdateLegacySuppressionsTests

src/Analyzers/VisualBasic/Tests/RemoveUnnecessaryParentheses/RemoveUnnecessaryParenthesesTests.vb

@@ -15,7 +15,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.RemoveUnnecessaryP
     ''' whose current option is set to something other than 'Ignore'.
     ''' </summary>
     <Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryParentheses)>
-    Partial Public Class RemoveUnnecessaryParenthesesTests
+    Partial Public NotInheritable Class RemoveUnnecessaryParenthesesTests
         Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_NoEditor
 
         Private Shared ReadOnly CheckOverflow As CompilationOptions = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication, checkOverflow:=True)
@@ -651,7 +651,16 @@ end class"
 
                 Assert.Equal("[1,2]", diagnostic.Properties.Item(WellKnownDiagnosticTags.Unnecessary))
             End Using
+        End Function
 
+        <Fact, WorkItem("https://github.com/dotnet/roslyn/issues/78187")>
+        Public Async Function TestWithNullMemberAccess() As Task
+            Await TestMissingAsync(
+"class C
+    sub M()
+        RoundTime($$(d.EndDate - d.StartDate)?.TotalMinutes / 60)
+    end sub
+end class", New TestParameters(options:=RequireArithmeticBinaryParenthesesForClarity))
         End Function
     End Class
 End Namespace

src/EditorFeatures/CSharpTest/AddMissingImports/CSharpAddMissingImportsRefactoringProviderTests.cs

@@ -2,13 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.AddImport;
 using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.AddMissingImports;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
@@ -26,6 +27,12 @@ public sealed class CSharpAddMissingImportsRefactoringProviderTests : AbstractCS
     protected override CodeRefactoringProvider CreateCodeRefactoringProvider(EditorTestWorkspace workspace, TestParameters parameters)
         => new CSharpAddMissingImportsRefactoringProvider();
 
+    private static readonly CodeStyleOption2<AddImportPlacement> InsideNamespaceOption =
+        new(AddImportPlacement.InsideNamespace, NotificationOption2.Error);
+
+    private static readonly CodeStyleOption2<AddImportPlacement> OutsideNamespaceOption =
+        new(AddImportPlacement.InsideNamespace, NotificationOption2.Error);
+
     protected override void InitializeWorkspace(EditorTestWorkspace workspace, TestParameters parameters)
     {
         // Treat the span being tested as the pasted span
@@ -46,13 +53,16 @@ protected override void InitializeWorkspace(EditorTestWorkspace workspace, TestP
     private Task TestInRegularAndScriptAsync(
         [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string initialMarkup,
         [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expectedMarkup,
-        bool placeSystemNamespaceFirst, bool separateImportDirectiveGroups)
+        bool placeSystemNamespaceFirst,
+        bool separateImportDirectiveGroups,
+        bool placeInsideNamespace = false)
     {
         var options =
             new OptionsCollection(GetLanguage())
             {
                 { GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst },
                 { GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups },
+                { CSharpCodeStyleOptions.PreferredUsingDirectivePlacement, placeInsideNamespace ? InsideNamespaceOption : OutsideNamespaceOption },
             };
         return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options: options);
     }
@@ -353,4 +363,29 @@ class C
                 List<Type> list;
             }
             """, placeSystemNamespaceFirst: true, separateImportDirectiveGroups: true);
+
+    [WpfTheory, CombinatorialData, WorkItem("https://github.com/dotnet/roslyn/issues/54842")]
+    public Task TestWithNamespace(bool placeInsideNamespace)
+        => TestInRegularAndScriptAsync("""
+            namespace N
+            {
+                using System;
+
+                class C
+                {
+                    [|List<Type> list;|]
+                }
+            }
+            """, """
+            namespace N
+            {
+                using System;
+                using System.Collections.Generic;
+
+                class C
+                {
+                    List<Type> list;
+                }
+            }
+            """, placeSystemNamespaceFirst: true, separateImportDirectiveGroups: true, placeInsideNamespace);
 }

src/EditorFeatures/CSharpTest/CodeActions/AddUsing/AbstractAddUsingTests.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
@@ -18,14 +16,10 @@
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.AddUsing;
 
-public abstract class AbstractAddUsingTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
+public abstract class AbstractAddUsingTests(ITestOutputHelper? logger = null)
+    : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest(logger)
 {
-    protected AbstractAddUsingTests(ITestOutputHelper logger = null)
-        : base(logger)
-    {
-    }
-
-    internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
+    internal override (DiagnosticAnalyzer?, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
         => (null, new CSharpAddImportCodeFixProvider());
 
     private protected OptionsCollection SeparateGroups => Option(GenerationOptions.SeparateImportDirectiveGroups, true);
@@ -36,7 +30,7 @@ internal Task TestAsync(
         TestHost testHost,
         int index = 0,
         CodeActionPriority? priority = null,
-        OptionsCollection options = null)
+        OptionsCollection? options = null)
         => TestInRegularAndScript1Async(
             initialMarkup,
             expectedMarkup,

src/EditorFeatures/CSharpTest/CodeActions/AddUsing/AddUsingTests.cs

@@ -6633,4 +6633,17 @@ class Program
             """,
             index: 0,
             parameters: new TestParameters(testHost: testHost));
+
+    [Theory, CombinatorialData]
+    [WorkItem("https://github.com/dotnet/roslyn/issues/72022")]
+    public Task TestAssemblyLevelAttribute(TestHost testHost)
+        => TestAsync(
+            """
+            [assembly: [|NeutralResourcesLanguage|]("en")]
+            """,
+            """
+            using System.Resources;
+
+            [assembly: NeutralResourcesLanguage("en")]
+            """, testHost);
 }

src/EditorFeatures/CSharpTest/CodeActions/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs

@@ -20,11 +20,12 @@
 using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeRefactoringVerifier<
-    Microsoft.CodeAnalysis.GenerateEqualsAndGetHashCodeFromMembers.GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateEqualsAndGetHashCodeFromMembers;
 
+using VerifyCS = CSharpCodeRefactoringVerifier<
+    GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider>;
+
 [UseExportProvider]
 [Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEqualsAndGetHashCode)]
 public sealed class GenerateEqualsAndGetHashCodeFromMembersTests
@@ -69,10 +70,7 @@ private static OptionsCollection PreferExplicitTypeWithInfo()
     internal static void EnableOption(ImmutableArray<PickMembersOption> options, string id)
     {
         var option = options.FirstOrDefault(o => o.Id == id);
-        if (option != null)
-        {
-            option.Value = true;
-        }
+        option?.Value = true;
     }
 
     [Fact]

src/EditorFeatures/CSharpTest/CodeActions/MoveStaticMembers/CSharpMoveStaticMembersTests.cs

@@ -4,16 +4,19 @@
 
 using System.Collections.Immutable;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.MoveStaticMembers;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.MoveStaticMembers;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Test.Utilities.MoveStaticMembers;
 using Roslyn.Test.Utilities;
 using Xunit;
-using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeRefactoringVerifier<
-    Microsoft.CodeAnalysis.CSharp.CodeRefactorings.MoveStaticMembers.CSharpMoveStaticMembersRefactoringProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.MoveStaticMembers;
 
+using VerifyCS = CSharpCodeRefactoringVerifier<
+    CSharpMoveStaticMembersRefactoringProvider>;
+
 [UseExportProvider]
 [Trait(Traits.Feature, Traits.Features.CodeActionsMoveStaticMembers)]
 public sealed class CSharpMoveStaticMembersTests