From 9586c29ac315768f3df80ba6c1a30a7cb1434a8c Mon Sep 17 00:00:00 2001
From: DoctorKrolic <mapmyp03@gmail.com>
Date: Sat, 26 Nov 2022 20:05:25 +0300
Subject: [PATCH 1/4] Move CSharpUseDefaultLiteralCodeFixProvider to VerifyCS

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs |   7 +-
 .../UseDefaultLiteralTests.cs                 | 407 ++++++++++++------
 2 files changed, 288 insertions(+), 126 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 55fad8454a415..680458225072b 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -7,19 +7,16 @@
 using System;
 using System.Collections.Immutable;
 using System.Composition;
-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.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Extensions;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral
 {
@@ -27,7 +24,7 @@ namespace Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral
     internal partial class CSharpUseDefaultLiteralCodeFixProvider : SyntaxEditorBasedCodeFixProvider
     {
         [ImportingConstructor]
-        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public CSharpUseDefaultLiteralCodeFixProvider()
         {
         }
diff --git a/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs b/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs
index 65a36a369e344..71be270b11437 100644
--- a/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs
@@ -2,84 +2,83 @@
 // 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.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.UseDefaultLiteral;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseDefaultLiteral
 {
+    using VerifyCS = CSharpCodeFixVerifier<
+        CSharpUseDefaultLiteralDiagnosticAnalyzer,
+        CSharpUseDefaultLiteralCodeFixProvider>;
+
     [Trait(Traits.Feature, Traits.Features.CodeActionsUseDefaultLiteral)]
-    public class UseDefaultLiteralTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
+    public class UseDefaultLiteralTests
     {
-        public UseDefaultLiteralTests(ITestOutputHelper logger)
-          : base(logger)
-        {
-        }
-
-        internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
-            => (new CSharpUseDefaultLiteralDiagnosticAnalyzer(), new CSharpUseDefaultLiteralCodeFixProvider());
-
-        private static readonly CSharpParseOptions s_parseOptions =
-            CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_1);
-
-        private static readonly TestParameters s_testParameters =
-            new TestParameters(parseOptions: s_parseOptions);
-
         [Fact]
         public async Task TestNotInCSharp7()
         {
-            await TestMissingAsync(
+            var code =
 @"
 class C
 {
-    void Goo(string s = [||]default(string))
+    void Goo(string s = default(string))
     {
     }
-}", parameters: new TestParameters(
-    parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7)));
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInParameterList()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
-    void Goo(string s = [||]default(string))
+    void Goo(string s = [|default(string)|])
     {
     }
 }",
+                FixedCode =
 @"
 class C
 {
     void Goo(string s = default)
     {
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInIfCheck()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo(string s)
     {
-        if (s == [||]default(string)) { }
+        if (s == [|default(string)|]) { }
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -87,21 +86,26 @@ void Goo(string s)
     {
         if (s == default) { }
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInReturnStatement()
         {
-            await TestAsync(
-@"
+            await new VerifyCS.Test
+            {
+                TestCode =
+ @"
 class C
 {
     string Goo()
     {
-        return [||]default(string);
+        return [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -109,27 +113,38 @@ string Goo()
     {
         return default;
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInReturnStatement2()
         {
-            await TestMissingAsync(
+            var code =
 @"
 class C
 {
     string Goo()
     {
-        return [||]default(int);
+        return {|CS0029:default(int)|};
     }
-}", parameters: s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInLambda1()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 using System;
 
@@ -137,9 +152,10 @@ class C
 {
     void Goo()
     {
-        Func<string> f = () => [||]default(string);
+        Func<string> f = () => [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 using System;
 
@@ -147,15 +163,17 @@ class C
 {
     void Goo()
     {
-        Func<string> f = () => [||]default;
+        Func<string> f = () => default;
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInLambda2()
         {
-            await TestMissingAsync(
+            var code =
 @"
 using System;
 
@@ -163,23 +181,33 @@ class C
 {
     void Goo()
     {
-        Func<string> f = () => [||]default(int);
+        Func<string> f = () => {|CS1662:{|CS0029:default(int)|}|};
     }
-}", parameters: s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInLocalInitializer()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo()
     {
-        string s = [||]default(string);
+        string s = [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -187,51 +215,70 @@ void Goo()
     {
         string s = default;
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInLocalInitializer2()
         {
-            await TestMissingAsync(
+            var code =
 @"
 class C
 {
     void Goo()
     {
-        string s = [||]default(int);
+        string s = {|CS0029:default(int)|};
     }
-}", parameters: s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotForVar()
         {
-            await TestMissingAsync(
+            var code =
 @"
 class C
 {
     void Goo()
     {
-        var s = [||]default(string);
+        var s = default(string);
     }
-}", parameters: s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInInvocationExpression()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo()
     {
-        Bar([||]default(string));
+        Bar([|default(string)|]);
     }
 
     void Bar(string s) { }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -241,38 +288,50 @@ void Goo()
     }
 
     void Bar(string s) { }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotWithMultipleOverloads()
         {
-            await TestMissingAsync(
+            var code =
 @"
 class C
 {
     void Goo()
     {
-        Bar([||]default(string));
+        Bar(default(string));
     }
 
     void Bar(string s) { }
-    void Bar(int i);
-}", parameters: s_testParameters);
+    void Bar(int i) { }
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestLeftSideOfTernary()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo(bool b)
     {
-        var v = b ? [||]default(string) : default(string);
+        var v = b ? [|default(string)|] : [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -280,21 +339,28 @@ void Goo(bool b)
     {
         var v = b ? default : default(string);
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1,
+                DiagnosticSelector = d => d[0],
+                CodeFixTestBehaviors = Testing.CodeFixTestBehaviors.FixOne | Testing.CodeFixTestBehaviors.SkipFixAllCheck
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestRightSideOfTernary()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo(bool b)
     {
-        var v = b ? default(string) : [||]default(string);
+        var v = b ? [|default(string)|] : [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -302,22 +368,29 @@ void Goo(bool b)
     {
         var v = b ? default(string) : default;
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1,
+                DiagnosticSelector = d => d[1],
+                CodeFixTestBehaviors = Testing.CodeFixTestBehaviors.FixOne | Testing.CodeFixTestBehaviors.SkipFixAllCheck
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestFixAll1()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo()
     {
-        string s1 = {|FixAllInDocument:default|}(string);
-        string s2 = default(string);
+        string s1 = [|default(string)|];
+        string s2 = [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -326,21 +399,26 @@ void Goo()
         string s1 = default;
         string s2 = default;
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestFixAll2()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo(bool b)
     {
-        string s1 = b ? {|FixAllInDocument:default|}(string) : default(string);
+        string s1 = b ? [|default(string)|] : [|default(string)|];
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -348,89 +426,112 @@ void Goo(bool b)
     {
         string s1 = b ? default : default(string);
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestFixAll3()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void Goo()
     {
-        string s1 = {|FixAllInDocument:default|}(string);
-        string s2 = default(int);
+        string s1 = [|default(string)|];
+        string s2 = {|CS0029:default(int)|};
     }
 }",
+                FixedCode =
 @"
 class C
 {
     void Goo()
     {
         string s1 = default;
-        string s2 = default(int);
+        string s2 = {|CS0029:default(int)|};
     }
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestDoNotOfferIfTypeWouldChange()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 struct S
 {
     void M()
     {
         var s = new S();
-        s.Equals([||]default(S));
+        s.Equals(default(S));
     }
 
     public override bool Equals(object obj)
     {
         return base.Equals(obj);
     }
-}", new TestParameters(parseOptions: s_parseOptions));
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestDoNotOfferIfTypeWouldChange2()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 struct S<T>
 {
     void M()
     {
         var s = new S<int>();
-        s.Equals([||]default(S<int>));
+        s.Equals(default(S<int>));
     }
 
     public override bool Equals(object obj)
     {
         return base.Equals(obj);
     }
-}", new TestParameters(parseOptions: s_parseOptions));
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestOnShadowedMethod()
         {
-            await TestAsync(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 struct S
 {
     void M()
     {
         var s = new S();
-        s.Equals([||]default(S));
+        s.Equals([|default(S)|]);
     }
 
     public new bool Equals(S s) => true;
 }",
-
+                FixedCode =
 @"
 struct S
 {
@@ -441,13 +542,15 @@ void M()
     }
 
     public new bool Equals(S s) => true;
-}", parseOptions: s_parseOptions);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact, WorkItem(25456, "https://github.com/dotnet/roslyn/issues/25456")]
         public async Task TestNotInSwitchCase()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 class C
 {
@@ -455,16 +558,23 @@ void M()
     {
         switch (true)
         {
-            case [||]default(bool):
+            case default(bool):
         }
     }
-}", s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotInSwitchCase_InsideParentheses()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 class C
 {
@@ -472,16 +582,25 @@ void M()
     {
         switch (true)
         {
-            case ([||]default(bool)):
+            case (default(bool)):
         }
     }
-}", s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInSwitchCase_InsideCast()
         {
-            await TestInRegularAndScript1Async(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
@@ -489,10 +608,11 @@ void M()
     {
         switch (true)
         {
-            case (bool)[||]default(bool):
+            case (bool)[|default(bool)|]:
         }
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -500,16 +620,18 @@ void M()
     {
         switch (true)
         {
-            case (bool)[||]default:
+            case (bool)default:
         }
     }
-}", parameters: s_testParameters);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotInPatternSwitchCase()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 class C
 {
@@ -517,16 +639,23 @@ void M()
     {
         switch (true)
         {
-            case [||]default(bool) when true:
+            case default(bool) when true:
         }
     }
-}", s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotInPatternSwitchCase_InsideParentheses()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 class C
 {
@@ -534,16 +663,25 @@ void M()
     {
         switch (true)
         {
-            case ([||]default(bool)) when true:
+            case (default(bool)) when true:
         }
     }
-}", s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInPatternSwitchCase_InsideCast()
         {
-            await TestInRegularAndScript1Async(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
@@ -551,10 +689,11 @@ void M()
     {
         switch (true)
         {
-            case (bool)[||]default(bool) when true:
+            case (bool)[|default(bool)|] when true:
         }
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -562,16 +701,20 @@ void M()
     {
         switch (true)
         {
-            case (bool)[||]default when true:
+            case (bool)default when true:
         }
     }
-}", parameters: s_testParameters);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInPatternSwitchCase_InsideWhenClause()
         {
-            await TestInRegularAndScript1Async(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
@@ -579,10 +722,11 @@ void M()
     {
         switch (true)
         {
-            case default(bool) when [||]default(bool):
+            case default(bool) when [|default(bool)|]:
         }
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -593,49 +737,68 @@ void M()
             case default(bool) when default:
         }
     }
-}", parameters: s_testParameters);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotInPatternIs()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 class C
 {
     void M()
     {
-        if (true is [||]default(bool));
+        if (true is default(bool));
     }
-}", s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestNotInPatternIs_InsideParentheses()
         {
-            await TestMissingInRegularAndScriptAsync(
+            var code =
 @"
 class C
 {
     void M()
     {
-        if (true is ([||]default(bool)));
+        if (true is (default(bool)));
     }
-}", s_testParameters);
+}";
+
+            await new VerifyCS.Test()
+            {
+                TestCode = code,
+                FixedCode = code,
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
 
         [Fact]
         public async Task TestInPatternIs_InsideCast()
         {
-            await TestInRegularAndScript1Async(
+            await new VerifyCS.Test
+            {
+                TestCode =
 @"
 class C
 {
     void M()
     {
-        if (true is (bool)[||]default(bool));
+        if (true is (bool)[|default(bool)|]);
     }
 }",
+                FixedCode =
 @"
 class C
 {
@@ -643,7 +806,9 @@ void M()
     {
         if (true is (bool)default);
     }
-}", parameters: s_testParameters);
+}",
+                LanguageVersion = LanguageVersion.CSharp7_1
+            }.RunAsync();
         }
     }
 }

From 5442bae4b02c5b0d93d8c544be93fa9277b0734d Mon Sep 17 00:00:00 2001
From: DoctorKrolic <mapmyp03@gmail.com>
Date: Sat, 26 Nov 2022 20:07:54 +0300
Subject: [PATCH 2/4] Enable nullable in codefix

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs                 | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 680458225072b..1fd2ca8c3f63a 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.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;
 using System.Collections.Immutable;
 using System.Composition;
@@ -50,7 +48,7 @@ protected override async Task FixAllAsync(
             // Here, we can replace either of the default expressions, but not both. So we have 
             // to replace one at a time, and only actually replace if it's still safe to do so.
 
-            var parseOptions = (CSharpParseOptions)document.Project.ParseOptions;
+            var parseOptions = (CSharpParseOptions)document.Project.ParseOptions!;
 
             var options = (CSharpAnalyzerOptionsProvider)await document.GetAnalyzerOptionsProviderAsync(cancellationToken).ConfigureAwait(false);
             var preferSimpleDefaultExpression = options.PreferSimpleDefaultExpression.Value;

From b5c58a401f365c0d0da48f93f1e6b91d5dbab70d Mon Sep 17 00:00:00 2001
From: DoctorKrolic <mapmyp03@gmail.com>
Date: Sat, 26 Nov 2022 20:17:40 +0300
Subject: [PATCH 3/4] Use raw strings

---
 .../UseDefaultLiteralTests.cs                 | 948 +++++++++---------
 1 file changed, 474 insertions(+), 474 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs b/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs
index 71be270b11437..b3439fc0fc238 100644
--- a/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseDefaultLiteral/UseDefaultLiteralTests.cs
@@ -22,14 +22,14 @@ public class UseDefaultLiteralTests
         [Fact]
         public async Task TestNotInCSharp7()
         {
-            var code =
-@"
-class C
-{
-    void Goo(string s = default(string))
-    {
-    }
-}";
+            var code = """
+                class C
+                {
+                    void Goo(string s = default(string))
+                    {
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -44,22 +44,22 @@ public async Task TestInParameterList()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo(string s = [|default(string)|])
-    {
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo(string s = default)
-    {
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo(string s = [|default(string)|])
+                        {
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo(string s = default)
+                        {
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -69,24 +69,24 @@ public async Task TestInIfCheck()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo(string s)
-    {
-        if (s == [|default(string)|]) { }
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo(string s)
-    {
-        if (s == default) { }
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo(string s)
+                        {
+                            if (s == [|default(string)|]) { }
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo(string s)
+                        {
+                            if (s == default) { }
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -96,24 +96,24 @@ public async Task TestInReturnStatement()
         {
             await new VerifyCS.Test
             {
-                TestCode =
- @"
-class C
-{
-    string Goo()
-    {
-        return [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    string Goo()
-    {
-        return default;
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        string Goo()
+                        {
+                            return [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        string Goo()
+                        {
+                            return default;
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -121,15 +121,15 @@ string Goo()
         [Fact]
         public async Task TestInReturnStatement2()
         {
-            var code =
-@"
-class C
-{
-    string Goo()
-    {
-        return {|CS0029:default(int)|};
-    }
-}";
+            var code = """
+                class C
+                {
+                    string Goo()
+                    {
+                        return {|CS0029:default(int)|};
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -144,28 +144,28 @@ public async Task TestInLambda1()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-using System;
-
-class C
-{
-    void Goo()
-    {
-        Func<string> f = () => [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-using System;
-
-class C
-{
-    void Goo()
-    {
-        Func<string> f = () => default;
-    }
-}",
+                TestCode = """
+                    using System;
+
+                    class C
+                    {
+                        void Goo()
+                        {
+                            Func<string> f = () => [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    using System;
+
+                    class C
+                    {
+                        void Goo()
+                        {
+                            Func<string> f = () => default;
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -173,17 +173,17 @@ void Goo()
         [Fact]
         public async Task TestInLambda2()
         {
-            var code =
-@"
-using System;
+            var code = """
+                using System;
 
-class C
-{
-    void Goo()
-    {
-        Func<string> f = () => {|CS1662:{|CS0029:default(int)|}|};
-    }
-}";
+                class C
+                {
+                    void Goo()
+                    {
+                        Func<string> f = () => {|CS1662:{|CS0029:default(int)|}|};
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -198,24 +198,24 @@ public async Task TestInLocalInitializer()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo()
-    {
-        string s = [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo()
-    {
-        string s = default;
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            string s = [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            string s = default;
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -223,15 +223,15 @@ void Goo()
         [Fact]
         public async Task TestInLocalInitializer2()
         {
-            var code =
-@"
-class C
-{
-    void Goo()
-    {
-        string s = {|CS0029:default(int)|};
-    }
-}";
+            var code = """
+                class C
+                {
+                    void Goo()
+                    {
+                        string s = {|CS0029:default(int)|};
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -244,15 +244,15 @@ void Goo()
         [Fact]
         public async Task TestNotForVar()
         {
-            var code =
-@"
-class C
-{
-    void Goo()
-    {
-        var s = default(string);
-    }
-}";
+            var code = """
+                class C
+                {
+                    void Goo()
+                    {
+                        var s = default(string);
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -267,28 +267,28 @@ public async Task TestInInvocationExpression()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo()
-    {
-        Bar([|default(string)|]);
-    }
-
-    void Bar(string s) { }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo()
-    {
-        Bar(default);
-    }
-
-    void Bar(string s) { }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            Bar([|default(string)|]);
+                        }
+
+                        void Bar(string s) { }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            Bar(default);
+                        }
+
+                        void Bar(string s) { }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -296,18 +296,18 @@ void Bar(string s) { }
         [Fact]
         public async Task TestNotWithMultipleOverloads()
         {
-            var code =
-@"
-class C
-{
-    void Goo()
-    {
-        Bar(default(string));
-    }
+            var code = """
+                class C
+                {
+                    void Goo()
+                    {
+                        Bar(default(string));
+                    }
 
-    void Bar(string s) { }
-    void Bar(int i) { }
-}";
+                    void Bar(string s) { }
+                    void Bar(int i) { }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -322,24 +322,24 @@ public async Task TestLeftSideOfTernary()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo(bool b)
-    {
-        var v = b ? [|default(string)|] : [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo(bool b)
-    {
-        var v = b ? default : default(string);
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo(bool b)
+                        {
+                            var v = b ? [|default(string)|] : [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo(bool b)
+                        {
+                            var v = b ? default : default(string);
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1,
                 DiagnosticSelector = d => d[0],
                 CodeFixTestBehaviors = Testing.CodeFixTestBehaviors.FixOne | Testing.CodeFixTestBehaviors.SkipFixAllCheck
@@ -351,24 +351,24 @@ public async Task TestRightSideOfTernary()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo(bool b)
-    {
-        var v = b ? [|default(string)|] : [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo(bool b)
-    {
-        var v = b ? default(string) : default;
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo(bool b)
+                        {
+                            var v = b ? [|default(string)|] : [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo(bool b)
+                        {
+                            var v = b ? default(string) : default;
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1,
                 DiagnosticSelector = d => d[1],
                 CodeFixTestBehaviors = Testing.CodeFixTestBehaviors.FixOne | Testing.CodeFixTestBehaviors.SkipFixAllCheck
@@ -380,26 +380,26 @@ public async Task TestFixAll1()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo()
-    {
-        string s1 = [|default(string)|];
-        string s2 = [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo()
-    {
-        string s1 = default;
-        string s2 = default;
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            string s1 = [|default(string)|];
+                            string s2 = [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            string s1 = default;
+                            string s2 = default;
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -409,24 +409,24 @@ public async Task TestFixAll2()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo(bool b)
-    {
-        string s1 = b ? [|default(string)|] : [|default(string)|];
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo(bool b)
-    {
-        string s1 = b ? default : default(string);
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo(bool b)
+                        {
+                            string s1 = b ? [|default(string)|] : [|default(string)|];
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo(bool b)
+                        {
+                            string s1 = b ? default : default(string);
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -436,26 +436,26 @@ public async Task TestFixAll3()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void Goo()
-    {
-        string s1 = [|default(string)|];
-        string s2 = {|CS0029:default(int)|};
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void Goo()
-    {
-        string s1 = default;
-        string s2 = {|CS0029:default(int)|};
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            string s1 = [|default(string)|];
+                            string s2 = {|CS0029:default(int)|};
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void Goo()
+                        {
+                            string s1 = default;
+                            string s2 = {|CS0029:default(int)|};
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -463,21 +463,21 @@ void Goo()
         [Fact]
         public async Task TestDoNotOfferIfTypeWouldChange()
         {
-            var code =
-@"
-struct S
-{
-    void M()
-    {
-        var s = new S();
-        s.Equals(default(S));
-    }
-
-    public override bool Equals(object obj)
-    {
-        return base.Equals(obj);
-    }
-}";
+            var code = """
+                struct S
+                {
+                    void M()
+                    {
+                        var s = new S();
+                        s.Equals(default(S));
+                    }
+
+                    public override bool Equals(object obj)
+                    {
+                        return base.Equals(obj);
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -490,21 +490,21 @@ public override bool Equals(object obj)
         [Fact]
         public async Task TestDoNotOfferIfTypeWouldChange2()
         {
-            var code =
-@"
-struct S<T>
-{
-    void M()
-    {
-        var s = new S<int>();
-        s.Equals(default(S<int>));
-    }
-
-    public override bool Equals(object obj)
-    {
-        return base.Equals(obj);
-    }
-}";
+            var code = """
+                struct S<T>
+                {
+                    void M()
+                    {
+                        var s = new S<int>();
+                        s.Equals(default(S<int>));
+                    }
+
+                    public override bool Equals(object obj)
+                    {
+                        return base.Equals(obj);
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -519,30 +519,30 @@ public async Task TestOnShadowedMethod()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-struct S
-{
-    void M()
-    {
-        var s = new S();
-        s.Equals([|default(S)|]);
-    }
-
-    public new bool Equals(S s) => true;
-}",
-                FixedCode =
-@"
-struct S
-{
-    void M()
-    {
-        var s = new S();
-        s.Equals(default);
-    }
-
-    public new bool Equals(S s) => true;
-}",
+                TestCode = """
+                    struct S
+                    {
+                        void M()
+                        {
+                            var s = new S();
+                            s.Equals([|default(S)|]);
+                        }
+
+                        public new bool Equals(S s) => true;
+                    }
+                    """,
+                FixedCode = """
+                    struct S
+                    {
+                        void M()
+                        {
+                            var s = new S();
+                            s.Equals(default);
+                        }
+
+                        public new bool Equals(S s) => true;
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -550,18 +550,18 @@ void M()
         [Fact, WorkItem(25456, "https://github.com/dotnet/roslyn/issues/25456")]
         public async Task TestNotInSwitchCase()
         {
-            var code =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case default(bool):
-        }
-    }
-}";
+            var code = """
+                class C
+                {
+                    void M()
+                    {
+                        switch (true)
+                        {
+                            case default(bool):
+                        }
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -574,18 +574,18 @@ void M()
         [Fact]
         public async Task TestNotInSwitchCase_InsideParentheses()
         {
-            var code =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case (default(bool)):
-        }
-    }
-}";
+            var code = """
+                class C
+                {
+                    void M()
+                    {
+                        switch (true)
+                        {
+                            case (default(bool)):
+                        }
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -600,30 +600,30 @@ public async Task TestInSwitchCase_InsideCast()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case (bool)[|default(bool)|]:
-        }
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case (bool)default:
-        }
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            switch (true)
+                            {
+                                case (bool)[|default(bool)|]:
+                            }
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            switch (true)
+                            {
+                                case (bool)default:
+                            }
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -631,18 +631,18 @@ void M()
         [Fact]
         public async Task TestNotInPatternSwitchCase()
         {
-            var code =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case default(bool) when true:
-        }
-    }
-}";
+            var code = """
+                class C
+                {
+                    void M()
+                    {
+                        switch (true)
+                        {
+                            case default(bool) when true:
+                        }
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -655,18 +655,18 @@ void M()
         [Fact]
         public async Task TestNotInPatternSwitchCase_InsideParentheses()
         {
-            var code =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case (default(bool)) when true:
-        }
-    }
-}";
+            var code = """
+                class C
+                {
+                    void M()
+                    {
+                        switch (true)
+                        {
+                            case (default(bool)) when true:
+                        }
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -681,30 +681,30 @@ public async Task TestInPatternSwitchCase_InsideCast()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case (bool)[|default(bool)|] when true:
-        }
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case (bool)default when true:
-        }
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            switch (true)
+                            {
+                                case (bool)[|default(bool)|] when true:
+                            }
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            switch (true)
+                            {
+                                case (bool)default when true:
+                            }
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -714,30 +714,30 @@ public async Task TestInPatternSwitchCase_InsideWhenClause()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case default(bool) when [|default(bool)|]:
-        }
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void M()
-    {
-        switch (true)
-        {
-            case default(bool) when default:
-        }
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            switch (true)
+                            {
+                                case default(bool) when [|default(bool)|]:
+                            }
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            switch (true)
+                            {
+                                case default(bool) when default:
+                            }
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }
@@ -745,15 +745,15 @@ void M()
         [Fact]
         public async Task TestNotInPatternIs()
         {
-            var code =
-@"
-class C
-{
-    void M()
-    {
-        if (true is default(bool));
-    }
-}";
+            var code = """
+                class C
+                {
+                    void M()
+                    {
+                        if (true is default(bool));
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -766,15 +766,15 @@ void M()
         [Fact]
         public async Task TestNotInPatternIs_InsideParentheses()
         {
-            var code =
-@"
-class C
-{
-    void M()
-    {
-        if (true is (default(bool)));
-    }
-}";
+            var code = """
+                class C
+                {
+                    void M()
+                    {
+                        if (true is (default(bool)));
+                    }
+                }
+                """;
 
             await new VerifyCS.Test()
             {
@@ -789,24 +789,24 @@ public async Task TestInPatternIs_InsideCast()
         {
             await new VerifyCS.Test
             {
-                TestCode =
-@"
-class C
-{
-    void M()
-    {
-        if (true is (bool)[|default(bool)|]);
-    }
-}",
-                FixedCode =
-@"
-class C
-{
-    void M()
-    {
-        if (true is (bool)default);
-    }
-}",
+                TestCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (true is (bool)[|default(bool)|]);
+                        }
+                    }
+                    """,
+                FixedCode = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (true is (bool)default);
+                        }
+                    }
+                    """,
                 LanguageVersion = LanguageVersion.CSharp7_1
             }.RunAsync();
         }

From 2d9aeeffe477f1a2bccadd96cacbfe6d230c96d4 Mon Sep 17 00:00:00 2001
From: DoctorKrolic <mapmyp03@gmail.com>
Date: Sat, 26 Nov 2022 20:33:01 +0300
Subject: [PATCH 4/4] Avoid null suppression

---
 .../CSharpUseDefaultLiteralCodeFixProvider.cs                  | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
index 1fd2ca8c3f63a..cb7cf429285e2 100644
--- a/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
+++ b/src/Analyzers/CSharp/CodeFixes/UseDefaultLiteral/CSharpUseDefaultLiteralCodeFixProvider.cs
@@ -48,12 +48,11 @@ protected override async Task FixAllAsync(
             // Here, we can replace either of the default expressions, but not both. So we have 
             // to replace one at a time, and only actually replace if it's still safe to do so.
 
-            var parseOptions = (CSharpParseOptions)document.Project.ParseOptions!;
-
             var options = (CSharpAnalyzerOptionsProvider)await document.GetAnalyzerOptionsProviderAsync(cancellationToken).ConfigureAwait(false);
             var preferSimpleDefaultExpression = options.PreferSimpleDefaultExpression.Value;
 
             var originalRoot = editor.OriginalRoot;
+            var parseOptions = (CSharpParseOptions)originalRoot.SyntaxTree.Options;
 
             var originalNodes = diagnostics.SelectAsArray(
                 d => (DefaultExpressionSyntax)originalRoot.FindNode(d.Location.SourceSpan, getInnermostNodeForTie: true));