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, IndexerDeclarationSyntax indexerDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
context.SupportsCSharp6)
{
AccessorListSyntax accessorList = indexerDeclaration.AccessorList;
if (accessorList != null &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(accessorList))
{
AccessorDeclarationSyntax accessor = indexerDeclaration
.AccessorList?
.Accessors
.SingleOrDefault(shouldThrow: false);
if (accessor?.AttributeLists.Any() == false &&
accessor.IsKind(SyntaxKind.GetAccessorDeclaration) &&
accessor.Body != null &&
(UseExpressionBodiedMemberAnalysis.GetReturnExpression(accessor.Body) != null))
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
ct => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, indexerDeclaration, ct),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberAbstract) &&
indexerDeclaration.HeaderSpan().Contains(context.Span))
{
MakeIndexerAbstractRefactoring.ComputeRefactoring(context, indexerDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberVirtual) &&
indexerDeclaration.HeaderSpan().Contains(context.Span))
{
MakeIndexerVirtualRefactoring.ComputeRefactoring(context, indexerDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) &&
indexerDeclaration.HeaderSpan().Contains(context.Span) &&
!indexerDeclaration.HasDocumentationComment())
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoring(context, indexerDeclaration, semanticModel);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddMemberToInterface) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(indexerDeclaration.ThisKeyword))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AddMemberToInterfaceRefactoring.ComputeRefactoring(context, indexerDeclaration, semanticModel);
}
}
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, 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 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)
{
BlockSyntax body = accessor.Body;
if (body != null &&
(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(accessor) ||
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(body)) &&
!accessor.AttributeLists.Any() &&
((accessor.IsKind(SyntaxKind.GetAccessorDeclaration))
? UseExpressionBodiedMemberAnalysis.GetReturnExpression(body) != null
: UseExpressionBodiedMemberAnalysis.GetExpression(body) != null) &&
(accessor.Parent as AccessorListSyntax)?
.Accessors
.SingleOrDefault(shouldThrow: false)?
.Kind() != SyntaxKind.GetAccessorDeclaration)
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
ct => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, accessor, 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.GetReturnExpression(operatorDeclaration.Body) != null)
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, operatorDeclaration, cancellationToken),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
}
public static bool CanRefactor(AccessorDeclarationSyntax accessorDeclaration, TextSpan?span = null)
{
BlockSyntax body = accessorDeclaration.Body;
return(body != null &&
(span?.IsEmptyAndContainedInSpanOrBetweenSpans(accessorDeclaration) != false ||
span.Value.IsEmptyAndContainedInSpanOrBetweenSpans(body)) &&
!accessorDeclaration.AttributeLists.Any() &&
((accessorDeclaration.IsKind(SyntaxKind.GetAccessorDeclaration))
? UseExpressionBodiedMemberAnalysis.GetReturnExpression(body) != null
: UseExpressionBodiedMemberAnalysis.GetExpression(body) != null) &&
(accessorDeclaration.Parent as AccessorListSyntax)?
.Accessors
.SingleOrDefault(shouldThrow: false)?
.Kind() != SyntaxKind.GetAccessorDeclaration);
}
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, ConstructorDeclarationSyntax constructorDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
context.SupportsCSharp6 &&
constructorDeclaration.Body != null &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(constructorDeclaration.Body) &&
UseExpressionBodiedMemberAnalysis.GetExpression(constructorDeclaration.Body) != null)
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, constructorDeclaration, cancellationToken),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) &&
constructorDeclaration.HeaderSpan().Contains(context.Span))
{
await CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoringAsync(context, constructorDeclaration).ConfigureAwait(false);
}
}
public static bool CanRefactor(PropertyDeclarationSyntax propertyDeclaration, TextSpan?span = null)
{
AccessorListSyntax accessorList = propertyDeclaration.AccessorList;
if (accessorList != null &&
span?.IsEmptyAndContainedInSpanOrBetweenSpans(accessorList) != false)
{
AccessorDeclarationSyntax accessor = propertyDeclaration
.AccessorList?
.Accessors
.SingleOrDefault(shouldThrow: false);
if (accessor?.AttributeLists.Any() == false &&
accessor.IsKind(SyntaxKind.GetAccessorDeclaration) &&
accessor.Body != null &&
(UseExpressionBodiedMemberAnalysis.GetReturnExpression(accessor.Body) != null))
{
return(true);
}
}
return(false);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMethodReturnTypeToVoid)
&& context.Span.IsEmptyAndContainedInSpan(methodDeclaration))
{
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),
RefactoringIdentifiers.ReplaceMethodWithProperty);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember)
&& context.SupportsCSharp6
&& methodDeclaration.Body != null
&& context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(methodDeclaration.Body)
&& UseExpressionBodiedMemberAnalysis.GetExpression(methodDeclaration.Body) != null)
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, methodDeclaration, cancellationToken),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
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)
&& !methodDeclaration.HasDocumentationComment())
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoring(context, methodDeclaration, semanticModel);
}
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);
}
}
private static SyntaxNode GetNewNode(SyntaxNode node)
{
switch (node.Kind())
{
case SyntaxKind.MethodDeclaration:
{
var methodDeclaration = (MethodDeclarationSyntax)node;
ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpressionOrThrowExpression(methodDeclaration.Body);
return(methodDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.ConstructorDeclaration:
{
var constructorDeclaration = (ConstructorDeclarationSyntax)node;
ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpressionOrThrowExpression(constructorDeclaration.Body);
return(constructorDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.DestructorDeclaration:
{
var destructorDeclaration = (DestructorDeclarationSyntax)node;
ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpressionOrThrowExpression(destructorDeclaration.Body);
return(destructorDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.LocalFunctionStatement:
{
var local = (LocalFunctionStatementSyntax)node;
ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpressionOrThrowExpression(local.Body);
return(local
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.OperatorDeclaration:
{
var operatorDeclaration = (OperatorDeclarationSyntax)node;
ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpressionOrThrowExpression(operatorDeclaration.Body);
return(operatorDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.ConversionOperatorDeclaration:
{
var operatorDeclaration = (ConversionOperatorDeclarationSyntax)node;
ExpressionSyntax expression = UseExpressionBodiedMemberAnalysis.GetExpressionOrThrowExpression(operatorDeclaration.Body);
return(operatorDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.PropertyDeclaration:
{
var propertyDeclaration = (PropertyDeclarationSyntax)node;
ExpressionSyntax expression = GetReturnExpressionOrThrowExpression(propertyDeclaration.AccessorList);
return(propertyDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithAccessorList(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.IndexerDeclaration:
{
var indexerDeclaration = (IndexerDeclarationSyntax)node;
ExpressionSyntax expression = GetReturnExpressionOrThrowExpression(indexerDeclaration.AccessorList);
return(indexerDeclaration
.WithExpressionBody(ArrowExpressionClause(expression))
.WithAccessorList(null)
.WithSemicolonToken(SemicolonToken()));
}
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
case SyntaxKind.AddAccessorDeclaration:
case SyntaxKind.RemoveAccessorDeclaration:
{
var accessor = (AccessorDeclarationSyntax)node;
ExpressionSyntax expression = GetExpressionOrThrowExpression(accessor);
return(accessor
.WithExpressionBody(ArrowExpressionClause(expression))
.WithBody(null)
.WithSemicolonToken(SemicolonToken()));
}
default:
{
Debug.Fail(node.Kind().ToString());
return(node);
}
}
}
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),
RefactoringIdentifiers.RemoveMember);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateMember))
{
context.RegisterRefactoring(
"Duplicate local function",
cancellationToken => DuplicateMemberDeclarationRefactoring.RefactorAsync(context.Document, localFunctionStatement, cancellationToken),
RefactoringIdentifiers.DuplicateMember);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutMember))
{
CommentOutRefactoring.RegisterRefactoring(context, localFunctionStatement);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMethodReturnTypeToVoid) &&
context.Span.IsEmptyAndContainedInSpan(localFunctionStatement))
{
await ChangeMethodReturnTypeToVoidRefactoring.ComputeRefactoringAsync(context, localFunctionStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddTypeParameter))
{
AddTypeParameterRefactoring.ComputeRefactoring(context, localFunctionStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
localFunctionStatement.Body != null &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(localFunctionStatement.Body) &&
UseExpressionBodiedMemberAnalysis.GetExpression(localFunctionStatement.Body) != null)
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, localFunctionStatement, cancellationToken),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MoveUnsafeContextToContainingDeclaration))
{
MoveUnsafeContextToContainingDeclarationRefactoring.ComputeRefactoring(context, localFunctionStatement);
}
}
public static bool CanRefactor(ConversionOperatorDeclarationSyntax operatorDeclaration, TextSpan?span = null)
{
return(operatorDeclaration.Body != null &&
span?.IsEmptyAndContainedInSpanOrBetweenSpans(operatorDeclaration.Body) != false &&
UseExpressionBodiedMemberAnalysis.GetReturnExpression(operatorDeclaration.Body) != null);
}
public static bool CanRefactor(MethodDeclarationSyntax methodDeclaration, TextSpan?span = null)
{
return(methodDeclaration.Body != null &&
span?.IsEmptyAndContainedInSpanOrBetweenSpans(methodDeclaration.Body) != false &&
UseExpressionBodiedMemberAnalysis.GetExpression(methodDeclaration.Body) != null);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, PropertyDeclarationSyntax propertyDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplacePropertyWithMethod) &&
propertyDeclaration.HeaderSpan().Contains(context.Span))
{
ReplacePropertyWithMethodRefactoring.ComputeRefactoring(context, propertyDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemovePropertyInitializer) &&
RemovePropertyInitializerRefactoring.CanRefactor(context, propertyDeclaration))
{
context.RegisterRefactoring(
"Remove property initializer",
cancellationToken => RemovePropertyInitializerRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken),
RefactoringIdentifiers.RemovePropertyInitializer);
}
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ExpandProperty,
RefactoringIdentifiers.ExpandPropertyAndAddBackingField) &&
propertyDeclaration.Span.Contains(context.Span) &&
ExpandPropertyRefactoring.CanRefactor(propertyDeclaration))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandProperty))
{
context.RegisterRefactoring(
"Expand property",
cancellationToken => ExpandPropertyRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken),
RefactoringIdentifiers.ExpandProperty);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandPropertyAndAddBackingField))
{
context.RegisterRefactoring(
"Expand property and add backing field",
cancellationToken => ExpandPropertyAndAddBackingFieldRefactoring.RefactorAsync(context.Document, propertyDeclaration, context.Settings.PrefixFieldIdentifierWithUnderscore, cancellationToken),
RefactoringIdentifiers.ExpandPropertyAndAddBackingField);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) &&
context.SupportsCSharp6)
{
AccessorListSyntax accessorList = propertyDeclaration.AccessorList;
if (accessorList != null &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(accessorList))
{
AccessorDeclarationSyntax accessor = propertyDeclaration
.AccessorList?
.Accessors
.SingleOrDefault(shouldThrow: false);
if (accessor?.AttributeLists.Any() == false &&
accessor.IsKind(SyntaxKind.GetAccessorDeclaration) &&
accessor.Body != null &&
(UseExpressionBodiedMemberAnalysis.GetReturnExpression(accessor.Body) != null))
{
context.RegisterRefactoring(
UseExpressionBodiedMemberRefactoring.Title,
ct => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, propertyDeclaration, ct),
RefactoringIdentifiers.UseExpressionBodiedMember);
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.NotifyPropertyChanged) &&
await NotifyPropertyChangedRefactoring.CanRefactorAsync(context, propertyDeclaration).ConfigureAwait(false))
{
context.RegisterRefactoring(
"Notify property changed",
cancellationToken =>
{
return(NotifyPropertyChangedRefactoring.RefactorAsync(
context.Document,
propertyDeclaration,
context.SupportsCSharp6,
cancellationToken));
},
RefactoringIdentifiers.NotifyPropertyChanged);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberAbstract) &&
propertyDeclaration.HeaderSpan().Contains(context.Span))
{
MakePropertyAbstractRefactoring.ComputeRefactoring(context, propertyDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberVirtual) &&
propertyDeclaration.HeaderSpan().Contains(context.Span))
{
MakePropertyVirtualRefactoring.ComputeRefactoring(context, propertyDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) &&
propertyDeclaration.HeaderSpan().Contains(context.Span))
{
await CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoringAsync(context, propertyDeclaration).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenamePropertyAccordingToTypeName))
{
await RenamePropertyAccodingToTypeName(context, propertyDeclaration).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddMemberToInterface) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(propertyDeclaration.Identifier))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AddMemberToInterfaceRefactoring.ComputeRefactoring(context, propertyDeclaration, semanticModel);
}
}
public static bool CanRefactor(LocalFunctionStatementSyntax localFunctionStatement, TextSpan?span = null)
{
return(localFunctionStatement.Body != null &&
span?.IsEmptyAndContainedInSpanOrBetweenSpans(localFunctionStatement.Body) != false &&
UseExpressionBodiedMemberAnalysis.GetExpression(localFunctionStatement.Body) != null);
}
