Add FAR support for modern-extension parameters (#77503)

Blocked on #77502
Relates to test plan #76130

Author: CyrusNajmabadi

src/EditorFeatures/Test2/FindReferences/FindReferencesTests.ExtensionSymbols.vb

@@ -99,6 +99,56 @@ public static class MyExtension
         public int {|Definition:ExtensionProp|} => 0;
     }
 }
+]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        Public Async Function TestModernExtensionMethodParameter1(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true" LanguageVersion="preview">
+        <Document><![CDATA[
+using System;
+ 
+public static class MyExtension
+{
+    extension(string $${|Definition:s|})
+    {
+        public int ExtensionMethod()
+        {
+            return [|s|].Length;
+        }
+    }
+}
+]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        Public Async Function TestModernExtensionMethodTypeParameter1(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true" LanguageVersion="preview">
+        <Document><![CDATA[
+using System;
+ 
+public static class MyExtension
+{
+    extension<$${|Definition:T|}>(string s)
+    {
+        public int ExtensionMethod([|T|] t)
+        {
+            return s.Length;
+        }
+    }
+}
 ]]>
         </Document>
     </Project>

src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/TypeParameterSymbolReferenceFinder.cs

@@ -32,6 +32,8 @@ protected override Task DetermineDocumentsToSearchAsync<TData>(
         // parameter has a different name in different parts that we won't find it.  However,
         // this only happens in error situations.  It is not legal in C# to use a different
         // name for a type parameter in different parts.
-        return FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name, symbol.ContainingType.Name);
+        return symbol.ContainingType is { IsExtension: true, ContainingType.Name: var staticClassName }
+            ? FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name, staticClassName)
+            : FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name, symbol.ContainingType.Name);
     }
 }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/SymbolKey/SymbolKey.NamedTypeSymbolKey.cs

@@ -2,9 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Immutable;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis;
 
