Merge pull request #36776 from dotnet/merges/master-to-master-vs-deps

Merge master to master-vs-deps

src/Compilers/CSharp/Portable/Symbols/Source/ExplicitInterfaceHelpers.cs

@@ -207,7 +207,7 @@ public static string GetMemberNameWithoutInterfaceName(string fullName)
             // interface in its base class list that contains a member ..."
             MultiDictionary<NamedTypeSymbol, NamedTypeSymbol>.ValueSet set = containingType.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics[explicitInterfaceNamedType];
             int setCount = set.Count;
-            if (setCount == 0 || !set.Contains(explicitInterfaceNamedType))
+            if (setCount == 0 || !set.Contains(explicitInterfaceNamedType, TypeSymbol.EqualsObliviousNullableModifierMatchesAny))
             {
                 //we'd like to highlight just the type part of the name
                 var explicitInterfaceSyntax = explicitInterfaceSpecifierSyntax.Name;

src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs

@@ -125,6 +125,8 @@ private InterfaceInfo GetInterfaceInfo()
 
         internal static readonly EqualityComparer<TypeSymbol> EqualsIgnoringNullableComparer = new TypeSymbolComparer(TypeCompareKind.IgnoreNullableModifiersForReferenceTypes);
 
+        internal static readonly EqualityComparer<TypeSymbol> EqualsObliviousNullableModifierMatchesAny = new TypeSymbolComparer(TypeCompareKind.ObliviousNullableModifierMatchesAny);
+
         internal static readonly EqualityComparer<TypeSymbol> EqualsAllIgnoreOptionsPlusNullableWithUnknownMatchesAnyComparer =
                                                                   new TypeSymbolComparer(TypeCompareKind.AllIgnoreOptions & ~(TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
 

src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs

@@ -1180,6 +1180,16 @@ internal static bool IsPrimitiveRecursiveStruct(this TypeSymbol t)
         /// </summary>
         internal static int ComputeHashCode(this NamedTypeSymbol type)
         {
+            Debug.Assert(!type.Equals(type.OriginalDefinition, TypeCompareKind.AllIgnoreOptions) || wasConstructedForAnnotations(type));
+
+            if (wasConstructedForAnnotations(type))
+            {
+                // A type that uses its own type parameters as type arguments was constructed only for the purpose of adding annotations.
+                // In that case we'll use the hash from the definition.
+
+                return type.OriginalDefinition.GetHashCode();
+            }
+
             int code = type.OriginalDefinition.GetHashCode();
             code = Hash.Combine(type.ContainingType, code);
 
@@ -1209,6 +1219,28 @@ internal static int ComputeHashCode(this NamedTypeSymbol type)
                 code++;
             }
             return code;
+
+            static bool wasConstructedForAnnotations(NamedTypeSymbol type)
+            {
+                do
+                {
+                    var typeArguments = type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics;
+                    var typeParameters = type.OriginalDefinition.TypeParameters;
+
+                    for (int i = 0; i < typeArguments.Length; i++)
+                    {
+                        if (!typeParameters[i].Equals(typeArguments[i].Type.OriginalDefinition))
+                        {
+                            return false;
+                        }
+                    }
+
+                    type = type.ContainingType;
+                }
+                while (type is object && !type.IsDefinition);
+
+                return true;
+            }
         }
 
         /// <summary>

src/Compilers/VisualBasic/Portable/Symbols/SubstitutedErrorType.vb

@@ -221,6 +221,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         End Property
 
         Public Overrides Function GetHashCode() As Integer
+            If Me._substitution.WasConstructedForModifiers() Then
+                Return OriginalDefinition.GetHashCode()
+            End If
+
             Dim _hash As Integer = _fullInstanceType.GetHashCode()
 
             _hash = Hash.Combine(ContainingType, _hash)

src/Compilers/VisualBasic/Portable/Symbols/SubstitutedNamedType.vb

@@ -491,6 +491,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
         Public Overrides Function GetHashCode() As Integer
             Dim _hash As Integer = OriginalDefinition.GetHashCode()
+            If Me._substitution.WasConstructedForModifiers() Then
+                Return _hash
+            End If
+
             _hash = Hash.Combine(ContainingType, _hash)
 
             ' There is a circularity problem here with alpha-renamed type parameters.
@@ -978,6 +982,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             End Function
 
             Public Overrides Function GetHashCode() As Integer
+                If Me._substitution.WasConstructedForModifiers() Then
+                    Return OriginalDefinition.GetHashCode()
+                End If
+
                 Dim _hash As Integer = MyBase.GetHashCode()
 
                 For Each typeArgument In TypeArgumentsNoUseSiteDiagnostics
@@ -1201,7 +1209,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                 Return Me
             End Function
 
-
         End Class
 
         ''' <summary>

src/Compilers/VisualBasic/Portable/Symbols/TypeSubstitution.vb

@@ -904,5 +904,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             Return customModifiers
         End Function
 
+        Public Function WasConstructedForModifiers() As Boolean
+            For Each pair In _pairs
+                If Not pair.Key.Equals(pair.Value.Type.OriginalDefinition) Then
+                    Return False
+                End If
+            Next
+
+            Return If(_parent Is Nothing, True, _parent.WasConstructedForModifiers())
+        End Function
+
     End Class
 End Namespace

src/Compilers/VisualBasic/Portable/Symbols/TypeSymbolExtensions.vb

@@ -285,12 +285,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                 Dim t1IsDefinition = t1.IsDefinition
                 Dim t2IsDefinition = t2.IsDefinition
 
-                If (t1IsDefinition <> t2IsDefinition) AndAlso
-                   Not ((compareKind And TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds) <> 0 AndAlso
-                            (DirectCast(t1, NamedTypeSymbol).HasTypeArgumentsCustomModifiers OrElse DirectCast(t2, NamedTypeSymbol).HasTypeArgumentsCustomModifiers)) Then
-                    Return False
-                End If
-
                 If Not (t1IsDefinition AndAlso t2IsDefinition) Then ' This is a generic instantiation case
 
                     If Not t1.OriginalDefinition.Equals(t2.OriginalDefinition) Then
@@ -303,20 +297,24 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
                     Do
 
-                        If (compareKind And Global.Microsoft.CodeAnalysis.TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds) = 0 AndAlso
-                           Not HasSameTypeArgumentCustomModifiers(container1, container2) Then
-
-                            Return False
-                        End If
+                        If Not (container1 Is container1.ConstructedFrom AndAlso container2 Is container2.ConstructedFrom) Then
+                            ' No need to compare type arguments on those containers when they didn't add type arguments (that would cause cycles)
 
-                        Dim args1 As ImmutableArray(Of TypeSymbol) = container1.TypeArgumentsNoUseSiteDiagnostics
-                        Dim args2 As ImmutableArray(Of TypeSymbol) = container2.TypeArgumentsNoUseSiteDiagnostics
+                            If (compareKind And Global.Microsoft.CodeAnalysis.TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds) = 0 AndAlso
+                                Not HasSameTypeArgumentCustomModifiers(container1, container2) Then
 
-                        For i As Integer = 0 To args1.Length - 1 Step 1
-                            If Not args1(i).IsSameType(args2(i), compareKind) Then
                                 Return False
                             End If
-                        Next
+
+                            Dim args1 As ImmutableArray(Of TypeSymbol) = container1.TypeArgumentsNoUseSiteDiagnostics
+                            Dim args2 As ImmutableArray(Of TypeSymbol) = container2.TypeArgumentsNoUseSiteDiagnostics
+
+                            For i As Integer = 0 To args1.Length - 1 Step 1
+                                If Not args1(i).IsSameType(args2(i), compareKind) Then
+                                    Return False
+                                End If
+                            Next
+                        End If
 
                         container1 = container1.ContainingType
                         container2 = container2.ContainingType
@@ -326,16 +324,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                             Exit Do
                         End If
 
-                        If (container1.IsDefinition <> container2.IsDefinition) AndAlso
-                            Not ((compareKind And TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds) <> 0 AndAlso
-                            (container1.HasTypeArgumentsCustomModifiers OrElse container2.HasTypeArgumentsCustomModifiers)) Then
-
-                            Return False
-                        End If
                     Loop
 
                     Return True
                 End If
+            ElseIf kind = SymbolKind.TypeParameter Then
+                If Not t1.OriginalDefinition.Equals(t2.OriginalDefinition) Then
+                    Return False ' different definition
+                End If
+
+                Return t1.ContainingType.IsSameType(t2.ContainingType, compareKind)
             End If
 
             Return t1.Equals(t2)

src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb

@@ -4,6 +4,7 @@ Imports System.Collections.Immutable
 Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
+Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
@@ -3782,6 +3783,169 @@ End Interface
 
             Assert.True(i1.IsExplicitDefinitionOfNoPiaLocalType)
         End Sub
+
+        <WorkItem(30673, "https://github.com/dotnet/roslyn/issues/30673")>
+        <Fact>
+        Public Sub TypeSymbolGetHashCode_ContainingType_GenericNestedType()
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40(
+<compilation name="TypeSymbolGetHashCode_ContainingType_GenericNestedType">
+    <file name="a.vb">
+Public Class C(Of T)
+    Public Interface I(Of U)
+    End Interface
+End Class
+    </file>
+</compilation>)
+
+            AssertNoDeclarationDiagnostics(compilation)
+            Dim modifiers = ImmutableArray.Create(VisualBasicCustomModifier.CreateOptional(compilation.GetSpecialType(SpecialType.System_Object)))
+
+            Dim iDefinition = compilation.GetMember(Of NamedTypeSymbol)("C.I")
+            Assert.Equal("C(Of T).I(Of U)", iDefinition.ToTestDisplayString())
+            Assert.True(iDefinition.IsDefinition)
+
+            ' Construct from iDefinition with modified U from iDefinition
+            Dim modifiedU = ImmutableArray.Create(New TypeWithModifiers(iDefinition.TypeParameters.Single(), modifiers))
+            Dim i1 = iDefinition.Construct(TypeSubstitution.Create(iDefinition, iDefinition.TypeParameters, modifiedU))
+            Assert.Equal("C(Of T).I(Of U modopt(System.Object))", i1.ToTestDisplayString())
+            AssertHashCodesMatch(iDefinition, i1)
+
+            Dim cDefinition = iDefinition.ContainingType
+            Assert.Equal("C(Of T)", cDefinition.ToTestDisplayString())
+            Assert.True(cDefinition.IsDefinition)
+
+            ' Construct from cDefinition with modified T from cDefinition
+            Dim modifiedT = ImmutableArray.Create(New TypeWithModifiers(cDefinition.TypeParameters.Single(), modifiers))
+            Dim c2 = cDefinition.Construct(TypeSubstitution.Create(cDefinition, cDefinition.TypeParameters, modifiedT))
+            Dim i2 = c2.GetTypeMember("I")
+            Assert.Equal("C(Of T modopt(System.Object)).I(Of U)", i2.ToTestDisplayString())
+            Assert.Same(i2.OriginalDefinition, iDefinition)
+            AssertHashCodesMatch(iDefinition, i2)
+
+            ' Construct from i2 with U from iDefinition
+            Dim i2a = i2.Construct(iDefinition.TypeParameters.Single())
+            Assert.Equal("C(Of T modopt(System.Object)).I(Of U)", i2a.ToTestDisplayString())
+            AssertHashCodesMatch(iDefinition, i2a)
+
+            ' Construct from i2 (reconstructed) with modified U from iDefinition
+            Dim i2b = iDefinition.Construct(TypeSubstitution.Create(iDefinition,
+                                                                    ImmutableArray.Create(cDefinition.TypeParameters.Single(), iDefinition.TypeParameters.Single()),
+                                                                    ImmutableArray.Create(modifiedT.Single(), modifiedU.Single())))
+            Assert.Equal("C(Of T modopt(System.Object)).I(Of U modopt(System.Object))", i2b.ToTestDisplayString())
+            AssertHashCodesMatch(iDefinition, i2b)
+
+            ' Construct from cDefinition with modified T from cDefinition
+            Dim c4 = cDefinition.Construct(TypeSubstitution.Create(cDefinition, cDefinition.TypeParameters, modifiedT))
+            Assert.Equal("C(Of T modopt(System.Object))", c4.ToTestDisplayString())
+            Assert.False(c4.IsDefinition)
+            AssertHashCodesMatch(cDefinition, c4)
+
+            Dim i4 = c4.GetTypeMember("I")
+            Assert.Equal("C(Of T modopt(System.Object)).I(Of U)", i4.ToTestDisplayString())
+            Assert.Same(i4.OriginalDefinition, iDefinition)
+            AssertHashCodesMatch(iDefinition, i4)
+        End Sub
+
+        <WorkItem(30673, "https://github.com/dotnet/roslyn/issues/30673")>
+        <Fact>
+        Public Sub TypeSymbolGetHashCode_ContainingType_GenericNestedType_Nested()
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40(
+<compilation name="TypeSymbolGetHashCode_ContainingType_GenericNestedType">
+    <file name="a.vb">
+Public Class C(Of T)
+    Public Class C2(Of U)
+        Public Interface I(Of V)
+        End Interface
+    End Class
+End Class
+    </file>
+</compilation>)
+
+            AssertNoDeclarationDiagnostics(compilation)
+            Dim modifiers = ImmutableArray.Create(VisualBasicCustomModifier.CreateOptional(compilation.GetSpecialType(SpecialType.System_Object)))
+
+            Dim iDefinition = compilation.GetMember(Of NamedTypeSymbol)("C.C2.I")
+            Assert.Equal("C(Of T).C2(Of U).I(Of V)", iDefinition.ToTestDisplayString())
+            Assert.True(iDefinition.IsDefinition)
+
+            Dim c2Definition = iDefinition.ContainingType
+            Dim cDefinition = c2Definition.ContainingType
+            Dim modifiedT = New TypeWithModifiers(cDefinition.TypeParameters.Single(), modifiers)
+            Dim modifiedU = New TypeWithModifiers(c2Definition.TypeParameters.Single(), modifiers)
+            Dim modifiedV = New TypeWithModifiers(iDefinition.TypeParameters.Single(), modifiers)
+
+            Dim i = iDefinition.Construct(TypeSubstitution.Create(iDefinition,
+                                                                    ImmutableArray.Create(cDefinition.TypeParameters.Single(), c2Definition.TypeParameters.Single(), iDefinition.TypeParameters.Single()),
+                                                                    ImmutableArray.Create(modifiedT, modifiedU, modifiedV)))
+            Assert.Equal("C(Of T modopt(System.Object)).C2(Of U modopt(System.Object)).I(Of V modopt(System.Object))", i.ToTestDisplayString())
+            AssertHashCodesMatch(iDefinition, i)
+        End Sub
+
+        <WorkItem(30673, "https://github.com/dotnet/roslyn/issues/30673")>
+        <Fact>
+        Public Sub TypeSymbolGetHashCode_SubstitutedErrorType()
+            Dim missing = CompilationUtils.CreateCompilationWithMscorlib40(
+<compilation name="TypeSymbolGetHashCode_SubstitutedErrorType">
+    <file name="a.vb">
+Public Class C(Of T)
+    Public Class D(Of U)
+    End Class
+End Class
+    </file>
+</compilation>)
+            AssertNoDeclarationDiagnostics(missing)
+
+            Dim reference = CompilationUtils.CreateCompilationWithMscorlib40(
+<compilation name="TypeSymbolGetHashCode_SubstitutedErrorType">
+    <file name="a.vb">
+Public Class Reference(Of T, U)
+    Inherits C(Of T).D(Of U)
+End Class
+    </file>
+</compilation>, references:={missing.EmitToImageReference()})
+            AssertNoDeclarationDiagnostics(reference)
+
+            Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40(
+<compilation name="TypeSymbolGetHashCode_SubstitutedErrorType">
+    <file name="a.vb">
+Public Class Program(Of V, W)
+    Inherits Reference(Of V, W)
+End Class
+    </file>
+</compilation>, references:={reference.EmitToImageReference()})
+
+            compilation.AssertTheseDiagnostics(<errors><![CDATA[
+BC31091: Import of type 'C(Of ).D(Of )' from assembly or module 'TypeSymbolGetHashCode_SubstitutedErrorType.dll' failed.
+Public Class Program(Of V, W)
+             ~~~~~~~
+BC31091: Import of type 'C(Of ).D(Of )' from assembly or module 'TypeSymbolGetHashCode_SubstitutedErrorType.dll' failed.
+    Inherits Reference(Of V, W)
+             ~~~~~~~~~~~~~~~~~~
+            ]]></errors>)
+
+            Dim modifiers = ImmutableArray.Create(VisualBasicCustomModifier.CreateOptional(compilation.GetSpecialType(SpecialType.System_Object)))
+
+            Dim programType = compilation.GlobalNamespace.GetTypeMember("Program")
+            Dim errorType = programType.BaseType.BaseType
+
+            Dim definition = errorType.OriginalDefinition
+            Assert.Equal("Microsoft.CodeAnalysis.VisualBasic.Symbols.SubstitutedErrorType", errorType.GetType().ToString())
+            Assert.Equal("C(Of )[missing].D(Of )[missing]", definition.ToTestDisplayString())
+            Assert.True(definition.IsDefinition)
+
+            ' Construct from definition with modified U from definition
+            Dim modifiedU = ImmutableArray.Create(New TypeWithModifiers(definition.TypeParameters.Single(), modifiers))
+            Dim t1 = definition.Construct(TypeSubstitution.Create(definition, definition.TypeParameters, modifiedU))
+            Assert.Equal("C(Of )[missing].D(Of  modopt(System.Object))[missing]", t1.ToTestDisplayString())
+            AssertHashCodesMatch(definition, t1)
+        End Sub
+
+        Private Shared Sub AssertHashCodesMatch(c As TypeSymbol, c2 As TypeSymbol)
+            Assert.False(c.IsSameType(c2, TypeCompareKind.ConsiderEverything))
+            Assert.True(c.IsSameType(c2, (TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds Or TypeCompareKind.IgnoreTupleNames)))
+
+            Assert.Equal(c2.GetHashCode(), c.GetHashCode())
+        End Sub
     End Class
 
 End Namespace