public static async Task ComputeRefactoringAsync(RefactoringContext context, ConditionalExpressionSyntax conditionalExpression)
{
ExpressionSyntax expression = conditionalExpression.WalkUpParentheses();
SyntaxNode parent = expression.Parent;
if (parent.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.YieldReturnStatement))
{
context.RegisterRefactoring(
Title,
cancellationToken => RefactorAsync(context.Document, (StatementSyntax)parent, conditionalExpression, cancellationToken));
}
else
{
var assignment = parent as AssignmentExpressionSyntax;
if (assignment != null)
{
var expressionStatement = assignment.Parent as ExpressionStatementSyntax;
if (expressionStatement != null)
{
context.RegisterRefactoring(
Title,
cancellationToken => RefactorAsync(context.Document, expressionStatement, conditionalExpression, cancellationToken));
}
}
else
{
SingleLocalDeclarationStatement localDeclaration;
if (SingleLocalDeclarationStatement.TryCreateFromValue(expression, out localDeclaration))
{
TypeSyntax type = localDeclaration.Type;
if (type != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (!type.IsVar ||
semanticModel.GetTypeSymbol(type, context.CancellationToken)?.SupportsExplicitDeclaration() == true)
{
context.RegisterRefactoring(
Title,
cancellationToken => RefactorAsync(context.Document, localDeclaration.Statement, conditionalExpression, semanticModel, cancellationToken));
}
}
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ConditionalExpressionSyntax conditionalExpression)
{
ExpressionSyntax expression = conditionalExpression.WalkUpParentheses();
SyntaxNode parent = expression.Parent;
if (parent.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.YieldReturnStatement))
{
context.RegisterRefactoring(
Title,
cancellationToken => RefactorAsync(context.Document, (StatementSyntax)parent, conditionalExpression, cancellationToken),
RefactoringIdentifiers.ReplaceConditionalExpressionWithIfElse);
}
else if (parent is AssignmentExpressionSyntax assignment)
{
if (assignment.Parent is ExpressionStatementSyntax expressionStatement)
{
context.RegisterRefactoring(
Title,
cancellationToken => RefactorAsync(context.Document, expressionStatement, conditionalExpression, cancellationToken),
RefactoringIdentifiers.ReplaceConditionalExpressionWithIfElse);
}
}
else
{
SingleLocalDeclarationStatementInfo localDeclarationInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo(expression);
if (localDeclarationInfo.Success)
{
TypeSyntax type = localDeclarationInfo.Type;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (!type.IsVar ||
semanticModel.GetTypeSymbol(type, context.CancellationToken)?.SupportsExplicitDeclaration() == true)
{
context.RegisterRefactoring(
Title,
cancellationToken => RefactorAsync(context.Document, localDeclarationInfo.Statement, conditionalExpression, semanticModel, cancellationToken),
RefactoringIdentifiers.ReplaceConditionalExpressionWithIfElse);
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ConditionalExpressionSyntax conditionalExpression)
{
ExpressionSyntax expression = conditionalExpression.WalkUpParentheses();
SyntaxNode parent = expression.Parent;
if (parent.IsKind(SyntaxKind.ReturnStatement, SyntaxKind.YieldReturnStatement))
{
var statement = (StatementSyntax)parent;
RegisterRefactoring(context, conditionalExpression, statement);
if (IsRecursive())
{
RegisterRefactoring(context, conditionalExpression, statement, recursive: true);
}
}
else if (parent is AssignmentExpressionSyntax assignment)
{
if (assignment.Parent is ExpressionStatementSyntax expressionStatement)
{
RegisterRefactoring(context, conditionalExpression, expressionStatement);
if (IsRecursive())
{
RegisterRefactoring(context, conditionalExpression, expressionStatement, recursive: true);
}
}
}
else
{
SingleLocalDeclarationStatementInfo localDeclarationInfo = SyntaxInfo.SingleLocalDeclarationStatementInfo(expression);
if (localDeclarationInfo.Success)
{
TypeSyntax type = localDeclarationInfo.Type;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (!type.IsVar ||
semanticModel.GetTypeSymbol(type, context.CancellationToken)?.SupportsExplicitDeclaration() == true)
{
LocalDeclarationStatementSyntax statement = localDeclarationInfo.Statement;
RegisterRefactoring(context, conditionalExpression, statement, semanticModel);
if (IsRecursive())
{
RegisterRefactoring(context, conditionalExpression, statement, semanticModel, recursive: true);
}
}
}
}
bool IsRecursive()
{
return(conditionalExpression
.WhenFalse
.WalkDownParentheses()
.IsKind(SyntaxKind.ConditionalExpression));
}
}
