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);
}
