Fix descriptions in completion for local functions (#15820)

Wires up local functions through the semantic model and the SymbolId
service so the description is available to the editor.

Fixes #14163

src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs

@@ -5499,5 +5499,99 @@ static void M()
             var description = symbol.ToMinimalDisplayParts(model, position, SymbolDisplayFormat.MinimallyQualifiedFormat);
             Verify(description, "A.B", SymbolDisplayPartKind.AliasName, SymbolDisplayPartKind.Punctuation, SymbolDisplayPartKind.ClassName);
         }
+
+        [Fact]
+        [CompilerTrait(CompilerFeature.LocalFunctions)]
+        public void LocalFunction()
+        {
+            var srcTree = SyntaxFactory.ParseSyntaxTree(@"
+class C
+{
+    void M()
+    {
+        void Local() {}
+    }
+}");
+            var root = srcTree.GetRoot();
+            var comp = CreateCompilationWithMscorlib(srcTree);
+
+            var semanticModel = comp.GetSemanticModel(comp.SyntaxTrees.Single());
+            var local = root.DescendantNodes()
+                .Where(n => n.Kind() == SyntaxKind.LocalFunctionStatement)
+                .Single();
+            var localSymbol = Assert.IsType<LocalFunctionSymbol>(
+                semanticModel.GetDeclaredSymbol(local));
+
+            Verify(localSymbol.ToDisplayParts(SymbolDisplayFormat.TestFormat),
+                "void Local()",
+                SymbolDisplayPartKind.Keyword, // void
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.MethodName, // Local
+                SymbolDisplayPartKind.Punctuation, // (
+                SymbolDisplayPartKind.Punctuation); // )
+        }
+
+        [Fact]
+        [CompilerTrait(CompilerFeature.LocalFunctions)]
+        public void LocalFunction2()
+        {
+            var srcTree = SyntaxFactory.ParseSyntaxTree(@"
+using System.Threading.Tasks;
+class C
+{
+    void M()
+    {
+        async unsafe Task<int> Local(ref int* x, out char? c)
+        {
+        }
+    }
+}");
+            var root = srcTree.GetRoot();
+            var comp = CreateCompilationWithMscorlib45(new[] { srcTree });
+
+            var semanticModel = comp.GetSemanticModel(comp.SyntaxTrees.Single());
+            var local = root.DescendantNodes()
+                .Where(n => n.Kind() == SyntaxKind.LocalFunctionStatement)
+                .Single();
+            var localSymbol = Assert.IsType<LocalFunctionSymbol>(
+                semanticModel.GetDeclaredSymbol(local));
+
+            Verify(localSymbol.ToDisplayParts(SymbolDisplayFormat.TestFormat),
+                "System.Threading.Tasks.Task<System.Int32> Local(ref System.Int32* x, out System.Char? c)",
+                SymbolDisplayPartKind.NamespaceName, // System
+                SymbolDisplayPartKind.Punctuation, // .
+                SymbolDisplayPartKind.NamespaceName, // Threading
+                SymbolDisplayPartKind.Punctuation, // .
+                SymbolDisplayPartKind.NamespaceName, // Tasks
+                SymbolDisplayPartKind.Punctuation, // .
+                SymbolDisplayPartKind.ClassName, // Task
+                SymbolDisplayPartKind.Punctuation, // <
+                SymbolDisplayPartKind.NamespaceName, // System
+                SymbolDisplayPartKind.Punctuation, // .
+                SymbolDisplayPartKind.StructName, // Int32
+                SymbolDisplayPartKind.Punctuation, // >
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.MethodName, // Local
+                SymbolDisplayPartKind.Punctuation, // (
+                SymbolDisplayPartKind.Keyword, // ref
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.NamespaceName, // System
+                SymbolDisplayPartKind.Punctuation, // .
+                SymbolDisplayPartKind.StructName, // Int32
+                SymbolDisplayPartKind.Punctuation, // *
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName, // x
+                SymbolDisplayPartKind.Punctuation, // ,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword, // out
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.NamespaceName, // System
+                SymbolDisplayPartKind.Punctuation, // .
+                SymbolDisplayPartKind.StructName, // Char
+                SymbolDisplayPartKind.Punctuation, // ?
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName, // c
+                SymbolDisplayPartKind.Punctuation); // )
+        }
     }
 }

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs

@@ -9036,5 +9036,46 @@ void M()
     }
 }", "C");
         }
+
+        [WorkItem(14163, "https://github.com/dotnet/roslyn/issues/14163")]
+        [Fact]
+        [Trait(Traits.Feature, Traits.Features.Completion)]
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.LocalFunctions)]
+        public async Task LocalFunctionDescription()
+        {
+            await VerifyItemExistsAsync(@"
+class C
+{
+    void M()
+    {
+        void Local() { }
+        
+        $$
+    }
+}", "Local", "void Local()");
+        }
+
+        [WorkItem(14163, "https://github.com/dotnet/roslyn/issues/14163")]
+        [Fact]
+        [Trait(Traits.Feature, Traits.Features.Completion)]
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.LocalFunctions)]
+        public async Task LocalFunctionDescription2()
+        {
+            await VerifyItemExistsAsync(@"
+using System;
+class C
+{
+    class var { }
+    void M()
+    {
+        Action<int> Local(string x, ref var @class, params Func<int, string> f)
+        {
+            return () => 0;
+        }
+
+        $$
+    }
+}", "Local", "Action<int> Local(string x, ref var @class, params Func<int, string> f)");
+        }
     }
 }
\ No newline at end of file

src/Workspaces/Core/Portable/SymbolKey/SymbolKey.SymbolKeyWriter.cs

@@ -384,20 +384,30 @@ public override object VisitMethod(IMethodSymbol methodSymbol)
                     WriteType(SymbolKeyType.ConstructedMethod);
                     ConstructedMethodSymbolKey.Create(methodSymbol, this);
                 }
-                else if (methodSymbol.MethodKind == MethodKind.ReducedExtension)
-                {
-                    WriteType(SymbolKeyType.ReducedExtensionMethod);
-                    ReducedExtensionMethodSymbolKey.Create(methodSymbol, this);
-                }
-                else if (methodSymbol.MethodKind == MethodKind.AnonymousFunction)
-                {
-                    WriteType(SymbolKeyType.AnonymousFunctionOrDelegate);
-                    AnonymousFunctionOrDelegateSymbolKey.Create(methodSymbol, this);
-                }
                 else
                 {
-                    WriteType(SymbolKeyType.Method);
-                    MethodSymbolKey.Create(methodSymbol, this);
+                    switch (methodSymbol.MethodKind)
+                    {
+                        case MethodKind.ReducedExtension:
+                            WriteType(SymbolKeyType.ReducedExtensionMethod);
+                            ReducedExtensionMethodSymbolKey.Create(methodSymbol, this);
+                            break;
+
+                        case MethodKind.AnonymousFunction:
+                            WriteType(SymbolKeyType.AnonymousFunctionOrDelegate);
+                            AnonymousFunctionOrDelegateSymbolKey.Create(methodSymbol, this);
+                            break;
+
+                        case MethodKind.LocalFunction:
+                            WriteType(SymbolKeyType.BodyLevel);
+                            BodyLevelSymbolKey.Create(methodSymbol, this);
+                            break;
+
+                        default:
+                            WriteType(SymbolKeyType.Method);
+                            MethodSymbolKey.Create(methodSymbol, this);
+                            break;
+                    }
                 }
 
                 return null;