Пример #1
0
        private static IfRefactoring CreateIfToReturnWithCoalesceExpression(
            IfStatementSyntax ifStatement,
            ExpressionSyntax expression1,
            ExpressionSyntax expression2,
            NullCheckExpression nullCheck,
            bool isYield,
            SemanticModel semanticModel,
            CancellationToken cancellationToken)
        {
            if (nullCheck.Kind == NullCheckKind.EqualsToNull ||
                nullCheck.Kind == NullCheckKind.NotEqualsToNull)
            {
                if (IsEquivalent(nullCheck.Expression, expression1))
                {
                    return(IfToReturnWithCoalesceExpression.Create(ifStatement, expression1, expression2, isYield));
                }
            }

            if (expression1.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
                SemanticUtilities.IsPropertyOfNullableOfT(expression1, "Value", semanticModel, cancellationToken))
            {
                expression1 = ((MemberAccessExpressionSyntax)expression1).Expression;

                if (IsEquivalent(nullCheck.Expression, expression1))
                {
                    return(IfToReturnWithCoalesceExpression.Create(ifStatement, expression1, expression2, isYield));
                }
            }

            return(null);
        }
Пример #2
0
        private static ImmutableArray <IfRefactoring> Analyze(
            IfStatementSyntax ifStatement,
            ExpressionSyntax condition,
            ExpressionSyntax expression1,
            ExpressionSyntax expression2,
            SemanticModel semanticModel,
            CancellationToken cancellationToken,
            IfAnalysisOptions options,
            bool isYield)
        {
            if (expression1?.IsMissing == false &&
                expression2?.IsMissing == false)
            {
                if (options.UseCoalesceExpression)
                {
                    SyntaxKind conditionKind = condition.Kind();

                    if (conditionKind == SyntaxKind.EqualsExpression)
                    {
                        var binaryExpression = (BinaryExpressionSyntax)condition;

                        if (IsNullLiteral(binaryExpression.Right) &&
                            IsEquivalent(binaryExpression.Left, expression2))
                        {
                            return(IfToReturnWithCoalesceExpression.Create(ifStatement, expression2, expression1, isYield).ToImmutableArray());
                        }
                    }
                    else if (conditionKind == SyntaxKind.NotEqualsExpression)
                    {
                        var binaryExpression = (BinaryExpressionSyntax)condition;

                        if (IsNullLiteral(binaryExpression.Right) &&
                            IsEquivalent(binaryExpression.Left, expression1))
                        {
                            return(IfToReturnWithCoalesceExpression.Create(ifStatement, expression1, expression2, isYield).ToImmutableArray());
                        }
                    }
                }

                IfToReturnWithBooleanExpression ifToReturnWithBooleanExpression = null;

                if (options.UseBooleanExpression &&
                    semanticModel.GetTypeSymbol(expression1, cancellationToken)?.IsBoolean() == true &&
                    semanticModel.GetTypeSymbol(expression2, cancellationToken)?.IsBoolean() == true)
                {
                    ifToReturnWithBooleanExpression = IfToReturnWithBooleanExpression.Create(ifStatement, expression1, expression2, isYield);
                }

                IfToReturnWithConditionalExpression ifToReturnWithConditionalExpression = null;

                if (options.UseConditionalExpression &&
                    (!expression1.IsBooleanLiteralExpression() || !expression2.IsBooleanLiteralExpression()))
                {
                    ifToReturnWithConditionalExpression = IfToReturnWithConditionalExpression.Create(ifStatement, expression1, expression2, isYield);
                }

                return(ToImmutableArray(ifToReturnWithBooleanExpression, ifToReturnWithConditionalExpression));
            }

            return(ImmutableArray <IfRefactoring> .Empty);
        }