public static void ComputeRefactorings(RefactoringContext context, DelegateDeclarationSyntax delegateDeclaration) { SyntaxToken identifier = delegateDeclaration.Identifier; ComputeRefactorings(context, delegateDeclaration, identifier); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SwitchSectionSyntax switchSection) { if (SelectedStatementsRefactoring.IsAnyRefactoringEnabled(context) && StatementsSelection.TryCreate(switchSection, context.Span, out StatementsSelection selectedStatements)) { await SelectedStatementsRefactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitSwitchLabels)) { SplitSwitchLabelsRefactoring.ComputeRefactoring(context, switchSection); } if (context.Span.IsEmpty && context.IsAnyRefactoringEnabled( RefactoringIdentifiers.AddBracesToSwitchSection, RefactoringIdentifiers.AddBracesToSwitchSections, RefactoringIdentifiers.RemoveBracesFromSwitchSection, RefactoringIdentifiers.RemoveBracesFromSwitchSections)) { var switchStatement = (SwitchStatementSyntax)switchSection.Parent; SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections; switch (CSharpAnalysis.AnalyzeBraces(switchSection)) { case BracesAnalysisResult.AddBraces: { if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSection)) { context.RegisterRefactoring( AddBracesToSwitchSectionRefactoring.Title, cancellationToken => AddBracesToSwitchSectionRefactoring.RefactorAsync(context.Document, switchSection, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSections) && sections.Any(f => f != switchSection && AddBracesToSwitchSectionRefactoring.CanAddBraces(f))) { context.RegisterRefactoring( AddBracesToSwitchSectionsRefactoring.Title, cancellationToken => AddBracesToSwitchSectionsRefactoring.RefactorAsync(context.Document, switchStatement, null, cancellationToken)); } break; } case BracesAnalysisResult.RemoveBraces: { if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSection)) { context.RegisterRefactoring( RemoveBracesFromSwitchSectionRefactoring.Title, cancellationToken => RemoveBracesFromSwitchSectionRefactoring.RefactorAsync(context.Document, switchSection, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSections) && sections.Any(f => f != switchSection && RemoveBracesFromSwitchSectionRefactoring.CanRemoveBraces(f))) { context.RegisterRefactoring( RemoveBracesFromSwitchSectionsRefactoring.Title, cancellationToken => RemoveBracesFromSwitchSectionsRefactoring.RefactorAsync(context.Document, switchStatement, null, cancellationToken)); } break; } } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ExpressionSyntax expression) { if (expression != null) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); MemberDeclarationSyntax declaration = await GetContainingMethodOrPropertyOrIndexerAsync(expression, semanticModel, context.CancellationToken).ConfigureAwait(false); if (declaration != null) { TypeSyntax memberType = GetMemberType(declaration); if (memberType != null) { ITypeSymbol memberTypeSymbol = semanticModel.GetTypeSymbol(memberType, context.CancellationToken); if (memberTypeSymbol != null) { ITypeSymbol expressionSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken); if (expressionSymbol?.IsErrorType() == false) { ISymbol memberSymbol = semanticModel.GetDeclaredSymbol(declaration, context.CancellationToken); if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMemberTypeAccordingToReturnExpression)) { ITypeSymbol newType = GetMemberNewType(memberSymbol, memberTypeSymbol, expression, expressionSymbol, semanticModel, context.CancellationToken); if (newType?.IsErrorType() == false && !memberTypeSymbol.Equals(newType)) { if (newType.IsNamedType() && memberTypeSymbol.IsNamedType()) { var newNamedType = (INamedTypeSymbol)newType; INamedTypeSymbol orderedEnumerableSymbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_Linq_IOrderedEnumerable_T); if (newNamedType.ConstructedFrom == orderedEnumerableSymbol) { INamedTypeSymbol enumerableSymbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_Collections_Generic_IEnumerable_T); if (enumerableSymbol != null && ((INamedTypeSymbol)memberTypeSymbol).ConstructedFrom != enumerableSymbol) { RegisterChangeType(context, declaration, memberType, enumerableSymbol.Construct(newNamedType.TypeArguments.ToArray()), semanticModel); } } } RegisterChangeType(context, declaration, memberType, newType, semanticModel); } } if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) && !memberTypeSymbol.IsErrorType()) { ITypeSymbol castTypeSymbol = GetCastTypeSymbol(memberSymbol, memberTypeSymbol, expressionSymbol, semanticModel); if (castTypeSymbol != null) { ModifyExpressionRefactoring.ComputeRefactoring( context, expression, castTypeSymbol, semanticModel); } } } } } } } }
public static bool IsAnyRefactoringEnabled(this RefactoringContext context, string identifier1, string identifier2, string identifier3, string identifier4, string identifier5) { return(context.Settings.IsAnyRefactoringEnabled(identifier1, identifier2, identifier3, identifier4, identifier5)); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SyntaxToken token) { switch (token.Parent) { case MethodDeclarationSyntax methodDeclaration: { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); using (RemoveAsyncAwaitAnalysis analysis = RemoveAsyncAwaitAnalysis.Create(methodDeclaration, semanticModel, context.CancellationToken)) { if (analysis.Success) { RegisterRefactoring(); } } return; } case LocalFunctionStatementSyntax localFunction: { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); using (RemoveAsyncAwaitAnalysis analysis = RemoveAsyncAwaitAnalysis.Create(localFunction, semanticModel, context.CancellationToken)) { if (analysis.Success) { RegisterRefactoring(); } } return; } case ParenthesizedLambdaExpressionSyntax parenthesizedLambda: { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); using (RemoveAsyncAwaitAnalysis analysis = RemoveAsyncAwaitAnalysis.Create(parenthesizedLambda, semanticModel, context.CancellationToken)) { if (analysis.Success) { RegisterRefactoring(); } } return; } case SimpleLambdaExpressionSyntax simpleLambda: { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); using (RemoveAsyncAwaitAnalysis analysis = RemoveAsyncAwaitAnalysis.Create(simpleLambda, semanticModel, context.CancellationToken)) { if (analysis.Success) { RegisterRefactoring(); } } return; } case AnonymousMethodExpressionSyntax anonymousMethod: { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); using (RemoveAsyncAwaitAnalysis analysis = RemoveAsyncAwaitAnalysis.Create(anonymousMethod, semanticModel, context.CancellationToken)) { if (analysis.Success) { RegisterRefactoring(); } } return; } } void RegisterRefactoring() { CodeAction codeAction = CodeActionFactory.RemoveAsyncAwait(context.Document, token, equivalenceKey: RefactoringIdentifiers.RemoveAsyncAwait); context.RegisterRefactoring(codeAction); } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement) { if (ifStatement.IsTopmostIf() && (context.Span.IsEmptyAndContainedInSpan(ifStatement.IfKeyword) || context.Span.IsBetweenSpans(ifStatement))) { if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf, RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf, RefactoringIdentifiers.SimplifyIf)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); var options = new IfAnalysisOptions( useCoalesceExpression: context.IsRefactoringEnabled(RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf), useConditionalExpression: context.IsRefactoringEnabled(RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf), useBooleanExpression: context.IsRefactoringEnabled(RefactoringIdentifiers.SimplifyIf), useExpression: false); foreach (IfRefactoring refactoring in IfRefactoring.Analyze(ifStatement, options, semanticModel, context.CancellationToken)) { context.RegisterRefactoring( refactoring.Title, cancellationToken => refactoring.RefactorAsync(context.Document, cancellationToken)); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapIfElse)) { SwapIfElseRefactoring.ComputeRefactoring(context, ifStatement); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfWithSwitch)) { await ReplaceIfWithSwitchRefactoring.ComputeRefactoringAsync(context, ifStatement).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfStatement)) { SplitIfStatementRefactoring.ComputeRefactoring(context, ifStatement); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeIfWithParentIf) && context.Span.IsEmptyAndContainedInSpan(ifStatement.IfKeyword)) { MergeIfWithParentIfRefactoring.ComputeRefactoring(context, ifStatement); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReduceIfNesting) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(ifStatement.IfKeyword)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ReduceIfNestingAnalysis analysis = ReduceIfNestingRefactoring.Analyze( ifStatement, semanticModel, options: ReduceIfNestingOptions.AllowNestedFix | ReduceIfNestingOptions.AllowIfInsideIfElse | ReduceIfNestingOptions.AllowLoop | ReduceIfNestingOptions.AllowSwitchSection, taskSymbol: semanticModel.GetTypeByMetadataName(MetadataNames.System_Threading_Tasks_Task), cancellationToken: context.CancellationToken); if (analysis.Success) { context.RegisterRefactoring( "Reduce if nesting", cancellationToken => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, analysis.JumpKind, false, cancellationToken)); if (ReduceIfNestingRefactoring.IsFixableRecursively(ifStatement, analysis.JumpKind)) { context.RegisterRefactoring( "Reduce if nesting (recursively)", cancellationToken => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, analysis.JumpKind, true, cancellationToken)); } } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfElseWithIfReturn) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(ifStatement.IfKeyword)) { ReplaceIfElseWithIfReturnRefactoring.ComputeRefactoring(context, ifStatement); } }
public static void ComputeRefactoring( RefactoringContext context, LocalDeclarationStatementSyntax localDeclaration, SemanticModel semanticModel) { if (!(semanticModel.GetEnclosingSymbol(localDeclaration.SpanStart, context.CancellationToken) is IMethodSymbol methodSymbol)) { return; } if (methodSymbol.IsImplicitlyDeclared) { return; } if (methodSymbol.MethodKind != MethodKind.Ordinary) { return; } if (methodSymbol.PartialImplementationPart != null) { methodSymbol = methodSymbol.PartialImplementationPart; } if (!(methodSymbol.GetSyntax(context.CancellationToken) is MethodDeclarationSyntax methodDeclaration)) { return; } VariableDeclarationSyntax declaration = localDeclaration.Declaration; if (declaration == null) { return; } VariableDeclaratorSyntax variable = declaration .Variables .FirstOrDefault(f => !f.IsMissing && f.Identifier.Span.Contains(context.Span)); if (variable == null) { return; } TypeSyntax type = declaration.Type; if (type == null) { return; } if (type.IsVar) { ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken); if (typeSymbol?.SupportsExplicitDeclaration() == true) { type = typeSymbol.ToTypeSyntax(); } else { return; } } context.RegisterRefactoring( $"Promote '{variable.Identifier.ValueText}' to parameter", cancellationToken => { return(RefactorAsync( context.Document, methodDeclaration, localDeclaration, type.WithoutTrivia().WithSimplifierAnnotation(), variable, cancellationToken)); }); }
private static async Task RenameMethodAccoringToTypeNameAsync( RefactoringContext context, MethodDeclarationSyntax methodDeclaration) { TypeSyntax returnType = methodDeclaration.ReturnType; if (returnType?.IsVoid() != false) { return; } SyntaxToken identifier = methodDeclaration.Identifier; if (!context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(identifier)) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken); ITypeSymbol typeSymbol = GetType(returnType, semanticModel, context.CancellationToken); if (typeSymbol == null) { return; } string newName = NameGenerator.CreateName(typeSymbol); if (string.IsNullOrEmpty(newName)) { return; } newName = "Get" + newName; if (methodSymbol.IsAsync) { newName += "Async"; } string oldName = identifier.ValueText; if (string.Equals(oldName, newName, StringComparison.Ordinal)) { return; } if (!await MemberNameGenerator.IsUniqueMemberNameAsync( newName, methodSymbol, context.Solution, cancellationToken: context.CancellationToken).ConfigureAwait(false)) { return; } context.RegisterRefactoring( $"Rename '{oldName}' to '{newName}'", cancellationToken => Renamer.RenameSymbolAsync(context.Solution, methodSymbol, newName, default(OptionSet), cancellationToken), RefactoringIdentifiers.RenameMethodAccordingToTypeName); }
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 && UseExpressionBodiedMemberRefactoring.CanRefactor(methodDeclaration, context.Span)) { context.RegisterRefactoring( UseExpressionBodiedMemberRefactoring.Title, cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, methodDeclaration, cancellationToken), RefactoringIdentifiers.UseExpressionBodiedMember); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.MakeMemberAbstract) && context.Span.IsEmptyAndContainedInSpan(methodDeclaration.Identifier)) { 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.AddParameterToInterfaceMember) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(methodDeclaration.Identifier)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); foreach (CodeAction codeAction in AddParameterToInterfaceMemberRefactoring.ComputeRefactoringForImplicitImplementation( new CommonFixContext(context.Document, RefactoringIdentifiers.AddParameterToInterfaceMember, semanticModel, context.CancellationToken), methodDeclaration)) { context.RegisterRefactoring(codeAction); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddMemberToInterface) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(methodDeclaration.Identifier)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); AddMemberToInterfaceRefactoring.ComputeRefactoring(context, methodDeclaration, semanticModel); } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, InvocationExpressionSyntax invocation) { MemberInvocationExpression memberInvocation; if (MemberInvocationExpression.TryCreate(invocation, out memberInvocation) && memberInvocation.ArgumentList != null) { switch (memberInvocation.Name?.Identifier.ValueText) { case "First": { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); if (memberInvocation.ArgumentList.Arguments.Count == 0 && UseElementAccessInsteadOfFirstRefactoring.CanRefactor(memberInvocation, semanticModel, context.CancellationToken)) { context.RegisterRefactoring( "Use [] instead of calling 'First'", cancellationToken => UseElementAccessInsteadOfFirstRefactoring.RefactorAsync(context.Document, invocation, cancellationToken)); } break; } case "Last": { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); if (memberInvocation.ArgumentList.Arguments.Count == 0 && UseElementAccessInsteadOfLastRefactoring.CanRefactor(memberInvocation, semanticModel, context.CancellationToken)) { string propertyName = UseElementAccessInsteadOfLastRefactoring.GetCountOrLengthPropertyName(memberInvocation.Expression, semanticModel, context.CancellationToken); if (propertyName != null) { context.RegisterRefactoring( "Use [] instead of calling 'Last'", cancellationToken => UseElementAccessInsteadOfLastRefactoring.RefactorAsync(context.Document, invocation, propertyName, cancellationToken)); } } break; } case "ElementAt": { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); if (memberInvocation.ArgumentList.Arguments.Count == 1 && UseElementAccessInsteadOfElementAtRefactoring.CanRefactor(memberInvocation, semanticModel, context.CancellationToken)) { context.RegisterRefactoring( "Use [] instead of calling 'ElementAt'", cancellationToken => UseElementAccessInsteadOfElementAtRefactoring.RefactorAsync(context.Document, invocation, cancellationToken)); } break; } } } }
private static void RegisterRefactoring(RefactoringContext context, ExpressionSyntax expression, StatementSyntax statement, int statementCount) { context.RegisterRefactoring( GetTitle(expression), cancellationToken => RefactorAsync(context.Document, expression, statement, statementCount, cancellationToken)); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, InvocationExpressionSyntax invocationExpression) { if (context.IsAnyRefactoringEnabled( RefactoringDescriptors.UseElementAccessInsteadOfLinqMethod, RefactoringDescriptors.InvertLinqMethodCall, RefactoringDescriptors.CallExtensionMethodAsInstanceMethod, RefactoringDescriptors.CallIndexOfInsteadOfContains)) { ExpressionSyntax expression = invocationExpression.Expression; if (expression != null && invocationExpression.ArgumentList != null) { if (expression.IsKind(SyntaxKind.SimpleMemberAccessExpression) && ((MemberAccessExpressionSyntax)expression).Name?.Span.Contains(context.Span) == true) { if (context.IsRefactoringEnabled(RefactoringDescriptors.UseElementAccessInsteadOfLinqMethod)) { await UseElementAccessRefactoring.ComputeRefactoringsAsync(context, invocationExpression).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringDescriptors.InvertLinqMethodCall)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); InvertLinqMethodCallRefactoring.ComputeRefactoring(context, invocationExpression, semanticModel); } if (context.IsRefactoringEnabled(RefactoringDescriptors.CallIndexOfInsteadOfContains)) { await CallIndexOfInsteadOfContainsRefactoring.ComputeRefactoringAsync(context, invocationExpression).ConfigureAwait(false); } } if (context.IsRefactoringEnabled(RefactoringDescriptors.CallExtensionMethodAsInstanceMethod)) { SyntaxNodeOrToken nodeOrToken = CallExtensionMethodAsInstanceMethodAnalysis.GetNodeOrToken(expression); if (nodeOrToken.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); CallExtensionMethodAsInstanceMethodAnalysisResult analysis = CallExtensionMethodAsInstanceMethodAnalysis.Analyze(invocationExpression, semanticModel, allowAnyExpression: true, cancellationToken: context.CancellationToken); if (analysis.Success) { context.RegisterRefactoring( CallExtensionMethodAsInstanceMethodRefactoring.Title, ct => { return(context.Document.ReplaceNodeAsync( analysis.InvocationExpression, analysis.NewInvocationExpression, ct)); }, RefactoringDescriptors.CallExtensionMethodAsInstanceMethod); } } } } } if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertStringFormatToInterpolatedString) && context.SupportsCSharp6) { await ConvertStringFormatToInterpolatedStringRefactoring.ComputeRefactoringsAsync(context, invocationExpression).ConfigureAwait(false); } if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertHasFlagCallToBitwiseOperation)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); if (ConvertHasFlagCallToBitwiseOperationAnalysis.IsFixable(invocationExpression, semanticModel, context.CancellationToken)) { context.RegisterRefactoring( ConvertHasFlagCallToBitwiseOperationRefactoring.Title, ct => { return(ConvertHasFlagCallToBitwiseOperationRefactoring.RefactorAsync( context.Document, invocationExpression, semanticModel, ct)); }, RefactoringDescriptors.ConvertHasFlagCallToBitwiseOperation); } } if (context.IsRefactoringEnabled(RefactoringDescriptors.InlineMethod)) { await InlineMethodRefactoring.ComputeRefactoringsAsync(context, invocationExpression).ConfigureAwait(false); } }
public static void ComputeRefactorings(RefactoringContext context, AccessorDeclarationSyntax accessor) { BlockSyntax body = accessor.Body; if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatAccessorBraces) && 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", cancellationToken => CSharpFormatter.ToMultiLineAsync(context.Document, accessor, cancellationToken)); } } else { SyntaxList <StatementSyntax> statements = body.Statements; if (statements.Count == 1 && statements[0].IsSingleLine()) { context.RegisterRefactoring( "Format braces on a single line", cancellationToken => CSharpFormatter.ToSingleLineAsync(context.Document, accessor, cancellationToken)); } } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseExpressionBodiedMember) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(accessor) && context.SupportsCSharp6 && UseExpressionBodiedMemberRefactoring.CanRefactor(accessor)) { SyntaxNode node = accessor; var accessorList = accessor.Parent as AccessorListSyntax; if (accessorList != null) { SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors; if (accessors.Count == 1 && accessors.First().IsKind(SyntaxKind.GetAccessorDeclaration)) { var parent = accessorList.Parent as MemberDeclarationSyntax; if (parent != null) { node = parent; } } } context.RegisterRefactoring( "Use expression-bodied member", cancellationToken => UseExpressionBodiedMemberRefactoring.RefactorAsync(context.Document, node, 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 NameGenerator.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)); } } } } } } } }
public static void ComputeRefactorings(RefactoringContext context, InterpolatedStringExpressionSyntax interpolatedString) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.InsertStringInterpolation) && context.Span.IsEmpty && InsertInterpolationRefactoring.CanRefactor(context, interpolatedString)) { context.RegisterRefactoring("Insert interpolation", cancellationToken => { return(InsertInterpolationRefactoring.RefactorAsync( context.Document, interpolatedString, context.Span, addNameOf: false, cancellationToken: cancellationToken)); }, RefactoringIdentifiers.InsertStringInterpolation); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceInterpolatedStringWithStringLiteral) && ReplaceInterpolatedStringWithStringLiteralAnalysis.IsFixable(interpolatedString)) { context.RegisterRefactoring("Remove $", cancellationToken => { return(ReplaceInterpolatedStringWithStringLiteralRefactoring.RefactorAsync( context.Document, interpolatedString, cancellationToken)); }, RefactoringIdentifiers.ReplaceInterpolatedStringWithStringLiteral); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceInterpolatedStringWithInterpolationExpression) && interpolatedString.Span.Contains(context.Span) && ReplaceInterpolatedStringWithInterpolationExpressionRefactoring.CanRefactor(interpolatedString)) { ExpressionSyntax expression = ((InterpolationSyntax)(interpolatedString.Contents[0])).Expression; context.RegisterRefactoring( $"Replace interpolated string with '{expression}'", cancellationToken => { return(ReplaceInterpolatedStringWithInterpolationExpressionRefactoring.RefactorAsync( context.Document, interpolatedString, cancellationToken)); }, RefactoringIdentifiers.ReplaceInterpolatedStringWithInterpolationExpression); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceInterpolatedStringWithConcatenation) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(interpolatedString)) { ReplaceInterpolatedStringWithConcatenationRefactoring.ComputeRefactoring(context, interpolatedString); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceInterpolatedStringWithStringFormat) && context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(interpolatedString)) { ReplaceInterpolatedStringWithStringFormatRefactoring.ComputeRefactoring(context, interpolatedString); } }
public static void ComputeRefactoring(RefactoringContext context, in StringConcatenationExpressionInfo concatenationInfo)
public static void ComputeRefactoring(RefactoringContext context, IsPatternExpressionSyntax isPatternExpression) { ComputeRefactoringCore(context, isPatternExpression); }
private static void RegisterRefactoring(RefactoringContext context, ParameterSyntax parameter, SemanticModel semanticModel) { RegisterRefactoring(context, ImmutableArray.Create(parameter), $"'{parameter.Identifier.ValueText}'", semanticModel); }
public static void ComputeRefactoring( RefactoringContext context, EnumDeclarationSyntax enumDeclaration, SemanticModel semanticModel) { SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members; if (!members.Any()) { return; } if (members.All(f => f.EqualsValue?.Value == null)) { return; } INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken); bool isFlags = enumSymbol.HasAttribute(MetadataNames.System_FlagsAttribute); if (!AreNewValuesDifferentFromExistingValues()) { return; } Document document = context.Document; context.RegisterRefactoring( "Declare explicit values (overwrite existing values)", ct => RefactorAsync(document, enumDeclaration, enumSymbol, semanticModel, ct), EquivalenceKey); bool AreNewValuesDifferentFromExistingValues() { ulong value = 0; foreach (EnumMemberDeclarationSyntax member in enumDeclaration.Members) { IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(member, context.CancellationToken); EnumFieldSymbolInfo fieldSymbolInfo = EnumFieldSymbolInfo.Create(fieldSymbol); if (!fieldSymbolInfo.HasValue) { return(true); } if (isFlags && fieldSymbolInfo.HasCompositeValue()) { continue; } if (value != fieldSymbolInfo.Value) { return(true); } if (isFlags) { value = (value == 0) ? 1 : value * 2; } else { value++; } if (!ConvertHelpers.CanConvert(value, enumSymbol.EnumUnderlyingType.SpecialType)) { return(false); } } return(false); } }
private static StatementSyntax GetStatement( RefactoringContext context, BlockSyntax block, SyntaxNode parent) { switch (parent?.Kind()) { case SyntaxKind.WhileStatement: case SyntaxKind.DoStatement: case SyntaxKind.ForStatement: case SyntaxKind.ForEachStatement: case SyntaxKind.ForEachVariableStatement: case SyntaxKind.FixedStatement: case SyntaxKind.CheckedStatement: case SyntaxKind.UncheckedStatement: case SyntaxKind.UnsafeStatement: case SyntaxKind.UsingStatement: case SyntaxKind.LockStatement: { if (block.OpenBraceToken.Span.Contains(context.Span) || block.CloseBraceToken.Span.Contains(context.Span)) { if (parent.IsKind(SyntaxKind.UsingStatement)) { var usingStatement = (UsingStatementSyntax)parent; while (usingStatement.IsParentKind(SyntaxKind.UsingStatement)) { usingStatement = (UsingStatementSyntax)usingStatement.Parent; } return(usingStatement); } return((StatementSyntax)parent); } break; } case SyntaxKind.TryStatement: { var tryStatement = (TryStatementSyntax)parent; if (tryStatement.Block?.OpenBraceToken.Span.Contains(context.Span) == true) { return((StatementSyntax)parent); } break; } case SyntaxKind.IfStatement: { var ifStatement = (IfStatementSyntax)parent; if (IfElseChain.IsTopmostIf(ifStatement) && block.OpenBraceToken.Span.Contains(context.Span)) { return(ifStatement); } if (ifStatement.Else == null && block.CloseBraceToken.Span.Contains(context.Span)) { return(ifStatement); } break; } case SyntaxKind.ElseClause: { var elseClause = (ElseClauseSyntax)parent; if (block.CloseBraceToken.Span.Contains(context.Span)) { return(IfElseChain.GetTopmostIf(elseClause)); } break; } case SyntaxKind.CatchClause: { var catchClause = (CatchClauseSyntax)parent; if (catchClause.IsParentKind(SyntaxKind.TryStatement)) { var tryStatement = (TryStatementSyntax)catchClause.Parent; if (tryStatement.Finally == null && catchClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true) { return(tryStatement); } } break; } case SyntaxKind.FinallyClause: { var finallyClause = (FinallyClauseSyntax)parent; if (finallyClause.IsParentKind(SyntaxKind.TryStatement)) { var tryStatement = (TryStatementSyntax)finallyClause.Parent; if (finallyClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true) { return(tryStatement); } } break; } } return(null); }
public static bool IsRefactoringEnabled(this RefactoringContext context, string identifier) { return(context.Settings.IsRefactoringEnabled(identifier)); }
public static void ComputeRefactoring( RefactoringContext context, SwitchStatementSyntax switchStatement, SemanticModel semanticModel) { ExpressionSyntax expression = switchStatement.Expression; if (expression?.IsMissing != false) { return; } SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections; ISymbol symbol = semanticModel.GetSymbol(expression, context.CancellationToken); if (symbol?.IsErrorType() != false) { return; } ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken); if (typeSymbol?.TypeKind != TypeKind.Enum) { return; } if (!typeSymbol.ContainsMember <IFieldSymbol>()) { return; } if (sections.Any() && !ContainsOnlyDefaultSection(sections)) { if (context.Span.IsEmptyAndContainedInSpan(switchStatement.SwitchKeyword)) { ImmutableArray <ISymbol> members = typeSymbol.GetMembers(); if (members.Length == 0) { return; } var fieldsToValue = new Dictionary <object, IFieldSymbol>(members.Length); foreach (ISymbol member in members) { if (member.Kind == SymbolKind.Field) { var fieldSymbol = (IFieldSymbol)member; if (fieldSymbol.HasConstantValue) { object constantValue = fieldSymbol.ConstantValue; if (!fieldsToValue.ContainsKey(constantValue)) { fieldsToValue.Add(constantValue, fieldSymbol); } } } } foreach (SwitchSectionSyntax section in sections) { foreach (SwitchLabelSyntax label in section.Labels) { if (label is CaseSwitchLabelSyntax caseLabel) { ExpressionSyntax value = caseLabel.Value.WalkDownParentheses(); if (value?.IsMissing == false) { Optional <object> optional = semanticModel.GetConstantValue(value, context.CancellationToken); if (optional.HasValue && fieldsToValue.Remove(optional.Value) && fieldsToValue.Count == 0) { return; } } } } } Document document = context.Document; context.RegisterRefactoring( Title, ct => AddCasesAsync(document, switchStatement, fieldsToValue.Select(f => f.Value), ct), RefactoringDescriptors.AddMissingCasesToSwitchStatement); } } else if (context.IsRefactoringEnabled(RefactoringDescriptors.AddMissingCasesToSwitchStatement)) { Document document = context.Document; context.RegisterRefactoring( Title, ct => AddCasesAsync(document, switchStatement, semanticModel, ct), RefactoringDescriptors.AddMissingCasesToSwitchStatement); } }
public static async Task ComputeRefactoringsForNodeAsync(this RefactoringContext context) { SyntaxNode node = context.FindNode(); if (node == null) { return; } bool fAccessor = false; bool fArgument = false; bool fArgumentList = false; bool fAttributeArgumentList = false; bool fArrowExpressionClause = false; bool fParameter = false; bool fParameterList = false; bool fSwitchSection = false; bool fVariableDeclaration = false; bool fInterpolatedStringText = false; bool fElseClause = false; bool fCaseSwitchLabel = false; bool fUsingDirective = false; bool fExpression = false; bool fAnonymousMethod = false; bool fAssignmentExpression = false; bool fBinaryExpression = false; bool fConditionalExpression = false; bool fQualifiedName = false; bool fGenericName = false; bool fIdentifierName = false; bool fInitializerExpression = false; bool fInterpolatedStringExpression = false; bool fInterpolation = false; bool fInvocationExpression = false; bool fLambdaExpression = false; bool fLiteralExpression = false; bool fSimpleMemberAccessExpression = false; bool fParenthesizedExpression = false; bool fPostfixUnaryExpression = false; bool fPrefixUnaryExpression = false; bool fAwaitExpression = false; bool fCastExpression = false; bool fThrowExpression = false; bool fDeclarationExpression = false; bool fMemberDeclaration = false; bool fStatement = false; bool fDoStatement = false; bool fExpressionStatement = false; bool fForEachStatement = false; bool fForStatement = false; bool fIfStatement = false; bool fLocalDeclarationStatement = false; bool fReturnStatement = false; bool fSwitchStatement = false; bool fUsingStatement = false; bool fWhileStatement = false; bool fYieldReturnStatement = false; bool fLockStatement = false; bool fBlock = false; bool fStatementRefactoring = false; bool fThrowStatement = false; SyntaxNode firstNode = node; using (IEnumerator <SyntaxNode> en = node.AncestorsAndSelf().GetEnumerator()) { while (en.MoveNext()) { node = en.Current; SyntaxKind kind = node.Kind(); Debug.WriteLine(kind.ToString()); if (!fAccessor) { var accessor = node as AccessorDeclarationSyntax; if (accessor != null) { AccessorDeclarationRefactoring.ComputeRefactorings(context, accessor); fAccessor = true; continue; } } if (!fArgument && kind == SyntaxKind.Argument) { await ArgumentRefactoring.ComputeRefactoringsAsync(context, (ArgumentSyntax)node).ConfigureAwait(false); fArgument = true; continue; } if (!fArgumentList && kind == SyntaxKind.ArgumentList) { await ArgumentListRefactoring.ComputeRefactoringsAsync(context, (ArgumentListSyntax)node).ConfigureAwait(false); fArgumentList = true; continue; } if (!fAttributeArgumentList && kind == SyntaxKind.AttributeArgumentList) { await AttributeArgumentListRefactoring.ComputeRefactoringsAsync(context, (AttributeArgumentListSyntax)node).ConfigureAwait(false); fAttributeArgumentList = true; continue; } if (!fArrowExpressionClause && kind == SyntaxKind.ArrowExpressionClause) { await ArrowExpressionClauseRefactoring.ComputeRefactoringsAsync(context, (ArrowExpressionClauseSyntax)node).ConfigureAwait(false); fArrowExpressionClause = true; continue; } if (!fParameter && kind == SyntaxKind.Parameter) { await ParameterRefactoring.ComputeRefactoringsAsync(context, (ParameterSyntax)node).ConfigureAwait(false); fParameter = true; continue; } if (!fParameterList && kind == SyntaxKind.ParameterList) { await ParameterListRefactoring.ComputeRefactoringsAsync(context, (ParameterListSyntax)node).ConfigureAwait(false); fParameterList = true; continue; } if (!fSwitchSection && kind == SyntaxKind.SwitchSection) { await SwitchSectionRefactoring.ComputeRefactoringsAsync(context, (SwitchSectionSyntax)node).ConfigureAwait(false); fSwitchSection = true; continue; } if (!fVariableDeclaration && kind == SyntaxKind.VariableDeclaration) { await VariableDeclarationRefactoring.ComputeRefactoringsAsync(context, (VariableDeclarationSyntax)node).ConfigureAwait(false); fVariableDeclaration = true; continue; } if (!fInterpolatedStringText && kind == SyntaxKind.InterpolatedStringText) { InterpolatedStringTextRefactoring.ComputeRefactorings(context, (InterpolatedStringTextSyntax)node); fInterpolatedStringText = true; continue; } if (!fInterpolation && kind == SyntaxKind.Interpolation) { InterpolationRefactoring.ComputeRefactorings(context, (InterpolationSyntax)node); fInterpolation = true; continue; } if (!fElseClause && kind == SyntaxKind.ElseClause) { ElseClauseRefactoring.ComputeRefactorings(context, (ElseClauseSyntax)node); fElseClause = true; continue; } if (!fCaseSwitchLabel && kind == SyntaxKind.CaseSwitchLabel) { await CaseSwitchLabelRefactoring.ComputeRefactoringsAsync(context, (CaseSwitchLabelSyntax)node).ConfigureAwait(false); fCaseSwitchLabel = true; continue; } if (!fUsingDirective && kind == SyntaxKind.UsingDirective) { UsingDirectiveRefactoring.ComputeRefactoring(context, (UsingDirectiveSyntax)node); fUsingDirective = true; continue; } var expression = node as ExpressionSyntax; if (expression != null) { if (!fExpression) { await ExpressionRefactoring.ComputeRefactoringsAsync(context, expression).ConfigureAwait(false); fExpression = true; } if (!fAssignmentExpression) { var assignmentExpression = node as AssignmentExpressionSyntax; if (assignmentExpression != null) { await AssignmentExpressionRefactoring.ComputeRefactoringsAsync(context, assignmentExpression).ConfigureAwait(false); fAssignmentExpression = true; } } if (!fAnonymousMethod && kind == SyntaxKind.AnonymousMethodExpression) { AnonymousMethodExpressionRefactoring.ComputeRefactorings(context, (AnonymousMethodExpressionSyntax)node); fAnonymousMethod = true; } if (!fBinaryExpression) { var binaryExpression = node as BinaryExpressionSyntax; if (binaryExpression != null) { await BinaryExpressionRefactoring.ComputeRefactoringsAsync(context, binaryExpression).ConfigureAwait(false); fBinaryExpression = true; } } if (!fConditionalExpression && kind == SyntaxKind.ConditionalExpression) { await ConditionalExpressionRefactoring.ComputeRefactoringsAsync(context, (ConditionalExpressionSyntax)expression).ConfigureAwait(false); fConditionalExpression = true; } if (!fQualifiedName && kind == SyntaxKind.QualifiedName) { await QualifiedNameRefactoring.ComputeRefactoringsAsync(context, (QualifiedNameSyntax)expression).ConfigureAwait(false); fQualifiedName = true; } if (!fGenericName && kind == SyntaxKind.GenericName) { GenericNameRefactoring.ComputeRefactorings(context, (GenericNameSyntax)expression); fGenericName = true; } if (!fIdentifierName && kind == SyntaxKind.IdentifierName) { await IdentifierNameRefactoring.ComputeRefactoringsAsync(context, (IdentifierNameSyntax)expression).ConfigureAwait(false); fIdentifierName = true; } if (!fInitializerExpression) { var initializer = node as InitializerExpressionSyntax; if (initializer != null) { await InitializerExpressionRefactoring.ComputeRefactoringsAsync(context, initializer).ConfigureAwait(false); fInitializerExpression = true; } } if (!fInterpolatedStringExpression && kind == SyntaxKind.InterpolatedStringExpression) { InterpolatedStringRefactoring.ComputeRefactorings(context, (InterpolatedStringExpressionSyntax)expression); fInterpolatedStringExpression = true; } if (!fInvocationExpression && kind == SyntaxKind.InvocationExpression) { await InvocationExpressionRefactoring.ComputeRefactoringsAsync(context, (InvocationExpressionSyntax)expression).ConfigureAwait(false); fInvocationExpression = true; } if (!fLambdaExpression) { var lambdaExpression = node as LambdaExpressionSyntax; if (lambdaExpression != null) { LambdaExpressionRefactoring.ComputeRefactorings(context, lambdaExpression); fLambdaExpression = true; } } if (!fLiteralExpression) { var literalExpression = node as LiteralExpressionSyntax; if (literalExpression != null) { await LiteralExpressionRefactoring.ComputeRefactoringsAsync(context, literalExpression).ConfigureAwait(false); fLiteralExpression = true; } } if (!fSimpleMemberAccessExpression && kind == SyntaxKind.SimpleMemberAccessExpression) { await SimpleMemberAccessExpressionRefactoring.ComputeRefactoringAsync(context, (MemberAccessExpressionSyntax)node).ConfigureAwait(false); fSimpleMemberAccessExpression = true; } if (!fParenthesizedExpression && kind == SyntaxKind.ParenthesizedExpression) { ParenthesizedExpressionRefactoring.ComputeRefactorings(context, (ParenthesizedExpressionSyntax)expression); fParenthesizedExpression = true; } if (!fPostfixUnaryExpression) { var postfixUnaryExpression = node as PostfixUnaryExpressionSyntax; if (postfixUnaryExpression != null) { PostfixUnaryExpressionRefactoring.ComputeRefactorings(context, postfixUnaryExpression); fPostfixUnaryExpression = true; } } if (!fPrefixUnaryExpression) { var prefixUnaryExpression = node as PrefixUnaryExpressionSyntax; if (prefixUnaryExpression != null) { PrefixUnaryExpressionRefactoring.ComputeRefactorings(context, prefixUnaryExpression); fPrefixUnaryExpression = true; } } if (!fAwaitExpression && kind == SyntaxKind.AwaitExpression) { await AwaitExpressionRefactoring.ComputeRefactoringsAsync(context, (AwaitExpressionSyntax)node).ConfigureAwait(false); fAwaitExpression = true; } if (!fCastExpression && kind == SyntaxKind.CastExpression) { CastExpressionRefactoring.ComputeRefactorings(context, (CastExpressionSyntax)node); fCastExpression = true; } if (!fThrowExpression && kind == SyntaxKind.ThrowExpression) { await ThrowExpressionRefactoring.ComputeRefactoringsAsync(context, (ThrowExpressionSyntax)node).ConfigureAwait(false); fThrowExpression = true; } if (!fDeclarationExpression && kind == SyntaxKind.DeclarationExpression) { await DeclarationExpressionRefactoring.ComputeRefactoringsAsync(context, (DeclarationExpressionSyntax)node).ConfigureAwait(false); fDeclarationExpression = true; } continue; } var memberDeclaration = node as MemberDeclarationSyntax; if (memberDeclaration != null) { if (!fMemberDeclaration) { await MemberDeclarationRefactoring.ComputeRefactoringsAsync(context, memberDeclaration).ConfigureAwait(false); AttributeListRefactoring.ComputeRefactorings(context, memberDeclaration); await IntroduceConstructorRefactoring.ComputeRefactoringsAsync(context, memberDeclaration).ConfigureAwait(false); fMemberDeclaration = true; } continue; } var statement = node as StatementSyntax; if (statement != null) { if (!fDoStatement && kind == SyntaxKind.DoStatement) { DoStatementRefactoring.ComputeRefactorings(context, (DoStatementSyntax)statement); fDoStatement = true; } if (!fExpressionStatement && kind == SyntaxKind.ExpressionStatement) { await ExpressionStatementRefactoring.ComputeRefactoringsAsync(context, (ExpressionStatementSyntax)statement).ConfigureAwait(false); fExpressionStatement = true; } if (!fForEachStatement && kind == SyntaxKind.ForEachStatement) { await ForEachStatementRefactoring.ComputeRefactoringsAsync(context, (ForEachStatementSyntax)statement).ConfigureAwait(false); fForEachStatement = true; } if (!fForStatement && kind == SyntaxKind.ForStatement) { await ForStatementRefactoring.ComputeRefactoringsAsync(context, (ForStatementSyntax)statement).ConfigureAwait(false); fForStatement = true; } if (!fIfStatement && kind == SyntaxKind.IfStatement) { await IfStatementRefactoring.ComputeRefactoringsAsync(context, (IfStatementSyntax)statement).ConfigureAwait(false); fIfStatement = true; } if (!fLocalDeclarationStatement && kind == SyntaxKind.LocalDeclarationStatement) { await LocalDeclarationStatementRefactoring.ComputeRefactoringsAsync(context, (LocalDeclarationStatementSyntax)statement).ConfigureAwait(false); fLocalDeclarationStatement = true; } if (!fReturnStatement && kind == SyntaxKind.ReturnStatement) { await ReturnStatementRefactoring.ComputeRefactoringsAsync(context, (ReturnStatementSyntax)statement).ConfigureAwait(false); fReturnStatement = true; } if (!fSwitchStatement && kind == SyntaxKind.SwitchStatement) { await SwitchStatementRefactoring.ComputeRefactoringsAsync(context, (SwitchStatementSyntax)statement).ConfigureAwait(false); fSwitchStatement = true; } if (!fUsingStatement && kind == SyntaxKind.UsingStatement) { await UsingStatementRefactoring.ComputeRefactoringsAsync(context, (UsingStatementSyntax)statement).ConfigureAwait(false); fUsingStatement = true; } if (!fWhileStatement && kind == SyntaxKind.WhileStatement) { WhileStatementRefactoring.ComputeRefactorings(context, (WhileStatementSyntax)statement); fWhileStatement = true; } if (!fYieldReturnStatement) { var yieldStatement = node as YieldStatementSyntax; if (yieldStatement != null) { await YieldStatementRefactoring.ComputeRefactoringsAsync(context, yieldStatement).ConfigureAwait(false); fYieldReturnStatement = true; } } if (!fLockStatement && kind == SyntaxKind.LockStatement) { LockStatementRefactoring.ComputeRefactorings(context, (LockStatementSyntax)node); fLockStatement = true; } if (!fBlock && kind == SyntaxKind.Block) { await BlockRefactoring.ComputeRefactoringAsync(context, (BlockSyntax)node).ConfigureAwait(false); fBlock = true; } if (!fThrowStatement && kind == SyntaxKind.ThrowStatement) { await ThrowStatementRefactoring.ComputeRefactoringAsync(context, (ThrowStatementSyntax)node).ConfigureAwait(false); fThrowStatement = true; } if (!fStatement) { AddBracesRefactoring.ComputeRefactoring(context, statement); RemoveBracesRefactoring.ComputeRefactoring(context, statement); ExtractStatementRefactoring.ComputeRefactoring(context, statement); fStatement = true; } if (!fStatementRefactoring) { if (kind == SyntaxKind.Block) { StatementRefactoring.ComputeRefactoring(context, (BlockSyntax)node); fStatementRefactoring = true; } else if (kind == SyntaxKind.SwitchStatement) { StatementRefactoring.ComputeRefactoring(context, (SwitchStatementSyntax)node); fStatementRefactoring = true; } } continue; } } } await SyntaxNodeRefactoring.ComputeRefactoringsAsync(context, firstNode).ConfigureAwait(false); CommentTriviaRefactoring.ComputeRefactorings(context, firstNode); }
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationListSelection selectedMembers) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeAccessibility)) { Accessibilities validAccessibilities = ChangeAccessibilityAnalysis.GetValidAccessibilities(selectedMembers, allowOverride: true); if (validAccessibilities != Accessibilities.None) { bool canHaveMultipleDeclarations = CanHaveMultipleDeclarations(); TryRegisterRefactoring(validAccessibilities, Accessibility.Public, canHaveMultipleDeclarations); TryRegisterRefactoring(validAccessibilities, Accessibility.Internal, canHaveMultipleDeclarations); TryRegisterRefactoring(validAccessibilities, Accessibility.Protected, canHaveMultipleDeclarations); TryRegisterRefactoring(validAccessibilities, Accessibility.Private, canHaveMultipleDeclarations); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.InitializeFieldFromConstructor)) { InitializeFieldFromConstructorRefactoring.ComputeRefactoring(context, selectedMembers); } void TryRegisterRefactoring(Accessibilities accessibilities, Accessibility accessibility, bool canHaveMultipleDeclarations) { if ((accessibilities & accessibility.GetAccessibilities()) != 0) { if (canHaveMultipleDeclarations) { context.RegisterRefactoring( ChangeAccessibilityRefactoring.GetTitle(accessibility), async cancellationToken => { SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); return(await ChangeAccessibilityRefactoring.RefactorAsync(context.Document.Solution(), selectedMembers, accessibility, semanticModel, cancellationToken).ConfigureAwait(false)); }); } else { context.RegisterRefactoring( ChangeAccessibilityRefactoring.GetTitle(accessibility), cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, selectedMembers, accessibility, cancellationToken)); } } } bool CanHaveMultipleDeclarations() { foreach (MemberDeclarationSyntax member in selectedMembers) { switch (member.Kind()) { case SyntaxKind.ClassDeclaration: { if (((ClassDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword)) { return(true); } break; } case SyntaxKind.InterfaceDeclaration: { if (((InterfaceDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword)) { return(true); } break; } case SyntaxKind.StructDeclaration: { if (((StructDeclarationSyntax)member).Modifiers.Contains(SyntaxKind.PartialKeyword)) { return(true); } break; } case SyntaxKind.MethodDeclaration: { if (((MethodDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.PartialKeyword, SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.PropertyDeclaration: { if (((PropertyDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.IndexerDeclaration: { if (((IndexerDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.EventDeclaration: { if (((EventDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } case SyntaxKind.EventFieldDeclaration: { if (((EventFieldDeclarationSyntax)member).Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword)) { return(true); } break; } } } return(false); } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, StatementListSelection selectedStatements) { if (selectedStatements.Count <= 1) { return; } StatementSyntax firstStatement = selectedStatements.First(); SemanticModel semanticModel = null; ISymbol symbol = null; ObjectCreationExpressionSyntax objectCreation = null; SyntaxKind kind = firstStatement.Kind(); if (kind == SyntaxKind.LocalDeclarationStatement) { var localDeclaration = (LocalDeclarationStatementSyntax)firstStatement; VariableDeclaratorSyntax variable = localDeclaration .Declaration? .Variables .SingleOrDefault(shouldThrow: false); objectCreation = variable?.Initializer?.Value as ObjectCreationExpressionSyntax; if (objectCreation != null) { semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); symbol = semanticModel.GetDeclaredSymbol(variable, context.CancellationToken); } } else if (kind == SyntaxKind.ExpressionStatement) { var expressionStatement = (ExpressionStatementSyntax)firstStatement; if (expressionStatement.Expression is AssignmentExpressionSyntax assignment) { objectCreation = assignment.Right as ObjectCreationExpressionSyntax; if (objectCreation != null) { semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); symbol = semanticModel.GetSymbol(assignment.Left, context.CancellationToken); } } } if (objectCreation == null) { return; } if (symbol?.IsErrorType() != false) { return; } for (int i = 1; i < selectedStatements.Count; i++) { if (!IsValidAssignmentStatement(selectedStatements[i], symbol, semanticModel, context.CancellationToken)) { return; } } context.RegisterRefactoring( "Collapse to initializer", ct => RefactorAsync(context.Document, objectCreation, selectedStatements, ct), RefactoringIdentifiers.CollapseToInitializer); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, LiteralExpressionSyntax literalExpression) { StringLiteralExpressionInfo info = SyntaxInfo.StringLiteralExpressionInfo(literalExpression); Debug.Assert(info.Success); if (!info.Success) { return; } if (context.IsRefactoringEnabled(RefactoringIdentifiers.InsertStringInterpolation) && context.SupportsCSharp6 && context.Span.End < literalExpression.Span.End && !CSharpUtility.IsPartOfExpressionThatMustBeConstant(literalExpression)) { int startIndex = GetStartIndex(info, context.Span); if (startIndex != -1) { context.RegisterRefactoring( "Insert interpolation", cancellationToken => { return(ConvertToInterpolatedStringAsync( context.Document, literalExpression, startIndex, context.Span.Length, addNameOf: false, cancellationToken: cancellationToken)); }, RefactoringIdentifiers.InsertStringInterpolation); if (!context.Span.IsEmpty) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); string name = StringLiteralParser.Parse(literalExpression.Token.Text, startIndex, context.Span.Length, info.IsVerbatim, isInterpolatedText: false); foreach (ISymbol symbol in semanticModel.LookupSymbols(literalExpression.SpanStart)) { if (string.Equals(name, symbol.MetadataName, StringComparison.Ordinal)) { context.RegisterRefactoring( "Insert interpolation with nameof", cancellationToken => { return(ConvertToInterpolatedStringAsync( context.Document, literalExpression, startIndex, context.Span.Length, addNameOf: true, cancellationToken: cancellationToken)); }, EquivalenceKey.Join(RefactoringIdentifiers.InsertStringInterpolation, "WithNameOf")); break; } } } } } if (context.Span.IsBetweenSpans(literalExpression)) { if (info.IsVerbatim) { if (info.ContainsEscapeSequence) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertVerbatimStringLiteralToRegularStringLiteral)) { context.RegisterRefactoring( "Convert to regular string", ct => ReplaceWithRegularStringLiteralAsync(context.Document, literalExpression, ct), RefactoringIdentifiers.ConvertVerbatimStringLiteralToRegularStringLiteral); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertVerbatimStringLiteralToRegularStringLiterals) && info.ContainsLinefeed) { context.RegisterRefactoring( "Convert to regular strings", ct => ConvertToRegularStringLiteralsAsync(context.Document, literalExpression, ct), RefactoringIdentifiers.ConvertVerbatimStringLiteralToRegularStringLiterals); } } } else if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertRegularStringLiteralToVerbatimStringLiteral) && info.ContainsEscapeSequence) { context.RegisterRefactoring( "Convert to verbatim string", ct => ConvertToVerbatimStringLiteralAsync(context.Document, literalExpression, ct), RefactoringIdentifiers.ConvertRegularStringLiteralToVerbatimStringLiteral); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertEmptyStringToStringEmpty) && CanConvertToStringEmpty(literalExpression)) { context.RegisterRefactoring( "Convert to 'string.Empty'", ct => ConvertToStringEmptyAsync(context.Document, literalExpression, ct), RefactoringIdentifiers.ConvertEmptyStringToStringEmpty); } }
internal static async Task ComputeRefactoringAsync(RefactoringContext context, LocalDeclarationStatementSyntax localDeclarationStatement) { EqualsValueClauseSyntax equalsValueClause = localDeclarationStatement .Declaration .Variables .SingleOrDefault(shouldThrow: false)? .Initializer; if (equalsValueClause == null) { return; } if (!context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(equalsValueClause)) { return; } ExpressionSyntax value = equalsValueClause.Value; if (value == null) { return; } const string title = "Remove instantiation"; switch (value) { case ObjectCreationExpressionSyntax objectCreation: { InitializerExpressionSyntax initializer = objectCreation.Initializer; if (initializer?.Span.Contains(context.Span) == true) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(objectCreation, context.CancellationToken); ComputeRefactoring(context, title, typeSymbol, localDeclarationStatement, value); break; } case ArrayCreationExpressionSyntax arrayCreation: { InitializerExpressionSyntax initializer = arrayCreation.Initializer; if (initializer?.Span.Contains(context.Span) == true) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(arrayCreation, context.CancellationToken); ComputeRefactoring(context, title, typeSymbol, localDeclarationStatement, value); break; } case ImplicitArrayCreationExpressionSyntax implicitArrayCreation: { InitializerExpressionSyntax initializer = implicitArrayCreation.Initializer; if (initializer?.Span.Contains(context.Span) == true) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitArrayCreation, context.CancellationToken); ComputeRefactoring(context, title, typeSymbol, localDeclarationStatement, value); break; } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberDeclarationSyntax member) { switch (member.Kind()) { case SyntaxKind.MethodDeclaration: case SyntaxKind.IndexerDeclaration: case SyntaxKind.PropertyDeclaration: case SyntaxKind.OperatorDeclaration: case SyntaxKind.ConversionOperatorDeclaration: case SyntaxKind.ConstructorDeclaration: case SyntaxKind.EventDeclaration: case SyntaxKind.NamespaceDeclaration: case SyntaxKind.ClassDeclaration: case SyntaxKind.StructDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.EnumDeclaration: { if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.RemoveMember, RefactoringIdentifiers.DuplicateMember, RefactoringIdentifiers.CommentOutMember) && BraceContainsSpan(context, member)) { if (member.IsParentKind( SyntaxKind.NamespaceDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.CompilationUnit)) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveMember)) { context.RegisterRefactoring( "Remove " + member.GetTitle(), cancellationToken => context.Document.RemoveMemberAsync(member, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateMember)) { context.RegisterRefactoring( "Duplicate " + member.GetTitle(), cancellationToken => DuplicateMemberDeclarationRefactoring.RefactorAsync(context.Document, member, cancellationToken)); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutMember)) { CommentOutRefactoring.RegisterRefactoring(context, member); } } break; } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveAllStatements)) { RemoveAllStatementsRefactoring.ComputeRefactoring(context, member); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveAllMemberDeclarations)) { RemoveAllMemberDeclarationsRefactoring.ComputeRefactoring(context, member); } if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.SwapMemberDeclarations, RefactoringIdentifiers.RemoveMemberDeclarations) && !member.Span.IntersectsWith(context.Span)) { MemberDeclarationsRefactoring.ComputeRefactoring(context, member); } switch (member.Kind()) { case SyntaxKind.NamespaceDeclaration: { var namespaceDeclaration = (NamespaceDeclarationSyntax)member; NamespaceDeclarationRefactoring.ComputeRefactorings(context, namespaceDeclaration); SelectedMemberDeclarationsRefactoring.ComputeRefactoring(context, namespaceDeclaration); break; } case SyntaxKind.ClassDeclaration: { var classDeclaration = (ClassDeclarationSyntax)member; await ClassDeclarationRefactoring.ComputeRefactoringsAsync(context, classDeclaration).ConfigureAwait(false); SelectedMemberDeclarationsRefactoring.ComputeRefactoring(context, classDeclaration); break; } case SyntaxKind.StructDeclaration: { var structDeclaration = (StructDeclarationSyntax)member; await StructDeclarationRefactoring.ComputeRefactoringsAsync(context, structDeclaration).ConfigureAwait(false); SelectedMemberDeclarationsRefactoring.ComputeRefactoring(context, structDeclaration); break; } case SyntaxKind.InterfaceDeclaration: { InterfaceDeclarationRefactoring.ComputeRefactorings(context, (InterfaceDeclarationSyntax)member); break; } case SyntaxKind.EnumDeclaration: { await EnumDeclarationRefactoring.ComputeRefactoringAsync(context, (EnumDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.EnumMemberDeclaration: { await EnumMemberDeclarationRefactoring.ComputeRefactoringAsync(context, (EnumMemberDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.DelegateDeclaration: { DelegateDeclarationRefactoring.ComputeRefactorings(context, (DelegateDeclarationSyntax)member); break; } case SyntaxKind.MethodDeclaration: { await MethodDeclarationRefactoring.ComputeRefactoringsAsync(context, (MethodDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.ConstructorDeclaration: { await ConstructorDeclarationRefactoring.ComputeRefactoringsAsync(context, (ConstructorDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.DestructorDeclaration: { DestructorDeclarationRefactoring.ComputeRefactorings(context, (DestructorDeclarationSyntax)member); break; } case SyntaxKind.IndexerDeclaration: { await IndexerDeclarationRefactoring.ComputeRefactoringsAsync(context, (IndexerDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.PropertyDeclaration: { await PropertyDeclarationRefactoring.ComputeRefactoringsAsync(context, (PropertyDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.OperatorDeclaration: { ComputeRefactorings(context, (OperatorDeclarationSyntax)member); break; } case SyntaxKind.ConversionOperatorDeclaration: { ComputeRefactorings(context, (ConversionOperatorDeclarationSyntax)member); break; } case SyntaxKind.FieldDeclaration: { await FieldDeclarationRefactoring.ComputeRefactoringsAsync(context, (FieldDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.EventDeclaration: { await EventDeclarationRefactoring.ComputeRefactoringsAsync(context, (EventDeclarationSyntax)member).ConfigureAwait(false); break; } case SyntaxKind.EventFieldDeclaration: { await EventFieldDeclarationRefactoring.ComputeRefactoringsAsync(context, (EventFieldDeclarationSyntax)member).ConfigureAwait(false); break; } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SelectedStatementCollection selectedStatements) { StatementSyntax firstStatement = selectedStatements.First; SemanticModel semanticModel = null; ISymbol symbol = null; ObjectCreationExpressionSyntax objectCreation = null; if (selectedStatements.IsMultiple) { SyntaxKind kind = firstStatement.Kind(); if (kind == SyntaxKind.LocalDeclarationStatement) { var localDeclaration = (LocalDeclarationStatementSyntax)firstStatement; VariableDeclaratorSyntax variable = localDeclaration.Declaration?.SingleVariableOrDefault(); objectCreation = variable?.Initializer?.Value as ObjectCreationExpressionSyntax; if (objectCreation != null) { semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); symbol = semanticModel.GetDeclaredSymbol(variable, context.CancellationToken); } } else if (kind == SyntaxKind.ExpressionStatement) { var expressionStatement = (ExpressionStatementSyntax)firstStatement; var assignment = expressionStatement.Expression as AssignmentExpressionSyntax; if (assignment != null) { objectCreation = assignment.Right as ObjectCreationExpressionSyntax; if (objectCreation != null) { semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); symbol = semanticModel.GetSymbol(assignment.Left, context.CancellationToken); } } } if (objectCreation != null && symbol?.IsErrorType() == false && selectedStatements .Skip(1) .All(f => IsValidAssignmentStatement(f, symbol, semanticModel, context.CancellationToken))) { context.RegisterRefactoring( "Collapse to initializer", cancellationToken => { return(RefactorAsync( context.Document, objectCreation, selectedStatements, cancellationToken)); }); } } }
public static void ComputeRefactorings(RefactoringContext context, EnumDeclarationSyntax enumDeclaration) { SyntaxToken identifier = enumDeclaration.Identifier; ComputeRefactorings(context, enumDeclaration, identifier); }