OpenAPI: Fix duplicate xml documentation ids for Generic properties and references

src/OpenApi/gen/Helpers/AssemblyTypeSymbolsVisitor.cs

@@ -43,6 +43,11 @@ public override void VisitNamespace(INamespaceSymbol symbol)
     public override void VisitNamedType(INamedTypeSymbol type)
     {
         _cancellationToken.ThrowIfCancellationRequested();
+        if (type.IsGenericType)
+        {
+            // Because type comments are based on the Unbound generic type, i.e. List`1, we want to use the unbound generic type
+            type = type.ConstructUnboundGenericType();
+        }
 
         if (!IsAccessibleType(type) || !_exportedTypes.Add(type))
         {

src/OpenApi/gen/XmlCommentGenerator.Parser.cs

@@ -110,7 +110,7 @@ internal static string NormalizeDocId(string docId)
         return comments;
     }
 
-    internal static IEnumerable<(string, XmlComment?)> ParseComments(
+    internal static IEnumerable<(string, XmlComment?)> ParseCommentsApplicationAssembly(
         (List<(string, string)> RawComments, Compilation Compilation) input,
         CancellationToken cancellationToken)
     {
@@ -136,6 +136,31 @@ internal static string NormalizeDocId(string docId)
         return comments;
     }
 
+    internal static IEnumerable<(string, XmlComment?)> ParseCommentsReference(
+        (List<(string, string)> RawComments, Compilation Compilation) input,
+        CancellationToken cancellationToken)
+    {
+        var compilation = input.Compilation;
+        var comments = new List<(string, XmlComment?)>();
+        foreach (var (name, value) in input.RawComments)
+        {
+            if (DocumentationCommentId.GetFirstSymbolForDeclarationId(name, compilation) is ISymbol symbol &&
+                // Only include symbols that are accessible from the application assembly.
+                symbol.IsAccessibleType() &&
+                // Skip static classes that are just containers for members with annotations
+                // since they cannot be instantiated.
+                symbol is not INamedTypeSymbol { TypeKind: TypeKind.Class, IsStatic: true })
+            {
+                var parsedComment = XmlComment.Parse(symbol, compilation, value, cancellationToken);
+                if (parsedComment is not null)
+                {
+                    comments.Add((name, parsedComment));
+                }
+            }
+        }
+        return comments;
+    }
+
     internal static bool FilterInvocations(SyntaxNode node, CancellationToken _)
         => node is InvocationExpressionSyntax { Expression: MemberAccessExpressionSyntax { Name.Identifier.ValueText: "AddOpenApi" } };
 

src/OpenApi/gen/XmlCommentGenerator.cs

@@ -24,10 +24,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         // and the target assembly.
         var parsedCommentsFromXmlFile = commentsFromXmlFile
             .Combine(context.CompilationProvider)
-            .Select(ParseComments);
+            .Select(ParseCommentsReference);
         var parsedCommentsFromCompilation = commentsFromTargetAssembly
             .Combine(context.CompilationProvider)
-            .Select(ParseComments);
+            .Select(ParseCommentsApplicationAssembly);
         // Discover AddOpenApi invocations so that we can intercept them with an implicit
         // registration of the transformers for mapping XML doc comments to the OpenAPI file.
         var groupedAddOpenApiInvocations = context.SyntaxProvider

src/OpenApi/test/Microsoft.AspNetCore.OpenApi.SourceGenerators.Tests/XmlCommentDocumentationIdTests.cs

@@ -87,4 +87,84 @@ public void NormalizeDocId_ReturnsExpectedResult(string input, string expected)
         var result = XmlCommentGenerator.NormalizeDocId(input);
         Assert.Equal(expected, result);
     }
-}
+
+    [Fact]
+    public async Task ShouldNotDuplicateDocumentationIds()
+    {
+        var source = """
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenApi();
+
+var app = builder.Build();
+app.MapOpenApi();
+
+app.MapPost("/", (GenericFoo<bool> fooBool) => new Bar());
+
+app.Run();
+
+/// <summary>
+/// Should not be duplicated. <see cref="T" />
+/// </summary>
+public class GenericFoo<T>
+{
+}
+
+public class Bar
+{
+    /// <summary>
+    /// FooString property xml comment.
+    /// </summary>
+    public GenericFoo<string> FooString { get; set; }
+
+    /// <summary>
+    /// FooInt property xml comment.
+    /// </summary>
+    public GenericFoo<int> FooInt { get; set; }
+
+    /// <summary>
+    /// Method with GenericFoo<double> parameter.
+    /// </summary>
+    /// <param name="fooDouble">The GenericFoo of double.</param>
+    public void Test(GenericFoo<double> fooDouble)
+    {
+
+    }
+}
+
+namespace Sample {
+
+    /// <summary>
+    /// Duplicated internal class.
+    /// </summary>
+    internal class Duplicate {
+    }
+}
+""";
+
+        var internalDuplicatedSource = """
+namespace Sample {
+
+    /// <summary>
+    /// Duplicated internal class.
+    /// </summary>
+    internal class Duplicate {
+    }
+}
+""";
+        var references = new Dictionary<string, List<string>>
+        {
+            { "InternalDuplicateLibrary1", [internalDuplicatedSource] },
+            { "InternalDuplicateLibrary2", [internalDuplicatedSource] }
+        };
+
+        var generator = new XmlCommentGenerator();
+        await SnapshotTestHelper.Verify(source, generator, references, out var compilation, out var additionalAssemblies);
+        await SnapshotTestHelper.VerifyOpenApi(compilation, additionalAssemblies, Assert.NotNull);
+    }
+}