public static bool Analyze(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation)
        {
            var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;

            ExpressionSyntax expression = memberAccess?.Expression;

            if (expression?.IsKind(SyntaxKind.InvocationExpression) == true)
            {
                var invocation2 = (InvocationExpressionSyntax)expression;

                ArgumentListSyntax argumentList = invocation2.ArgumentList;

                if (argumentList?.IsMissing == false)
                {
                    SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;

                    if (arguments.Count == 1 &&
                        invocation2.Expression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == true)
                    {
                        var memberAccess2 = (MemberAccessExpressionSyntax)invocation2.Expression;

                        if (string.Equals(memberAccess2.Name?.Identifier.ValueText, "Where", StringComparison.Ordinal))
                        {
                            SemanticModel     semanticModel     = context.SemanticModel;
                            CancellationToken cancellationToken = context.CancellationToken;

                            if (SyntaxAnalyzer.IsEnumerableCastMethod(invocation, semanticModel, cancellationToken) &&
                                (SyntaxAnalyzer.IsEnumerableWhereMethod(invocation2, semanticModel, cancellationToken)))
                            {
                                BinaryExpressionSyntax isExpression = GetIsExpression(arguments.First().Expression);

                                if (isExpression != null)
                                {
                                    var type = isExpression.Right as TypeSyntax;

                                    if (type != null)
                                    {
                                        TypeSyntax type2 = GetTypeArgument(memberAccess.Name);

                                        if (type2 != null)
                                        {
                                            ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type);

                                            if (typeSymbol != null)
                                            {
                                                ITypeSymbol typeSymbol2 = semanticModel.GetTypeSymbol(type2);

                                                if (typeSymbol.Equals(typeSymbol2))
                                                {
                                                    TextSpan span = TextSpan.FromBounds(memberAccess2.Name.Span.Start, invocation.Span.End);

                                                    if (!invocation.ContainsDirectives(span))
                                                    {
                                                        context.ReportDiagnostic(
                                                            DiagnosticDescriptors.SimplifyLinqMethodChain,
                                                            Location.Create(invocation.SyntaxTree, span));
                                                    }

                                                    return(true);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(false);
        }
        public static void Analyze(
            SyntaxNodeAnalysisContext context,
            InvocationExpressionSyntax invocation,
            MemberAccessExpressionSyntax memberAccess)
        {
            if (memberAccess.Expression?.IsKind(SyntaxKind.InvocationExpression) == true)
            {
                var invocation2 = (InvocationExpressionSyntax)memberAccess.Expression;

                if (invocation2.ArgumentList?.Arguments.Count == 1 &&
                    invocation2.Expression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == true)
                {
                    var memberAccess2 = (MemberAccessExpressionSyntax)invocation2.Expression;

                    SemanticModel     semanticModel     = context.SemanticModel;
                    CancellationToken cancellationToken = context.CancellationToken;

                    if (string.Equals(memberAccess2.Name?.Identifier.ValueText, "Where", StringComparison.Ordinal))
                    {
                        IMethodSymbol methodSymbol = semanticModel.GetMethodSymbol(invocation2, cancellationToken);

                        if (methodSymbol != null)
                        {
                            IMethodSymbol reducedFrom = methodSymbol.ReducedFrom;

                            if (reducedFrom?.Name.Equals("Where", StringComparison.Ordinal) == true)
                            {
                                ImmutableArray <IParameterSymbol> parameters = methodSymbol.Parameters;

                                if (parameters.Length == 1 &&
                                    SyntaxAnalyzer.IsContainedInEnumerable(reducedFrom, semanticModel) &&
                                    SyntaxAnalyzer.IsGenericIEnumerable(reducedFrom.Parameters.First().Type))
                                {
                                    if (SyntaxAnalyzer.IsPredicateFunc(
                                            parameters[0].Type,
                                            methodSymbol.TypeArguments[0],
                                            semanticModel))
                                    {
                                        if (SyntaxAnalyzer.IsEnumerableWhereMethod(invocation, semanticModel, cancellationToken))
                                        {
                                            Analyze(context, invocation, invocation2, memberAccess, memberAccess2);
                                        }
                                    }
                                    else if (SyntaxAnalyzer.IsPredicateFunc(
                                                 parameters[0].Type,
                                                 methodSymbol.TypeArguments[0],
                                                 semanticModel.Compilation.GetSpecialType(SpecialType.System_Int32),
                                                 semanticModel))
                                    {
                                        if (SyntaxAnalyzer.IsEnumerableWhereMethodWithIndex(invocation, semanticModel, cancellationToken))
                                        {
                                            Analyze(context, invocation, invocation2, memberAccess, memberAccess2);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }