Support the casted form.

src/EditorFeatures/CSharpTest/UseLocalFunction/UseLocalFunctionTests.cs

@@ -351,6 +351,216 @@ void M()
 }",
 @"using System;
 
+class C
+{
+    void M()
+    {
+        int fibonacci(int v) =>
+            v <= 1
+                ? 1
+                : fibonacci(v - 1, v - 2);
+    }
+}", ignoreTrivia: false);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        public async Task TestCastInitialization_SimpleLambda_Block()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M()
+    {
+        var [||]fibonacci = (Func<int, int>)(v =>
+        {
+            if (v <= 1)
+            {
+                return 1;
+            }
+
+            return fibonacci(v - 1, v - 2);
+        });
+    }
+}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        int fibonacci(int v)
+        {
+            if (v <= 1)
+            {
+                return 1;
+            }
+
+            return fibonacci(v - 1, v - 2);
+        }
+    }
+}", ignoreTrivia: false);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        public async Task TestCastInitialization_ParenLambdaNoType_Block()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M()
+    {
+        var [||]fibonacci = (Func<int, int>)((v) =>
+        {
+            if (v <= 1)
+            {
+                return 1;
+            }
+
+            return fibonacci(v - 1, v - 2);
+        });
+    }
+}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        int fibonacci(int v)
+        {
+            if (v <= 1)
+            {
+                return 1;
+            }
+
+            return fibonacci(v - 1, v - 2);
+        }
+    }
+}", ignoreTrivia: false);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        public async Task TestCastInitialization_ParenLambdaWithType_Block()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M()
+    {
+        var [||]fibonacci = (Func<int, int>)((int v) =>
+        {
+            if (v <= 1)
+            {
+                return 1;
+            }
+
+            return fibonacci(v - 1, v - 2);
+        });
+    }
+}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        int fibonacci(int v)
+        {
+            if (v <= 1)
+            {
+                return 1;
+            }
+
+            return fibonacci(v - 1, v - 2);
+        }
+    }
+}", ignoreTrivia: false);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        public async Task TestCastInitialization_SimpleLambda_ExprBody()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M()
+    {
+        var [||]fibonacci = (Func<int, int>)(v =>
+            v <= 1
+                ? 1
+                : fibonacci(v - 1, v - 2));
+    }
+}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        int fibonacci(int v) =>
+            v <= 1
+                ? 1
+                : fibonacci(v - 1, v - 2);
+    }
+}", ignoreTrivia: false);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        public async Task TestCastInitialization_ParenLambdaNoType_ExprBody()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M()
+    {
+        var [||]fibonacci = (Func<int, int>)((v) =>
+            v <= 1
+                ? 1
+                : fibonacci(v - 1, v - 2));
+    }
+}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        int fibonacci(int v) =>
+            v <= 1
+                ? 1
+                : fibonacci(v - 1, v - 2);
+    }
+}", ignoreTrivia: false);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseLocalFunction)]
+        public async Task TestCastInitialization_ParenLambdaWithType_ExprBody()
+        {
+            await TestInRegularAndScriptAsync(
+@"using System;
+
+class C
+{
+    void M()
+    {
+        var [||]fibonacci = (Func<int, int>)((int v) =>
+            v <= 1
+                ? 1
+                : fibonacci(v - 1, v - 2));
+    }
+}",
+@"using System;
+
 class C
 {
     void M()

src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionCodeFixProvider.cs

@@ -76,6 +76,10 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
                     ReplaceSimpleLocalDeclaration(semanticModel, editor, localDeclaration, anonymousFunction, cancellationToken);
                     return;
 
+                case CSharpUseLocalFunctionDiagnosticAnalyzer.CastedLocalDeclarationForm:
+                    ReplaceCastedLocalDeclaration(semanticModel, editor, localDeclaration, anonymousFunction, cancellationToken);
+                    return;
+
                 default:
                     throw ExceptionUtilities.UnexpectedValue(form);
             }
@@ -96,6 +100,21 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             editor.ReplaceNode(localDeclaration, localFunctionStatement);
         }
 
+        private void ReplaceCastedLocalDeclaration(
+            SemanticModel semanticModel, SyntaxEditor editor,
+            LocalDeclarationStatementSyntax localDeclaration,
+            LambdaExpressionSyntax anonymousFunction,
+            CancellationToken cancellationToken)
+        {
+            // var t = (Type)(<anonymous function>);
+            var localFunctionStatement = CreateLocalFunctionStatement(
+                semanticModel, localDeclaration, anonymousFunction, cancellationToken);
+
+            localFunctionStatement = localFunctionStatement.WithTriviaFrom(localDeclaration)
+                                                           .WithAdditionalAnnotations(Formatter.Annotation);
+            editor.ReplaceNode(localDeclaration, localFunctionStatement);
+        }
+
         private LocalFunctionStatementSyntax CreateLocalFunctionStatement(
             SemanticModel semanticModel,
             LocalDeclarationStatementSyntax localDeclaration,

src/Features/CSharp/Portable/UseLocalFunction/CSharpUseLocalFunctionDiagnosticAnalyzer.cs

@@ -93,13 +93,12 @@ private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
                 return;
             }
 
-
             if (!(localDeclaration.Parent is BlockSyntax block))
             {
                 return;
             }
 
-            var local = semanticModel.GetDeclaredSymbol(anonymousFunction.Parent.Parent, cancellationToken);
+            var local = semanticModel.GetDeclaredSymbol(localDeclaration.Declaration.Variables[0], cancellationToken);
             if (local == null)
             {
                 return;