Merge pull request #487 from Hosch250/Issue269

Close issue #269

Author: Vannevelj

VSDiagnostics/VSDiagnostics/VSDiagnostics.Test/Tests/General/UseAliasesInsteadOfConcreteTypeTests.cs

@@ -940,7 +940,7 @@ namespace ConsoleApplication1
 {
     class MyClass
     {
-        public static explicit operator int(MyClass c)
+        public static explicit operator int (MyClass c)
         {
             return 5;
         }
@@ -1571,7 +1571,7 @@ static void Main() { }
         }
 
         [TestMethod]
-        public void UseAliasesInsteadOfConcreteType_DisplaysCorrectWarning()
+        public void UseAliasesInsteadOfConcreteType_DoesNotDisplayWarningWithAlias()
         {
             var original = @"
 using Single = System.String;
@@ -1587,22 +1587,7 @@ static void Main()
     }
 }";
 
-            var result = @"
-using Single = System.String;
-
-namespace ConsoleApplication1
-{
-    class Foo
-    {
-        static void Main()
-        {
-            string bar = ""test"";
-        }
-    }
-}";
-
-            VerifyDiagnostic(original, string.Format(UseAliasesInsteadOfConcreteTypeAnalyzer.Rule.MessageFormat.ToString(), "string", "String"));
-            VerifyFix(original, result, allowNewCompilerDiagnostics: true);
+            VerifyDiagnostic(original);
         }
     }
 }

VSDiagnostics/VSDiagnostics/VSDiagnostics/Diagnostics/General/UseAliasesInsteadOfConcreteType/UseAliasesInsteadOfConcreteTypeAnalyzer.cs

@@ -44,10 +44,6 @@ private void AnalyzeSymbol(SyntaxNodeAnalysisContext context)
 
             // If we're dealing with a self-defined type 'Char' then we ignore it
             var identifierSymbol = context.SemanticModel.GetSymbolInfo(identifier);
-            if (identifierSymbol.Symbol == null)
-            {
-                return;
-            }
 
             var typeSymbol = identifierSymbol.Symbol as INamedTypeSymbol;
             if (typeSymbol == null || typeSymbol.SpecialType == SpecialType.None)
@@ -70,10 +66,14 @@ private void AnalyzeSymbol(SyntaxNodeAnalysisContext context)
                 location = qualifiedName.GetLocation();
             }
 
-            string alias;
-            if (identifier.Identifier.Text.HasAlias() && typeSymbol.MetadataName.HasAlias(out alias))
+            // This ensures that we are not using aliases.  Both the identifier and the actual type must have a registered alias.
+            // If the identifier alias and the alias for the actual type do not match (as when `using Single = System.String`),
+            // the aliases do not match, so we do not create a diagnostic because the Simplifier does not create an alias in this case.
+            string identifierAlias;
+            string metadataAlias;
+            if (identifier.Identifier.Text.HasAlias(out identifierAlias) && typeSymbol.MetadataName.HasAlias(out metadataAlias) && identifierAlias == metadataAlias)
             {
-                context.ReportDiagnostic(Diagnostic.Create(Rule, location, alias, typeSymbol.MetadataName));
+                context.ReportDiagnostic(Diagnostic.Create(Rule, location, metadataAlias, typeSymbol.MetadataName));
             }
         }
     }

VSDiagnostics/VSDiagnostics/VSDiagnostics/Diagnostics/General/UseAliasesInsteadOfConcreteType/UseAliasesInsteadOfConcreteTypeCodeFix.cs

@@ -1,15 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
+using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Simplification;
 
 namespace VSDiagnostics.Diagnostics.General.UseAliasesInsteadOfConcreteType
 {
@@ -36,35 +32,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
         private async Task<Solution> UseAliasAsync(Document document, SyntaxNode root, SyntaxNode statement)
         {
-            var semanticModel = await document.GetSemanticModelAsync();
-            var typeName = semanticModel.GetSymbolInfo(statement).Symbol.MetadataName;
-            var aliasToken = MapConcreteTypeToPredefinedTypeAlias[typeName];
-
-            var newExpression = SyntaxFactory.PredefinedType(SyntaxFactory.Token(aliasToken)).WithTriviaFrom(statement);
-            var newRoot = root.ReplaceNode(statement, newExpression);
-            var newDocument = document.WithSyntaxRoot(newRoot);
+            var newRoot = root.ReplaceNode(statement, statement.WithAdditionalAnnotations(Simplifier.Annotation));
+            var newDocument = await Simplifier.ReduceAsync(document.WithSyntaxRoot(newRoot));
 
             return newDocument.Project.Solution;
         }
-
-        private static readonly Dictionary<string, SyntaxKind> MapConcreteTypeToPredefinedTypeAlias =
-            new Dictionary<string, SyntaxKind>
-            {
-                {nameof(Int16), SyntaxKind.ShortKeyword},
-                {nameof(Int32), SyntaxKind.IntKeyword},
-                {nameof(Int64), SyntaxKind.LongKeyword},
-                {nameof(UInt16), SyntaxKind.UShortKeyword},
-                {nameof(UInt32), SyntaxKind.UIntKeyword},
-                {nameof(UInt64), SyntaxKind.ULongKeyword},
-                {nameof(Object), SyntaxKind.ObjectKeyword},
-                {nameof(Byte), SyntaxKind.ByteKeyword},
-                {nameof(SByte), SyntaxKind.SByteKeyword},
-                {nameof(Char), SyntaxKind.CharKeyword},
-                {nameof(Boolean), SyntaxKind.BoolKeyword},
-                {nameof(Single), SyntaxKind.FloatKeyword},
-                {nameof(Double), SyntaxKind.DoubleKeyword},
-                {nameof(Decimal), SyntaxKind.DecimalKeyword},
-                {nameof(String), SyntaxKind.StringKeyword}
-            };
     }
 }

VSDiagnostics/VSDiagnostics/VSDiagnostics/Utilities/Extensions.cs

@@ -135,16 +135,6 @@ public static bool HasAlias(this string type, out string alias)
             return AliasMapping.TryGetValue(type, out alias);
         }
 
-        public static bool HasAlias(this string type)
-        {
-            if (type == null)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            return AliasMapping.Keys.Contains(type);
-        }
-
         /// <summary>
         ///     Determines whether or not the specified <see cref="IMethodSymbol" /> is the symbol of an asynchronous method. This
         ///     can be a method declared as async (e.g. returning <see cref="Task" /> or <see cref="Task{TResult}" />), or a method