Fix handling of SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes option for non-native symbol implementations

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -402,12 +402,16 @@ private void AddNameAndTypeArgumentsOrParameters(INamedTypeSymbol symbol)
 
             if (Format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes))
             {
-                // Only the compiler can set the internal option and the compiler doesn't use other implementations of INamedTypeSymbol.
-                if (underlyingTypeSymbol?.MangleName == true)
+                if (symbol.Arity > 0)
                 {
-                    Debug.Assert(symbol.Arity > 0);
-                    Builder.Add(CreatePart(InternalSymbolDisplayPartKind.Arity, null,
-                        MetadataHelpers.GetAritySuffix(symbol.Arity)));
+                    string suffix = MetadataHelpers.GetAritySuffix(symbol.Arity);
+
+                    if (underlyingTypeSymbol is not null ? underlyingTypeSymbol.MangleName : (symbol.MetadataName == symbol.Name + suffix))
+                    {
+                        Debug.Assert(symbol.Arity > 0);
+                        Builder.Add(CreatePart(InternalSymbolDisplayPartKind.Arity, null,
+                            suffix));
+                    }
                 }
             }
             else if (symbol.Arity > 0 && Format.GenericsOptions.IncludesOption(SymbolDisplayGenericsOptions.IncludeTypeParameters))

src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs

@@ -9157,6 +9157,83 @@ public void PreprocessingSymbol()
                 actual: displayParts);
         }
 
