private static void AnalyzeBody(SyntaxNodeAnalysisContext context, BlockSyntax body)
        {
            ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetReturnExpression(body);

            if (expression != null)
            {
                AnalyzeExpression(context, body, expression);
            }
        }
        private static void  AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context)
        {
            var declaration = (ConstructorDeclarationSyntax)context.Node;

            if (declaration.ExpressionBody == null)
            {
                BlockSyntax body = declaration.Body;

                ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpression(body);

                if (expression != null)
                {
                    AnalyzeExpression(context, body, expression);
                }
            }
        }
        private static void  AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
        {
            var method = (MethodDeclarationSyntax)context.Node;

            if (method.ExpressionBody == null)
            {
                BlockSyntax body = method.Body;

                ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpression(body);

                if (expression != null)
                {
                    AnalyzeExpression(context, body, expression);
                }
            }
        }
        private static void  AnalyzeLocalFunctionStatement(SyntaxNodeAnalysisContext context)
        {
            var localFunctionStatement = (LocalFunctionStatementSyntax)context.Node;

            if (localFunctionStatement.ExpressionBody == null)
            {
                BlockSyntax body = localFunctionStatement.Body;

                ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpression(body);

                if (expression != null)
                {
                    AnalyzeExpression(context, body, expression);
                }
            }
        }
        private static void AnalyzeAccessorDeclaration(SyntaxNodeAnalysisContext context)
        {
            var accessor = (AccessorDeclarationSyntax)context.Node;

            BlockSyntax body = accessor.Body;

            if (body == null)
            {
                return;
            }

            if (accessor.AttributeLists.Any())
            {
                return;
            }

            bool isGetter = accessor.IsKind(SyntaxKind.GetAccessorDeclaration);

            ExpressionSyntax expression = (isGetter)
                ? UseExpressionBodiedMemberAnalysis.GetReturnExpression(body)
                : UseExpressionBodiedMemberAnalysis.GetExpression(body);

            if (expression?.IsSingleLine() != true)
            {
                return;
            }

            if (isGetter &&
                accessor.Parent is AccessorListSyntax accessorList &&
                accessorList.Accessors.Count == 1)
            {
                if (accessorList.DescendantTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
                {
                    ReportDiagnostic(context, accessorList, expression);
                    context.ReportToken(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, accessor.Keyword);
                    context.ReportBraces(DiagnosticDescriptors.UseExpressionBodiedMemberFadeOut, body);
                }

                return;
            }

            if (accessor.DescendantTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
            {
                ReportDiagnostic(context, body, expression);
            }
        }
        private static void AnalyzeConversionOperatorDeclaration(SyntaxNodeAnalysisContext context)
        {
            var declaration = (ConversionOperatorDeclarationSyntax)context.Node;

            BlockSyntax body = declaration.Body;

            if (body == null)
            {
                return;
            }

            ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetReturnExpression(body);

            if (expression == null)
            {
                return;
            }

            AnalyzeExpression(context, body, expression);
        }