Merge pull request #42825 from CyrusNajmabadi/stackOverflow

Fix stack overflow in symbol equivalence

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/SymbolEquivalenceComparer.EquivalenceVisitor.cs

@@ -46,18 +46,15 @@ public bool AreEquivalent(ISymbol x, ISymbol y, Dictionary<INamedTypeSymbol, INa
                 }
 #endif
 
-                // https://github.com/dotnet/roslyn/issues/39643 This is a temporary workaround sufficient to get existing tests passing.
-                // This component should be modified to properly deal with differences caused by nullability.
-                if (x is ITypeSymbol xType && y is ITypeSymbol yType && xType.IsDefinition != yType.IsDefinition)
+                if (x is ITypeSymbol xType && y is ITypeSymbol yType)
                 {
-                    if (x.IsDefinition)
-                    {
-                        y = yType.WithNullableAnnotationFrom(xType);
-                    }
-                    else
-                    {
-                        x = xType.WithNullableAnnotationFrom(yType);
-                    }
+                    // Nullability is not considered a distinguishing factor between symbols in this component.  Strip
+                    // nullability from these symbols.  This also ensures we can do reference-equality checks later as
+                    // stripping nullability returns the underlying symbol and does not produce new symbols with the
+                    // updated nullability value.
+
+                    x = xType.WithNullableAnnotation(xType.IsValueType ? NullableAnnotation.NotAnnotated : NullableAnnotation.None);
+                    y = yType.WithNullableAnnotation(yType.IsValueType ? NullableAnnotation.NotAnnotated : NullableAnnotation.None);
                 }
 
                 if (ReferenceEquals(x, y))

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/SymbolEquivalenceComparer.cs

@@ -12,21 +12,17 @@ namespace Microsoft.CodeAnalysis.Shared.Utilities
     /// Provides a way to test two symbols for equivalence.  While there are ways to ask for
     /// different sorts of equivalence, the following must hold for two symbols to be considered
     /// equivalent.
-    /// 
-    /// 1) The kinds of the two symbols must match.
-    /// 
-    /// 2) The names of the two symbols must match.
-    /// 
-    /// 3) The arity of the two symbols must match.
-    /// 
-    /// 4) If the symbols are methods or parameterized properties, then the signatures of the two
-    /// symbols must match.
-    /// 
-    /// 5) Both symbols must be definitions or must be instantiations.  If they are instantiations,
-    /// then they must be instantiated in the same manner.
-    /// 
-    /// 6) The containing symbols of the two symbols must be equivalent.
-    /// 
+    /// <list type="number">
+    /// <item>The kinds of the two symbols must match.</item>
+    /// <item>The names of the two symbols must match.</item>
+    /// <item>The arity of the two symbols must match.</item>
+    /// <item>If the symbols are methods or parameterized properties, then the signatures of the two
+    /// symbols must match.</item>
+    /// <item>Both symbols must be definitions or must be instantiations.  If they are instantiations,
+    /// then they must be instantiated in the same manner.</item>
+    /// <item>The containing symbols of the two symbols must be equivalent.</item>
+    /// <item>Nullability of symbols is not involved in the comparison.</item>
+    /// </list>
     /// Note: equivalence does not concern itself with whole symbols.  Two types are considered
     /// equivalent if the above hold, even if one type has different members than the other.  Note:
     /// type parameters, and signature parameters are not considered 'children' when comparing