private static bool CheckSpeculativeSymbol(
            AnonymousFunctionExpressionSyntax anonymousFunction,
            ExpressionSyntax expression,
            IMethodSymbol methodSymbol,
            SemanticModel semanticModel)
        {
            SymbolInfo symbolInfo = semanticModel.GetSpeculativeSymbolInfo(anonymousFunction.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

            ISymbol symbol = symbolInfo.Symbol;

            if (symbol?.Equals(methodSymbol) == true)
                return true;

            ImmutableArray<ISymbol> candidateSymbols = symbolInfo.CandidateSymbols;

            if (candidateSymbols.Any())
            {
                if (candidateSymbols.Length == 1)
                {
                    if (candidateSymbols[0].Equals(methodSymbol))
                        return true;
                }
                else if (!anonymousFunction.WalkUpParentheses().IsParentKind(SyntaxKind.Argument, SyntaxKind.AttributeArgument))
                {
                    foreach (ISymbol candidateSymbol in candidateSymbols)
                    {
                        if (candidateSymbol.Equals(methodSymbol))
                            return true;
                    }
                }
            }

            return false;
        }
        private static bool CheckSpeculativeSymbol(
            AnonymousFunctionExpressionSyntax anonymousFunction,
            ExpressionSyntax expression,
            IMethodSymbol methodSymbol,
            SemanticModel semanticModel,
            CancellationToken cancellationToken)
        {
            SyntaxNode argumentExpression = anonymousFunction.WalkUpParentheses();

            if (argumentExpression.Parent is ArgumentSyntax argument)
            {
                if (argument.Parent is BaseArgumentListSyntax)
                {
                    SyntaxNode node = argument.Parent.Parent;

                    // related to https://github.com/dotnet/roslyn/issues/25262
                    if (CSharpUtility.IsConditionallyAccessed(node))
                    {
                        return(false);
                    }

                    SyntaxNode newNode = node.ReplaceNode(argument.Expression, expression);

                    SymbolInfo symbolInfo = semanticModel.GetSpeculativeSymbolInfo(node.SpanStart, newNode, SpeculativeBindingOption.BindAsExpression);

                    methodSymbol = semanticModel.GetSymbol(node, cancellationToken) as IMethodSymbol;

                    return(methodSymbol != null &&
                           CheckSpeculativeSymbol(symbolInfo));
                }
            }
            else
            {
                SymbolInfo symbolInfo = semanticModel.GetSpeculativeSymbolInfo(anonymousFunction.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

                return(CheckSpeculativeSymbol(symbolInfo));
            }

            return(false);

            bool CheckSpeculativeSymbol(SymbolInfo symbolInfo)
            {
                return(symbolInfo.Symbol?.Equals(methodSymbol) == true ||
                       symbolInfo.CandidateSymbols.SingleOrDefault(shouldThrow: false)?.Equals(methodSymbol) == true);
            }
        }