public static bool IsFixable(LambdaExpressionSyntax lambda)
        {
            CSharpSyntaxNode body = lambda.Body;

            if (body?.Kind() != SyntaxKind.Block)
            {
                return(false);
            }

            var block = (BlockSyntax)body;

            StatementSyntax statement = block.Statements.SingleOrDefault(shouldThrow: false);

            if (statement == null)
            {
                return(false);
            }

            ExpressionSyntax expression = GetExpression(statement);

            return(expression?.IsSingleLine() == true &&
                   lambda
                   .DescendantTrivia(TextSpan.FromBounds(lambda.ArrowToken.Span.End, expression.SpanStart))
                   .All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
                   lambda
                   .DescendantTrivia(TextSpan.FromBounds(expression.Span.End, block.Span.End))
                   .All(f => f.IsWhitespaceOrEndOfLineTrivia()));
        }
Exemplo n.º 2
0
        public static bool CanRefactor(LambdaExpressionSyntax lambda)
        {
            if (lambda == null)
            {
                throw new ArgumentNullException(nameof(lambda));
            }

            CSharpSyntaxNode body = lambda.Body;

            if (body?.IsKind(SyntaxKind.Block) == true)
            {
                var block = (BlockSyntax)body;

                StatementSyntax statement = block.Statements.SingleOrDefault(shouldThrow: false);

                if (statement != null)
                {
                    ExpressionSyntax expression = GetExpression(statement);

                    if (expression?.IsSingleLine() == true &&
                        lambda
                        .DescendantTrivia(TextSpan.FromBounds(lambda.ArrowToken.Span.End, expression.Span.Start))
                        .All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
                        lambda
                        .DescendantTrivia(TextSpan.FromBounds(expression.Span.End, block.Span.End))
                        .All(f => f.IsWhitespaceOrEndOfLineTrivia()))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
        public static bool CanRefactor(LambdaExpressionSyntax lambda)
        {
            if (lambda == null)
            {
                throw new ArgumentNullException(nameof(lambda));
            }

            CSharpSyntaxNode body = lambda.Body;

            if (body?.IsKind(SyntaxKind.Block) == true)
            {
                var block = (BlockSyntax)body;
                SyntaxList <StatementSyntax> statements = block.Statements;

                if (statements.Count == 1)
                {
                    StatementSyntax statement = statements[0];

                    if (statement.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.ExpressionStatement))
                    {
                        ExpressionSyntax expression = GetExpression(statement);

                        if (expression?.IsSingleLine() == true)
                        {
                            TextSpan span = TextSpan.FromBounds(lambda.ArrowToken.Span.End, expression.Span.Start);

                            if (lambda
                                .DescendantTrivia(span)
                                .All(f => f.IsWhitespaceOrEndOfLineTrivia()))
                            {
                                span = TextSpan.FromBounds(expression.Span.End, block.Span.End);

                                return(lambda
                                       .DescendantTrivia(span)
                                       .All(f => f.IsWhitespaceOrEndOfLineTrivia()));
                            }
                        }
                    }
                }
            }

            return(false);
        }