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 void ComputeRefactorings(RefactoringContext context, AccessorDeclarationSyntax accessor)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatAccessorBraces))
{
BlockSyntax body = accessor.Body;
if (body?.Span.Contains(context.Span) == true &&
!body.OpenBraceToken.IsMissing &&
!body.CloseBraceToken.IsMissing)
{
if (body.IsSingleLine())
{
if (accessor.Parent?.IsMultiLine() == true)
{
context.RegisterRefactoring(
"Format braces on separate lines",
ct => SyntaxFormatter.ToMultiLineAsync(context.Document, accessor, ct),
RefactoringIdentifiers.FormatAccessorBraces);
}
}
else
{
SyntaxList <StatementSyntax> statements = body.Statements;
if (body.Statements.SingleOrDefault(shouldThrow: false)?.IsSingleLine() == true &&
accessor.DescendantTrivia(accessor.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.RegisterRefactoring(
"Format braces on a single line",
ct => SyntaxFormatter.ToSingleLineAsync(context.Document, accessor, ct),
RefactoringIdentifiers.FormatAccessorBraces);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
context.SupportsCSharp6 &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(accessor) &&
UseExpressionBodiedMemberAnalysis.IsFixable(accessor))
{
SyntaxNode node = accessor;
if (accessor.Parent is AccessorListSyntax accessorList &&
accessorList.Accessors.SingleOrDefault(shouldThrow: false)?.Kind() == SyntaxKind.GetAccessorDeclaration &&
(accessorList.Parent is MemberDeclarationSyntax parent))
{
node = parent;
}
context.RegisterRefactoring(
"Use expression-bodied member",
ct => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, node, ct),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
}
public static void ComputeRefactorings(RefactoringContext context, DestructorDeclarationSyntax destructorDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
destructorDeclaration.Body?.Span.Contains(context.Span) == true &&
context.SupportsCSharp6 &&
UseExpressionBodiedMemberAnalysis.IsFixable(destructorDeclaration))
{
context.RegisterRefactoring(
"Use expression-bodied member",
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, destructorDeclaration, cancellationToken));
}
}
private static void ComputeRefactorings(RefactoringContext context, ConversionOperatorDeclarationSyntax operatorDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
context.SupportsCSharp6 &&
operatorDeclaration.Body != null &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(operatorDeclaration.Body) &&
UseExpressionBodiedMemberAnalysis.IsFixable(operatorDeclaration))
{
context.RegisterRefactoring(
"Use expression-bodied member",
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, operatorDeclaration, cancellationToken),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ConstructorDeclarationSyntax constructorDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
constructorDeclaration.Body?.Span.Contains(context.Span) == true &&
context.SupportsCSharp6 &&
UseExpressionBodiedMemberAnalysis.IsFixable(constructorDeclaration))
{
context.RegisterRefactoring(
"Use expression-bodied member",
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, constructorDeclaration, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) &&
constructorDeclaration.HeaderSpan().Contains(context.Span))
{
await CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoringAsync(context, constructorDeclaration).ConfigureAwait(false);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMethodReturnTypeToVoid) &&
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 &&
UseExpressionBodiedMemberAnalysis.IsFixable(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);
}
}