Merge pull request #906 from nunit/Issue896_typeof_generic

Don't treat typeof(T) as a constant as it depends on parameters.

Author: mikkelbu

src/nunit.analyzers.tests/ConstActualValueUsage/ConstActualValueUsageAnalyzerTests.cs

@@ -481,5 +481,27 @@ public void Test()
 
             RoslynAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
         }
+
+        [Test]
+        public void TypeOfGenericIsNotAConstant()
+        {
+            var testCode = TestUtility.WrapClassInNamespaceAndAddUsing("""
+                public class MyExplicitlyTypedTests
+                {
+                    [TestCaseSource(nameof(ExplicitTypeArgsTestCases))]
+                    public void ExplicitTypeArgs<T>(T input)
+                    {
+                        Assert.That(typeof(T), Is.EqualTo(typeof(long)));
+                    }
+
+                    private static IEnumerable<TestCaseData> ExplicitTypeArgsTestCases()
+                    {
+                        yield return new TestCaseData(2);
+                        yield return new TestCaseData(2L);
+                    }
+                }
+                """, "using System.Collections.Generic;");
+            RoslynAssert.Valid(analyzer, testCode);
+        }
     }
 }

src/nunit.analyzers/ConstActualValueUsage/ConstActualValueUsageAnalyzer.cs

@@ -62,6 +62,13 @@ void Report(IOperation operation)
                 return;
             }
 
+            if (actualOperation is ITypeOfOperation typeOfOperation &&
+                typeOfOperation.TypeOperand.Kind == SymbolKind.TypeParameter)
+            {
+                // typeof(T) is a special case, it is not a constant value as it depends on the parameter.
+                return;
+            }
+
             // The actual expression is a constant field, check if expected is also constant
             var expectedOperation = GetExpectedOperation(assertOperation);