Cleanup the code in FullyQualify

src/Features/CSharp/Portable/FullyQualify/CSharpFullyQualifyCodeFixProvider.cs

@@ -18,7 +18,7 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.FullyQualify
 {
     [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.FullyQualify), Shared]
     [ExtensionOrder(After = PredefinedCodeFixProviderNames.AddImport)]
-    internal class CSharpFullyQualifyCodeFixProvider : AbstractFullyQualifyCodeFixProvider
+    internal class CSharpFullyQualifyCodeFixProvider : AbstractFullyQualifyCodeFixProvider<SimpleNameSyntax>
     {
         /// <summary>
         /// name does not exist in context
@@ -51,45 +51,32 @@ public CSharpFullyQualifyCodeFixProvider()
         {
         }
 
-        public override ImmutableArray<string> FixableDiagnosticIds
-        {
-            get { return ImmutableArray.Create(CS0103, CS0104, CS0246, CS0305, CS0308, IDEDiagnosticIds.UnboundIdentifierId); }
-        }
-
-        protected override bool IgnoreCase => false;
+        public override ImmutableArray<string> FixableDiagnosticIds { get; } =
+            ImmutableArray.Create(CS0103, CS0104, CS0246, CS0305, CS0308, IDEDiagnosticIds.UnboundIdentifierId);
 
-        protected override bool CanFullyQualify(Diagnostic diagnostic, ref SyntaxNode node)
+        protected override bool CanFullyQualify(Diagnostic diagnostic, SyntaxNode node, [NotNullWhen(true)] out SimpleNameSyntax? simpleName)
         {
-            if (node is not SimpleNameSyntax simpleName)
-            {
+            simpleName = node as SimpleNameSyntax;
+            if (simpleName is null)
                 return false;
-            }
 
             if (!simpleName.LooksLikeStandaloneTypeName())
-            {
                 return false;
-            }
 
             if (!simpleName.CanBeReplacedWithAnyName())
-            {
                 return false;
-            }
 
             return true;
         }
 
-        protected override async Task<SyntaxNode> ReplaceNodeAsync(SyntaxNode node, string containerName, bool resultingSymbolIsType, CancellationToken cancellationToken)
+        protected override async Task<SyntaxNode> ReplaceNodeAsync(SimpleNameSyntax simpleName, string containerName, bool resultingSymbolIsType, CancellationToken cancellationToken)
         {
-            var simpleName = (SimpleNameSyntax)node;
-
             var leadingTrivia = simpleName.GetLeadingTrivia();
             var newName = simpleName.WithLeadingTrivia(SyntaxTriviaList.Empty);
 
-            var qualifiedName = SyntaxFactory.QualifiedName(
-                SyntaxFactory.ParseName(containerName), newName);
-
-            qualifiedName = qualifiedName.WithLeadingTrivia(leadingTrivia);
-            qualifiedName = qualifiedName.WithAdditionalAnnotations(Formatter.Annotation);
+            var qualifiedName = SyntaxFactory.QualifiedName(SyntaxFactory.ParseName(containerName), newName)
+                .WithLeadingTrivia(leadingTrivia)
+                .WithAdditionalAnnotations(Formatter.Annotation);
 
             var syntaxTree = simpleName.SyntaxTree;
             var root = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
@@ -99,7 +86,7 @@ protected override async Task<SyntaxNode> ReplaceNodeAsync(SyntaxNode node, stri
             // CS0138 that would result from the former.  Don't do this for using aliases though as `static` and using
             // aliases cannot be combined.
             if (resultingSymbolIsType &&
-                node.Parent is UsingDirectiveSyntax { Alias: null, StaticKeyword.RawKind: 0 } usingDirective)
+                simpleName.Parent is UsingDirectiveSyntax { Alias: null, StaticKeyword.RawKind: 0 } usingDirective)
             {
                 var newUsingDirective = usingDirective
                     .WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword))

src/Features/Core/Portable/AddImport/SearchScopes/SourceSymbolsProjectSearchScope.cs

@@ -52,16 +52,16 @@ protected override async Task<ImmutableArray<ISymbol>> FindDeclarationsAsync(
                     searchQuery, lazyAssembly, filter, CancellationToken).ConfigureAwait(false);
 
                 return declarations;
-            }
 
-            private static AsyncLazy<IAssemblySymbol> CreateLazyAssembly(Project project)
-            {
-                return new AsyncLazy<IAssemblySymbol>(
-                    async c =>
-                    {
-                        var compilation = await project.GetRequiredCompilationAsync(c).ConfigureAwait(false);
-                        return compilation.Assembly;
-                    }, cacheResult: true);
+                static AsyncLazy<IAssemblySymbol> CreateLazyAssembly(Project project)
+                {
+                    return new AsyncLazy<IAssemblySymbol>(
+                        async c =>
+                        {
+                            var compilation = await project.GetRequiredCompilationAsync(c).ConfigureAwait(false);
+                            return compilation.Assembly;
+                        }, cacheResult: true);
+                }
             }
         }
     }

src/Features/Core/Portable/FullyQualify/AbstractFullyQualifyCodeFixProvider.SymbolResult.cs

@@ -9,7 +9,7 @@
 
 namespace Microsoft.CodeAnalysis.CodeFixes.FullyQualify
 {
-    internal abstract partial class AbstractFullyQualifyCodeFixProvider : CodeFixProvider
+    internal abstract partial class AbstractFullyQualifyCodeFixProvider<TSimpleNameSyntax>
     {
         private readonly struct SymbolResult : IEquatable<SymbolResult>, IComparable<SymbolResult>
         {