// 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.Diagnostics;
using System.Linq;
using Microsoft.CodeAnalysis.Shared.Extensions;
 
namespace Microsoft.CodeAnalysis
{
    internal partial struct SymbolKey
    {
        /// <summary>
        /// Anonymous functions and anonymous-delegates (the special VB synthesized delegate types),
        /// only come into existence when someone has explicitly written a lambda in their source 
        /// code. So to appropriately round-trip this symbol we store the location that the lambda
        /// was at so that we can find the symbol again when we resolve the key.
        /// </summary>
        private static class AnonymousFunctionOrDelegateSymbolKey
        {
            public static void Create(ISymbol symbol, SymbolKeyWriter visitor)
            {
                Debug.Assert(symbol.IsAnonymousDelegateType() || symbol.IsAnonymousFunction());
 
                // Write out if this was an anonymous delegate or anonymous function.
                // In both cases they'll have the same location (the location of 
                // the lambda that forced them into existence).  When we resolve the
                // symbol later, if it's an anonymous delegate, we'll first resolve to
                // the anonymous-function, then use that anonymous-functoin to get at
                // the synthesized anonymous delegate.
                visitor.WriteBoolean(symbol.IsAnonymousDelegateType());
                visitor.WriteLocation(symbol.Locations.First());
            }
 
            public static SymbolKeyResolution Resolve(SymbolKeyReader reader, out string? failureReason)
            {
                var isAnonymousDelegateType = reader.ReadBoolean();
                var location = reader.ReadLocation(out var locationFailureReason)!;
 
                if (locationFailureReason != null)
                {
                    failureReason = $"({nameof(AnonymousFunctionOrDelegateSymbolKey)} {nameof(location)} failed -> {locationFailureReason})";
                    return default;
                }
 
                var syntaxTree = location.SourceTree;
                if (syntaxTree == null)
                {
                    failureReason = $"({nameof(AnonymousFunctionOrDelegateSymbolKey)} {nameof(SyntaxTree)} failed)";
                    return default;
                }
 
                var semanticModel = reader.Compilation.GetSemanticModel(syntaxTree);
                var root = syntaxTree.GetRoot(reader.CancellationToken);
                var node = root.FindNode(location.SourceSpan, getInnermostNodeForTie: true);
 
                var symbol = semanticModel.GetSymbolInfo(node, reader.CancellationToken)
                                          .GetAnySymbol();
 
                // If this was a key for an anonymous delegate type, then go find the
                // associated delegate for this lambda and return that instead of the 
                // lambda function symbol itself.
                if (isAnonymousDelegateType && symbol is IMethodSymbol methodSymbol)
                {
                    var anonymousDelegate = methodSymbol.AssociatedAnonymousDelegate;
                    symbol = anonymousDelegate;
                }
 
                failureReason = null;
                return new SymbolKeyResolution(symbol);
            }
        }
    }
}