Extensions: xml docs

Author: jcouv

src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs

@@ -1213,7 +1213,7 @@ public override Binder VisitXmlNameAttribute(XmlNameAttributeSyntax parent)
                         {
                             case XmlNameAttributeElementKind.Parameter:
                             case XmlNameAttributeElementKind.ParameterReference:
-                                result = GetParameterNameAttributeValueBinder(memberSyntax, result);
+                                result = GetParameterNameAttributeValueBinder(memberSyntax, isParamRef: elementKind == XmlNameAttributeElementKind.ParameterReference, nextBinder: result);
                                 break;
                             case XmlNameAttributeElementKind.TypeParameter:
                                 result = GetTypeParameterNameAttributeValueBinder(memberSyntax, includeContainingSymbols: false, nextBinder: result);
@@ -1234,16 +1234,28 @@ public override Binder VisitXmlNameAttribute(XmlNameAttributeSyntax parent)
             /// We're in a <param> or <paramref> element, so we want a binder that can see
             /// the parameters of the associated member and nothing else.
             /// </summary>
-            private Binder GetParameterNameAttributeValueBinder(MemberDeclarationSyntax memberSyntax, Binder nextBinder)
+            private Binder GetParameterNameAttributeValueBinder(MemberDeclarationSyntax memberSyntax, bool isParamRef, Binder nextBinder)
             {
                 if (memberSyntax is BaseMethodDeclarationSyntax { ParameterList: { ParameterCount: > 0 } } baseMethodDeclSyntax)
                 {
                     Binder outerBinder = VisitCore(memberSyntax.Parent);
                     MethodSymbol method = GetMethodSymbol(baseMethodDeclSyntax, outerBinder);
+
+                    if (isParamRef && method.TryGetInstanceExtensionParameter(out var _))
+                    {
+                        nextBinder = new WithExtensionParameterBinder(method.ContainingType, nextBinder);
+                    }
+
                     return new WithParametersBinder(method.Parameters, nextBinder);
                 }
-
-                if (memberSyntax is TypeDeclarationSyntax { ParameterList: { ParameterCount: > 0 } } typeDeclaration)
+                else if (memberSyntax is ExtensionDeclarationSyntax extensionDeclaration)
+                {
+                    _ = extensionDeclaration.ParameterList;
+                    Binder outerBinder = VisitCore(memberSyntax);
+                    SourceNamedTypeSymbol type = ((NamespaceOrTypeSymbol)outerBinder.ContainingMemberOrLambda).GetSourceTypeMember((TypeDeclarationSyntax)memberSyntax);
+                    return new WithExtensionParameterBinder(type, nextBinder);
+                }
+                else if (memberSyntax is TypeDeclarationSyntax { ParameterList: { ParameterCount: > 0 } } typeDeclaration)
                 {
                     _ = typeDeclaration.ParameterList;
                     Binder outerBinder = VisitCore(memberSyntax);
@@ -1268,6 +1280,11 @@ private Binder GetParameterNameAttributeValueBinder(MemberDeclarationSyntax memb
 
                     ImmutableArray<ParameterSymbol> parameters = property.Parameters;
 
+                    if (isParamRef && property.TryGetInstanceExtensionParameter(out var _))
+                    {
+                        nextBinder = new WithExtensionParameterBinder(property.ContainingType, nextBinder);
+                    }
+
                     // BREAK: Dev11 also allows "value" for readonly properties, but that doesn't
                     // make sense and we don't have a symbol.
                     if ((object)property.SetMethod != null)
@@ -1278,8 +1295,10 @@ private Binder GetParameterNameAttributeValueBinder(MemberDeclarationSyntax memb
 
                     if (parameters.Any())
                     {
-                        return new WithParametersBinder(parameters, nextBinder);
+                        nextBinder = new WithParametersBinder(parameters, nextBinder);
                     }
+
+                    return nextBinder;
                 }
                 else if (memberKind == SyntaxKind.DelegateDeclaration)
                 {

src/Compilers/CSharp/Portable/Compiler/DocumentationCommentCompiler.cs

@@ -237,6 +237,29 @@ public override void VisitNamedType(NamedTypeSymbol symbol)
         }
 
 #nullable enable
+        public override void VisitMethod(MethodSymbol symbol)
+        {
+            if (symbol is SourceExtensionImplementationMethodSymbol implementation)
+            {
+                var symbolForDocComment = implementation.UnderlyingMethod is SourcePropertyAccessorSymbol accessorSymbol
+                    ? accessorSymbol.AssociatedSymbol
+                    : implementation.UnderlyingMethod;
+
+                if (symbolForDocComment.GetDocumentationCommentXml(preferredCulture: null, _processIncludes, _cancellationToken).IsEmpty())
+                {
+                    return;
+                }
+
+                WriteLine("<member name=\"{0}\">", symbol.GetDocumentationCommentId());
+                Indent();
+                WriteLine("<inheritdoc cref=\"{0}\"/>", symbolForDocComment.GetDocumentationCommentId());
+                Unindent();
+                WriteLine("</member>");
+                return;
+            }
+
+            DefaultVisit(symbol);
+        }
 
         /// <summary>
         /// Compile documentation comments on the symbol and write them to the stream if one is provided.

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.Name);
+                builder.Append(symbol.IsExtension ? symbol.ExtensionName : symbol.Name);
 
                 if (symbol.Arity != 0)
                 {

src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs

@@ -11,6 +11,8 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     internal sealed class SourceExtensionImplementationMethodSymbol : RewrittenMethodSymbol // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Do we need to implement ISynthesizedMethodBodyImplementationSymbol?
     {
+        private string? lazyDocComment;
+
         public SourceExtensionImplementationMethodSymbol(MethodSymbol sourceMethod)
             : base(sourceMethod, TypeMap.Empty, sourceMethod.ContainingType.TypeParameters.Concat(sourceMethod.TypeParameters))
         {
@@ -131,6 +133,11 @@ internal override int TryGetOverloadResolutionPriority()
             return UnderlyingMethod.TryGetOverloadResolutionPriority();
         }
 
+        public override string GetDocumentationCommentXml(CultureInfo? preferredCulture = null, bool expandIncludes = false, CancellationToken cancellationToken = default)
+        {
+            return SourceDocumentationCommentUtils.GetAndCacheDocumentationComment(this, expandIncludes, ref lazyDocComment);
+        }
+
         private sealed class ExtensionMetadataMethodParameterSymbol : RewrittenMethodParameterSymbol
         {
             public ExtensionMetadataMethodParameterSymbol(SourceExtensionImplementationMethodSymbol containingMethod, ParameterSymbol sourceParameter) :