// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Collections.Generic;
using System.Linq;
using Microsoft.CodeAnalysis.Shared.Utilities;
 
namespace Microsoft.CodeAnalysis.FindSymbols
{
    internal sealed class MetadataUnifyingEquivalenceComparer : IEqualityComparer<ISymbol>
    {
        public static readonly IEqualityComparer<ISymbol> Instance = new MetadataUnifyingEquivalenceComparer();
 
        private MetadataUnifyingEquivalenceComparer()
        {
        }
 
        public bool Equals(ISymbol? x, ISymbol? y)
        {
            // If either symbol is from source, then we must do stricter equality. Consider this:
            //
            //     S1 <-> M <-> S2     (where S# = source symbol, M = some metadata symbol)
            //
            // In this case, imagine that both the comparisons denoted by <-> were done with the
            // SymbolEquivalenceComparer, and returned true. If S1 and S2 were from different projects,
            // they would compare false but transitivity would say they must be true. Another way to think
            // of this is any use of a source symbol "poisons" the comparison and requires it to be stricter.
            if (x == null || y == null || IsInSource(x) || IsInSource(y))
            {
                return object.Equals(x, y);
            }
 
            // Both of the symbols are from metadata, so defer to the equivalence comparer
            return SymbolEquivalenceComparer.Instance.Equals(x, y);
        }
 
        public int GetHashCode(ISymbol obj)
        {
            if (IsInSource(obj))
            {
                return obj.GetHashCode();
            }
            else
            {
                return SymbolEquivalenceComparer.Instance.GetHashCode(obj);
            }
        }
 
        private static bool IsInSource(ISymbol symbol)
            => symbol.Locations.Any(static l => l.IsInSource);
    }
}