public static async Task ComputeRefactoringsAsync(RefactoringContext context, ArgumentSyntax argument)
{
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod))
{
ExpressionSyntax expression = argument.Expression;
if (expression?.IsMissing == false)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(expression).ConvertedType;
if (typeSymbol?.IsErrorType() == false)
{
IEnumerable <ITypeSymbol> newTypes = DetermineParameterTypes(argument, semanticModel, context.CancellationToken)
.Where(f => !typeSymbol.Equals(f));
ModifyExpressionRefactoring.ComputeRefactoring(context, expression, newTypes, semanticModel);
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceMethodGroupWithLambda))
{
await ReplaceMethodGroupWithLambdaRefactoring.ComputeRefactoringAsync(context, argument).ConfigureAwait(false);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, VariableDeclaratorSyntax variableDeclarator)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.InitializeFieldFromConstructor) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(variableDeclarator.Identifier))
{
InitializeFieldFromConstructorRefactoring.ComputeRefactoring(context, variableDeclarator);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceMethodGroupWithLambda))
{
await ReplaceMethodGroupWithLambdaRefactoring.ComputeRefactoringAsync(context, variableDeclarator).ConfigureAwait(false);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, AssignmentExpressionSyntax assignmentExpression)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandAssignmentExpression) &&
assignmentExpression.OperatorToken.Span.Contains(context.Span) &&
ExpandAssignmentExpressionRefactoring.CanRefactor(assignmentExpression))
{
context.RegisterRefactoring(
"Expand assignment",
cancellationToken =>
{
return(ExpandAssignmentExpressionRefactoring.RefactorAsync(
context.Document,
assignmentExpression,
cancellationToken));
});
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) &&
assignmentExpression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
ExpressionSyntax left = assignmentExpression.Left;
ExpressionSyntax right = assignmentExpression.Right;
if (left?.IsMissing == false &&
right?.IsMissing == false &&
right.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol leftSymbol = semanticModel.GetTypeSymbol(left, context.CancellationToken);
if (leftSymbol?.IsErrorType() == false)
{
ITypeSymbol rightSymbol = semanticModel.GetTypeSymbol(right, context.CancellationToken);
if (rightSymbol?.IsErrorType() == false &&
!leftSymbol.Equals(rightSymbol))
{
ModifyExpressionRefactoring.ComputeRefactoring(context, right, leftSymbol, semanticModel);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceMethodGroupWithLambda) &&
context.SupportsSemanticModel)
{
await ReplaceMethodGroupWithLambdaRefactoring.ComputeRefactoringAsync(context, assignmentExpression).ConfigureAwait(false);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, AssignmentExpressionSyntax assignmentExpression)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandCompoundAssignmentOperator) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(assignmentExpression.OperatorToken) &&
CSharpFacts.IsCompoundAssignmentExpression(assignmentExpression.Kind()) &&
SyntaxInfo.AssignmentExpressionInfo(assignmentExpression).Success)
{
context.RegisterRefactoring(
$"Expand {assignmentExpression.OperatorToken}",
ct => ExpandCompoundAssignmentOperatorRefactoring.RefactorAsync(context.Document, assignmentExpression, ct));
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) &&
assignmentExpression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
SimpleAssignmentExpressionInfo simpleAssignment = SyntaxInfo.SimpleAssignmentExpressionInfo(assignmentExpression);
ExpressionSyntax right = simpleAssignment.Right;
if (simpleAssignment.Success &&
right.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol leftSymbol = semanticModel.GetTypeSymbol(simpleAssignment.Left, context.CancellationToken);
if (leftSymbol?.IsErrorType() == false)
{
ITypeSymbol rightSymbol = semanticModel.GetTypeSymbol(right, context.CancellationToken);
if (rightSymbol?.IsErrorType() == false &&
!leftSymbol.Equals(rightSymbol))
{
ModifyExpressionRefactoring.ComputeRefactoring(context, right, leftSymbol, semanticModel);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceMethodGroupWithLambda) &&
context.SupportsSemanticModel)
{
await ReplaceMethodGroupWithLambdaRefactoring.ComputeRefactoringAsync(context, assignmentExpression).ConfigureAwait(false);
}
}
