private static ImmutableArray <IfRefactoring> Analyze(
ExpressionStatementSyntax expressionStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
SimpleAssignmentStatement assignment;
if (SimpleAssignmentStatement.TryCreate(expressionStatement, out assignment))
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) == false)
{
SimpleAssignmentStatement assignment1;
if (SimpleAssignmentStatement.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment1))
{
SimpleAssignmentStatement assignment2;
if (SimpleAssignmentStatement.TryCreate(elseClause.GetSingleStatementOrDefault(), out assignment2) &&
assignment1.Left.IsEquivalentTo(assignment2.Left, topLevel: false) &&
assignment1.Left.IsEquivalentTo(assignment.Left, topLevel: false) &&
options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(expressionStatement.SpanStart, ifStatement.Span.End)))
{
return(new AssignmentAndIfElseToAssignmentWithConditionalExpression(expressionStatement, assignment.Right, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray());
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
private static ImmutableArray<IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
ReturnStatementSyntax returnStatement,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
ExpressionSyntax condition = ifStatement.Condition?.WalkDownParentheses();
if (condition?.IsMissing != false)
return Empty;
StatementSyntax statement = ifStatement.GetSingleStatementOrDefault();
if (statement?.IsKind(SyntaxKind.ReturnStatement) != true)
return Empty;
if (!options.CheckSpanDirectives(ifStatement, TextSpan.FromBounds(ifStatement.SpanStart, returnStatement.Span.End)))
return Empty;
return Analyze(
ifStatement,
condition,
((ReturnStatementSyntax)statement).Expression?.WalkDownParentheses(),
returnStatement.Expression?.WalkDownParentheses(),
semanticModel,
cancellationToken,
options,
isYield: false);
}
private static IfRefactoring CreateIfToAssignment(
IfStatementSyntax ifStatement,
ExpressionSyntax left,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
NullCheckExpressionInfo nullCheck,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if ((nullCheck.Kind & NullCheckKind.ComparisonToNull) != 0 &&
SyntaxComparer.AreEquivalent(nullCheck.Expression, expression1))
{
return(CreateIfToAssignment(ifStatement, left, expression1, expression2, options, isNullable: false));
}
expression1 = GetNullableOfTValueProperty(expression1, semanticModel, cancellationToken);
if (SyntaxComparer.AreEquivalent(nullCheck.Expression, expression1))
{
return(CreateIfToAssignment(ifStatement, left, expression1, expression2, options, isNullable: true));
}
return(null);
}
private static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
ReturnStatementSyntax returnStatement,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
ExpressionSyntax condition = ifStatement.Condition;
if (condition?.IsMissing == false)
{
StatementSyntax statement = ifStatement.GetSingleStatementOrDefault();
if (statement?.IsKind(SyntaxKind.ReturnStatement) == true &&
options.CheckSpanDirectives(ifStatement, TextSpan.FromBounds(ifStatement.SpanStart, returnStatement.Span.End)))
{
return(Analyze(
ifStatement,
condition,
((ReturnStatementSyntax)statement).Expression,
returnStatement.Expression,
semanticModel,
cancellationToken,
options,
isYield: false));
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
private static ImmutableArray<IfRefactoring> Analyze(
ExpressionStatementSyntax expressionStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
SimpleAssignmentStatementInfo assignment = SyntaxInfo.SimpleAssignmentStatementInfo(expressionStatement);
if (!assignment.Success)
return Empty;
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) != false)
return Empty;
SimpleAssignmentStatementInfo assignment1 = SyntaxInfo.SimpleAssignmentStatementInfo(ifStatement.GetSingleStatementOrDefault());
if (!assignment1.Success)
return Empty;
SimpleAssignmentStatementInfo assignment2 = SyntaxInfo.SimpleAssignmentStatementInfo(elseClause.GetSingleStatementOrDefault());
if (!assignment2.Success)
return Empty;
if (!SyntaxComparer.AreEquivalent(assignment1.Left, assignment2.Left, assignment.Left))
return Empty;
if (!options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(expressionStatement.SpanStart, ifStatement.Span.End)))
return Empty;
return new AssignmentAndIfElseToAssignmentWithConditionalExpression(expressionStatement, assignment.Right, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray();
}
public static ImmutableArray <IfRefactoring> Analyze(
StatementsSelection selectedStatements,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (selectedStatements.Count != 2)
{
return(Empty);
}
StatementSyntax[] statements = selectedStatements.ToArray();
StatementSyntax statement1 = statements[0];
StatementSyntax statement2 = statements[1];
if (statement1.ContainsDiagnostics)
{
return(Empty);
}
if (statement2.ContainsDiagnostics)
{
return(Empty);
}
SyntaxKind kind1 = statement1.Kind();
SyntaxKind kind2 = statement2.Kind();
if (kind1 == SyntaxKind.IfStatement)
{
if (kind2 == SyntaxKind.ReturnStatement)
{
var ifStatement = (IfStatementSyntax)statement1;
if (ifStatement.IsSimpleIf())
{
return(Analyze(ifStatement, (ReturnStatementSyntax)statement2, options, semanticModel, cancellationToken));
}
}
}
else if (options.UseConditionalExpression)
{
if (kind1 == SyntaxKind.LocalDeclarationStatement)
{
if (kind2 == SyntaxKind.IfStatement)
{
return(Analyze((LocalDeclarationStatementSyntax)statement1, (IfStatementSyntax)statement2, options));
}
}
else if (kind1 == SyntaxKind.ExpressionStatement &&
kind2 == SyntaxKind.IfStatement)
{
return(Analyze((ExpressionStatementSyntax)statement1, (IfStatementSyntax)statement2, options));
}
}
return(Empty);
}
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)
{
NullCheckExpression nullCheck;
if (NullCheckExpression.TryCreate(condition, semanticModel, out nullCheck, cancellationToken))
{
IfRefactoring refactoring = CreateIfToReturnWithCoalesceExpression(
ifStatement,
(nullCheck.IsCheckingNull) ? expression2 : expression1,
(nullCheck.IsCheckingNull) ? expression1 : expression2,
nullCheck,
isYield,
semanticModel,
cancellationToken);
if (refactoring != null)
{
return(refactoring.ToImmutableArray());
}
}
}
IfToReturnWithBooleanExpression ifToReturnWithBooleanExpression = null;
if (options.UseBooleanExpression &&
(expression1.IsBooleanLiteralExpression() || expression2.IsBooleanLiteralExpression()) &&
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);
}
private static ImmutableArray<IfRefactoring> Analyze(
LocalDeclarationStatementSyntax localDeclarationStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
VariableDeclaratorSyntax declarator = localDeclarationStatement
.Declaration?
.Variables
.SingleOrDefault(shouldthrow: false);
if (declarator == null)
return Empty;
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) != false)
return Empty;
SimpleAssignmentStatementInfo assignment1 = SyntaxInfo.SimpleAssignmentStatementInfo(ifStatement.GetSingleStatementOrDefault());
if (!assignment1.Success)
return Empty;
SimpleAssignmentStatementInfo assignment2 = SyntaxInfo.SimpleAssignmentStatementInfo(elseClause.GetSingleStatementOrDefault());
if (!assignment2.Success)
return Empty;
if (!assignment1.Left.IsKind(SyntaxKind.IdentifierName))
return Empty;
if (!assignment2.Left.IsKind(SyntaxKind.IdentifierName))
return Empty;
string identifier1 = ((IdentifierNameSyntax)assignment1.Left).Identifier.ValueText;
string identifier2 = ((IdentifierNameSyntax)assignment2.Left).Identifier.ValueText;
if (!string.Equals(identifier1, identifier2, StringComparison.Ordinal))
return Empty;
if (!string.Equals(identifier1, declarator.Identifier.ValueText, StringComparison.Ordinal))
return Empty;
if (!options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(localDeclarationStatement.SpanStart, ifStatement.Span.End)))
return Empty;
return new LocalDeclarationAndIfElseAssignmentWithConditionalExpression(localDeclarationStatement, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray();
}
private static IfRefactoring CreateIfToAssignment(
IfStatementSyntax ifStatement,
ExpressionSyntax left,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
IfAnalysisOptions options,
bool isNullable)
{
if (!isNullable
&& expression2.Kind() == SyntaxKind.NullLiteralExpression)
{
if (options.UseExpression)
return new IfElseToAssignmentWithExpression(ifStatement, expression1.FirstAncestor<ExpressionStatementSyntax>());
}
else if (options.UseCoalesceExpression)
{
return new IfElseToAssignmentWithCoalesceExpression(ifStatement, left, expression1, expression2);
}
return null;
}
private static IfRefactoring CreateIfToReturnStatement(
IfStatementSyntax ifStatement,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
IfAnalysisOptions options,
bool isYield,
bool isNullable)
{
if (!isNullable
&& expression2.Kind() == SyntaxKind.NullLiteralExpression)
{
if (options.UseExpression)
return new IfToReturnWithExpression(ifStatement, expression1, isYield);
}
else if (options.UseCoalesceExpression)
{
return new IfToReturnWithCoalesceExpression(ifStatement, expression1, expression2, isYield);
}
return null;
}
private static ImmutableArray <IfRefactoring> Analyze(
LocalDeclarationStatementSyntax localDeclarationStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
VariableDeclaratorSyntax declarator = localDeclarationStatement
.Declaration?
.Variables
.SingleOrDefault(throwException: false);
if (declarator != null)
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) == false)
{
SimpleAssignmentStatement assignment1;
if (SimpleAssignmentStatement.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment1))
{
SimpleAssignmentStatement assignment2;
if (SimpleAssignmentStatement.TryCreate(elseClause.GetSingleStatementOrDefault(), out assignment2) &&
assignment1.Left.IsKind(SyntaxKind.IdentifierName) &&
assignment2.Left.IsKind(SyntaxKind.IdentifierName))
{
string identifier1 = ((IdentifierNameSyntax)assignment1.Left).Identifier.ValueText;
string identifier2 = ((IdentifierNameSyntax)assignment2.Left).Identifier.ValueText;
if (string.Equals(identifier1, identifier2, StringComparison.Ordinal) &&
string.Equals(identifier1, declarator.Identifier.ValueText, StringComparison.Ordinal) &&
options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(localDeclarationStatement.SpanStart, ifStatement.Span.End)))
{
return(new LocalDeclarationAndIfElseAssignmentWithConditionalExpression(localDeclarationStatement, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray());
}
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
private static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
ExpressionSyntax condition,
ExpressionStatementSyntax expressionStatement1,
ExpressionStatementSyntax expressionStatement2,
SemanticModel semanticModel,
CancellationToken cancellationToken,
IfAnalysisOptions options)
{
ExpressionSyntax expression1 = expressionStatement1.Expression;
if (IsSimpleAssignment(expression1))
{
ExpressionSyntax expression2 = expressionStatement2.Expression;
if (IsSimpleAssignment(expression2))
{
var assignment1 = (AssignmentExpressionSyntax)expression1;
var assignment2 = (AssignmentExpressionSyntax)expression2;
ExpressionSyntax left1 = assignment1.Left;
ExpressionSyntax right1 = assignment1.Right;
if (left1?.IsMissing == false &&
right1?.IsMissing == false)
{
ExpressionSyntax left2 = assignment2.Left;
ExpressionSyntax right2 = assignment2.Right;
if (left2?.IsMissing == false &&
right2?.IsMissing == false &&
IsEquivalent(left1, left2))
{
if (options.UseCoalesceExpression)
{
NullCheckExpression nullCheck;
if (NullCheckExpression.TryCreate(condition, semanticModel, out nullCheck, cancellationToken))
{
IfRefactoring refactoring = CreateIfToAssignmentWithWithCoalesceExpression(
ifStatement,
left1,
(nullCheck.IsCheckingNull) ? right2 : right1,
(nullCheck.IsCheckingNull) ? right1 : right2,
nullCheck,
semanticModel,
cancellationToken);
if (refactoring != null)
{
return(refactoring.ToImmutableArray());
}
}
}
if (options.UseConditionalExpression)
{
return(new IfElseToAssignmentWithConditionalExpression(ifStatement, left1, right1, right2).ToImmutableArray());
}
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
public static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (!ifStatement.IsTopmostIf())
{
return(Empty);
}
ExpressionSyntax condition = ifStatement.Condition?.WalkDownParentheses();
if (condition == null)
{
return(Empty);
}
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause != null)
{
if (!options.CheckSpanDirectives(ifStatement))
{
return(Empty);
}
StatementSyntax statement1 = ifStatement.GetSingleStatementOrDefault();
if (statement1 == null)
{
return(Empty);
}
SyntaxKind kind1 = statement1.Kind();
if (kind1.Is(
SyntaxKind.ExpressionStatement,
SyntaxKind.ReturnStatement,
SyntaxKind.YieldReturnStatement))
{
StatementSyntax statement2 = elseClause.GetSingleStatementOrDefault();
if (statement2?.Kind() == kind1)
{
switch (kind1)
{
case SyntaxKind.ExpressionStatement:
{
return(Analyze(
ifStatement,
condition,
(ExpressionStatementSyntax)statement1,
(ExpressionStatementSyntax)statement2,
options,
semanticModel,
cancellationToken));
}
case SyntaxKind.ReturnStatement:
{
return(Analyze(
ifStatement,
condition,
((ReturnStatementSyntax)statement1).Expression?.WalkDownParentheses(),
((ReturnStatementSyntax)statement2).Expression?.WalkDownParentheses(),
options,
isYield: false,
semanticModel: semanticModel,
cancellationToken: cancellationToken));
}
case SyntaxKind.YieldReturnStatement:
{
return(Analyze(
ifStatement,
condition,
((YieldStatementSyntax)statement1).Expression?.WalkDownParentheses(),
((YieldStatementSyntax)statement2).Expression?.WalkDownParentheses(),
options,
isYield: true,
semanticModel: semanticModel,
cancellationToken: cancellationToken));
}
}
}
}
}
else if (ifStatement.NextStatementOrDefault() is ReturnStatementSyntax returnStatement)
{
return(Analyze(ifStatement, returnStatement, options, semanticModel, cancellationToken));
}
return(Empty);
}
private static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
ExpressionSyntax condition,
ExpressionStatementSyntax expressionStatement1,
ExpressionStatementSyntax expressionStatement2,
IfAnalysisOptions options)
{
ExpressionSyntax expression1 = expressionStatement1.Expression;
if (IsSimpleAssignment(expression1))
{
ExpressionSyntax expression2 = expressionStatement2.Expression;
if (IsSimpleAssignment(expression2))
{
var assignment1 = (AssignmentExpressionSyntax)expression1;
var assignment2 = (AssignmentExpressionSyntax)expression2;
ExpressionSyntax left1 = assignment1.Left;
ExpressionSyntax right1 = assignment1.Right;
if (left1?.IsMissing == false &&
right1?.IsMissing == false)
{
ExpressionSyntax left2 = assignment2.Left;
ExpressionSyntax right2 = assignment2.Right;
if (left2?.IsMissing == false &&
right2?.IsMissing == false &&
IsEquivalent(left1, left2))
{
if (options.UseCoalesceExpression)
{
SyntaxKind conditionKind = condition.Kind();
if (conditionKind == SyntaxKind.EqualsExpression)
{
var binaryExpression = (BinaryExpressionSyntax)condition;
if (IsNullLiteral(binaryExpression.Right) &&
IsEquivalent(binaryExpression.Left, right2))
{
return(new IfElseToAssignmentWithCoalesceExpression(ifStatement, condition, left1, right2, right1).ToImmutableArray());
}
}
else if (conditionKind == SyntaxKind.NotEqualsExpression)
{
var binaryExpression = (BinaryExpressionSyntax)condition;
if (IsNullLiteral(binaryExpression.Right) &&
IsEquivalent(binaryExpression.Left, right1))
{
return(new IfElseToAssignmentWithCoalesceExpression(ifStatement, condition, left1, right1, right2).ToImmutableArray());
}
}
}
if (options.UseConditionalExpression)
{
return(new IfElseToAssignmentWithConditionalExpression(ifStatement, left1, right1, right2).ToImmutableArray());
}
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
private static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
ExpressionSyntax condition,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
IfAnalysisOptions options,
bool isYield,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (expression1?.IsMissing != false)
{
return(Empty);
}
if (expression2?.IsMissing != false)
{
return(Empty);
}
if (options.UseCoalesceExpression ||
options.UseExpression)
{
SyntaxKind kind1 = expression1.Kind();
SyntaxKind kind2 = expression2.Kind();
if (kind1.IsBooleanLiteralExpression() &&
kind2.IsBooleanLiteralExpression() &&
kind1 != kind2)
{
if (options.UseExpression)
{
if (ifStatement.IsSimpleIf() &&
(ifStatement.PreviousStatementOrDefault() is IfStatementSyntax previousIf) &&
previousIf.IsSimpleIf() &&
(previousIf.GetSingleStatementOrDefault() is ReturnStatementSyntax returnStatement) &&
returnStatement.Expression?.WalkDownParentheses().Kind() == kind1)
{
return(Empty);
}
return(new IfToReturnWithExpression(ifStatement, condition, isYield, negate: kind1 == SyntaxKind.FalseLiteralExpression).ToImmutableArray());
}
return(Empty);
}
NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(condition, semanticModel: semanticModel, cancellationToken: cancellationToken);
if (nullCheck.Success)
{
IfRefactoring refactoring = CreateIfToReturnStatement(
ifStatement,
(nullCheck.IsCheckingNull) ? expression2 : expression1,
(nullCheck.IsCheckingNull) ? expression1 : expression2,
nullCheck,
options,
isYield,
semanticModel,
cancellationToken);
if (refactoring != null)
{
return(refactoring.ToImmutableArray());
}
}
}
IfToReturnWithBooleanExpression ifToReturnWithBooleanExpression = null;
if (options.UseBooleanExpression &&
(expression1.Kind().IsBooleanLiteralExpression() || expression2.Kind().IsBooleanLiteralExpression()) &&
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.Kind().IsBooleanLiteralExpression() || !expression2.Kind().IsBooleanLiteralExpression()))
{
ifToReturnWithConditionalExpression = IfToReturnWithConditionalExpression.Create(ifStatement, expression1, expression2, isYield);
}
return(ToImmutableArray(ifToReturnWithBooleanExpression, ifToReturnWithConditionalExpression));
}
private static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
ExpressionSyntax condition,
ExpressionStatementSyntax expressionStatement1,
ExpressionStatementSyntax expressionStatement2,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
SimpleAssignmentStatementInfo assignment1 = SyntaxInfo.SimpleAssignmentStatementInfo(expressionStatement1);
if (!assignment1.Success)
{
return(Empty);
}
SimpleAssignmentStatementInfo assignment2 = SyntaxInfo.SimpleAssignmentStatementInfo(expressionStatement2);
if (!assignment2.Success)
{
return(Empty);
}
ExpressionSyntax left1 = assignment1.Left;
ExpressionSyntax left2 = assignment2.Left;
ExpressionSyntax right1 = assignment1.Right;
ExpressionSyntax right2 = assignment2.Right;
if (!SyntaxComparer.AreEquivalent(left1, left2))
{
return(Empty);
}
if (options.UseCoalesceExpression ||
options.UseExpression)
{
SyntaxKind kind1 = right1.Kind();
SyntaxKind kind2 = right2.Kind();
if (kind1.IsBooleanLiteralExpression() &&
kind2.IsBooleanLiteralExpression() &&
kind1 != kind2)
{
if (options.UseExpression)
{
return(new IfElseToAssignmentWithCondition(ifStatement, left1, condition, negate: kind1 == SyntaxKind.FalseLiteralExpression).ToImmutableArray());
}
return(Empty);
}
NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(condition, semanticModel: semanticModel, cancellationToken: cancellationToken);
if (nullCheck.Success)
{
IfRefactoring refactoring = CreateIfToAssignment(
ifStatement,
left1,
(nullCheck.IsCheckingNull) ? right2 : right1,
(nullCheck.IsCheckingNull) ? right1 : right2,
nullCheck,
options,
semanticModel,
cancellationToken);
if (refactoring != null)
{
return(refactoring.ToImmutableArray());
}
}
}
if (options.UseConditionalExpression)
{
return(new IfElseToAssignmentWithConditionalExpression(ifStatement, left1, right1, right2).ToImmutableArray());
}
return(Empty);
}
public static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (ifStatement.IsTopmostIf())
{
ExpressionSyntax condition = ifStatement.Condition;
if (condition != null)
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause != null)
{
if (options.CheckSpanDirectives(ifStatement))
{
StatementSyntax statement1 = ifStatement.GetSingleStatementOrDefault();
if (statement1 != null)
{
SyntaxKind kind1 = statement1.Kind();
if (kind1 == SyntaxKind.ExpressionStatement ||
kind1 == SyntaxKind.ReturnStatement ||
kind1 == SyntaxKind.YieldReturnStatement)
{
StatementSyntax statement2 = elseClause.GetSingleStatementOrDefault();
if (statement2?.IsKind(kind1) == true)
{
switch (kind1)
{
case SyntaxKind.ExpressionStatement:
{
return(Analyze(ifStatement, condition, (ExpressionStatementSyntax)statement1, (ExpressionStatementSyntax)statement2, semanticModel, cancellationToken, options));
}
case SyntaxKind.ReturnStatement:
{
return(Analyze(ifStatement, condition, ((ReturnStatementSyntax)statement1).Expression, ((ReturnStatementSyntax)statement2).Expression, semanticModel, cancellationToken, options, isYield: false));
}
case SyntaxKind.YieldReturnStatement:
{
return(Analyze(ifStatement, condition, ((YieldStatementSyntax)statement1).Expression, ((YieldStatementSyntax)statement2).Expression, semanticModel, cancellationToken, options, isYield: true));
}
}
}
}
}
}
}
else
{
StatementSyntax nextStatement = ifStatement.NextStatement();
if (nextStatement?.IsKind(SyntaxKind.ReturnStatement) == true)
{
return(Analyze(ifStatement, (ReturnStatementSyntax)nextStatement, options, semanticModel, cancellationToken));
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
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);
}
