Qualify the type when negating a pattern to a not pattern

src/Analyzers/CSharp/Tests/UsePatternMatching/CSharpUseNotPatternTests.cs

@@ -174,6 +174,49 @@ void M(object x)
         }.RunAsync();
     }
 
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72370")]
+    public async Task UseNotPattern2()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                       public class Program
+                       {
+                           public class C
+                           {
+                           }
+                           public static void Main()
+                           {
+                               C C = new();
+                               object O = C;
+
+                               if (!(O [|is|] C))
+                               {
+                               }
+                           }
+                       }
+                       """,
+            FixedCode = """
+                        public class Program
+                        {
+                            public class C
+                            {
+                            }
+                            public static void Main()
+                            {
+                                C C = new();
+                                object O = C;
+
+                                if (O is not Program.C)
+                                {
+                                }
+                            }
+                        }
+                        """,
+            LanguageVersion = LanguageVersion.CSharp9,
+        }.RunAsync();
+    }
+
     [Fact]
     public async Task UnavailableInCSharp8()
     {

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_Negate.cs

@@ -158,6 +158,23 @@ private static SyntaxNode GetNegationOfBinaryExpression(
                     return generatorInternal.IsPatternExpression(leftOperand, operatorToken, generatorInternal.ConstantPattern(generator.NullLiteralExpression()));
                 }
 
+                // With a not pattern, it is possible to have an ambiguity between a type name or a local identifier.
+                // For example, if a class is named C and we have:
+                // C C = new();
+                // object O = C;
+                // if (O is not C)
+                // ...
+                // Then there is an ambiguity between the type C and the local named C.
+                // To address this, we use an expression with the fully qualified type name which the simplifier
+                // will shorten to the shortest possible without ambiguity
+                if (!syntaxFacts.IsPredefinedType(rightOperand) &&
+                    operation is IIsTypeOperation isTypeOperation &&
+                    syntaxFacts.SupportsNotPattern(semanticModel.SyntaxTree.Options))
+                {
+                    var typeNode = generatorInternal.Type(isTypeOperation.TypeOperand, typeContext: false);
+                    return generatorInternal.IsPatternExpression(leftOperand, operatorToken, generatorInternal.NotPattern(generatorInternal.ConstantPattern(typeNode)));
+                }
+
                 // `is y`   ->    `is not y`
                 if (syntaxFacts.SupportsNotPattern(semanticModel.SyntaxTree.Options))
                     return generatorInternal.IsPatternExpression(leftOperand, operatorToken, generatorInternal.NotPattern(generatorInternal.TypePattern(rightOperand)));