Fix global using detection

The previous implementation could incorrectly report a non-global using
directive as a global using directive because it didn't check for the
global keyword.

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers/Helpers/UsingAliasCache.cs

@@ -64,18 +64,28 @@ private static bool ContainsLocalUsingAliasNoCache(SyntaxTree tree)
         {
             // Check for "local" using aliases
             var nodes = tree.GetRoot().DescendantNodes(node => node.IsKind(SyntaxKind.CompilationUnit) || node.IsKind(SyntaxKind.NamespaceDeclaration) || node.IsKind(SyntaxKindEx.FileScopedNamespaceDeclaration));
-            return nodes.OfType<UsingDirectiveSyntax>().Any(x => x.Alias != null);
+            return nodes.OfType<UsingDirectiveSyntax>().Any(x => x.GlobalKeyword().IsKind(SyntaxKind.None) && x.Alias != null);
+        }
+
+        private static bool ContainsGlobalUsingAliasInCurrentFileNoCache(SyntaxTree tree)
+        {
+            // Check for "global" using aliases in one specific syntax tree
+            var nodes = ((CompilationUnitSyntax)tree.GetRoot()).Usings;
+            return nodes.Any(x => x.GlobalKeyword().IsKind(SyntaxKindEx.GlobalKeyword) && x.Alias != null);
         }
 
         private bool ContainsGlobalUsingAlias(SemanticModel semanticModel, CancellationToken cancellationToken)
         {
             if (this.perCompilationCache == -1)
             {
-                // Check for global using aliases. We check at the end of the file since GetImportScopes is observed to
-                // omit global using directives in the current file at position 0 for the specific case where there is
-                // no whitespace preceding the global using directives.
-                var scopes = semanticModel.GetImportScopes(semanticModel.SyntaxTree.Length, cancellationToken);
-                Interlocked.CompareExchange(ref this.perCompilationCache, scopes.Any(x => x.Aliases.Length > 0) ? 1 : 0, -1);
+                // Check for global using aliases. We check at the beginning of the file to ensure using directives in
+                // the current file are not picked up as a scope. Since global using directives in the current file may
+                // not be reported by this call, we include a second check specifically for global usings defined in the
+                // current file.
+                var scopes = semanticModel.GetImportScopes(0, cancellationToken);
+                bool hasGlobalUsingAlias = scopes.Any(x => x.Aliases.Length > 0)
+                    || ContainsGlobalUsingAliasInCurrentFileNoCache(semanticModel.SyntaxTree);
+                Interlocked.CompareExchange(ref this.perCompilationCache, hasGlobalUsingAlias ? 1 : 0, -1);
             }
 
             return this.perCompilationCache == 1;

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxKindEx.cs

@@ -9,6 +9,7 @@ internal static class SyntaxKindEx
     {
         public const SyntaxKind DotDotToken = (SyntaxKind)8222;
         public const SyntaxKind QuestionQuestionEqualsToken = (SyntaxKind)8284;
+        public const SyntaxKind GlobalKeyword = (SyntaxKind)8408;
         public const SyntaxKind OrKeyword = (SyntaxKind)8438;
         public const SyntaxKind AndKeyword = (SyntaxKind)8439;
         public const SyntaxKind NotKeyword = (SyntaxKind)8440;

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/UsingDirectiveSyntaxExtensions.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    internal static class UsingDirectiveSyntaxExtensions
+    {
+        private static readonly Func<UsingDirectiveSyntax, SyntaxToken> GlobalKeywordAccessor;
+        private static readonly Func<UsingDirectiveSyntax, SyntaxToken> UnsafeKeywordAccessor;
+        private static readonly Func<UsingDirectiveSyntax, TypeSyntax> NamespaceOrTypeAccessor;
+        private static readonly Func<UsingDirectiveSyntax, SyntaxToken, UsingDirectiveSyntax> WithGlobalKeywordAccessor;
+        private static readonly Func<UsingDirectiveSyntax, SyntaxToken, UsingDirectiveSyntax> WithUnsafeKeywordAccessor;
+        private static readonly Func<UsingDirectiveSyntax, TypeSyntax, UsingDirectiveSyntax> WithNamespaceOrTypeAccessor;
+
+        static UsingDirectiveSyntaxExtensions()
+        {
+            GlobalKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<UsingDirectiveSyntax, SyntaxToken>(typeof(UsingDirectiveSyntax), nameof(GlobalKeyword));
+            UnsafeKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<UsingDirectiveSyntax, SyntaxToken>(typeof(UsingDirectiveSyntax), nameof(UnsafeKeyword));
+            NamespaceOrTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<UsingDirectiveSyntax, TypeSyntax>(typeof(UsingDirectiveSyntax), nameof(NamespaceOrType));
+            WithGlobalKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor<UsingDirectiveSyntax, SyntaxToken>(typeof(UsingDirectiveSyntax), nameof(GlobalKeyword));
+            WithUnsafeKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor<UsingDirectiveSyntax, SyntaxToken>(typeof(UsingDirectiveSyntax), nameof(UnsafeKeyword));
+            WithNamespaceOrTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor<UsingDirectiveSyntax, TypeSyntax>(typeof(UsingDirectiveSyntax), nameof(NamespaceOrType));
+        }
+
+        public static SyntaxToken GlobalKeyword(this UsingDirectiveSyntax syntax)
+        {
+            return GlobalKeywordAccessor(syntax);
+        }
+
+        public static SyntaxToken UnsafeKeyword(this UsingDirectiveSyntax syntax)
+        {
+            return UnsafeKeywordAccessor(syntax);
+        }
+
+        public static TypeSyntax NamespaceOrType(this UsingDirectiveSyntax syntax)
+        {
+            return NamespaceOrTypeAccessor(syntax);
+        }
+
+        public static UsingDirectiveSyntax WithGlobalKeyword(this UsingDirectiveSyntax syntax, SyntaxToken globalKeyword)
+        {
+            return WithGlobalKeywordAccessor(syntax, globalKeyword);
+        }
+
+        public static UsingDirectiveSyntax WithUnsafeKeyword(this UsingDirectiveSyntax syntax, SyntaxToken unsafeKeyword)
+        {
+            return WithUnsafeKeywordAccessor(syntax, unsafeKeyword);
+        }
+
+        public static UsingDirectiveSyntax WithNamespaceOrType(this UsingDirectiveSyntax syntax, TypeSyntax namespaceOrType)
+        {
+            return WithNamespaceOrTypeAccessor(syntax, namespaceOrType);
+        }
+    }
+}