public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CallToMethod) &&
yieldStatement.Kind() == SyntaxKind.YieldReturnStatement)
{
ExpressionSyntax expression = yieldStatement.Expression;
if (expression?.IsMissing == false &&
expression.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
(ISymbol memberSymbol, ITypeSymbol memberTypeSymbol) = ReturnExpressionRefactoring.GetContainingSymbolAndType(expression, semanticModel, context.CancellationToken);
if (memberSymbol != null &&
(memberTypeSymbol is INamedTypeSymbol namedTypeSymbol) &&
namedTypeSymbol.SpecialType != SpecialType.System_Collections_IEnumerable &&
namedTypeSymbol.OriginalDefinition.IsIEnumerableOfT())
{
ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0];
ITypeSymbol expressionTypeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (argumentSymbol != expressionTypeSymbol)
{
ModifyExpressionRefactoring.ComputeRefactoring(
context,
expression,
argumentSymbol,
semanticModel,
addCastExpression: false);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertReturnToIf) &&
(context.Span.IsEmptyAndContainedInSpan(yieldStatement.YieldKeyword) ||
context.Span.IsEmptyAndContainedInSpan(yieldStatement.ReturnOrBreakKeyword) ||
context.Span.IsBetweenSpans(yieldStatement)))
{
await ConvertReturnToIfRefactoring.ConvertYieldReturnToIfElse.ComputeRefactoringAsync(context, yieldStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseListInsteadOfYield) &&
yieldStatement.IsYieldReturn() &&
context.Span.IsEmptyAndContainedInSpan(yieldStatement.YieldKeyword))
{
SyntaxNode declaration = yieldStatement.FirstAncestor(SyntaxKind.MethodDeclaration, SyntaxKind.LocalFunctionStatement, SyntaxKind.GetAccessorDeclaration, ascendOutOfTrivia: false);
Debug.Assert(declaration != null);
if (declaration != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, declaration, semanticModel);
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertReturnStatementToIf) &&
(context.Span.IsEmptyAndContainedInSpan(yieldStatement.YieldKeyword) ||
context.Span.IsEmptyAndContainedInSpan(yieldStatement.ReturnOrBreakKeyword) ||
context.Span.IsBetweenSpans(yieldStatement)))
{
await ConvertReturnStatementToIfRefactoring.ConvertYieldReturnToIfElse.ComputeRefactoringAsync(context, yieldStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.UseListInsteadOfYield) &&
yieldStatement.IsYieldReturn() &&
context.Span.IsEmptyAndContainedInSpan(yieldStatement.YieldKeyword))
{
SyntaxNode declaration = yieldStatement.FirstAncestor(SyntaxKind.MethodDeclaration, SyntaxKind.LocalFunctionStatement, SyntaxKind.GetAccessorDeclaration, ascendOutOfTrivia: false);
Debug.Assert(declaration != null);
if (declaration != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, declaration, semanticModel);
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, LocalFunctionStatementSyntax localFunctionStatement)
{
if (localFunctionStatement.IsParentKind(SyntaxKind.Block))
{
BlockSyntax body = localFunctionStatement.Body;
if (body != null)
{
if (body.OpenBraceToken.Span.Contains(context.Span) ||
body.CloseBraceToken.Span.Contains(context.Span))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveMember))
{
context.RegisterRefactoring(
"Remove local function",
cancellationToken => context.Document.RemoveStatementAsync(localFunctionStatement, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateMember))
{
context.RegisterRefactoring(
"Duplicate local function",
cancellationToken => DuplicateMemberDeclarationRefactoring.RefactorAsync(context.Document, localFunctionStatement, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutMember))
{
CommentOutRefactoring.RegisterRefactoring(context, localFunctionStatement);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddTypeParameter))
{
AddTypeParameterRefactoring.ComputeRefactoring(context, localFunctionStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
localFunctionStatement.Body?.Span.Contains(context.Span) == true &&
UseExpressionBodiedMemberAnalysis.IsFixable(localFunctionStatement))
{
context.RegisterRefactoring(
"Use expression-bodied member",
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, localFunctionStatement, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseListInsteadOfYield) &&
localFunctionStatement.Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, localFunctionStatement, semanticModel);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MoveUnsafeContextToContainingDeclaration))
{
MoveUnsafeContextToContainingDeclarationRefactoring.ComputeRefactoring(context, localFunctionStatement);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, LocalFunctionStatementSyntax localFunctionStatement)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddTypeParameter))
{
AddTypeParameterRefactoring.ComputeRefactoring(context, localFunctionStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
localFunctionStatement.Body?.Span.Contains(context.Span) == true &&
UseExpressionBodiedMemberRefactoring.CanRefactor(localFunctionStatement))
{
context.RegisterRefactoring(
"Use expression-bodied member",
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, localFunctionStatement, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseListInsteadOfYield) &&
localFunctionStatement.Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, localFunctionStatement, semanticModel);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
if (methodDeclaration.Span.Contains(context.Span))
{
await ChangeMethodReturnTypeToVoidRefactoring.ComputeRefactoringAsync(context, methodDeclaration).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddTypeParameter))
{
AddTypeParameterRefactoring.ComputeRefactoring(context, methodDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceMethodWithProperty) &&
methodDeclaration.HeaderSpan().Contains(context.Span) &&
ReplaceMethodWithPropertyRefactoring.CanRefactor(methodDeclaration))
{
context.RegisterRefactoring(
$"Replace '{methodDeclaration.Identifier.ValueText}' with property",
cancellationToken => ReplaceMethodWithPropertyRefactoring.RefactorAsync(context.Document, methodDeclaration, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
methodDeclaration.Body?.Span.Contains(context.Span) == true &&
context.SupportsCSharp6 &&
UseExpressionBodiedMemberRefactoring.CanRefactor(methodDeclaration))
{
context.RegisterRefactoring(
"Use expression-bodied member",
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, methodDeclaration, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberAbstract) &&
methodDeclaration.HeaderSpan().Contains(context.Span))
{
MakeMethodAbstractRefactoring.ComputeRefactoring(context, methodDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberVirtual) &&
methodDeclaration.HeaderSpan().Contains(context.Span))
{
MakeMethodVirtualRefactoring.ComputeRefactoring(context, methodDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) &&
methodDeclaration.HeaderSpan().Contains(context.Span))
{
await CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoringAsync(context, methodDeclaration).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameMethodAccordingToTypeName))
{
await RenameMethodAccoringToTypeNameAsync(context, methodDeclaration).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddMemberToInterface) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(methodDeclaration.Identifier))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AddMemberToInterfaceRefactoring.ComputeRefactoring(context, methodDeclaration, semanticModel);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseListInsteadOfYield) &&
methodDeclaration.Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, methodDeclaration, semanticModel);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression,
RefactoringIdentifiers.AddCastExpression,
RefactoringIdentifiers.CallToMethod) &&
yieldStatement.IsYieldReturn() &&
yieldStatement.Expression != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol memberSymbol = ReturnExpressionRefactoring.GetContainingMethodOrPropertySymbol(yieldStatement.Expression, semanticModel, context.CancellationToken);
if (memberSymbol != null)
{
SyntaxNode node = await memberSymbol
.DeclaringSyntaxReferences[0]
.GetSyntaxAsync(context.CancellationToken)
.ConfigureAwait(false);
TypeSyntax type = ReturnExpressionRefactoring.GetTypeOrReturnType(node);
if (type != null)
{
ITypeSymbol memberTypeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
if (memberTypeSymbol?.SpecialType != SpecialType.System_Collections_IEnumerable)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(yieldStatement.Expression, context.CancellationToken);
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression) &&
typeSymbol?.IsErrorType() == false &&
!typeSymbol.IsVoid() &&
!memberSymbol.IsOverride &&
(memberTypeSymbol == null ||
memberTypeSymbol.IsErrorType() ||
!memberTypeSymbol.IsConstructedFromIEnumerableOfT() ||
!((INamedTypeSymbol)memberTypeSymbol).TypeArguments[0].Equals(typeSymbol)))
{
INamedTypeSymbol newTypeSymbol = semanticModel
.Compilation
.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T)
.Construct(typeSymbol);
TypeSyntax newType = newTypeSymbol.ToMinimalTypeSyntax(semanticModel, type.SpanStart);
context.RegisterRefactoring(
$"Change {ReturnExpressionRefactoring.GetText(node)} type to '{SymbolDisplay.GetMinimalString(newTypeSymbol, semanticModel, type.SpanStart)}'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeAsync(
context.Document,
type,
newType,
cancellationToken));
});
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) &&
yieldStatement.Expression.Span.Contains(context.Span) &&
memberTypeSymbol?.IsNamedType() == true)
{
var namedTypeSymbol = (INamedTypeSymbol)memberTypeSymbol;
if (namedTypeSymbol.IsConstructedFromIEnumerableOfT())
{
ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0];
if (argumentSymbol != typeSymbol)
{
ModifyExpressionRefactoring.ComputeRefactoring(
context,
yieldStatement.Expression,
argumentSymbol,
semanticModel);
}
}
}
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceStatementWithIfStatement) &&
context.Span.IsBetweenSpans(yieldStatement))
{
var refactoring = new ReplaceYieldStatementWithIfStatementRefactoring();
await refactoring.ComputeRefactoringAsync(context, yieldStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseListInsteadOfYield))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, yieldStatement, semanticModel);
}
}