private static async Task RenameMethodAccoringToTypeNameAsync(
RefactoringContext context,
MethodDeclarationSyntax methodDeclaration)
{
TypeSyntax returnType = methodDeclaration.ReturnType;
if (returnType?.IsVoid() == false)
{
SyntaxToken identifier = methodDeclaration.Identifier;
if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(identifier))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = GetType(returnType, semanticModel, context.CancellationToken);
if (typeSymbol != null)
{
string newName = NameGenerator.CreateName(typeSymbol);
if (!string.IsNullOrEmpty(newName))
{
newName = "Get" + newName;
if (methodSymbol.IsAsync)
{
newName += "Async";
}
string oldName = identifier.ValueText;
if (!string.Equals(oldName, newName, StringComparison.Ordinal) &&
await WorkspaceNameGenerator.IsUniqueMemberNameAsync(
newName,
methodSymbol,
context.Solution,
cancellationToken: context.CancellationToken).ConfigureAwait(false))
{
context.RegisterRefactoring(
$"Rename '{oldName}' to '{newName}'",
cancellationToken => Renamer.RenameSymbolAsync(context.Solution, methodSymbol, newName, default(OptionSet), cancellationToken));
}
}
}
}
}
}
private static async Task RenameFieldAccordingToPropertyNameAsync(
RefactoringContext context,
IdentifierNameSyntax identifierName)
{
if (!IsQualified(identifierName) ||
IsQualifiedWithThis(identifierName))
{
PropertyDeclarationSyntax propertyDeclaration = identifierName.FirstAncestor <PropertyDeclarationSyntax>();
if (propertyDeclaration != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var fieldSymbol = semanticModel.GetSymbol(identifierName, context.CancellationToken) as IFieldSymbol;
if (fieldSymbol?.IsPrivate() == true)
{
IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken);
if (propertySymbol != null &&
fieldSymbol.IsStatic == propertySymbol.IsStatic &&
fieldSymbol.ContainingType == propertySymbol.ContainingType)
{
string newName = StringUtility.ToCamelCase(propertySymbol.Name, context.Settings.PrefixFieldIdentifierWithUnderscore);
if (!string.Equals(fieldSymbol.Name, newName, StringComparison.Ordinal) &&
await WorkspaceNameGenerator.IsUniqueMemberNameAsync(
newName,
fieldSymbol,
context.Solution,
cancellationToken: context.CancellationToken).ConfigureAwait(false))
{
context.RegisterRefactoring(
$"Rename '{fieldSymbol.Name}' to '{newName}'",
cancellationToken => Renamer.RenameSymbolAsync(context.Solution, fieldSymbol, newName, default(OptionSet), cancellationToken));
}
}
}
}
}
}
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));
}
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));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandPropertyAndAddBackingField))
{
context.RegisterRefactoring(
"Expand property and add backing field",
cancellationToken => ExpandPropertyAndAddBackingFieldRefactoring.RefactorAsync(context.Document, propertyDeclaration, context.Settings.PrefixFieldIdentifierWithUnderscore, cancellationToken));
}
}
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));
});
}
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))
{
TypeSyntax type = propertyDeclaration.Type;
if (type != null)
{
SyntaxToken identifier = propertyDeclaration.Identifier;
if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(identifier))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
if (typeSymbol?.IsErrorType() == false)
{
string newName = NameGenerator.CreateName(typeSymbol);
if (!string.IsNullOrEmpty(newName))
{
string oldName = identifier.ValueText;
newName = StringUtility.FirstCharToUpper(newName);
if (!string.Equals(oldName, newName, StringComparison.Ordinal))
{
ISymbol symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken);
if (await WorkspaceNameGenerator.IsUniqueMemberNameAsync(
newName,
symbol,
context.Solution,
cancellationToken: context.CancellationToken).ConfigureAwait(false))
{
context.RegisterRefactoring(
$"Rename '{oldName}' to '{newName}'",
cancellationToken => Renamer.RenameSymbolAsync(context.Solution, symbol, newName, default(OptionSet), cancellationToken));
}
}
}
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddMemberToInterface) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(propertyDeclaration.Identifier))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
AddMemberToInterfaceRefactoring.ComputeRefactoring(context, propertyDeclaration, semanticModel);
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out MethodDeclarationSyntax methodDeclaration))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
Debug.Assert(methodSymbol != null, $"{nameof(methodSymbol)} is null");
if (methodSymbol != null)
{
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.AsynchronousMethodNameShouldEndWithAsync:
{
string oldName = methodDeclaration.Identifier.ValueText;
string newName = await WorkspaceNameGenerator.EnsureUniqueMemberNameAsync(
oldName,
methodSymbol,
context.Solution(),
NameGenerators.AsyncMethod,
cancellationToken : context.CancellationToken).ConfigureAwait(false);
CodeAction codeAction = CodeAction.Create(
$"Rename '{oldName}' to '{newName}'",
c => Renamer.RenameSymbolAsync(context.Solution(), methodSymbol, newName, default(OptionSet), c),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.NonAsynchronousMethodNameShouldNotEndWithAsync:
{
string name = methodDeclaration.Identifier.ValueText;
string newName = name.Remove(name.Length - AsyncSuffix.Length);
newName = await WorkspaceNameGenerator.EnsureUniqueMemberNameAsync(
newName,
methodSymbol,
context.Solution(),
NameGenerator.Default,
cancellationToken : context.CancellationToken).ConfigureAwait(false);
CodeAction codeAction = CodeAction.Create(
$"Rename '{name}' to '{newName}'",
c => Renamer.RenameSymbolAsync(context.Solution(), methodSymbol, newName, default(OptionSet), c),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
}
