Add HasUnconstraintGenericParameter check to suppress reporting of diagnostic.

src/EditorFeatures/CSharpTest/UseIsNullCheck/UseIsNullCheckTests.cs

@@ -217,5 +217,55 @@ void M(string s1, string s2)
     }
 }");
         }
+
+        [WorkItem(23581, "https://github.com/dotnet/roslyn/issues/23581")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestMissingIfValueParameterTypeIsUnconstraintGeneric()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    public static void NotNull<T>(T value, string parameterName)
+    {
+        if ([||]ReferenceEquals(value, null))
+        {
+            throw new System.ArgumentNullException(parameterName);
+        }
+    }
+}
+");
+        }
+
+        [WorkItem(23581, "https://github.com/dotnet/roslyn/issues/23581")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseIsNullCheck)]
+        public async Task TestValueParameterTypeIsConstraintGeneric()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    public static void NotNull<T>(T value, string parameterName) where T:class
+    {
+        if ([||]ReferenceEquals(value, null))
+        {
+            throw new System.ArgumentNullException(parameterName);
+        }
+    }
+}
+",
+@"
+class C
+{
+    public static void NotNull<T>(T value, string parameterName) where T:class
+    {
+        if (value is null)
+        {
+            throw new System.ArgumentNullException(parameterName);
+        }
+    }
+}
+");
+        }
     }
 }

src/Features/Core/Portable/UseIsNullCheck/AbstractUseIsNullDiagnosticAnalyzer.cs

@@ -2,6 +2,7 @@
 
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -49,7 +50,7 @@ protected override void InitializeWorker(AnalysisContext context)
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol referenceEqualsMethod)
         {
             var cancellationToken = context.CancellationToken;
-            
+
             var semanticModel = context.SemanticModel;
             var syntaxTree = semanticModel.SyntaxTree;
             if (!IsLanguageVersionSupported(syntaxTree.Options))
@@ -108,6 +109,10 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol refe
                 return;
             }
 
+            if (HasUnconstraintGenericParameter(syntaxFacts, semanticModel, arguments[0], arguments[1], cancellationToken))
+            {
+                return;
+            }
 
             var additionalLocations = ImmutableArray.Create(invocation.GetLocation());
             var properties = ImmutableDictionary<string, string>.Empty;
@@ -125,7 +130,23 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol refe
                     additionalLocations, properties));
         }
 
-        private bool MatchesPattern(ISyntaxFactsService syntaxFacts, SyntaxNode node1, SyntaxNode node2)
+        private static bool HasUnconstraintGenericParameter(ISyntaxFactsService syntaxFacts, SemanticModel semanticModel, SyntaxNode node1, SyntaxNode node2, CancellationToken cancellationToken)
+        {
+            var valueNode = syntaxFacts.IsNullLiteralExpression(node1) ? node2 : node1;
+            var argumentExpression = syntaxFacts.GetExpressionOfArgument(valueNode);
+            if (argumentExpression != null)
+            {
+                var parameterType = semanticModel.GetTypeInfo(argumentExpression, cancellationToken).Type;
+                if (parameterType is ITypeParameterSymbol typeParameter)
+                {
+                    return !typeParameter.HasReferenceTypeConstraint;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool MatchesPattern(ISyntaxFactsService syntaxFacts, SyntaxNode node1, SyntaxNode node2)
             => syntaxFacts.IsNullLiteralExpression(syntaxFacts.GetExpressionOfArgument(node1)) &&
                !syntaxFacts.IsNullLiteralExpression(syntaxFacts.GetExpressionOfArgument(node2));
     }