removed using static check & added nested enum test

Author: Vannevelj

VSDiagnostics/VSDiagnostics/VSDiagnostics.Test/Tests/General/SwitchDoesNotHandleAllEnumOptionsTests.cs

@@ -771,5 +771,60 @@ void Method()
             VerifyDiagnostic(original, SwitchDoesNotHandleAllEnumOptionsAnalyzer.Rule.MessageFormat.ToString());
             VerifyFix(original, result);
         }
+
+        [TestMethod]
+        public void SwitchDoesNotHandleAllEnumOptions_MissingEnumStatement_NestedEnum()
+        {
+            var original = @"
+namespace ConsoleApplication1
+{
+    class MyClass
+    {
+        enum MyEnum
+        {
+            Fizz, Buzz, FizzBuzz
+        }
+
+        void Method()
+        {
+            var e = MyEnum.Fizz;
+            switch (e)
+            {
+                case MyEnum.Fizz:
+                case MyEnum.Buzz:
+                    break;
+            }
+        }
+    }
+}";
+
+            var result = @"
+namespace ConsoleApplication1
+{
+    class MyClass
+    {
+        enum MyEnum
+        {
+            Fizz, Buzz, FizzBuzz
+        }
+
+        void Method()
+        {
+            var e = MyEnum.Fizz;
+            switch (e)
+            {
+                case MyEnum.FizzBuzz:
+                    throw new System.NotImplementedException();
+                case MyEnum.Fizz:
+                case MyEnum.Buzz:
+                    break;
+            }
+        }
+    }
+}";
+
+            VerifyDiagnostic(original, SwitchDoesNotHandleAllEnumOptionsAnalyzer.Rule.MessageFormat.ToString());
+            VerifyFix(original, result);
+        }
     }
 }

VSDiagnostics/VSDiagnostics/VSDiagnostics/Diagnostics/General/SwitchDoesNotHandleAllEnumOptions/SwitchDoesNotHandleAllEnumOptionsCodeFix.cs

@@ -41,7 +41,7 @@ private async Task<Solution> AddMissingCaseAsync(Document document, CompilationU
 
             var switchBlock = (SwitchStatementSyntax)statement;
 
-            var enumType = semanticModel.GetTypeInfo(switchBlock.Expression).Type as INamedTypeSymbol;
+            var enumType = (INamedTypeSymbol) semanticModel.GetTypeInfo(switchBlock.Expression).Type;
             var caseLabels = switchBlock.Sections.SelectMany(l => l.Labels)
                     .OfType<CaseSwitchLabelSyntax>()
                     .Select(l => l.Value)
@@ -50,9 +50,8 @@ private async Task<Solution> AddMissingCaseAsync(Document document, CompilationU
             var missingLabels = GetMissingLabels(caseLabels, enumType);
 
             // use simplified form if there are any in simplified form or if there are not any labels at all
-            var useSimplifiedForm = (caseLabels.OfType<IdentifierNameSyntax>().Any() ||
-                                    !caseLabels.OfType<MemberAccessExpressionSyntax>().Any()) &&
-                                    EnumIsUsingStatic(root, enumType);
+            var hasSimplifiedLabel = caseLabels.OfType<IdentifierNameSyntax>().Any();
+            var useSimplifiedForm = hasSimplifiedLabel || !caseLabels.OfType<MemberAccessExpressionSyntax>().Any();
 
             var qualifier = GetQualifierForException(root);
 
@@ -65,10 +64,10 @@ private async Task<Solution> AddMissingCaseAsync(Document document, CompilationU
 
             foreach (var label in missingLabels)
             {
-                // ReSharper disable once PossibleNullReferenceException
+                // If an existing simplified label exists, it means we can assume that works already and do it ourselves as well (ergo: there is a static using)
                 var caseLabel =
                     SyntaxFactory.CaseSwitchLabel(
-                        SyntaxFactory.ParseExpression(useSimplifiedForm ? $" {label}" : $" {enumType.Name}.{label}")
+                        SyntaxFactory.ParseExpression(hasSimplifiedLabel ? $"{label}" : $"{enumType.Name}.{label}")
                             .WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)));
 
                 var section =
@@ -88,28 +87,6 @@ private async Task<Solution> AddMissingCaseAsync(Document document, CompilationU
             return newDocument.Project.Solution;
         }
 
-        private bool EnumIsUsingStatic(CompilationUnitSyntax root, INamedTypeSymbol enumType)
-        {
-            var fullyQualifiedName = enumType.Name;
-
-            var containingNamespace = enumType.ContainingNamespace;
-            while (!string.IsNullOrEmpty(containingNamespace.Name))
-            {
-                fullyQualifiedName = fullyQualifiedName.Insert(0, containingNamespace.Name + ".");
-                containingNamespace = containingNamespace.ContainingNamespace;
-            }
-
-            return root.Usings.Any(u =>
-                {
-                    if (!u.StaticKeyword.IsKind(SyntaxKind.StaticKeyword)) { return false; }
-
-                    var name = u.Name as QualifiedNameSyntax;
-                    if (name == null) { return false; }
-
-                    return new string(name.GetText().ToString().ToCharArray().Where(c => !char.IsWhiteSpace(c)).ToArray()) == fullyQualifiedName;
-                });
-        }
-
         private IEnumerable<string> GetMissingLabels(List<ExpressionSyntax> caseLabels, INamedTypeSymbol enumType)
         {
             // these are the labels like `MyEnum.EnumMember`
@@ -130,7 +107,7 @@ private string GetQualifierForException(CompilationUnitSyntax root)
             var qualifier = "System.";
             var usingSystemDirective =
                 root.Usings.Where(u => u.Name is IdentifierNameSyntax)
-                    .FirstOrDefault(u => ((IdentifierNameSyntax) u.Name).Identifier.ValueText == "System");
+                    .FirstOrDefault(u => ((IdentifierNameSyntax) u.Name).Identifier.ValueText == nameof(System));
 
             if (usingSystemDirective != null)
             {