public static async Task ComputeRefactoringAsync(RefactoringContext context, ExpressionStatementSyntax expressionStatement) { if (context.SupportsSemanticModel) { var expression = expressionStatement.Expression as TypeSyntax; if (expression != null) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel .GetTypeInfo(expression, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string name = SyntaxUtility.CreateIdentifier(typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(name)) { context.RegisterRefactoring( $"Add identifier '{name}'", c => RefactorAsync(context.Document, expressionStatement, name, c)); } } } } }
internal static async Task RenameIdentifierAccordingToTypeNameAsync( RefactoringContext context, ForEachStatementSyntax forEachStatement) { if (forEachStatement.Type != null && forEachStatement.Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); string oldName = forEachStatement.Identifier.ValueText; ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(forEachStatement.Type, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string newName = SyntaxUtility.CreateIdentifier( typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(newName) && !string.Equals(newName, oldName, StringComparison.Ordinal)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(forEachStatement, context.CancellationToken); context.RegisterRefactoring( $"Rename variable to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ParameterSyntax parameter) { if (!context.IsAnyRefactoringEnabled( RefactoringIdentifiers.AddParameterNameToParameter, RefactoringIdentifiers.RenameParameterAccordingToTypeName)) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IParameterSymbol parameterSymbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken); if (parameterSymbol?.Type == null) { return; } if (parameter.Identifier.IsMissing) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddParameterNameToParameter)) { TextSpan span = (parameter.Type != null) ? TextSpan.FromBounds(parameter.Type.Span.End, parameter.Span.End) : parameter.Span; if (span.Contains(context.Span)) { string name = SyntaxUtility.CreateIdentifier(parameterSymbol.Type, firstCharToLower: true); if (!string.IsNullOrEmpty(name)) { context.RegisterRefactoring( $"Add parameter name '{name}'", cancellationToken => AddParameterNameToParameterAsync(context.Document, parameter, name, cancellationToken)); } } } } else if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameParameterAccordingToTypeName) && parameter.Identifier.Span.Contains(context.Span)) { string name = parameter.Identifier.ValueText; string newName = SyntaxUtility.CreateIdentifier(parameterSymbol.Type, firstCharToLower: true); if (!string.IsNullOrEmpty(newName) && !string.Equals(name, newName, StringComparison.Ordinal)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken); context.RegisterRefactoring( $"Rename parameter to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } }
public static async Task ComputeRefactoringAsync(RefactoringContext context, LocalDeclarationStatementSyntax localDeclaration) { if (context.SupportsSemanticModel) { TypeSyntax type = localDeclaration.Declaration?.Type; if (type?.IsVar == false) { VariableDeclaratorSyntax declarator = localDeclaration.Declaration.Variables.FirstOrDefault(); if (declarator != null && context.Span.Start >= type.Span.Start) { SyntaxTriviaList triviaList = type.GetTrailingTrivia(); if (triviaList.Any()) { SyntaxTrivia trivia = triviaList .SkipWhile(f => f.IsKind(SyntaxKind.WhitespaceTrivia)) .FirstOrDefault(); if (trivia.IsKind(SyntaxKind.EndOfLineTrivia) && context.Span.End <= trivia.Span.Start) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(type, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string name = SyntaxUtility.CreateIdentifier(typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(name)) { context.RegisterRefactoring( $"Add identifier '{name}'", c => RefactorAsync(context.Document, declarator, type, name, c)); } } } } } } } }
private static async Task RenameVariableAccordingToTypeNameAsync( RefactoringContext context, VariableDeclarationSyntax variableDeclaration) { if (variableDeclaration.Type != null && variableDeclaration.Parent?.IsKind(SyntaxKind.EventFieldDeclaration) == false && variableDeclaration.Variables.Count == 1 && variableDeclaration.Variables[0].Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ISymbol symbol = semanticModel.GetDeclaredSymbol(variableDeclaration.Variables[0], context.CancellationToken); if (symbol != null) { ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string newName = SyntaxUtility.CreateIdentifier( typeSymbol, FirstCharToLower(symbol)); if (!string.IsNullOrEmpty(newName)) { if (context.Settings.PrefixFieldIdentifierWithUnderscore && symbol.IsField() && symbol.IsPrivate() && !((IFieldSymbol)symbol).IsConst) { newName = TextUtility.ToCamelCaseWithUnderscore(newName); } if (!string.Equals(variableDeclaration.Variables[0].Identifier.ValueText, newName, StringComparison.Ordinal)) { context.RegisterRefactoring( $"Rename {GetName(symbol)} to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } } } } }
private static async Task RenameMethodAccoringToTypeNameAsync( RefactoringContext context, MethodDeclarationSyntax methodDeclaration) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameMethodAccordingToTypeName) && context.SupportsSemanticModel && methodDeclaration.ReturnType?.IsVoid() == false && methodDeclaration.Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken); ITypeSymbol typeSymbol = GetType(methodDeclaration.ReturnType, semanticModel, context.CancellationToken); if (typeSymbol != null) { string newName = SyntaxUtility.CreateIdentifier(typeSymbol); if (!string.IsNullOrEmpty(newName)) { newName = "Get" + newName; if (methodSymbol.IsAsync) { newName += "Async"; } if (!string.Equals(newName, methodDeclaration.Identifier.ValueText, StringComparison.Ordinal)) { context.RegisterRefactoring( $"Rename method to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, methodSymbol, newName, cancellationToken)); } } } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, PropertyDeclarationSyntax propertyDeclaration) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.MarkMemberAsStatic) && propertyDeclaration.Span.Contains(context.Span) && MarkMemberAsStaticRefactoring.CanRefactor(propertyDeclaration)) { context.RegisterRefactoring( "Mark property as static", cancellationToken => MarkMemberAsStaticRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken)); MarkAllMembersAsStaticRefactoring.RegisterRefactoring(context, (ClassDeclarationSyntax)propertyDeclaration.Parent); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplacePropertyWithMethod) && propertyDeclaration.HeaderSpan().Contains(context.Span) && ReplacePropertyWithMethodRefactoring.CanRefactor(context, propertyDeclaration)) { string propertyName = propertyDeclaration.Identifier.ValueText; string title = $"Replace '{propertyName}' with method"; if (propertyDeclaration.AccessorList.Accessors.Count > 1) { title += "s"; } context.RegisterRefactoring( title, cancellationToken => ReplacePropertyWithMethodRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) && propertyDeclaration.AccessorList?.Span.Contains(context.Span) == true && context.SupportsCSharp6 && UseExpressionBodiedMemberRefactoring.CanRefactor(propertyDeclaration)) { context.RegisterRefactoring( "Use expression-bodied member", cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemovePropertyInitializer) && RemovePropertyInitializerRefactoring.CanRefactor(context, propertyDeclaration)) { context.RegisterRefactoring( "Remove property initializer", cancellationToken => RemovePropertyInitializerRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken)); } if (context.SupportsSemanticModel) { 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) && MakeMemberAbstractRefactoring.CanRefactor(propertyDeclaration)) { context.RegisterRefactoring( "Make property abstract", cancellationToken => MakeMemberAbstractRefactoring.RefactorAsync(context.Document, propertyDeclaration, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) && propertyDeclaration.HeaderSpan().Contains(context.Span)) { await CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoringAsync(context, propertyDeclaration).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenamePropertyAccordingToTypeName) && context.SupportsSemanticModel && propertyDeclaration.Type != null && propertyDeclaration.Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel .GetTypeInfo(propertyDeclaration.Type, context.CancellationToken) .Type; if (typeSymbol?.IsErrorType() == false) { string newName = SyntaxUtility.CreateIdentifier(typeSymbol); if (!string.IsNullOrEmpty(newName)) { newName = TextUtility.FirstCharToUpper(newName); if (!string.Equals(newName, propertyDeclaration.Identifier.ValueText, StringComparison.Ordinal)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken); context.RegisterRefactoring( $"Rename property to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } } } }