Extensions: allow cref references to extension members

Author: jcouv

src/Compilers/CSharp/Portable/Binder/Binder_Crefs.cs

@@ -35,6 +35,7 @@ private ImmutableArray<Symbol> BindCrefInternal(CrefSyntax syntax, out Symbol? a
                 case SyntaxKind.IndexerMemberCref:
                 case SyntaxKind.OperatorMemberCref:
                 case SyntaxKind.ConversionOperatorMemberCref:
+                case SyntaxKind.ExtensionMemberCref:
                     return BindMemberCref((MemberCrefSyntax)syntax, containerOpt: null, ambiguityWinner: out ambiguityWinner, diagnostics: diagnostics);
                 default:
                     throw ExceptionUtilities.UnexpectedValue(syntax.Kind());
@@ -125,6 +126,9 @@ private ImmutableArray<Symbol> BindMemberCref(MemberCrefSyntax syntax, Namespace
                 case SyntaxKind.ConversionOperatorMemberCref:
                     result = BindConversionOperatorMemberCref((ConversionOperatorMemberCrefSyntax)syntax, containerOpt, out ambiguityWinner, diagnostics);
                     break;
+                case SyntaxKind.ExtensionMemberCref:
+                    result = BindExtensionMemberCref((ExtensionMemberCrefSyntax)syntax, containerOpt, out ambiguityWinner, diagnostics);
+                    break;
                 default:
                     throw ExceptionUtilities.UnexpectedValue(syntax.Kind());
             }
@@ -216,6 +220,137 @@ private ImmutableArray<Symbol> BindIndexerMemberCref(IndexerMemberCrefSyntax syn
                 diagnostics: diagnostics);
         }
 