@@ -19,21 +17,16 @@ public sealed override void Create(INamedTypeSymbol symbol, SymbolKeyWriter visi
             visitor.WriteSymbolKey(symbol.ContainingSymbol);
             visitor.WriteString(symbol.Name);
             visitor.WriteInteger(symbol.Arity);
-            visitor.WriteString(symbol.IsFileLocal
-                ? symbol.DeclaringSyntaxReferences[0].SyntaxTree.FilePath
-                : null);
+            // Include the metadata name for extensions.  We need this to uniquely find it when resolving.
+            visitor.WriteString(symbol.IsExtension ? symbol.MetadataName : null);
+            // Include the file path for 'file-local' types.  We need this to uniquely find it when resolving.
+            visitor.WriteString(symbol.IsFileLocal ? symbol.DeclaringSyntaxReferences[0].SyntaxTree.FilePath : null);
             visitor.WriteBoolean(symbol.IsUnboundGenericType);
             visitor.WriteBoolean(symbol.IsNativeIntegerType);
             visitor.WriteBoolean(symbol.SpecialType == SpecialType.System_IntPtr);
 
-            if (!symbol.Equals(symbol.ConstructedFrom) && !symbol.IsUnboundGenericType)
-            {
-                visitor.WriteSymbolKeyArray(symbol.TypeArguments);
-            }
-            else
-            {
-                visitor.WriteSymbolKeyArray(ImmutableArray<ITypeSymbol>.Empty);
-            }
+            visitor.WriteSymbolKeyArray(
+                symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments);
         }
 
         protected sealed override SymbolKeyResolution Resolve(
@@ -42,6 +35,7 @@ protected sealed override SymbolKeyResolution Resolve(
             var containingSymbolResolution = reader.ReadSymbolKey(contextualSymbol?.ContainingSymbol, out var containingSymbolFailureReason);
             var name = reader.ReadRequiredString();
             var arity = reader.ReadInteger();
+            var extensionMetadataName = reader.ReadString();
             var filePath = reader.ReadString();
             var isUnboundGenericType = reader.ReadBoolean();
             var isNativeIntegerType = reader.ReadBoolean();
@@ -73,7 +67,8 @@ protected sealed override SymbolKeyResolution Resolve(
 
             var normalResolution = ResolveNormalNamedType(
                 containingSymbolResolution, containingSymbolFailureReason,
-                name, arity, filePath, isUnboundGenericType, typeArgumentsArray,
+                name, extensionMetadataName, arity, filePath,
+                isUnboundGenericType, typeArgumentsArray,
                 out failureReason);
 
             if (normalResolution.SymbolCount > 0)
@@ -140,10 +135,11 @@ private static SymbolKeyResolution ResolveNormalNamedType(
             SymbolKeyResolution containingSymbolResolution,
             string? containingSymbolFailureReason,
             string name,
+            string? extensionMetadataName,
             int arity,
             string? filePath,
             bool isUnboundGenericType,
-            ITypeSymbol[] typeArgumentsArray,
+            ITypeSymbol[] typeArguments,
             out string? failureReason)
         {
             if (containingSymbolFailureReason != null)
@@ -154,43 +150,46 @@ private static SymbolKeyResolution ResolveNormalNamedType(
 
             using var result = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
             foreach (var nsOrType in containingSymbolResolution.OfType<INamespaceOrTypeSymbol>())
-            {
-                Resolve(
-                    result, nsOrType, name, arity, filePath,
-                    isUnboundGenericType, typeArgumentsArray);
-            }
+                Resolve(nsOrType, result);
 
             return CreateResolution(result, $"({nameof(NamedTypeSymbolKey)} failed)", out failureReason);
-        }
 
-        private static void Resolve(
-            PooledArrayBuilder<INamedTypeSymbol> result,
-            INamespaceOrTypeSymbol container,
-            string name,
-            int arity,
-            string? filePath,
-            bool isUnboundGenericType,
-            ITypeSymbol[] typeArguments)
-        {
-            foreach (var type in container.GetTypeMembers(name, arity))
+            void Resolve(
+                INamespaceOrTypeSymbol container,
+                PooledArrayBuilder<INamedTypeSymbol> result)
             {
-                // if this is a file-local type, then only resolve to a file-local type from this same file
-                if (filePath != null)
+                if (extensionMetadataName != null)
                 {
-                    if (!type.IsFileLocal ||
-                        // note: if we found 'IsFile' returned true, we can assume DeclaringSyntaxReferences is non-empty.
-                        type.DeclaringSyntaxReferences[0].SyntaxTree.FilePath != filePath)
+                    // Unfortunately, no fast index from metadata name to type, so we have to iterate all nested types.
+                    foreach (var type in container.GetTypeMembers())
                     {
-                        continue;
+                        if (type.MetadataName == extensionMetadataName)
+                            result.AddIfNotNull(Construct(type, isUnboundGenericType, typeArguments));
                     }
                 }
-                else if (type.IsFileLocal)
+                else
                 {
-                    // since this key lacks a file path it can't match against a file-local type
-                    continue;
+                    foreach (var type in container.GetTypeMembers(name, arity))
+                    {
+                        // if this is a file-local type, then only resolve to a file-local type from this same file
+                        if (filePath != null)
+                        {
+                            if (!type.IsFileLocal ||
+                                // note: if we found 'IsFile' returned true, we can assume DeclaringSyntaxReferences is non-empty.
+                                type.DeclaringSyntaxReferences[0].SyntaxTree.FilePath != filePath)
+                            {
+                                continue;
+                            }
+                        }
+                        else if (type.IsFileLocal)
+                        {
+                            // since this key lacks a file path it can't match against a file-local type
+                            continue;
+                        }
+
+                        result.AddIfNotNull(Construct(type, isUnboundGenericType, typeArguments));
+                    }
                 }
-
-                result.AddIfNotNull(Construct(type, isUnboundGenericType, typeArguments));
             }
         }
 

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/SymbolKey/SymbolKey.ParameterSymbolKey.cs

@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
-using System.Diagnostics;
 
 namespace Microsoft.CodeAnalysis;
 
@@ -69,6 +68,9 @@ protected sealed override SymbolKeyResolution Resolve(
                             Resolve(result, reader, metadataName, ordinal, delegateInvoke.Parameters);
                         }
 
+                        break;
+                    case INamedTypeSymbol { IsExtension: true, ExtensionParameter: { } extensionParameter }:
+                        Resolve(result, reader, metadataName, ordinal, [extensionParameter]);
                         break;
                 }
             }