Code review feedback + additional tests

src/EditorFeatures/CSharpTest2/Recommendations/AndKeywordRecommenderTests.cs

@@ -42,6 +42,56 @@ public async Task TestAfterRelationalOperator()
 @"if (e is >= 0 $$"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterGenericType()
+        {
+            await VerifyKeywordAsync(
+@"class C<T>
+{
+    void M()
+    {
+        var e = new object();
+        if (e is T $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterArrayType()
+        {
+            await VerifyKeywordAsync(
+@"class C
+{
+    void M()
+    {
+        var e = new object();
+        if (e is int[] $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterListType()
+        {
+            await VerifyKeywordAsync(
+@"using System.Collections.Generic;
+
+class C
+{
+    void M()
+    {
+        var e = new object();
+        if (e is List<int> $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterListType_FullyQualified()
+        {
+            await VerifyKeywordAsync(
+@"class C
+{
+    void M()
+    {
+        var e = new object();
+        if (e is System.Collections.Generic.List<int> $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestInsideSubpattern()
         {
@@ -384,6 +434,13 @@ public async Task TestMissingAfterNotKeyword()
 @"if (e is not $$"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestMissingAfterVarKeyword()
+        {
+            await VerifyAbsenceAsync(AddInsideMethod(InitializeObjectE +
+@"if (e is var $$"));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestMissingAfterAndKeyword()
         {
@@ -405,6 +462,13 @@ public async Task TestMissingAfterOpenParen()
 @"if (e is ($$"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestMissingAfterOpenBracket()
+        {
+            await VerifyAbsenceAsync(AddInsideMethod(InitializeObjectE +
+@"if (e is { $$"));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestMissingAtBeginningOfSwitchExpression()
         {

src/EditorFeatures/CSharpTest2/Recommendations/NotKeywordRecommenderTests.cs

@@ -79,7 +79,7 @@ public async Task TestInMiddleofCompletePattern()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestInMiddleofCompleteQualifiedPattern()
+        public async Task TestInMiddleOfCompleteQualifiedPattern()
         {
             await VerifyKeywordAsync(
 @"namespace N
@@ -96,6 +96,24 @@ void M()
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestInMiddleOfCompleteQualifiedPattern_List()
+        {
+            await VerifyKeywordAsync(
+@"namespace N
+{
+    class C
+    {
+        const int P = 1;
+
+        void M()
+        {
+            if (e is $$ System.Collections.Generic.List<int> or 2) { }
+        }
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestInMiddleofCompletePattern_MultipleParens()
         {

src/EditorFeatures/CSharpTest2/Recommendations/OrKeywordRecommenderTests.cs

@@ -42,6 +42,56 @@ public async Task TestAfterRelationalOperator()
 @"if (e is >= 0 $$"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterGenericType()
+        {
+            await VerifyKeywordAsync(
+@"class C<T>
+{
+    void M()
+    {
+        var e = new object();
+        if (e is T $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterArrayType()
+        {
+            await VerifyKeywordAsync(
+@"class C
+{
+    void M()
+    {
+        var e = new object();
+        if (e is int[] $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterListType()
+        {
+            await VerifyKeywordAsync(
+@"using System.Collections.Generic;
+
+class C
+{
+    void M()
+    {
+        var e = new object();
+        if (e is List<int> $$");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestAfterListType_FullyQualified()
+        {
+            await VerifyKeywordAsync(
+@"class C
+{
+    void M()
+    {
+        var e = new object();
+        if (e is System.Collections.Generic.List<int> $$");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestInsideSubpattern()
         {
@@ -384,6 +434,13 @@ public async Task TestMissingAfterNotKeyword()
 @"if (e is not $$"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestMissingAfterVarKeyword()
+        {
+            await VerifyAbsenceAsync(AddInsideMethod(InitializeObjectE +
+@"if (e is var $$"));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestMissingAfterAndKeyword()
         {
@@ -405,6 +462,13 @@ public async Task TestMissingAfterOpenParen()
 @"if (e is ($$"));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        public async Task TestMissingAfterOpenBracket()
+        {
+            await VerifyAbsenceAsync(AddInsideMethod(InitializeObjectE +
+@"if (e is { $$"));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestMissingAtBeginningOfSwitchExpression()
         {

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs

@@ -1259,15 +1259,15 @@ public static bool IsAtStartOfPattern(this SyntaxTree syntaxTree, SyntaxToken le
 
             if (leftToken.IsKind(SyntaxKind.OpenParenToken))
             {
-                if (leftToken.Parent.IsKind(SyntaxKind.ParenthesizedExpression))
+                if (leftToken.Parent.IsKind(SyntaxKind.ParenthesizedExpression, out ParenthesizedExpressionSyntax parenthesizedExpression))
                 {
                     // If we're dealing with an expression surrounded by one or more sets of open parentheses, we need to
                     // walk up the parens in order to see if we're actually at the start of a valid pattern or not.
-                    var tokenPrecedingParenthesizedExpression = leftToken.Parent.GetFirstToken().GetPreviousToken();
-                    return IsAtStartOfPattern(syntaxTree, tokenPrecedingParenthesizedExpression, tokenPrecedingParenthesizedExpression.Span.End + 1);
+                    return IsAtStartOfPattern(syntaxTree, parenthesizedExpression.GetFirstToken().GetPreviousToken(), parenthesizedExpression.SpanStart);
                 }
 
 #if !CODE_STYLE
+                // e is ((($$ 1 or 2)))
                 if (leftToken.Parent.IsKind(SyntaxKind.ParenthesizedPattern))
                 {
                     return true;
@@ -1367,14 +1367,14 @@ public static bool IsAtEndOfPattern(this SyntaxTree syntaxTree, SyntaxToken left
                 // If typeSyntax is part of a qualified name, we want to get the fully-qualified name so that we can
                 // later accurately perform the check comparing the right side of the BinaryExpressionSyntax to
                 // the typeSyntax.
-                while (typeSyntax.Parent is QualifiedNameSyntax qualifiedNameSyntax)
+                while (typeSyntax.Parent is TypeSyntax parentTypeSyntax)
                 {
-                    typeSyntax = qualifiedNameSyntax;
+                    typeSyntax = parentTypeSyntax;
                 }
 
-                var binaryExpressionSyntax = typeSyntax.GetAncestor<BinaryExpressionSyntax>();
-                if (binaryExpressionSyntax != null && binaryExpressionSyntax.OperatorToken.IsKind(SyntaxKind.IsKeyword) &&
-                    binaryExpressionSyntax.Right == typeSyntax)
+                if (typeSyntax.Parent is BinaryExpressionSyntax binaryExpressionSyntax &&
+                    binaryExpressionSyntax.OperatorToken.IsKind(SyntaxKind.IsKeyword) &&
+                    binaryExpressionSyntax.Right == typeSyntax && !typeSyntax.IsVar)
                 {
                     return true;
                 }