public static async Task ComputeRefactoringAsync(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMethodReturnTypeToVoid) &&
methodDeclaration.ReturnType?.IsVoid() == false &&
methodDeclaration.Body?.Statements.Count > 0 &&
!methodDeclaration.IsIterator() &&
context.SupportsSemanticModel)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (!IsAsyncMethodThatReturnsTask(methodDeclaration, semanticModel, context.CancellationToken))
{
ControlFlowAnalysis analysis = semanticModel.AnalyzeControlFlow(methodDeclaration.Body);
if (analysis.Succeeded &&
analysis.ReturnStatements.All(node => IsReturnStatementWithoutExpression(node)))
{
context.RegisterRefactoring(
"Change return type to 'void'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeAsync(
context.Document,
methodDeclaration.ReturnType,
CSharpFactory.VoidType(),
cancellationToken));
});
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMethodReturnTypeToVoid))
{
TypeSyntax returnType = methodDeclaration.ReturnType;
if (returnType?.IsVoid() == false)
{
BlockSyntax body = methodDeclaration.Body;
if (body != null)
{
SyntaxList <StatementSyntax> statements = body.Statements;
if (statements.Any() &&
!ContainsOnlyThrowStatement(statements) &&
!methodDeclaration.ContainsYield())
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol?.IsOverride == false &&
!methodSymbol.ImplementsInterfaceMember() &&
!IsAsyncMethodThatReturnsTask(methodSymbol, semanticModel))
{
ControlFlowAnalysis analysis = semanticModel.AnalyzeControlFlow(body);
if (analysis.Succeeded &&
analysis.ReturnStatements.All(IsReturnStatementWithoutExpression))
{
context.RegisterRefactoring(
"Change return type to 'void'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeAsync(
context.Document,
returnType,
CSharpFactory.VoidType(),
cancellationToken));
});
}
}
}
}
}
}
}
private static void ComputeRefactoring(
RefactoringContext context,
IMethodSymbol methodSymbol,
SemanticModel semanticModel,
BlockSyntax body,
TypeSyntax returnType)
{
if (methodSymbol?.IsOverride != false)
{
return;
}
if (methodSymbol.ImplementsInterfaceMember())
{
return;
}
if (methodSymbol.IsAsync &&
methodSymbol.ReturnType.HasMetadataName(MetadataNames.System_Threading_Tasks_Task))
{
return;
}
ControlFlowAnalysis analysis = semanticModel.AnalyzeControlFlow(body);
if (!analysis.Succeeded)
{
return;
}
if (!analysis.ReturnStatements.All(f => (f as ReturnStatementSyntax)?.Expression == null))
{
return;
}
Document document = context.Document;
context.RegisterRefactoring(
"Change return type to 'void'",
ct => document.ReplaceNodeAsync(returnType, CSharpFactory.VoidType().WithTriviaFrom(returnType), ct),
RefactoringDescriptors.ChangeMethodReturnTypeToVoid);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveMemberDeclaration) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RenameDestructorToMatchClassName) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RenameTupleElement))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.MissingXmlCommentForPubliclyVisibleTypeOrMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add documentation comment",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, false, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
CodeAction codeAction2 = CodeAction.Create(
"Add documentation comment (copy from base if available)",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, true, cancellationToken),
GetEquivalenceKey(diagnostic, "CopyFromBaseIfAvailable"));
context.RegisterCodeFix(codeAction2, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MethodReturnTypeMustMatchOverriddenMethodReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = methodSymbol.OverriddenMethod.ReturnType;
CodeFixRegistrator.ChangeMemberDeclarationType(context, diagnostic, memberDeclaration, typeSymbol, semanticModel);
break;
}
case CompilerDiagnosticIdentifiers.PartialMethodsMustHaveVoidReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;
MethodDeclarationSyntax otherPart = semanticModel.GetOtherPart(methodDeclaration, context.CancellationToken);
if (otherPart == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Change return type to 'void'",
cancellationToken =>
{
return(context.Document.Solution().ReplaceNodesAsync(
new MethodDeclarationSyntax[] { methodDeclaration, otherPart },
(node, _) => node.WithReturnType(CSharpFactory.VoidType().WithTriviaFrom(node.ReturnType)),
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MemberTypeMustMatchOverriddenMemberType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
{
var propertySymbol = (IPropertySymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = propertySymbol.OverriddenProperty.Type;
break;
}
case SyntaxKind.EventDeclaration:
{
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
case SyntaxKind.EventFieldDeclaration:
{
VariableDeclaratorSyntax declarator = ((EventFieldDeclarationSyntax)memberDeclaration).Declaration.Variables.First();
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
}
CodeFixRegistrator.ChangeMemberDeclarationType(context, diagnostic, memberDeclaration, typeSymbol, semanticModel);
break;
}
case CompilerDiagnosticIdentifiers.MissingPartialModifier:
case CompilerDiagnosticIdentifiers.PartialMethodMustBeDeclaredInPartialClassOrPartialStruct:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier))
{
break;
}
SyntaxNode node = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.MethodDeclaration:
{
if (memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
node = memberDeclaration.Parent;
}
break;
}
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
{
node = memberDeclaration;
break;
}
}
Debug.Assert(node != null, memberDeclaration.ToString());
if (node == null)
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.PartialKeyword);
break;
}
case CompilerDiagnosticIdentifiers.MemberIsAbstractButItIsContainedInNonAbstractClass:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract))
{
break;
}
if (!memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration))
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
memberDeclaration.Parent,
SyntaxKind.AbstractKeyword,
title: "Make containing class abstract");
break;
}
case CompilerDiagnosticIdentifiers.StaticConstructorMustBeParameterless:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor))
{
break;
}
var constructorDeclaration = (ConstructorDeclarationSyntax)memberDeclaration;
CodeAction codeAction = CodeAction.Create(
"Remove parameters",
cancellationToken =>
{
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
ParameterListSyntax newParameterList = parameterList
.WithParameters(default(SeparatedSyntaxList <ParameterSyntax>))
.WithOpenParenToken(parameterList.OpenParenToken.WithoutTrailingTrivia())
.WithCloseParenToken(parameterList.CloseParenToken.WithoutLeadingTrivia());
ConstructorDeclarationSyntax newNode = constructorDeclaration.WithParameterList(newParameterList);
return(context.Document.ReplaceNodeAsync(constructorDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ExplicitInterfaceDeclarationCanOnlyBeDeclaredInClassOrStruct:
case CompilerDiagnosticIdentifiers.InterfacesCannotContainFields:
case CompilerDiagnosticIdentifiers.InterfacesCannotContainOperators:
case CompilerDiagnosticIdentifiers.InterfacesCannotDeclareTypes:
case CompilerDiagnosticIdentifiers.OnlyClassTypesCanContainDestructors:
case CompilerDiagnosticIdentifiers.StructsCannotContainExplicitParameterlessConstructors:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveMemberDeclaration))
{
break;
}
CodeFixRegistrator.RemoveMember(context, diagnostic, memberDeclaration);
break;
}
case CompilerDiagnosticIdentifiers.NameOfDestructorMustMatchNameOfClass:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RenameDestructorToMatchClassName))
{
break;
}
if (!(memberDeclaration is DestructorDeclarationSyntax destructorDeclaration))
{
break;
}
if (!(memberDeclaration.Parent is ClassDeclarationSyntax classDeclaration))
{
break;
}
if (classDeclaration.Identifier.ValueText.Length == 0)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Rename destructor to match class name",
cancellationToken =>
{
DestructorDeclarationSyntax newNode = destructorDeclaration.WithIdentifier(classDeclaration.Identifier.WithTriviaFrom(destructorDeclaration.Identifier));
return(context.Document.ReplaceNodeAsync(destructorDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CannotChangeTupleElementNameWhenOverridingInheritedMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RenameTupleElement))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (memberDeclaration is MethodDeclarationSyntax methodDeclaration)
{
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (!(methodSymbol.ReturnType is INamedTypeSymbol tupleType))
{
break;
}
if (!tupleType.IsTupleType)
{
break;
}
if (!(methodSymbol.OverriddenMethod?.ReturnType is INamedTypeSymbol baseTupleType))
{
break;
}
if (!baseTupleType.IsTupleType)
{
break;
}
ImmutableArray <IFieldSymbol> elements = tupleType.TupleElements;
ImmutableArray <IFieldSymbol> baseElements = baseTupleType.TupleElements;
if (elements.Length != baseElements.Length)
{
break;
}
int i = 0;
while (i < elements.Length)
{
if (elements[i].Name != baseElements[i].Name)
{
break;
}
i++;
}
if (i == elements.Length)
{
break;
}
TupleElementSyntax tupleElement = ((TupleTypeSyntax)methodDeclaration.ReturnType).Elements[i];
CodeAction codeAction = CodeAction.Create(
$"Rename '{elements[i].Name}' to '{baseElements[i].Name}'",
ct => RenameTupleElementAsync(context.Document, methodDeclaration, tupleElement, elements[i], baseElements[i].Name, semanticModel, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
else if (memberDeclaration is PropertyDeclarationSyntax propertyDeclaration)
{
IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken);
if (!(propertySymbol.Type is INamedTypeSymbol tupleType))
{
break;
}
if (!tupleType.IsTupleType)
{
break;
}
if (!(propertySymbol.OverriddenProperty?.Type is INamedTypeSymbol baseTupleType))
{
break;
}
if (!baseTupleType.IsTupleType)
{
break;
}
ImmutableArray <IFieldSymbol> elements = tupleType.TupleElements;
ImmutableArray <IFieldSymbol> baseElements = baseTupleType.TupleElements;
if (elements.Length != baseElements.Length)
{
break;
}
int i = 0;
while (i < elements.Length)
{
if (elements[i].Name != baseElements[i].Name)
{
break;
}
i++;
}
if (i == elements.Length)
{
break;
}
TupleElementSyntax tupleElement = ((TupleTypeSyntax)propertyDeclaration.Type).Elements[i];
CodeAction codeAction = CodeAction.Create(
$"Rename '{elements[i].Name}' to '{baseElements[i].Name}'",
ct => RenameTupleElementAsync(context.Document, propertyDeclaration, tupleElement, elements[i], baseElements[i].Name, semanticModel, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.OverridingMemberCannotChangeAccessModifiers) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeMemberNonStatic) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
MemberDeclarationSyntax memberDeclaration = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <MemberDeclarationSyntax>();
Debug.Assert(memberDeclaration != null, $"{nameof(memberDeclaration)} is null");
if (memberDeclaration == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotChangeAccessModifiersWhenOverridingInheritedMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.OverridingMemberCannotChangeAccessModifiers))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
OverrideInfo overrideInfo = OverridingMemberCannotChangeAccessModifiersRefactoring.GetOverrideInfo(memberDeclaration, semanticModel, context.CancellationToken);
Accessibility newAccessibility = overrideInfo.OverriddenSymbol.DeclaredAccessibility;
string title = $"Change accessibility to '{AccessibilityHelper.GetAccessibilityName(newAccessibility)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => OverridingMemberCannotChangeAccessModifiersRefactoring.RefactorAsync(context.Document, memberDeclaration, newAccessibility, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MissingXmlCommentForPubliclyVisibleTypeOrMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add documentation comment",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, false, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
CodeAction codeAction2 = CodeAction.Create(
"Add documentation comment (copy from base if available)",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, true, cancellationToken),
GetEquivalenceKey(diagnostic, "CopyFromBaseIfAvailable"));
context.RegisterCodeFix(codeAction2, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MethodReturnTypeMustMatchOverriddenMethodReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = methodSymbol.OverriddenMethod.ReturnType;
if (typeSymbol?.IsErrorType() == false)
{
TypeSyntax newType = typeSymbol.ToMinimalTypeSyntax(semanticModel, memberDeclaration.SpanStart);
CodeAction codeAction = CodeAction.Create(
$"Change return type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, memberDeclaration.SpanStart)}'",
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.PartialMethodsMustHaveVoidReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;
MethodDeclarationSyntax otherPart = semanticModel.GetOtherPart(methodDeclaration, context.CancellationToken);
if (otherPart == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Change return type to 'void'",
cancellationToken =>
{
return(context.Document.Solution().ReplaceNodesAsync(
new MethodDeclarationSyntax[] { methodDeclaration, otherPart },
(node, rewrittenNode) => node.WithReturnType(CSharpFactory.VoidType().WithTriviaFrom(node.ReturnType)),
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MemberTypeMustMatchOverriddenMemberType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
{
var propertySymbol = (IPropertySymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = propertySymbol.OverriddenProperty.Type;
break;
}
case SyntaxKind.EventDeclaration:
{
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
case SyntaxKind.EventFieldDeclaration:
{
VariableDeclaratorSyntax declarator = ((EventFieldDeclarationSyntax)memberDeclaration).Declaration.Variables.First();
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
}
if (typeSymbol?.IsErrorType() == false)
{
string title = $"Change type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, memberDeclaration.SpanStart)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.MissingPartialModifier:
case CompilerDiagnosticIdentifiers.PartialMethodMustBeDeclaredWithinPartialClassOrPartialStruct:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add 'partial' modifier",
cancellationToken =>
{
if (memberDeclaration.IsKind(SyntaxKind.MethodDeclaration) &&
memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
return(context.Document.InsertModifierAsync(memberDeclaration.Parent, SyntaxKind.PartialKeyword, ModifierComparer.Instance, cancellationToken));
}
else if (memberDeclaration.IsKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration))
{
return(context.Document.InsertModifierAsync(memberDeclaration, SyntaxKind.PartialKeyword, ModifierComparer.Instance, cancellationToken));
}
return(Task.FromResult(context.Document));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MemberIsAbstractButItIsContainedInNonAbstractClass:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract))
{
break;
}
if (!memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Make containing class abstract",
cancellationToken => context.Document.InsertModifierAsync(memberDeclaration.Parent, SyntaxKind.AbstractKeyword, ModifierComparer.Instance, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ObjectReferenceIsRequiredForNonStaticMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeMemberNonStatic))
{
break;
}
SyntaxTokenList modifiers = memberDeclaration.GetModifiers();
Debug.Assert(modifiers.Contains(SyntaxKind.StaticKeyword), memberDeclaration.ToString());
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
break;
}
CodeAction codeAction = CodeAction.Create(
$"Make containing {memberDeclaration.GetTitle()} non-static",
cancellationToken => context.Document.RemoveModifierAsync(memberDeclaration, SyntaxKind.StaticKeyword, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.StaticConstructorMustBeParameterless:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor))
{
break;
}
var constructorDeclaration = (ConstructorDeclarationSyntax)memberDeclaration;
CodeAction codeAction = CodeAction.Create(
"Remove parameters",
cancellationToken =>
{
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
ParameterListSyntax newParameterList = parameterList
.WithParameters(default(SeparatedSyntaxList <ParameterSyntax>))
.WithOpenParenToken(parameterList.OpenParenToken.WithoutTrailingTrivia())
.WithCloseParenToken(parameterList.CloseParenToken.WithoutLeadingTrivia());
ConstructorDeclarationSyntax newNode = constructorDeclaration.WithParameterList(newParameterList);
return(context.Document.ReplaceNodeAsync(constructorDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveMemberDeclaration))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.MissingXmlCommentForPubliclyVisibleTypeOrMember:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDocumentationComment))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add documentation comment",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, false, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
CodeAction codeAction2 = CodeAction.Create(
"Add documentation comment (copy from base if available)",
cancellationToken => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, true, cancellationToken),
GetEquivalenceKey(diagnostic, "CopyFromBaseIfAvailable"));
context.RegisterCodeFix(codeAction2, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MethodReturnTypeMustMatchOverriddenMethodReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = methodSymbol.OverriddenMethod.ReturnType;
if (typeSymbol?.IsErrorType() == false)
{
CodeAction codeAction = CodeAction.Create(
$"Change return type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, memberDeclaration.SpanStart)}'",
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.PartialMethodsMustHaveVoidReturnType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;
MethodDeclarationSyntax otherPart = semanticModel.GetOtherPart(methodDeclaration, context.CancellationToken);
if (otherPart == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Change return type to 'void'",
cancellationToken =>
{
return(context.Document.Solution().ReplaceNodesAsync(
new MethodDeclarationSyntax[] { methodDeclaration, otherPart },
(node, rewrittenNode) => node.WithReturnType(CSharpFactory.VoidType().WithTriviaFrom(node.ReturnType)),
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.MemberTypeMustMatchOverriddenMemberType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
{
var propertySymbol = (IPropertySymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = propertySymbol.OverriddenProperty.Type;
break;
}
case SyntaxKind.EventDeclaration:
{
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
case SyntaxKind.EventFieldDeclaration:
{
VariableDeclaratorSyntax declarator = ((EventFieldDeclarationSyntax)memberDeclaration).Declaration.Variables.First();
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
}
if (typeSymbol?.IsErrorType() == false)
{
string title = $"Change type to '{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, memberDeclaration.SpanStart)}'";
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => MemberTypeMustMatchOverriddenMemberTypeRefactoring.RefactorAsync(context.Document, memberDeclaration, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.MissingPartialModifier:
case CompilerDiagnosticIdentifiers.PartialMethodMustBeDeclaredWithinPartialClassOrPartialStruct:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddPartialModifier))
{
break;
}
SyntaxNode node = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.MethodDeclaration:
{
if (memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
node = memberDeclaration.Parent;
}
break;
}
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
{
node = memberDeclaration;
break;
}
}
Debug.Assert(node != null, memberDeclaration.ToString());
if (node == null)
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.PartialKeyword);
break;
}
case CompilerDiagnosticIdentifiers.MemberIsAbstractButItIsContainedInNonAbstractClass:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.MakeContainingClassAbstract))
{
break;
}
if (!memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration))
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
memberDeclaration.Parent,
SyntaxKind.AbstractKeyword,
title: "Make containing class abstract");
break;
}
case CompilerDiagnosticIdentifiers.StaticConstructorMustBeParameterless:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor))
{
break;
}
var constructorDeclaration = (ConstructorDeclarationSyntax)memberDeclaration;
CodeAction codeAction = CodeAction.Create(
"Remove parameters",
cancellationToken =>
{
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
ParameterListSyntax newParameterList = parameterList
.WithParameters(default(SeparatedSyntaxList <ParameterSyntax>))
.WithOpenParenToken(parameterList.OpenParenToken.WithoutTrailingTrivia())
.WithCloseParenToken(parameterList.CloseParenToken.WithoutLeadingTrivia());
ConstructorDeclarationSyntax newNode = constructorDeclaration.WithParameterList(newParameterList);
return(context.Document.ReplaceNodeAsync(constructorDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ExplicitInterfaceDeclarationCanOnlyBeDeclaredInClassOrStruct:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveMemberDeclaration))
{
break;
}
CodeFixRegistrator.RemoveMember(context, diagnostic, memberDeclaration);
break;
}
}
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CS1591_MissingXmlCommentForPubliclyVisibleTypeOrMember:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddDocumentationComment, context.Document, root.SyntaxTree))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add documentation comment",
ct => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, false, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
CodeAction codeAction2 = CodeAction.Create(
"Add documentation comment (copy from base if available)",
ct => AddDocumentationCommentRefactoring.RefactorAsync(context.Document, memberDeclaration, true, ct),
GetEquivalenceKey(diagnostic, "CopyFromBaseIfAvailable"));
context.RegisterCodeFix(codeAction2, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CS0508_MethodReturnTypeMustMatchOverriddenMethodReturnType:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeMethodReturnType, context.Document, root.SyntaxTree))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = methodSymbol.OverriddenMethod.ReturnType;
CodeFixRegistrator.ChangeTypeOrReturnType(context, diagnostic, memberDeclaration, typeSymbol, semanticModel);
break;
}
case CompilerDiagnosticIdentifiers.CS0766_PartialMethodsMustHaveVoidReturnType:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeMethodReturnType, context.Document, root.SyntaxTree))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;
MethodDeclarationSyntax otherPart = semanticModel.GetOtherPart(methodDeclaration, context.CancellationToken);
if (otherPart == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Change return type to 'void'",
ct =>
{
return(context.Document.Solution().ReplaceNodesAsync(
new MethodDeclarationSyntax[] { methodDeclaration, otherPart },
(node, _) => node.WithReturnType(CSharpFactory.VoidType().WithTriviaFrom(node.ReturnType)),
ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CS1715_MemberTypeMustMatchOverriddenMemberType:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType, context.Document, root.SyntaxTree))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
{
var propertySymbol = (IPropertySymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = propertySymbol.OverriddenProperty.Type;
break;
}
case SyntaxKind.EventDeclaration:
{
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
case SyntaxKind.EventFieldDeclaration:
{
VariableDeclaratorSyntax declarator = ((EventFieldDeclarationSyntax)memberDeclaration).Declaration.Variables[0];
var eventSymbol = (IEventSymbol)semanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
typeSymbol = eventSymbol.OverriddenEvent.Type;
break;
}
}
CodeFixRegistrator.ChangeTypeOrReturnType(context, diagnostic, memberDeclaration, typeSymbol, semanticModel);
break;
}
case CompilerDiagnosticIdentifiers.CS0260_MissingPartialModifier:
case CompilerDiagnosticIdentifiers.CS0751_PartialMethodMustBeDeclaredInPartialClassOrPartialStruct:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddPartialModifier, context.Document, root.SyntaxTree))
{
break;
}
SyntaxNode node = null;
switch (memberDeclaration.Kind())
{
case SyntaxKind.MethodDeclaration:
{
if (memberDeclaration.IsParentKind(
SyntaxKind.ClassDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.RecordDeclaration,
SyntaxKind.RecordStructDeclaration))
{
node = memberDeclaration.Parent;
}
break;
}
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.RecordStructDeclaration:
case SyntaxKind.InterfaceDeclaration:
case SyntaxKind.RecordDeclaration:
{
node = memberDeclaration;
break;
}
}
SyntaxDebug.Assert(node != null, memberDeclaration);
if (node == null)
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.PartialKeyword, title: $"Make {CSharpFacts.GetTitle(node)} partial");
break;
}
case CompilerDiagnosticIdentifiers.CS0513_MemberIsAbstractButItIsContainedInNonAbstractClass:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeContainingClassAbstract, context.Document, root.SyntaxTree))
{
break;
}
if (!memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration))
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
memberDeclaration.Parent,
SyntaxKind.AbstractKeyword,
title: "Make containing class abstract");
break;
}
case CompilerDiagnosticIdentifiers.CS0132_StaticConstructorMustBeParameterless:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveParametersFromStaticConstructor, context.Document, root.SyntaxTree))
{
break;
}
var constructorDeclaration = (ConstructorDeclarationSyntax)memberDeclaration;
CodeAction codeAction = CodeAction.Create(
"Remove parameters",
ct =>
{
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
ParameterListSyntax newParameterList = parameterList
.WithParameters(default(SeparatedSyntaxList <ParameterSyntax>))
.WithOpenParenToken(parameterList.OpenParenToken.WithoutTrailingTrivia())
.WithCloseParenToken(parameterList.CloseParenToken.WithoutLeadingTrivia());
ConstructorDeclarationSyntax newNode = constructorDeclaration.WithParameterList(newParameterList);
return(context.Document.ReplaceNodeAsync(constructorDeclaration, newNode, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CS0541_ExplicitInterfaceDeclarationCanOnlyBeDeclaredInClassOrStruct:
case CompilerDiagnosticIdentifiers.CS0525_InterfacesCannotContainFields:
case CompilerDiagnosticIdentifiers.CS0567_InterfacesCannotContainOperators:
case CompilerDiagnosticIdentifiers.CS0524_InterfacesCannotDeclareTypes:
case CompilerDiagnosticIdentifiers.CS0575_OnlyClassTypesCanContainDestructors:
case CompilerDiagnosticIdentifiers.CS0568_StructsCannotContainExplicitParameterlessConstructors:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveMemberDeclaration, context.Document, root.SyntaxTree))
{
break;
}
CodeFixRegistrator.RemoveMemberDeclaration(context, diagnostic, memberDeclaration);
break;
}
case CompilerDiagnosticIdentifiers.CS0574_NameOfDestructorMustMatchNameOfClass:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.RenameDestructorToMatchClassName, context.Document, root.SyntaxTree))
{
break;
}
if (memberDeclaration is not DestructorDeclarationSyntax destructorDeclaration)
{
break;
}
if (memberDeclaration.Parent is not ClassDeclarationSyntax classDeclaration)
{
break;
}
if (classDeclaration.Identifier.ValueText.Length == 0)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Rename destructor to match class name",
ct =>
{
DestructorDeclarationSyntax newNode = destructorDeclaration.WithIdentifier(classDeclaration.Identifier.WithTriviaFrom(destructorDeclaration.Identifier));
return(context.Document.ReplaceNodeAsync(destructorDeclaration, newNode, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CS8139_CannotChangeTupleElementNameWhenOverridingInheritedMember:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.RenameTupleElement, context.Document, root.SyntaxTree))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (memberDeclaration is MethodDeclarationSyntax methodDeclaration)
{
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol.ReturnType is not INamedTypeSymbol tupleType)
{
break;
}
if (!tupleType.IsTupleType)
{
break;
}
if (methodSymbol.OverriddenMethod?.ReturnType is not INamedTypeSymbol baseTupleType)
{
break;
}
if (!baseTupleType.IsTupleType)
{
break;
}
ImmutableArray <IFieldSymbol> elements = tupleType.TupleElements;
ImmutableArray <IFieldSymbol> baseElements = baseTupleType.TupleElements;
if (elements.Length != baseElements.Length)
{
break;
}
int i = 0;
while (i < elements.Length)
{
if (elements[i].Name != baseElements[i].Name)
{
break;
}
i++;
}
if (i == elements.Length)
{
break;
}
TupleElementSyntax tupleElement = ((TupleTypeSyntax)methodDeclaration.ReturnType).Elements[i];
CodeAction codeAction = CodeAction.Create(
$"Rename '{elements[i].Name}' to '{baseElements[i].Name}'",
ct => RenameTupleElementAsync(context.Document, methodDeclaration, tupleElement, elements[i], baseElements[i].Name, semanticModel, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
else if (memberDeclaration is PropertyDeclarationSyntax propertyDeclaration)
{
IPropertySymbol propertySymbol = semanticModel.GetDeclaredSymbol(propertyDeclaration, context.CancellationToken);
if (propertySymbol.Type is not INamedTypeSymbol tupleType)
{
break;
}
if (!tupleType.IsTupleType)
{
break;
}
if (propertySymbol.OverriddenProperty?.Type is not INamedTypeSymbol baseTupleType)
{
break;
}
if (!baseTupleType.IsTupleType)
{
break;
}
ImmutableArray <IFieldSymbol> elements = tupleType.TupleElements;
ImmutableArray <IFieldSymbol> baseElements = baseTupleType.TupleElements;
if (elements.Length != baseElements.Length)
{
break;
}
int i = 0;
while (i < elements.Length)
{
if (elements[i].Name != baseElements[i].Name)
{
break;
}
i++;
}
if (i == elements.Length)
{
break;
}
TupleElementSyntax tupleElement = ((TupleTypeSyntax)propertyDeclaration.Type).Elements[i];
CodeAction codeAction = CodeAction.Create(
$"Rename '{elements[i].Name}' to '{baseElements[i].Name}'",
ct => RenameTupleElementAsync(context.Document, propertyDeclaration, tupleElement, elements[i], baseElements[i].Name, semanticModel, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.CS3000_MethodsWithVariableArgumentsAreNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3001_ArgumentTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3002_ReturnTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3003_TypeOfVariableIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3005_IdentifierDifferingOnlyInCaseIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3006_OverloadedMethodDifferingOnlyInRefOrOutOrInArrayRankIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3007_OverloadedMethodDifferingOnlyByUnnamedArrayTypesIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3008_IdentifierIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3009_BaseTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3016_ArraysAsAttributeArgumentsIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3024_ConstraintTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.CS3027_TypeIsNotCLSCompliantBecauseBaseInterfaceIsNotCLSCompliant:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.MarkDeclarationAsNonCLSCompliant, context.Document, root.SyntaxTree))
{
break;
}
CodeAction codeAction = CodeAction.Create(
$"Mark {CSharpFacts.GetTitle(memberDeclaration)} as non-CLS-compliant",
ct => MarkDeclarationAsNonCLSCompliantAsync(context.Document, memberDeclaration, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CS0539_ExplicitInterfaceDeclarationIsNotMemberOfInterface:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddParameterToExplicitlyImplementedInterfaceMember, context.Document, root.SyntaxTree))
{
break;
}
var context2 = new CommonFixContext(
context.Document,
GetEquivalenceKey(diagnostic),
await context.GetSemanticModelAsync().ConfigureAwait(false),
context.CancellationToken);
CodeAction codeAction = AddParameterToInterfaceMemberRefactoring.ComputeRefactoringForExplicitImplementation(context2, memberDeclaration);
if (codeAction != null)
{
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, MethodDeclarationSyntax methodDeclaration)
{
TypeSyntax returnType = methodDeclaration.ReturnType;
if (returnType?.IsVoid() != false)
{
return;
}
BlockSyntax body = methodDeclaration.Body;
if (body == null)
{
return;
}
SyntaxList <StatementSyntax> statements = body.Statements;
if (!statements.Any())
{
return;
}
if (statements.SingleOrDefault(shouldThrow: false)?.Kind() == SyntaxKind.ThrowStatement)
{
return;
}
if (methodDeclaration.ContainsYield())
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
if (methodSymbol?.IsOverride != false)
{
return;
}
if (methodSymbol.ImplementsInterfaceMember())
{
return;
}
if (IsAsyncMethodThatReturnsTask(methodSymbol, semanticModel))
{
return;
}
ControlFlowAnalysis analysis = semanticModel.AnalyzeControlFlow(body);
if (!analysis.Succeeded)
{
return;
}
if (!analysis.ReturnStatements.All(IsReturnStatementWithoutExpression))
{
return;
}
context.RegisterRefactoring(
"Change return type to 'void'",
ct => ChangeTypeRefactoring.ChangeTypeAsync(context.Document, returnType, CSharpFactory.VoidType(), ct),
RefactoringIdentifiers.ChangeMethodReturnTypeToVoid);
}