Fix analyzer UseExplicitlyOrImplicitlyTypedArray (RCS1014)

dotnet · Jan 28, 2022 · 004a837 · 004a837
1 parent f4e0d53
commit 004a837
Show file tree

Hide file tree

Showing 3 changed files with 39 additions and 25 deletions.
diff --git a/src/Analyzers/CSharp/Analysis/UseExplicitlyOrImplicitlyTypedArrayAnalyzer.cs b/src/Analyzers/CSharp/Analysis/UseExplicitlyOrImplicitlyTypedArrayAnalyzer.cs
@@ -128,11 +128,21 @@ private static void AnalyzeArrayCreationExpression(SyntaxNodeAnalysisContext con
             if (!expressions.Any())
                 return;
 
+            ITypeSymbol typeSymbol = null;
+
             if (kind == ArrayCreationTypeStyle.ImplicitWhenTypeIsObvious)
             {
                 foreach (ExpressionSyntax expression in expressions)
                 {
-                    if (!CSharpTypeAnalysis.IsTypeObvious(expression, null, context.SemanticModel, context.CancellationToken))
+                    if (typeSymbol == null)
+                    {
+                        typeSymbol = context.SemanticModel.GetTypeSymbol(arrayCreation.Type.ElementType, context.CancellationToken);
+
+                        if (typeSymbol?.IsErrorType() != false)
+                            return;
+                    }
+
+                    if (!CSharpTypeAnalysis.IsTypeObvious(expression, typeSymbol, context.SemanticModel, context.CancellationToken))
                         return;
                 }
             }

diff --git a/src/CSharp/CSharp/CSharpTypeAnalysis.cs b/src/CSharp/CSharp/CSharpTypeAnalysis.cs
@@ -251,14 +251,20 @@ public static bool IsTypeObvious(ExpressionSyntax expression, ITypeSymbol typeSy
                 case SyntaxKind.CharacterLiteralExpression:
                 case SyntaxKind.TrueLiteralExpression:
                 case SyntaxKind.FalseLiteralExpression:
+                case SyntaxKind.ThisExpression:
+                    {
+                        return true;
+                    }
                 case SyntaxKind.ObjectCreationExpression:
                 case SyntaxKind.ArrayCreationExpression:
                 case SyntaxKind.CastExpression:
                 case SyntaxKind.AsExpression:
-                case SyntaxKind.ThisExpression:
                 case SyntaxKind.DefaultExpression:
                     {
-                        return true;
+                        return typeSymbol == null
+                            || SymbolEqualityComparer.IncludeNullability.Equals(
+                                typeSymbol,
+                                semanticModel.GetTypeSymbol(expression, cancellationToken));
                     }
                 case SyntaxKind.ImplicitArrayCreationExpression:
                     {

diff --git a/src/Tests/Analyzers.Tests/RCS1014UseImplicitlyTypedArrayTests.cs b/src/Tests/Analyzers.Tests/RCS1014UseImplicitlyTypedArrayTests.cs
@@ -85,12 +85,12 @@ void M()
         [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
         public async Task Test_TypesAreNotEqual()
         {
-            await VerifyDiagnosticAndFixAsync(@"
+            await VerifyNoDiagnosticAsync(@"
 class C : A
 {
     void M()
     {
-        var x = new [|A|][]
+        var x = new A[]
         {
             default(B),
             default(C)
@@ -102,26 +102,6 @@ class A
 {
 }
 
-class B : A
-{
-}
-", @"
-class C : A
-{
-    void M()
-    {
-        var x = new[]
-        {
-            default(B),
-            (A)default(C)
-        };
-    }
-}
-
-class A
-{
-}
-
 class B : A
 {
 }
@@ -183,5 +163,23 @@ void M()
 }
 ", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_Implicit));
         }
+
+        [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray)]
+        public async Task TestNoDiagnostic_ArrayInitializer_DerivedType()
+        {
+            await VerifyNoDiagnosticAsync(@"
+class C
+{
+    void M()
+    {
+        var items = new object[]
+        {
+            new double[] { 1d },
+            new double[] { 1d }
+        };
+    }
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.ArrayCreationTypeStyle, ConfigOptionValues.ArrayCreationTypeStyle_ImplicitWhenTypeIsObvious));
+        }
     }
 }