Fix handling of tuple types in using alias directives

Fixes #2690

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1135UnitTests.cs

@@ -228,6 +228,19 @@ public async Task TestFullyQualifiedAliasWithUnresolvedTypeParameterAsync()
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        [WorkItem(2690, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2690")]
+        public async Task TestFullyQualifiedAliasInsideNamespaceAsync()
+        {
+            var testCode = @"
+namespace Test {
+    using Example = System.ValueTuple<System.Collections.IList, int>;
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         protected override CodeFixProvider GetCSharpCodeFixProvider()
         {
             return new SA1135CodeFixProvider();

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CSharp7.md

@@ -65,12 +65,12 @@
 * [ ] `Microsoft.CodeAnalysis.IMethodSymbol.ReturnsByRef.get -> bool`
 * [ ] `Microsoft.CodeAnalysis.INamedTypeSymbol.GetTypeArgumentCustomModifiers(int ordinal) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.CustomModifier>`
 * [ ] `Microsoft.CodeAnalysis.INamedTypeSymbol.IsComImport.get -> bool`
-* [ ] `Microsoft.CodeAnalysis.INamedTypeSymbol.TupleElements.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IFieldSymbol>`
-* [ ] `Microsoft.CodeAnalysis.INamedTypeSymbol.TupleUnderlyingType.get -> Microsoft.CodeAnalysis.INamedTypeSymbol`
+* [x] `Microsoft.CodeAnalysis.INamedTypeSymbol.TupleElements.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IFieldSymbol>`
+* [x] `Microsoft.CodeAnalysis.INamedTypeSymbol.TupleUnderlyingType.get -> Microsoft.CodeAnalysis.INamedTypeSymbol`
 * [ ] `Microsoft.CodeAnalysis.IParameterSymbol.RefCustomModifiers.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.CustomModifier>`
 * [ ] `Microsoft.CodeAnalysis.IPropertySymbol.RefCustomModifiers.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.CustomModifier>`
 * [ ] `Microsoft.CodeAnalysis.IPropertySymbol.ReturnsByRef.get -> bool`
-* [ ] `Microsoft.CodeAnalysis.ITypeSymbol.IsTupleType.get -> bool`
+* [x] `Microsoft.CodeAnalysis.ITypeSymbol.IsTupleType.get -> bool`
 * [x] `Microsoft.CodeAnalysis.MethodKind.LocalFunction = 17 -> Microsoft.CodeAnalysis.MethodKind`
 * [ ] `Microsoft.CodeAnalysis.PortableExecutableReference.GetMetadataId() -> Microsoft.CodeAnalysis.MetadataId`
 * [ ] `Microsoft.CodeAnalysis.SymbolDisplayFormat.RemoveGenericsOptions(Microsoft.CodeAnalysis.SymbolDisplayGenericsOptions options) -> Microsoft.CodeAnalysis.SymbolDisplayFormat`

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/INamedTypeSymbolExtensions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using System;
+    using System.Collections.Immutable;
+    using Microsoft.CodeAnalysis;
+
+    internal static class INamedTypeSymbolExtensions
+    {
+        private static readonly Func<INamedTypeSymbol, INamedTypeSymbol> TupleUnderlyingTypeAccessor;
+        private static readonly Func<INamedTypeSymbol, ImmutableArray<IFieldSymbol>> TupleElementsAccessor;
+
+        static INamedTypeSymbolExtensions()
+        {
+            TupleUnderlyingTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<INamedTypeSymbol, INamedTypeSymbol>(typeof(INamedTypeSymbol), nameof(TupleUnderlyingType));
+            TupleElementsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<INamedTypeSymbol, ImmutableArray<IFieldSymbol>>(typeof(INamedTypeSymbol), nameof(TupleElements));
+        }
+
+        public static INamedTypeSymbol TupleUnderlyingType(this INamedTypeSymbol symbol)
+        {
+            return TupleUnderlyingTypeAccessor(symbol);
+        }
+
+        public static ImmutableArray<IFieldSymbol> TupleElements(this INamedTypeSymbol symbol)
+        {
+            return TupleElementsAccessor(symbol);
+        }
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ITypeSymbolExtensions.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+
+    internal static class ITypeSymbolExtensions
+    {
+        private static readonly Func<ITypeSymbol, bool> IsTupleTypeAccessor;
+
+        static ITypeSymbolExtensions()
+        {
+            IsTupleTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<ITypeSymbol, bool>(typeof(ITypeSymbol), nameof(IsTupleType));
+        }
+
+        public static bool IsTupleType(this ITypeSymbol symbol)
+        {
+            return IsTupleTypeAccessor(symbol);
+        }
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1135UsingDirectivesMustBeQualified.cs

@@ -10,6 +10,7 @@ namespace StyleCop.Analyzers.ReadabilityRules
     using Microsoft.CodeAnalysis.Diagnostics;
 
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// A using directive is not qualified.
@@ -89,6 +90,12 @@ private static void CheckUsingDeclaration(SyntaxNodeAnalysisContext context, Usi
                 return;
             }
 
+            if (symbol is INamedTypeSymbol typeSymbol
+                && typeSymbol.IsTupleType())
+            {
+                symbol = typeSymbol.TupleUnderlyingType();
+            }
+
             string symbolString = symbol.ToString();
             string usingString = usingDirective.Name.ToString();
             if ((symbolString != usingString) && !usingDirective.StartsWithAlias(context.SemanticModel, context.CancellationToken))