Extensions: fix issue with paramref (#81269)

Fixes #81217

Author: jcouv

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

@@ -1175,9 +1175,11 @@ public override Binder VisitXmlNameAttribute(XmlNameAttributeSyntax parent)
                 switch (elementKind)
                 {
                     case XmlNameAttributeElementKind.Parameter:
-                    case XmlNameAttributeElementKind.ParameterReference:
                         extraInfo = NodeUsage.DocumentationCommentParameter;
                         break;
+                    case XmlNameAttributeElementKind.ParameterReference:
+                        extraInfo = NodeUsage.DocumentationCommentParameterReference;
+                        break;
                     case XmlNameAttributeElementKind.TypeParameter:
                         extraInfo = NodeUsage.DocumentationCommentTypeParameter;
                         break;
@@ -1236,7 +1238,7 @@ public override Binder VisitXmlNameAttribute(XmlNameAttributeSyntax parent)
             /// </summary>
             private Binder GetParameterNameAttributeValueBinder(MemberDeclarationSyntax memberSyntax, bool isParamRef, Binder nextBinder)
             {
-                if (memberSyntax is BaseMethodDeclarationSyntax { ParameterList: { ParameterCount: > 0 } } baseMethodDeclSyntax)
+                if (memberSyntax is BaseMethodDeclarationSyntax baseMethodDeclSyntax)
                 {
                     Binder outerBinder = VisitCore(memberSyntax.Parent);
                     MethodSymbol method = GetMethodSymbol(baseMethodDeclSyntax, outerBinder);
@@ -1246,7 +1248,14 @@ private Binder GetParameterNameAttributeValueBinder(MemberDeclarationSyntax memb
                         nextBinder = new WithExtensionParameterBinder(method.ContainingType, nextBinder);
                     }
 
-                    return new WithParametersBinder(method.Parameters, nextBinder);
+                    if (method.ParameterCount > 0)
+                    {
+                        return new WithParametersBinder(method.Parameters, nextBinder);
+                    }
+                    else
+                    {
+                        return nextBinder;
+                    }
                 }
                 else if (memberSyntax is ExtensionBlockDeclarationSyntax extensionDeclaration)
                 {

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

@@ -27,8 +27,9 @@ internal enum NodeUsage : byte
             CompilationUnitScriptUsings = 1 << 2,
 
             DocumentationCommentParameter = 1 << 0,
-            DocumentationCommentTypeParameter = 1 << 1,
-            DocumentationCommentTypeParameterReference = 1 << 2,
+            DocumentationCommentParameterReference = 1 << 1,
+            DocumentationCommentTypeParameter = 1 << 2,
+            DocumentationCommentTypeParameterReference = 1 << 3,
 
             CrefParameterOrReturnType = 1 << 0,
         }

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs

@@ -51371,6 +51371,10 @@ static class E
             // (9,30): warning CS1573: Parameter 'o2' has no matching param tag in the XML comment for 'E.extension(object).M(object)' (but other parameters do)
             //         public void M(object o2) => throw null!;
             Diagnostic(ErrorCode.WRN_MissingParamTag, "o2").WithArguments("o2", "E.extension(object).M(object)").WithLocation(9, 30));
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(o, null)"], PrintXmlNameSymbols(tree, model));
     }
 
     [Fact]
@@ -51391,6 +51395,10 @@ static class E
 """;
         var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments);
         comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(o, System.Object o)"], PrintXmlNameSymbols(tree, model));
     }
 
     [Fact]
@@ -51509,7 +51517,7 @@ static class E
     /// <summary>Summary for extension block</summary>
     extension<T>(T t)
     {
-        /// <summary>Summary for M</summary>
+        /// <summary>Summary for M <typeparamref name="T"/> </summary>
         /// <typeparam name="T">Description for T</typeparam>
         public static void M<U>(U u) => throw null!;
     }
@@ -51735,6 +51743,86 @@ public static int P4 { set { } }
             Diagnostic(ErrorCode.WRN_UnmatchedParamRefTag, "value").WithArguments("value", "E.extension(object).P2").WithLocation(8, 53));
     }
 
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/81217")]
+    public void XmlDoc_ParamRef_04()
+    {
+        // No parameter on method
+        var src = """
+static class E
+{
+    extension(object o)
+    {
+        /// <returns><paramref name="o"/></returns>
+        public object M() => o;
+    }
+}
+""";
+        var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments,
+            assemblyName: "paramref_04");
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(o, System.Object o)"], PrintXmlNameSymbols(tree, model));
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/81217")]
+    public void XmlDoc_ParamRef_05()
+    {
+        // One parameter on method
+        var src = """
+static class E
+{
+    extension(object o)
+    {
+        /// <summary><paramref name="o"/></summary>
+        public object M(int i) => o;
+    }
+}
+""";
+        var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments,
+            assemblyName: "paramref_05");
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(o, System.Object o)"], PrintXmlNameSymbols(tree, model));
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/81217")]
+    public void XmlDoc_ParamRef_06()
+    {
+        // <params> preceeds <paramref>
+        var src = """
+using System;
+
+static class E
+{
+    /// <param name="value">Param value</param>
+    extension(ReadOnlySpan<char> value)
+    {
+        /// <param name="n">Param n</param>
+        /// <param name="delimiter">Param delimiter</param>
+        /// <returns><paramref name="value"/></returns>
+        public ReadOnlySpan<char> GetNthDelimitedItem(int n, ReadOnlySpan<char> delimiter) => throw null !;
+    }
+}
+""";
+        var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments,
+            assemblyName: "paramref_06", targetFramework: TargetFramework.Net100);
+
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual([
+            "(value, System.ReadOnlySpan<System.Char> value)",
+            "(n, System.Int32 n)",
+            "(delimiter, System.ReadOnlySpan<System.Char> delimiter)",
+            "(value, System.ReadOnlySpan<System.Char> value)"],
+            PrintXmlNameSymbols(tree, model));
+    }
+
     [Fact]
     public void XmlDoc_TypeParamRef_01()
     {
@@ -51791,6 +51879,73 @@ static class E
         AssertEx.SequenceEqual(["(T, null)", "(T, T)"], PrintXmlNameSymbols(tree, model));
     }
 
+    [Fact]
+    public void XmlDoc_TypeParamRef_03()
+    {
+        var src = """
+static class E
+{
+    /// <typeparam name="T1"/>
+    extension<T1>(int)
+    {
+        /// <summary><typeparamref name="T1"/></summary>
+        /// <typeparam name="T2"/>
+        public static void M<T2>() => throw null!;
+    }
+}
+""";
+        var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments);
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(T1, T1)", "(T1, T1)", "(T2, T2)"], PrintXmlNameSymbols(tree, model));
+    }
+
+    [Fact]
+    public void XmlDoc_TypeParamRef_04()
+    {
+        var src = """
+static class E
+{
+    /// <typeparam name="T1"/>
+    extension<T1>(int)
+    {
+        /// <summary><typeparamref name="T1"/></summary>
+        public static void M() => throw null!;
+    }
+}
+""";
+        var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments);
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(T1, T1)", "(T1, T1)"], PrintXmlNameSymbols(tree, model));
+    }
+
+    [Fact]
+    public void XmlDoc_TypeParamRef_05()
+    {
+        var src = """
+static class E
+{
+    /// <typeparam name="T1"/>
+    extension<T1>(T1)
+    {
+        /// <summary><typeparamref name="T1"/></summary>
+        public static int Property => throw null!;
+    }
+}
+""";
+        var comp = CreateCompilation(src, parseOptions: TestOptions.RegularPreviewWithDocumentationComments);
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.Single();
+        var model = comp.GetSemanticModel(tree);
+        AssertEx.SequenceEqual(["(T1, T1)", "(T1, T1)"], PrintXmlNameSymbols(tree, model));
+    }
+
     [Fact]
     public void AnalyzerActions_01()
     {