+        private ImmutableArray<Symbol> BindExtensionMemberCref(ExtensionMemberCrefSyntax syntax, NamespaceOrTypeSymbol? containerOpt, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics)
+        {
+            if (containerOpt is not NamedTypeSymbol namedContainer)
+            {
+                ambiguityWinner = null;
+                return ImmutableArray<Symbol>.Empty;
+            }
+
+            ImmutableArray<Symbol> sortedSymbols = default;
+            int arity = 0;
+            TypeArgumentListSyntax? typeArgumentListSyntax = null;
+            CrefParameterListSyntax? parameters = null;
+
+            if (syntax.Member is NameMemberCrefSyntax { Name: SimpleNameSyntax simpleName } nameMember)
+            {
+                arity = simpleName.Arity;
+                typeArgumentListSyntax = simpleName is GenericNameSyntax genericName ? genericName.TypeArgumentList : null;
+                parameters = nameMember.Parameters;
+
+                TypeArgumentListSyntax? extensionTypeArguments = syntax.TypeArgumentList;
+                int extensionArity = extensionTypeArguments?.Arguments.Count ?? 0;
+                sortedSymbols = computeSortedAndFilteredCrefExtensionMembers(namedContainer, simpleName.Identifier.ValueText, extensionArity, arity, extensionTypeArguments, diagnostics, syntax);
+            }
+
+            if (sortedSymbols.IsDefaultOrEmpty)
+            {
+                ambiguityWinner = null;
+                return [];
+            }
+
+            Debug.Assert(sortedSymbols.All(s => s.GetIsNewExtensionMember()));
+
+            return ProcessCrefMemberLookupResults(sortedSymbols, arity, syntax, typeArgumentListSyntax, parameters, out ambiguityWinner, diagnostics);
+
+            ImmutableArray<Symbol> computeSortedAndFilteredCrefExtensionMembers(NamedTypeSymbol container, string name, int extensionArity, int arity, TypeArgumentListSyntax? extensionTypeArguments, BindingDiagnosticBag diagnostics, ExtensionMemberCrefSyntax syntax)
+            {
+                Debug.Assert(name is not null);
+
+                LookupOptions options = LookupOptions.AllMethodsOnArityZero | LookupOptions.MustNotBeParameter;
+                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = this.GetNewCompoundUseSiteInfo(diagnostics);
+                ArrayBuilder<Symbol>? sortedSymbolsBuilder = null;
+
+                foreach (var nested in container.GetTypeMembers())
+                {
+                    if (!nested.IsExtension || nested.Arity != extensionArity || nested.ExtensionParameter is null)
+                    {
+                        continue;
+                    }
+
+                    var constructedNested = (NamedTypeSymbol)ConstructWithCrefTypeParameters(extensionArity, extensionTypeArguments, nested);
+
+                    var candidateExtensionSignature = new SignatureOnlyMethodSymbol(
+                         methodKind: MethodKind.Ordinary,
+                         typeParameters: IndexedTypeParameterSymbol.TakeSymbols(constructedNested.Arity),
+                         parameters: [constructedNested.ExtensionParameter],
+                         callingConvention: Cci.CallingConvention.Default,
+                         // These are ignored by this specific MemberSignatureComparer.
+                         containingType: null,
+                         name: null,
+                         refKind: RefKind.None,
+                         isInitOnly: false,
+                         isStatic: false,
+                         returnType: default,
+                         refCustomModifiers: [],
+                         explicitInterfaceImplementations: []);
+
+                    ImmutableArray<ParameterSymbol> extensionParameterSymbols = syntax.Parameters is { } extensionParameterListSyntax ? BindCrefParameters(extensionParameterListSyntax, diagnostics) : default;
+
+                    var providedExtensionSignature = new SignatureOnlyMethodSymbol(
+                         methodKind: MethodKind.Ordinary,
+                         typeParameters: IndexedTypeParameterSymbol.TakeSymbols(constructedNested.Arity),
+                         parameters: extensionParameterSymbols,
+                         callingConvention: Cci.CallingConvention.Default,
+                         // These are ignored by this specific MemberSignatureComparer.
+                         containingType: null,
+                         name: null,
+                         refKind: RefKind.None,
+                         isInitOnly: false,
+                         isStatic: false,
+                         returnType: default,
+                         refCustomModifiers: [],
+                         explicitInterfaceImplementations: []);
+
+                    if (!MemberSignatureComparer.CrefComparer.Equals(candidateExtensionSignature, providedExtensionSignature))
+                    {
+                        continue;
+                    }
+
+                    var candidates = constructedNested.GetMembers(name);
+
+                    foreach (var candidate in candidates)
+                    {
+                        if (!SourceMemberContainerTypeSymbol.IsAllowedExtensionMember(candidate))
+                        {
+                            continue;
+                        }
+
+                        if (arity != 0 && candidate.GetArity() != arity)
+                        {
+                            continue;
+                        }
+
+                        // Note: we bypass the arity check here, as it would check for total arity (extension + member arity)
+                        SingleLookupResult result = this.CheckViability(candidate, arity: 0, options, accessThroughType: null, diagnose: true, useSiteInfo: ref useSiteInfo);
+
+                        if (result.Kind == LookupResultKind.Viable)
+                        {
+                            sortedSymbolsBuilder ??= ArrayBuilder<Symbol>.GetInstance();
+                            sortedSymbolsBuilder.Add(result.Symbol);
+                        }
+                    }
+                }
+
+                diagnostics.Add(syntax, useSiteInfo);
+
+                if (sortedSymbolsBuilder is null)
+                {
+                    return ImmutableArray<Symbol>.Empty;
+                }
+
+                // Since we resolve ambiguities by just picking the first symbol we encounter,
+                // the order of the symbols matters for repeatability.
+                if (sortedSymbolsBuilder.Count > 1)
+                {
+                    sortedSymbolsBuilder.Sort(ConsistentSymbolOrder.Instance);
+                }
+
+                return sortedSymbolsBuilder.ToImmutableAndFree();
+            }
+        }
+
         // NOTE: not guaranteed to be a method (e.g. class op_Addition)
         // NOTE: constructor fallback logic applies
         private ImmutableArray<Symbol> BindOperatorMemberCref(OperatorMemberCrefSyntax syntax, NamespaceOrTypeSymbol? containerOpt, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics)

src/Compilers/CSharp/Portable/Binder/WithCrefTypeParametersBinder.cs

