Support analyzing overload of BenchmarkRunner.Run that takes a Type parameter created by using a typeof expression

Author: silkfire

build/common.props

@@ -21,7 +21,7 @@
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)CodingStyle.ruleset</CodeAnalysisRuleSet>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-
+    <WarningsNotAsErrors>NU1900</WarningsNotAsErrors>
     <Nullable>annotations</Nullable>
     <!-- Suppress warning for nuget package used in old (unsupported) tfm. -->
     <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>

src/BenchmarkDotNet.Analyzers/AnalyzerHelper.cs

@@ -70,5 +70,25 @@ public static ImmutableArray<AttributeSyntax> GetAttributes(INamedTypeSymbol? at
 
             return attributesBuilder.ToImmutable();
         }
+
+        public static string NormalizeTypeName(INamedTypeSymbol namedTypeSymbol)
+        {
+            string typeName;
+
+            if (namedTypeSymbol.SpecialType != SpecialType.None)
+            {
+                typeName = namedTypeSymbol.ToString();
+            }
+            else if (namedTypeSymbol.IsUnboundGenericType)
+            {
+                typeName = $"{namedTypeSymbol.Name}<{new string(',', namedTypeSymbol.TypeArguments.Length - 1)}>";
+            }
+            else
+            {
+                typeName = namedTypeSymbol.Name;
+            }
+
+            return typeName;
+        }
     }
 }

src/BenchmarkDotNet.Analyzers/BenchmarkDotNetAnalyzerResources.Designer.cs

@@ -163,7 +163,7 @@
     <value>A benchmark class referenced in the BenchmarkRunner.Run method must be unsealed</value>
   </data>
   <data name="BenchmarkRunner_Run_TypeArgumentClassMustBeUnsealed_MessageFormat" xml:space="preserve">
-    <value>Referenced benchmark class '{0}' cannot be sealed</value>
+    <value>Referenced benchmark class '{0}' is sealed</value>
   </data>
   <data name="BenchmarkRunner_Run_TypeArgumentClassMustBeUnsealed_Title" xml:space="preserve">
     <value>Benchmark classes must be unsealed</value>

src/BenchmarkDotNet.Analyzers/BenchmarkDotNetAnalyzerResources.resx

@@ -79,36 +79,56 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
                 return;
             }
 
-            if (memberAccessExpression.Expression is not IdentifierNameSyntax typeIdentifier)
+            if (memberAccessExpression.Expression is not IdentifierNameSyntax identifierNameSyntax)
             {
                 return;
             }
 
-            var classMemberAccessSymbol = context.SemanticModel.GetTypeInfo(typeIdentifier).Type;
-            if (classMemberAccessSymbol is null || !classMemberAccessSymbol.Equals(context.Compilation.GetTypeByMetadataName("BenchmarkDotNet.Running.BenchmarkRunner"), SymbolEqualityComparer.Default))
+            var classMemberAccessTypeSymbol = context.SemanticModel.GetTypeInfo(identifierNameSyntax).Type;
+            if (    classMemberAccessTypeSymbol is null
+                ||  classMemberAccessTypeSymbol.TypeKind == TypeKind.Error
+                || !classMemberAccessTypeSymbol.Equals(context.Compilation.GetTypeByMetadataName("BenchmarkDotNet.Running.BenchmarkRunner"), SymbolEqualityComparer.Default))
             {
                 return;
             }
 
-            // TODO: Support Type overloads that use the typeof() expression
-
-            if (memberAccessExpression.Name is not GenericNameSyntax genericMethod)
+            if (memberAccessExpression.Name.Identifier.ValueText != "Run")
             {
                 return;
             }
 
-            if (genericMethod.Identifier.ValueText != "Run")
+            INamedTypeSymbol? benchmarkClassTypeSymbol;
+            Location? diagnosticLocation;
+
+            if (memberAccessExpression.Name is GenericNameSyntax genericMethod)
             {
-                return;
-            }
+                if (genericMethod.TypeArgumentList.Arguments.Count != 1)
+                {
+                    return;
+                }
 
-            if (genericMethod.TypeArgumentList.Arguments.Count != 1)
+                diagnosticLocation = Location.Create(context.FilterTree, genericMethod.TypeArgumentList.Arguments.Span);
+                benchmarkClassTypeSymbol = context.SemanticModel.GetTypeInfo(genericMethod.TypeArgumentList.Arguments[0]).Type as INamedTypeSymbol;
+            }
+            else
             {
-                return;
+                if (invocationExpression.ArgumentList.Arguments.Count == 0)
+                {
+                    return;
+                }
+
+                // TODO: Support analyzing an array of typeof() expressions
+                if (invocationExpression.ArgumentList.Arguments[0].Expression is not TypeOfExpressionSyntax typeOfExpression)
+                {
+                    return;
+                }
+
+                diagnosticLocation = typeOfExpression.Type.GetLocation();
+                benchmarkClassTypeSymbol = context.SemanticModel.GetTypeInfo(typeOfExpression.Type).Type as INamedTypeSymbol;
+
             }
 
-            var benchmarkClassTypeSymbol = context.SemanticModel.GetTypeInfo(genericMethod.TypeArgumentList.Arguments[0]).Type;
-            if (benchmarkClassTypeSymbol == null || benchmarkClassTypeSymbol.TypeKind == TypeKind.Error)
+            if (benchmarkClassTypeSymbol == null || benchmarkClassTypeSymbol.TypeKind == TypeKind.Error || (benchmarkClassTypeSymbol.IsGenericType && !benchmarkClassTypeSymbol.IsUnboundGenericType))
             {
                 return;
             }
@@ -166,15 +186,15 @@ bool HasBenchmarkAttribute()
                         }
                     }
 
-                    baseType = baseType.BaseType;
+                    baseType = baseType.OriginalDefinition.BaseType;
                 }
 
                 return false;
             }
 
             void ReportDiagnostic(DiagnosticDescriptor diagnosticDescriptor)
             {
-                context.ReportDiagnostic(Diagnostic.Create(diagnosticDescriptor, Location.Create(context.FilterTree, genericMethod.TypeArgumentList.Arguments.Span), benchmarkClassTypeSymbol.Name));
+                context.ReportDiagnostic(Diagnostic.Create(diagnosticDescriptor, diagnosticLocation, AnalyzerHelper.NormalizeTypeName(benchmarkClassTypeSymbol)));
             }
         }
     }