+        [Theory, CombinatorialData]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/80165")]
+        public void UseArityForGenericTypes_CSharpSymbol(bool useMetadata)
+        {
+            var text =
+@"
+class A
+{
+    class B<T1> { }
+}
+
+class C<T2>
+{
+    class D<T3> { }
+    class E { }
+}
+";
+            var format = SymbolDisplayFormat.CSharpErrorMessageFormat.
+                WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes);
+
+            Compilation comp;
+            if (useMetadata)
+            {
+                var libComp = CreateCompilation(text);
+                comp = CreateCompilation("", references: [libComp.EmitToImageReference()]);
+            }
+            else
+            {
+                comp = CreateCompilation(text);
+            }
+
+            AssertEx.Equal("A", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A"), format));
+            AssertEx.Equal("A.B`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A+B`1"), format));
+            AssertEx.Equal("C`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1"), format));
+            AssertEx.Equal("C`1.D`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+D`1"), format));
+            AssertEx.Equal("C`1.E", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+E"), format));
+        }
+
+        [Theory, CombinatorialData]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/80165")]
+        public void UseArityForGenericTypes_VBSymbol(bool useMetadata)
+        {
+            var text =
+@"
+Class A
+    Class B(Of T1)
+    End Class
+End Class
+
+Class C(Of T2) 
+    Class D(Of T3)
+    End Class
+    Class E
+    End Class
+End Class
+";
+            var format = SymbolDisplayFormat.CSharpErrorMessageFormat.
+                WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes);
+
+            Compilation comp;
+            if (useMetadata)
+            {
+                var libComp = CreateVisualBasicCompilation(text);
+                comp = CreateVisualBasicCompilation("", referencedAssemblies: [libComp.EmitToImageReference()]);
+            }
+            else
+            {
+                comp = CreateVisualBasicCompilation("c", text);
+            }
+
+            AssertEx.Equal("A", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A"), format));
+            AssertEx.Equal("A.B`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A+B`1"), format));
+            AssertEx.Equal("C`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1"), format));
+            AssertEx.Equal("C`1.D`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+D`1"), format));
+            AssertEx.Equal("C`1.E", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+E"), format));
+        }
+
         [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/36654")]
         public void MinimalNameWithConflict()
         {

src/Compilers/VisualBasic/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.vb

@@ -280,11 +280,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim isMissingMetadataType As Boolean = TypeOf symbol Is MissingMetadataTypeSymbol
 
             If Format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes) Then
-                ' Only the compiler can set the internal option and the compiler doesn't use other implementations of INamedTypeSymbol.
-                If DirectCast(symbol, NamedTypeSymbol).MangleName Then
-                    Debug.Assert(symbol.Arity > 0)
-                    Builder.Add(CreatePart(InternalSymbolDisplayPartKind.Arity, Nothing,
-                                           MetadataHelpers.GenericTypeNameManglingChar & symbol.Arity.ToString(), False))
+                If symbol.Arity > 0 Then
+                    Dim suffix As String = MetadataHelpers.GetAritySuffix(symbol.Arity)
+                    Dim vbNamedType = TryCast(symbol, NamedTypeSymbol)
+
+                    If If(vbNamedType IsNot Nothing, vbNamedType.MangleName, symbol.MetadataName.Equals(symbol.Name + suffix)) Then
+                        Builder.Add(CreatePart(InternalSymbolDisplayPartKind.Arity, Nothing,
+                                           suffix, False))
+                    End If
                 End If
             ElseIf symbol.Arity > 0 AndAlso Format.GenericsOptions.IncludesOption(SymbolDisplayGenericsOptions.IncludeTypeParameters) AndAlso Not skipTypeArguments Then
                 If isMissingMetadataType OrElse symbol.IsUnboundGenericType Then

src/Compilers/VisualBasic/Test/Symbol/SymbolDisplay/SymbolDisplayTests.vb

@@ -6146,6 +6146,77 @@ static class E
             AssertEx.Equal("Public Sub E.<G>$8048A6C8BE30A622530249B904B537EB(Of T).M()", SymbolDisplay.ToDisplayString(skeletonM, format))
         End Sub
 
+        <Theory, CombinatorialData>
+        <WorkItem("https://github.com/dotnet/roslyn/issues/80165")>
+        Public Sub UseArityForGenericTypes_CSharpSymbol(useMetadata As Boolean)
+            Dim text =
+"
+class A
+{
+    class B<T1> { }
+}
+
+class C<T2>
+{
+    class D<T3> { }
+    class E { }
+}
+"
+            Dim format = SymbolDisplayFormat.VisualBasicErrorMessageFormat.
+                WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes)
+
+            Dim comp As Compilation
+            If useMetadata Then
+                Dim libComp = CreateCSharpCompilation("c", text)
+                comp = CreateCSharpCompilation("d", code:="", referencedAssemblies:=libComp.References.Concat(libComp.EmitToImageReference()))
+            Else
+                comp = CreateCSharpCompilation("c", text)
+            End If
+
+            AssertEx.Equal("A", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A"), format))
+            AssertEx.Equal("A.B`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A+B`1"), format))
+            AssertEx.Equal("C`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1"), format))
+            AssertEx.Equal("C`1.D`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+D`1"), format))
+            AssertEx.Equal("C`1.E", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+E"), format))
+        End Sub
+
+        <Theory, CombinatorialData>
+        <WorkItem("https://github.com/dotnet/roslyn/issues/80165")>
+        Public Sub UseArityForGenericTypes_VBSymbol(useMetadata As Boolean)
+            Dim source =
+"
+Class A
+    Class B(Of T1)
+    End Class
+End Class
+
+Class C(Of T2) 
+    Class D(Of T3)
+    End Class
+    Class E
+    End Class
+End Class
+"
+            Dim format = SymbolDisplayFormat.VisualBasicErrorMessageFormat.
+                WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.UseArityForGenericTypes)
+
+            Dim comp As Compilation
+            If useMetadata Then
+                Dim libComp = CreateCompilation(source)
+                comp = CreateCompilation("", references:={libComp.EmitToImageReference()})
+            Else
+                comp = CreateCompilation(source)
+            End If
+
+            Dim c = DirectCast(comp.GlobalNamespace.GetMembers("C").Single(), ITypeSymbol)
+
+            AssertEx.Equal("A", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A"), format))
+            AssertEx.Equal("A.B`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("A+B`1"), format))
+            AssertEx.Equal("C`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1"), format))
+            AssertEx.Equal("C`1.D`1", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+D`1"), format))
+            AssertEx.Equal("C`1.E", SymbolDisplay.ToDisplayString(comp.GetTypeByMetadataName("C`1+E"), format))
+        End Sub
+
 #Region "Helpers"
 
         Private Shared Sub TestSymbolDescription(