Implement SyntaxFacts.IsInTypeOnlyContext for type of recursive pattern. (#45699)

Fixes #45661
* Add test from contributor at #45742
Fixes #43834

src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs

@@ -205,6 +205,9 @@ public static bool IsInTypeOnlyContext(ExpressionSyntax node)
                     case DeclarationPattern:
                         return ((DeclarationPatternSyntax)parent).Type == node;
 
+                    case RecursivePattern:
+                        return ((RecursivePatternSyntax)parent).Type == node;
+
                     case TupleElement:
                         return ((TupleElementSyntax)parent).Type == node;
 

src/EditorFeatures/CSharpTest/CodeActions/ExtractMethod/ExtractMethodTests.cs

@@ -3910,6 +3910,65 @@ int local()
             return y;
         }
     }
+}");
+        }
+
+        [Fact, WorkItem(43834, "https://github.com/dotnet/roslyn/issues/43834")]
+        public async Task TestRecursivePatternRewrite()
+        {
+            await TestInRegularAndScript1Async(@"
+using System;
+namespace N
+{
+    class Context
+    {
+    }
+    class C
+    {
+        public void DoAction(Action<Context> action)
+        {
+        }
+        private void Recursive(object context)
+        {
+            DoAction(context =>
+            {
+                if (context is Context { })
+                {
+                    DoAction(
+                        [|context =>|] context.ToString());
+                }
+            });
+        }
+    }
+}", @"
+using System;
+namespace N
+{
+    class Context
+    {
+    }
+    class C
+    {
+        public void DoAction(Action<Context> action)
+        {
+        }
+        private void Recursive(object context)
+        {
+            DoAction(context =>
+            {
+                if (context is Context { })
+                {
+                    DoAction(
+                        {|Rename:NewMethod|}());
+                }
+            });
+        }
+
+        private static Action<Context> NewMethod()
+        {
+            return context => context.ToString();
+        }
+    }
 }");
         }
     }

src/EditorFeatures/CSharpTest/CodeActions/InlineTemporary/InlineTemporaryTests.cs

@@ -4923,7 +4923,7 @@ void LocalFunc()
 
         [WorkItem(22540, "https://github.com/dotnet/roslyn/issues/22540")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineTemporary)]
-        public async Task DoNotQualifyWhenInliningIntoPattern()
+        public async Task DoNotQualifyWhenInliningIntoPattern_01()
         {
             await TestInRegularAndScriptAsync(@"
 using Syntax;
@@ -4966,6 +4966,51 @@ static void Bar(AwaitExpressionSyntax awaitExpression)
 }");
         }
 
+        [WorkItem(45661, "https://github.com/dotnet/roslyn/issues/45661")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineTemporary)]
+        public async Task DoNotQualifyWhenInliningIntoPattern_02()
+        {
+            await TestInRegularAndScriptAsync(@"
+using Syntax;
+
+namespace Syntax
+{
+    class AwaitExpressionSyntax : ExpressionSyntax { public ExpressionSyntax Expression; }
+    class ExpressionSyntax { }
+    class ParenthesizedExpressionSyntax : ExpressionSyntax { }
+}
+
+static class Goo
+{
+    static void Bar(AwaitExpressionSyntax awaitExpression)
+    {
+        ExpressionSyntax [||]expression = awaitExpression.Expression;
+
+        if (!(expression is ParenthesizedExpressionSyntax { } parenthesizedExpression))
+            return;
+    }
+}",
+@"
+using Syntax;
+
+namespace Syntax
+{
+    class AwaitExpressionSyntax : ExpressionSyntax { public ExpressionSyntax Expression; }
+    class ExpressionSyntax { }
+    class ParenthesizedExpressionSyntax : ExpressionSyntax { }
+}
+
+static class Goo
+{
+    static void Bar(AwaitExpressionSyntax awaitExpression)
+    {
+
+        if (!(awaitExpression.Expression is ParenthesizedExpressionSyntax { } parenthesizedExpression))
+            return;
+    }
+}");
+        }
+
         [WorkItem(42835, "https://github.com/dotnet/roslyn/issues/42835")]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineTemporary)]
         public async Task WarnWhenPossibleChangeInSemanticMeaning()