Don't import System when it's already imported by global using

Author: Youssef1313

src/NetAnalyzers/CSharp/Microsoft.NetCore.Analyzers/Runtime/CSharpUseSpanBasedStringConcat.Fixer.cs

@@ -21,17 +21,6 @@ private protected override SyntaxNode ReplaceInvocationMethodName(SyntaxGenerato
             return invocationSyntax.ReplaceNode(oldNameSyntax, newNameSyntax);
         }
 
-        private protected override bool IsSystemNamespaceImported(Project project, IReadOnlyList<SyntaxNode> namespaceImports)
-        {
-            foreach (var import in namespaceImports)
-            {
-                if (import is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.ValueText: nameof(System) } })
-                    return true;
-            }
-
-            return false;
-        }
-
         private protected override IOperation WalkDownBuiltInImplicitConversionOnConcatOperand(IOperation operand)
         {
             return UseSpanBasedStringConcat.CSharpWalkDownBuiltInImplicitConversionOnConcatOperand(operand);

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/UseSpanBasedStringConcat.Fixer.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -23,11 +22,10 @@ public abstract class UseSpanBasedStringConcatFixer : CodeFixProvider
         private protected const string AsSpanName = nameof(MemoryExtensions.AsSpan);
         private protected const string AsSpanStartParameterName = "start";
         private protected const string ToStringName = nameof(ToString);
+        private static readonly SyntaxAnnotation s_asSpanSymbolAnnotation = new("SymbolId", "System.MemoryExtensions");
 
         private protected abstract SyntaxNode ReplaceInvocationMethodName(SyntaxGenerator generator, SyntaxNode invocationSyntax, string newName);
 
-        private protected abstract bool IsSystemNamespaceImported(Project project, IReadOnlyList<SyntaxNode> namespaceImports);
-
         private protected abstract IOperation WalkDownBuiltInImplicitConversionOnConcatOperand(IOperation operand);
 
         private protected abstract bool IsNamedArgument(IArgumentOperation argumentOperation);
@@ -110,13 +108,6 @@ async Task<Document> FixConcatOperationChain(CancellationToken cancellationToken
 
                 SyntaxNode newRoot = generator.ReplaceNode(root, concatExpressionSyntax, concatMethodInvocationSyntax);
 
-                //  Import 'System' namespace if it's absent.
-                if (!IsSystemNamespaceImported(context.Document.Project, generator.GetNamespaceImports(newRoot)))
-                {
-                    SyntaxNode systemNamespaceImport = generator.NamespaceImportDeclaration(nameof(System));
-                    newRoot = generator.AddNamespaceImports(newRoot, systemNamespaceImport);
-                }
-
                 editor.ReplaceNode(root, newRoot);
                 return editor.GetChangedDocument();
             }
@@ -140,7 +131,7 @@ private SyntaxNode ConvertOperandToArgument(in RequiredSymbols symbols, SyntaxGe
                     invocationSyntax = generator.ReplaceNode(invocationSyntax, namedStartIndexArgument.Syntax, renamedArgumentSyntax);
                 }
 
-                var asSpanInvocationSyntax = ReplaceInvocationMethodName(generator, invocationSyntax, AsSpanName);
+                var asSpanInvocationSyntax = ReplaceInvocationMethodName(generator, invocationSyntax, AsSpanName).WithAddImportsAnnotation().WithAdditionalAnnotations(s_asSpanSymbolAnnotation);
                 return generator.Argument(asSpanInvocationSyntax);
             }
             //  Character literals become string literals.

src/NetAnalyzers/UnitTests/Microsoft.NetCore.Analyzers/Runtime/UseSpanBasedStringConcatTests.cs

@@ -761,6 +761,31 @@ public Task WithNonStringNonCharLiteralOperands_NoDiagnostic_VBAsync(string expr
             };
             return test.RunAsync();
         }
+
+        [Fact]
+        public Task TestSystemImportedFromGlobalUsing()
+        {
+            var test = new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources =
+                    {
+                        "global using System;", CSWithBody("var _ = [|foo + bar.Substring(1)|];"),
+                    },
+                },
+                FixedState =
+                {
+                    Sources =
+                    {
+                        "global using System;", CSWithBody("var _ = string.Concat(foo, bar.AsSpan(1));"),
+                    },
+                },
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
+                LanguageVersion = CodeAnalysis.CSharp.LanguageVersion.CSharp10,
+            };
+            return test.RunAsync();
+        }
         #endregion
 
         #region Helpers

src/NetAnalyzers/VisualBasic/Microsoft.NetCore.Analyzers/Runtime/BasicUseSpanBasedStringConcat.Fixer.vb

@@ -22,35 +22,6 @@ Namespace Microsoft.NetCore.VisualBasic.Analyzers.Runtime
             Return invocationSyntax.ReplaceNode(oldNameSyntax, newNameSyntax)
         End Function
 
-        Private Protected Overrides Function IsSystemNamespaceImported(project As Project, namespaceImports As IReadOnlyList(Of SyntaxNode)) As Boolean
-
-            Dim options = DirectCast(project.CompilationOptions, VisualBasicCompilationOptions)
-            If options.GlobalImports.Any(Function(x) String.Compare(x.Name, NameOf(System), StringComparison.OrdinalIgnoreCase) = 0) Then
-                Return True
-            End If
-
-            For Each node As SyntaxNode In namespaceImports
-                Dim importsStatement = TryCast(node, ImportsStatementSyntax)
-                If importsStatement Is Nothing Then
-                    Continue For
-                End If
-
-                For Each importsClause As ImportsClauseSyntax In importsStatement.ImportsClauses
-                    Dim simpleClause = TryCast(importsClause, SimpleImportsClauseSyntax)
-                    Dim identifierName = TryCast(simpleClause?.Name, IdentifierNameSyntax)
-                    If identifierName Is Nothing Then
-                        Continue For
-                    End If
-
-                    If identifierName.Identifier.ValueText = NameOf(System) Then
-                        Return True
-                    End If
-                Next
-            Next
-
-            Return False
-        End Function
-
         Private Protected Overrides Function WalkDownBuiltInImplicitConversionOnConcatOperand(operand As IOperation) As IOperation
 
             Return UseSpanBasedStringConcat.BasicWalkDownBuiltInImplicitConversionOnConcatOperand(operand)