public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
IfStatementSyntax ifStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <IfStatementSyntax>();
if (ifStatement == null)
{
return;
}
AddBracesToIfElseChain(context, ifStatement);
if (ifStatement.Condition != null &&
ifStatement.Condition.Span.Contains(context.Span) &&
context.Document.SupportsSemanticModel)
{
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken);
AddBooleanComparisonRefactoring.Refactor(ifStatement.Condition, context, semanticModel);
}
FormatBinaryExpressionRefactoring.Refactor(context, ifStatement);
SwapStatements(context, ifStatement);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
ReturnStatementSyntax returnStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ReturnStatementSyntax>();
if (returnStatement == null)
{
return;
}
if (returnStatement.Expression != null &&
returnStatement.Expression.Span.Contains(context.Span) &&
context.Document.SupportsSemanticModel)
{
MemberDeclarationSyntax declaration = GetDeclaration(returnStatement);
if (declaration != null)
{
TypeSyntax memberType = GetMemberType(declaration);
if (memberType != null)
{
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken);
ITypeSymbol memberTypeSymbol = semanticModel
.GetTypeInfo(memberType, context.CancellationToken)
.Type;
if (memberTypeSymbol?.IsKind(SymbolKind.ErrorType) == false)
{
ITypeSymbol typeSymbol = semanticModel
.GetTypeInfo(returnStatement.Expression, context.CancellationToken)
.Type;
if (typeSymbol?.IsKind(SymbolKind.ErrorType) == false)
{
if (memberTypeSymbol.SpecialType == SpecialType.System_Boolean &&
typeSymbol.IsKind(SymbolKind.NamedType))
{
var namedTypeSymbol = (INamedTypeSymbol)typeSymbol;
if (namedTypeSymbol?.ConstructedFrom.SpecialType == SpecialType.System_Nullable_T &&
namedTypeSymbol.TypeArguments[0].SpecialType == SpecialType.System_Boolean)
{
CodeAction codeAction = CodeAction.Create(
AddBooleanComparisonRefactoring.Title,
cancellationToken =>
{
return(AddBooleanComparisonRefactoring.RefactorAsync(
context.Document,
returnStatement.Expression,
context.CancellationToken));
});
context.RegisterRefactoring(codeAction);
}
}
if (!memberTypeSymbol.Equals(typeSymbol))
{
TypeSyntax newType = TypeSyntaxRefactoring.CreateTypeSyntax(typeSymbol);
if (newType != null)
{
CodeAction codeAction = CodeAction.Create(
$"Change {GetText(declaration)} type to '{typeSymbol.ToDisplayString(TypeSyntaxRefactoring.SymbolDisplayFormat)}'",
cancellationToken =>
{
return(ChangeReturnTypeAsync(
context.Document,
memberType,
newType,
cancellationToken));
});
context.RegisterRefactoring(codeAction);
}
}
}
}
}
}
}
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
BinaryExpressionSyntax binaryExpression = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <BinaryExpressionSyntax>();
if (binaryExpression == null)
{
return;
}
if (binaryExpression.IsAnyKind(SyntaxKind.LogicalAndExpression, SyntaxKind.LogicalOrExpression) &&
binaryExpression.Left?.IsMissing == false &&
binaryExpression.Right?.IsMissing == false)
{
if (context.Document.SupportsSemanticModel)
{
SemanticModel semanticModel = null;
if (binaryExpression.Left.Span.Contains(context.Span))
{
if (semanticModel == null)
{
semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken);
}
AddBooleanComparisonRefactoring.Refactor(binaryExpression.Left, context, semanticModel);
}
else if (binaryExpression.Right.Span.Contains(context.Span))
{
if (semanticModel == null)
{
semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken);
}
AddBooleanComparisonRefactoring.Refactor(binaryExpression.Right, context, semanticModel);
}
}
context.RegisterRefactoring(
"Negate binary expression",
cancellationToken =>
{
return(NegateBinaryExpressionAsync(
context.Document,
GetTopmostExpression(binaryExpression),
cancellationToken));
});
}
if (binaryExpression.OperatorToken.Span.Contains(context.Span) &&
ExpandCoalesceExpressionRefactoring.CanRefactor(binaryExpression))
{
context.RegisterRefactoring(
"Expand coalesce expression",
cancellationToken =>
{
return(ExpandCoalesceExpressionRefactoring.RefactorAsync(
context.Document,
binaryExpression,
cancellationToken));
});
}
SwapExpressionsRefactoring.Refactor(context, binaryExpression);
}