@@ -90,7 +90,7 @@ private void AddTypeParameters(TypeSyntax typeSyntax, MultiDictionary<string, Ty
                     AddTypeParameters(qualifiedNameSyntax.Left, map);
                     break;
                 case SyntaxKind.GenericName:
-                    AddTypeParameters((GenericNameSyntax)typeSyntax, map);
+                    AddTypeParameters(((GenericNameSyntax)typeSyntax).TypeArgumentList.Arguments, map);
                     break;
                 case SyntaxKind.IdentifierName:
                 case SyntaxKind.PredefinedType:
@@ -103,20 +103,28 @@ private void AddTypeParameters(TypeSyntax typeSyntax, MultiDictionary<string, Ty
         private void AddTypeParameters(MemberCrefSyntax memberSyntax, MultiDictionary<string, TypeParameterSymbol> map)
         {
             // Other members have arity 0.
-            if (memberSyntax.Kind() == SyntaxKind.NameMemberCref)
+            if (memberSyntax is NameMemberCrefSyntax nameMemberCref)
             {
-                AddTypeParameters(((NameMemberCrefSyntax)memberSyntax).Name, map);
+                AddTypeParameters(nameMemberCref.Name, map);
+            }
+            else if (memberSyntax is ExtensionMemberCrefSyntax extensionCref)
+            {
+                if (extensionCref.TypeArgumentList is { } extensionTypeArguments)
+                {
+                    AddTypeParameters(extensionTypeArguments.Arguments, map);
+                }
+
+                AddTypeParameters(extensionCref.Member, map);
             }
         }
 
-        private static void AddTypeParameters(GenericNameSyntax genericNameSyntax, MultiDictionary<string, TypeParameterSymbol> map)
+        private static void AddTypeParameters(SeparatedSyntaxList<TypeSyntax> typeArguments, MultiDictionary<string, TypeParameterSymbol> map)
         {
             // NOTE: Dev11 does not warn about duplication, it just matches parameter types to the
             // *last* type parameter with the same name.  That's why we're iterating backwards and
             // skipping subsequent symbols with the same name.  This can result in some surprising
             // behavior.  For example, both 'T's in "A<T>.B<T>" bind to the second implicitly
             // declared type parameter.
-            SeparatedSyntaxList<TypeSyntax> typeArguments = genericNameSyntax.TypeArgumentList.Arguments;
             for (int i = typeArguments.Count - 1; i >= 0; i--)
             {
                 // Other types (non-identifiers) are allowed in error scenarios, but they do not introduce new 

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -357,6 +357,8 @@ internal static bool HasParameterList(CrefSyntax crefSyntax)
                     return ((OperatorMemberCrefSyntax)crefSyntax).Parameters != null;
                 case SyntaxKind.ConversionOperatorMemberCref:
                     return ((ConversionOperatorMemberCrefSyntax)crefSyntax).Parameters != null;
+                case SyntaxKind.ExtensionMemberCref:
+                    return HasParameterList(((ExtensionMemberCrefSyntax)crefSyntax).Member);
             }
 
             return false;
@@ -379,7 +381,7 @@ private static SymbolInfo GetCrefSymbolInfo(OneOrMany<Symbol> symbols, SymbolInf
 
                     LookupResultKind resultKind = LookupResultKind.Ambiguous;
 
-                    // The boundary between Ambiguous and OverloadResolutionFailure is let clear-cut for crefs.
+                    // The boundary between Ambiguous and OverloadResolutionFailure is less clear-cut for crefs.
                     // We'll say that overload resolution failed if the syntax has a parameter list and if
                     // all of the candidates have the same kind.
                     SymbolKind firstCandidateKind = symbols[0].Kind;

src/Compilers/CSharp/Portable/DocumentationComments/DocumentationCommentIDVisitor.PartVisitor.cs

@@ -181,7 +181,7 @@ public override object VisitNamedType(NamedTypeSymbol symbol, StringBuilder buil
                     builder.Append('.');
                 }
 
-                builder.Append(symbol.IsExtension ? symbol.ExtensionName : symbol.Name);
+                builder.Append(symbol.IsExtension ? escape(symbol.ExtensionName) : symbol.Name);
 
                 if (symbol.Arity != 0)
                 {
@@ -215,6 +215,12 @@ public override object VisitNamedType(NamedTypeSymbol symbol, StringBuilder buil
                 }
 
                 return null;
+
+                static string escape(string s)
+                {
+                    Debug.Assert(!s.Contains("&"));
+                    return s.Replace("<", "&lt;").Replace(">", "&gt;");
+                }
             }
 
             public override object VisitPointerType(PointerTypeSymbol symbol, StringBuilder builder)