Fix tests

src/EditorFeatures/CSharpTest/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzerTests.cs

@@ -4,6 +4,7 @@
 
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.CSharp.UsePatternCombinators;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
@@ -14,9 +15,17 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UsePatternCombinators
 {
     public class CSharpUsePatternCombinatorsDiagnosticAnalyzerTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
     {
+        private static readonly ParseOptions CSharp9 = TestOptions.RegularPreview;
+
         internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
             => (new CSharpUsePatternCombinatorsDiagnosticAnalyzer(), new CSharpUsePatternCombinatorsCodeFixProvider());
 
+        private Task TestMissingInCSharp9Async(string initialMarkup)
+            => TestMissingAsync(initialMarkup, new TestParameters(CSharp9));
+
+        private Task TestInCSharp9Async(string initialMarkup, string expectedMarkup)
+            => TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, parseOptions: CSharp9);
+
         private static readonly string s_initialMarkup = @"
 using System;
 using System.Collections.Generic;
@@ -35,31 +44,35 @@ class C
     void Assignment() { _ = EXPRESSION; }
     void Do() { do ; while (EXPRESSION); }
     void While() { while (EXPRESSION) ; }
-    void When() { _ = o switch { _ when EXPRESSION => 0 }; }
+    bool When() => o switch { _ when EXPRESSION => EXPRESSION };
     bool Return() { return EXPRESSION; }
     IEnumerable<bool> YieldReturn() { yield return EXPRESSION; }
     Func<object, bool> SimpleLambda() => o => EXPRESSION;
     Func<bool> ParenthesizedLambda() => () => EXPRESSION;
+    int i;
+    object o;
 }
 ";
 
         [InlineData("i == 0")]
         [InlineData("i > 0")]
-        [InlineData("i is C")]
-        [InlineData("i is C c")]
-        [InlineData("!(i > 0)")]
+        [InlineData("o is C")]
+        [InlineData("o is C c")]
         [InlineData("o != null")]
         [InlineData("!(o is C c)")]
+        [InlineData("!(o is null)")]
+        [InlineData("o is int ii || o is long jj")]
         [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUsePatternCombinators)]
         public async Task TestMissingOnExpression(string expression)
         {
-            await TestMissingAsync(s_initialMarkup.Replace("EXPRESSION", expression));
+            await TestMissingInCSharp9Async(s_initialMarkup.Replace("EXPRESSION", expression));
         }
 
+        [InlineData("o is int ii && o is long jj", "o is int ii and long jj")]
         [InlineData("!(o is C)", "o is not C")]
         [InlineData("!(o is C _)", "o is not C _")]
         [InlineData("i == 1 || 2 == i", "i is 1 or 2")]
-        [InlineData("i != 1 || 2 != i", "i is not 1 or not 2")]
+        [InlineData("i != 1 || 2 != i", "i is not (1 and 2)")]
         [InlineData("i != 1 && 2 != i", "i is not (1 or 2)")]
         [InlineData("!(i != 1 && 2 != i)", "i is 1 or 2")]
         [InlineData("i < 1 && 2 <= i", "i is < 1 and >= 2")]
@@ -68,7 +81,7 @@ public async Task TestMissingOnExpression(string expression)
         [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUsePatternCombinators)]
         public async Task TestOnExpression(string expression, string expected)
         {
-            await TestInRegularAndScriptAsync(
+            await TestInCSharp9Async(
                 s_initialMarkup.Replace("EXPRESSION", expression),
                 s_initialMarkup.Replace("EXPRESSION", expected));
         }
@@ -76,7 +89,7 @@ public async Task TestOnExpression(string expression, string expected)
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUsePatternCombinators)]
         public async Task TestMultiline()
         {
-            await TestInRegularAndScript1Async(
+            await TestInCSharp9Async(
 @"class C
 {
     bool M0(int variable)

src/Features/CSharp/Portable/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs

@@ -6,6 +6,7 @@
 
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -58,7 +59,7 @@ protected override void InitializeWorker(AnalysisContext context)
                 ArrowExpressionClauseSyntax n => n.Expression,
                 AssignmentExpressionSyntax n => n.Right,
                 LambdaExpressionSyntax n => n.ExpressionBody,
-                ArgumentSyntax n when n.RefKindKeyword.IsMissing => n.Expression,
+                ArgumentSyntax n when n.GetRefKind() == RefKind.None => n.Expression,
                 _ => null,
             };
 
@@ -123,6 +124,7 @@ private static bool IsTrivial(AnalyzedPattern pattern)
             => pattern switch
             {
                 Not { Pattern: Constant _ } => true,
+                Not { Pattern: Source { PatternSyntax: ConstantPatternSyntax _ } } => true,
                 Not _ => false,
                 Binary _ => false,
                 _ => true