public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddComparisonWithBooleanLiteral) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.CreateSingletonArray) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseUncheckedExpression) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConstModifier) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseCoalesceExpression) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConditionThatIsAlwaysEqualToTrueOrFalse) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.IntroduceLocalVariable) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.IntroduceField) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceStringLiteralWithCharacterLiteral) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseYieldReturnInsteadOfReturn) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMemberTypeAccordingToReturnExpression) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddArgumentList) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceConditionalExpressionWithIfElse) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceConstantWithField) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeTypeAccordingToInitializer) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceYieldReturnWithForEach) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceComparisonWithAssignment) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParentheses))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindNode(root, context.Span, out ExpressionSyntax expression))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotImplicitlyConvertTypeExplicitConversionExists:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeInfo typeInfo = semanticModel.GetTypeInfo(expression, context.CancellationToken);
ITypeSymbol type = typeInfo.Type;
ITypeSymbol convertedType = typeInfo.ConvertedType;
if ((type is INamedTypeSymbol namedType) &&
namedType.IsNullableType())
{
if (convertedType?.SpecialType == SpecialType.System_Boolean ||
AddComparisonWithBooleanLiteralRefactoring.IsCondition(expression))
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddComparisonWithBooleanLiteral))
{
CodeAction codeAction = CodeAction.Create(
AddComparisonWithBooleanLiteralRefactoring.GetTitle(expression),
cancellationToken => AddComparisonWithBooleanLiteralRefactoring.RefactorAsync(context.Document, expression, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.AddComparisonWithBooleanLiteral));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
else if (namedType.TypeArguments[0].Equals(convertedType))
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseCoalesceExpression))
{
CodeAction codeAction = CodeAction.Create(
"Use coalesce expression",
cancellationToken =>
{
ExpressionSyntax defaultValue = (context.Document.SupportsLanguageFeature(CSharpLanguageFeature.DefaultLiteral))
? DefaultLiteralExpression()
: convertedType.GetDefaultValueSyntax(semanticModel, expression.SpanStart);
ExpressionSyntax newNode = CoalesceExpression(expression.WithoutTrivia(), defaultValue)
.WithTriviaFrom(expression)
.Parenthesize()
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(expression, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.UseCoalesceExpression));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMemberTypeAccordingToReturnExpression) &&
expression.IsParentKind(SyntaxKind.ReturnStatement, SyntaxKind.YieldReturnStatement))
{
ChangeMemberTypeRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddCastExpression))
{
CodeFixRegistrator.AddCastExpression(context, diagnostic, expression, convertedType, semanticModel);
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeTypeAccordingToInitializer))
{
ChangeTypeAccordingToInitializerRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.CreateSingletonArray) &&
type?.IsErrorType() == false &&
!type.Equals(convertedType) &&
(convertedType is IArrayTypeSymbol arrayType) &&
semanticModel.IsImplicitConversion(expression, arrayType.ElementType))
{
CodeAction codeAction = CodeAction.Create(
"Create singleton array",
cancellationToken => CreateSingletonArrayRefactoring.RefactorAsync(context.Document, expression, arrayType.ElementType, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.CreateSingletonArray));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.ConstantValueCannotBeConverted:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseUncheckedExpression))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Use 'unchecked'",
cancellationToken =>
{
CheckedExpressionSyntax newNode = CSharpFactory.UncheckedExpression(expression.WithoutTrivia());
newNode = newNode.WithTriviaFrom(expression);
return(context.Document.ReplaceNodeAsync(expression, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ExpressionBeingAssignedMustBeConstant:
{
SyntaxNode parent = expression.Parent;
if (parent?.IsKind(SyntaxKind.EqualsValueClause) != true)
{
break;
}
parent = parent.Parent;
if (parent?.IsKind(SyntaxKind.VariableDeclarator) != true)
{
break;
}
parent = parent.Parent;
if (!(parent is VariableDeclarationSyntax variableDeclaration))
{
break;
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConstModifier) &&
variableDeclaration.Parent is LocalDeclarationStatementSyntax localDeclarationStatement)
{
SyntaxTokenList modifiers = localDeclarationStatement.Modifiers;
if (!modifiers.Contains(SyntaxKind.ConstKeyword))
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, localDeclarationStatement, SyntaxKind.ConstKeyword);
}
else if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceConstantWithField) &&
variableDeclaration.Variables.Count == 1 &&
(variableDeclaration.Parent is FieldDeclarationSyntax fieldDeclaration) &&
fieldDeclaration.Modifiers.Contains(SyntaxKind.ConstKeyword))
{
CodeAction codeAction = CodeAction.Create(
ReplaceConstantWithFieldRefactoring.Title,
cancellationToken => ReplaceConstantWithFieldRefactoring.RefactorAsync(context.Document, fieldDeclaration, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
break;
}
case CompilerDiagnosticIdentifiers.CannotConvertNullToTypeBecauseItIsNonNullableValueType:
case CompilerDiagnosticIdentifiers.CannotConvertNullToTypeParameterBecauseItCouldBeNonNullableValueType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CodeFixRegistrator.ReplaceNullWithDefaultValue(context, diagnostic, expression, semanticModel);
break;
}
case CompilerDiagnosticIdentifiers.ResultOfExpressionIsAlwaysConstantSinceValueIsNeverEqualToNull:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConditionThatIsAlwaysEqualToTrueOrFalse))
{
break;
}
NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(expression, allowedStyles: NullCheckStyles.ComparisonToNull);
if (!nullCheck.Success)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Remove condition",
cancellationToken =>
{
cancellationToken.ThrowIfCancellationRequested();
SyntaxNode newRoot = RemoveCondition(root, expression, nullCheck.Style == NullCheckStyles.NotEqualsToNull);
cancellationToken.ThrowIfCancellationRequested();
return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot)));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.OnlyAssignmentCallIncrementDecrementAndNewObjectExpressionsCanBeUsedAsStatement:
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveParentheses) &&
expression is ParenthesizedExpressionSyntax parenthesizedExpression &&
parenthesizedExpression?.IsMissing == false)
{
CodeAction codeAction = CodeAction.Create(
"Remove parentheses",
cancellationToken => RemoveRedundantParenthesesRefactoring.RefactorAsync(context.Document, parenthesizedExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (expression.Parent is ArrowExpressionClauseSyntax arrowExpresssionClause)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMemberTypeAccordingToReturnExpression))
{
break;
}
ChangeMemberTypeRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
}
else if (expression.Parent is ExpressionStatementSyntax expressionStatement)
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddArgumentList) &&
expression.IsKind(
SyntaxKind.IdentifierName,
SyntaxKind.SimpleMemberAccessExpression))
{
SyntaxNode invocationExpression = InvocationExpression(expression);
if (semanticModel.GetSpeculativeMethodSymbol(expression.SpanStart, invocationExpression) != null)
{
CodeAction codeAction = CodeAction.Create(
"Add argument list",
cancellationToken => context.Document.ReplaceNodeAsync(expression, invocationExpression, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.AddArgumentList));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceComparisonWithAssignment) &&
expression.IsKind(SyntaxKind.EqualsExpression))
{
BinaryExpressionInfo info = SyntaxInfo.BinaryExpressionInfo(expression);
if (!info.Success)
{
break;
}
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(info.Left, context.CancellationToken);
if (typeSymbol?.IsErrorType() != false)
{
break;
}
if (!semanticModel.IsImplicitConversion(info.Right, typeSymbol))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Replace comparison with assignment",
cancellationToken =>
{
AssignmentExpressionSyntax simpleAssignment = SimpleAssignmentExpression(info.Left, info.Right).WithTriviaFrom(expression);
return(context.Document.ReplaceNodeAsync(expression, simpleAssignment, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.ReplaceComparisonWithAssignment));
context.RegisterCodeFix(codeAction, diagnostic);
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceConditionalExpressionWithIfElse) &&
(expression is ConditionalExpressionSyntax conditionalExpression) &&
conditionalExpression.Condition != null)
{
ExpressionSyntax whenTrue = conditionalExpression.WhenTrue;
ExpressionSyntax whenFalse = conditionalExpression.WhenFalse;
if (whenTrue != null &&
whenFalse != null &&
semanticModel.GetTypeSymbol(whenTrue, context.CancellationToken)?.SpecialType == SpecialType.System_Void &&
semanticModel.GetTypeSymbol(whenFalse, context.CancellationToken)?.SpecialType == SpecialType.System_Void)
{
CodeAction codeAction = CodeAction.Create(
"Replace ?: with if-else",
cancellationToken =>
{
IfStatementSyntax newNode = IfStatement(
conditionalExpression.Condition.WalkDownParentheses(),
Block(ExpressionStatement(whenTrue)),
ElseClause(Block(ExpressionStatement(whenFalse))));
newNode = newNode
.WithTriviaFrom(expressionStatement)
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(expressionStatement, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.ReplaceConditionalExpressionWithIfElse));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
if (Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.IntroduceLocalVariable,
CodeFixIdentifiers.IntroduceField))
{
if (semanticModel.GetSymbol(expression, context.CancellationToken)?.IsErrorType() != false)
{
break;
}
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (typeSymbol?.IsErrorType() != false)
{
break;
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.IntroduceLocalVariable) &&
!expressionStatement.IsEmbedded())
{
bool addAwait = typeSymbol.OriginalDefinition.EqualsOrInheritsFromTaskOfT() &&
semanticModel.GetEnclosingSymbol(expressionStatement.SpanStart, context.CancellationToken).IsAsyncMethod();
CodeAction codeAction = CodeAction.Create(
IntroduceLocalVariableRefactoring.GetTitle(expression),
cancellationToken => IntroduceLocalVariableRefactoring.RefactorAsync(context.Document, expressionStatement, typeSymbol, addAwait, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.IntroduceLocalVariable));
context.RegisterCodeFix(codeAction, diagnostic);
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.IntroduceField))
{
CodeAction codeAction = CodeAction.Create(
$"Introduce field for '{expression}'",
cancellationToken => IntroduceFieldRefactoring.RefactorAsync(context.Document, expressionStatement, typeSymbol, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.IntroduceField));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
break;
}
case CompilerDiagnosticIdentifiers.CannotImplicitlyConvertType:
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceYieldReturnWithForEach) &&
expression.IsParentKind(SyntaxKind.YieldReturnStatement))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ReplaceYieldReturnWithForEachRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
break;
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMemberTypeAccordingToReturnExpression) &&
expression.IsParentKind(SyntaxKind.ReturnStatement, SyntaxKind.YieldReturnStatement))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ChangeMemberTypeRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
break;
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeTypeAccordingToInitializer))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ChangeTypeAccordingToInitializerRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
break;
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceStringLiteralWithCharacterLiteral) &&
expression?.Kind() == SyntaxKind.StringLiteralExpression)
{
var literalExpression = (LiteralExpressionSyntax)expression;
if (literalExpression.Token.ValueText.Length == 1)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetTypeInfo(expression, context.CancellationToken).ConvertedType?.SpecialType == SpecialType.System_Char)
{
CodeAction codeAction = CodeAction.Create(
"Replace string literal with character literal",
cancellationToken => ReplaceStringLiteralWithCharacterLiteralRefactoring.RefactorAsync(context.Document, literalExpression, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.ReplaceStringLiteralWithCharacterLiteral));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseYieldReturnInsteadOfReturn) &&
expression.IsParentKind(SyntaxKind.ReturnStatement))
{
var returnStatement = (ReturnStatementSyntax)expression.Parent;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol containingSymbol = semanticModel.GetEnclosingSymbol(returnStatement.SpanStart, context.CancellationToken);
if (containingSymbol?.Kind == SymbolKind.Method &&
((IMethodSymbol)containingSymbol).ReturnType.OriginalDefinition.IsIEnumerableOrIEnumerableOfT())
{
CodeAction codeAction = CodeAction.Create(
"Use yield return instead of return",
cancellationToken => UseYieldReturnInsteadOfReturnRefactoring.RefactorAsync(context.Document, returnStatement, SyntaxKind.YieldReturnStatement, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.UseYieldReturnInsteadOfReturn));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
break;
}
}
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(
root,
context.Span,
out SyntaxNode node,
predicate: f => f.IsKind(
SyntaxKind.VariableDeclaration,
SyntaxKind.ForEachStatement,
SyntaxKind.Parameter,
SyntaxKind.DeclarationPattern,
SyntaxKind.DeclarationExpression,
SyntaxKind.LocalFunctionStatement)))
{
return;
}
if (node.IsKind(SyntaxKind.ForEachStatement, SyntaxKind.Parameter, SyntaxKind.DeclarationPattern, SyntaxKind.DeclarationExpression, SyntaxKind.LocalFunctionStatement))
{
return;
}
var variableDeclaration = (VariableDeclarationSyntax)node;
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.ImplicitlyTypedVariablesCannotHaveMultipleDeclarators:
case CompilerDiagnosticIdentifiers.ImplicitlyTypedVariablesCannotBeConstant:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.UseExplicitTypeInsteadOfVar))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeSyntax type = variableDeclaration.Type;
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
if (typeSymbol?.SupportsExplicitDeclaration() == true)
{
CodeAction codeAction = CodeActionFactory.ChangeType(context.Document, type, typeSymbol, semanticModel, equivalenceKey: GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.LocalVariableOrFunctionIsAlreadyDefinedInThisScope:
case CompilerDiagnosticIdentifiers.LocalOrParameterCannotBeDeclaredInThisScopeBecauseThatNameIsUsedInEnclosingScopeToDefineLocalOrParameter:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ReplaceVariableDeclarationWithAssignment))
{
return;
}
if (!(variableDeclaration.Parent is LocalDeclarationStatementSyntax localDeclaration))
{
return;
}
VariableDeclaratorSyntax variableDeclarator = variableDeclaration.Variables.SingleOrDefault(shouldThrow: false);
if (variableDeclarator == null)
{
break;
}
ExpressionSyntax value = variableDeclarator.Initializer?.Value;
if (value == null)
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
VariableDeclaratorSyntax variableDeclarator2 = FindVariableDeclarator(
variableDeclarator.Identifier.ValueText,
semanticModel.GetEnclosingSymbolSyntax(localDeclaration.SpanStart, context.CancellationToken));
if (variableDeclarator2?.SpanStart < localDeclaration.SpanStart)
{
CodeAction codeAction = CodeAction.Create(
"Replace variable declaration with assignment",
cancellationToken =>
{
ExpressionStatementSyntax newNode = CSharpFactory.SimpleAssignmentStatement(
SyntaxFactory.IdentifierName(variableDeclarator.Identifier),
value);
newNode = newNode
.WithTriviaFrom(localDeclaration)
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(localDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.DefineObjectEquals,
CodeFixIdentifiers.DefineObjectGetHashCode))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out TypeDeclarationSyntax typeDeclaration))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.TypeDefinesEqualityOperatorButDoesNotOverrideObjectEquals:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.DefineObjectEquals))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var typeSymbol = semanticModel.GetDeclaredSymbol(typeDeclaration, context.CancellationToken) as ITypeSymbol;
if (typeSymbol?.IsErrorType() != false)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Override object.Equals",
cancellationToken =>
{
TypeSyntax type = typeSymbol.ToMinimalTypeSyntax(semanticModel, typeDeclaration.Identifier.SpanStart);
MethodDeclarationSyntax methodDeclaration = ObjectEqualsMethodDeclaration(type, semanticModel, typeDeclaration.OpenBraceToken.Span.End);
TypeDeclarationSyntax newNode = MemberDeclarationInserter.Default.Insert(typeDeclaration, methodDeclaration);
return(context.Document.ReplaceNodeAsync(typeDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.TypeDefinesEqualityOperatorButDoesNotOverrideObjectGetHashCode:
case CompilerDiagnosticIdentifiers.TypeOverridesObjectEqualsButDoesNotOverrideObjectGetHashCode:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.DefineObjectGetHashCode))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
MethodDeclarationSyntax methodDeclaration = ObjectGetHashCodeMethodDeclaration(semanticModel, typeDeclaration.CloseBraceToken.Span.End);
CodeAction codeAction = CodeAction.Create(
"Override object.GetHashCode",
cancellationToken =>
{
TypeDeclarationSyntax newNode = MemberDeclarationInserter.Default.Insert(typeDeclaration, methodDeclaration);
return(context.Document.ReplaceNodeAsync(typeDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
ClassDeclarationSyntax classDeclaration = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ClassDeclarationSyntax>();
Debug.Assert(classDeclaration != null, $"{nameof(classDeclaration)} is null");
if (classDeclaration == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.MakeClassStatic:
{
CodeAction codeAction = null;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken);
ImmutableArray <SyntaxReference> syntaxReferences = symbol.DeclaringSyntaxReferences;
if (syntaxReferences.Length == 1)
{
codeAction = CodeAction.Create(
$"Make '{classDeclaration.Identifier.ValueText}' static",
cancellationToken =>
{
return(MakeClassStaticRefactoring.RefactorAsync(
context.Document,
classDeclaration,
cancellationToken));
},
diagnostic.Id + EquivalenceKeySuffix);
}
else
{
ImmutableArray <ClassDeclarationSyntax> classDeclarations = syntaxReferences
.Select(f => (ClassDeclarationSyntax)f.GetSyntax(context.CancellationToken))
.ToImmutableArray();
codeAction = CodeAction.Create(
$"Make '{classDeclaration.Identifier.ValueText}' static",
cancellationToken =>
{
return(MakeClassStaticRefactoring.RefactorAsync(
context.Solution(),
classDeclarations,
cancellationToken));
},
diagnostic.Id + EquivalenceKeySuffix);
}
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AddStaticModifierToAllPartialClassDeclarations:
{
CodeAction codeAction = CodeAction.Create(
"Add 'static' modifier",
cancellationToken =>
{
return(AddStaticModifierToAllPartialClassDeclarationsRefactoring.RefactorAsync(
context.Document,
classDeclaration,
cancellationToken));
},
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ImplementExceptionConstructors:
{
CodeAction codeAction = CodeAction.Create(
"Generate exception constructors",
cancellationToken =>
{
return(ImplementExceptionConstructorsRefactoring.RefactorAsync(
context.Document,
classDeclaration,
cancellationToken));
},
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.ReplaceStringLiteralWithCharacterLiteral,
CodeFixIdentifiers.UseYieldReturnInsteadOfReturn))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
SyntaxNode node = root.FindNode(context.Span, getInnermostNodeForTie: true);
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotImplicitlyConvertType:
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceStringLiteralWithCharacterLiteral) &&
node?.IsKind(SyntaxKind.StringLiteralExpression) == true)
{
var literalExpression = (LiteralExpressionSyntax)node;
if (literalExpression.Token.ValueText.Length == 1)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetTypeInfo(node, context.CancellationToken).ConvertedType?.IsChar() == true)
{
CodeAction codeAction = CodeAction.Create(
"Replace string literal with character literal",
cancellationToken => ReplaceStringLiteralWithCharacterLiteralRefactoring.RefactorAsync(context.Document, literalExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseYieldReturnInsteadOfReturn) &&
node.IsParentKind(SyntaxKind.ReturnStatement))
{
var returnStatement = (ReturnStatementSyntax)node.Parent;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol containingSymbol = semanticModel.GetEnclosingSymbol(returnStatement.SpanStart, context.CancellationToken);
if (containingSymbol?.IsKind(SymbolKind.Method) == true &&
((IMethodSymbol)containingSymbol).ReturnType?.IsIEnumerableOrConstructedFromIEnumerableOfT() == true)
{
CodeAction codeAction = CodeAction.Create(
"Use yield return instead of return",
cancellationToken => UseYieldReturnInsteadOfReturnRefactoring.RefactorAsync(context.Document, returnStatement, SyntaxKind.YieldReturnStatement, semanticModel, 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.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:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveMemberDeclaration))
{
break;
}
CodeFixRegistrator.RemoveMember(context, diagnostic, memberDeclaration);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.InitializeLocalVariableWithDefaultValue,
CodeFixIdentifiers.AddVariableType))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out IdentifierNameSyntax identifierName))
{
return;
}
Document document = context.Document;
CancellationToken cancellationToken = context.CancellationToken;
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.UseOfUnassignedLocalVariable:
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (!(semanticModel.GetSymbol(identifierName, cancellationToken) is ILocalSymbol localSymbol))
{
break;
}
ITypeSymbol typeSymbol = localSymbol.Type;
if (typeSymbol.Kind == SymbolKind.ErrorType)
{
break;
}
if (!(localSymbol.GetSyntax(cancellationToken) is VariableDeclaratorSyntax variableDeclarator))
{
break;
}
CodeAction codeAction = CodeAction.Create(
$"Initialize '{identifierName.Identifier.ValueText}' with default value",
ct =>
{
SyntaxToken identifier = variableDeclarator.Identifier;
var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent;
ExpressionSyntax value = typeSymbol.GetDefaultValueSyntax(variableDeclaration.Type.WithoutTrivia());
if (value.IsKind(SyntaxKind.DefaultExpression) &&
document.SupportsLanguageFeature(CSharpLanguageFeature.DefaultLiteral))
{
value = CSharpFactory.DefaultLiteralExpression().WithTriviaFrom(value);
}
EqualsValueClauseSyntax newEqualsValue = EqualsValueClause(value)
.WithLeadingTrivia(TriviaList(Space))
.WithTrailingTrivia(identifier.TrailingTrivia);
VariableDeclaratorSyntax newNode = variableDeclarator
.WithInitializer(newEqualsValue)
.WithIdentifier(identifier.WithoutTrailingTrivia());
return(document.ReplaceNodeAsync(variableDeclarator, newNode, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.NameDoesNotExistInCurrentContext:
{
if (!(identifierName.Parent is ArgumentSyntax argument))
{
break;
}
if (argument.RefOrOutKeyword.Kind() != SyntaxKind.OutKeyword)
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
foreach (ITypeSymbol typeSymbol in DetermineParameterTypeHelper.DetermineParameterTypes(argument, semanticModel, cancellationToken))
{
if (typeSymbol.Kind == SymbolKind.TypeParameter)
{
continue;
}
string typeName = SymbolDisplay.ToMinimalDisplayString(typeSymbol, semanticModel, identifierName.SpanStart, SymbolDisplayFormats.Default);
CodeAction codeAction = CodeAction.Create(
$"Add variable type '{typeName}'",
ct =>
{
DeclarationExpressionSyntax newNode = DeclarationExpression(
ParseName(typeName),
SingleVariableDesignation(identifierName.Identifier.WithoutTrivia()).WithLeadingTrivia(Space));
newNode = newNode
.WithTriviaFrom(identifierName)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(identifierName, newNode, ct));
},
GetEquivalenceKey(diagnostic, typeName));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
MethodDeclarationSyntax methodDeclaration = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <MethodDeclarationSyntax>();
if (methodDeclaration == null)
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
Debug.Assert(methodSymbol != null, $"{nameof(methodSymbol)} is null");
if (methodSymbol != null)
{
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.AsynchronousMethodNameShouldEndWithAsync:
{
string oldName = methodDeclaration.Identifier.ValueText;
string newName = await NameGenerators.AsyncMethod.EnsureUniqueMemberNameAsync(
oldName,
methodSymbol,
context.Solution(),
cancellationToken : context.CancellationToken).ConfigureAwait(false);
CodeAction codeAction = CodeAction.Create(
$"Rename '{oldName}' to '{newName}'",
c => Renamer.RenameSymbolAsync(context.Solution(), methodSymbol, newName, default(OptionSet), c),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.NonAsynchronousMethodNameShouldNotEndWithAsync:
{
string name = methodDeclaration.Identifier.ValueText;
string newName = name.Remove(name.Length - AsyncSuffix.Length);
newName = await NameGenerator.Default.EnsureUniqueMemberNameAsync(
newName,
methodSymbol,
context.Solution(),
cancellationToken : context.CancellationToken).ConfigureAwait(false);
CodeAction codeAction = CodeAction.Create(
$"Rename '{name}' to '{newName}'",
c => Renamer.RenameSymbolAsync(context.Solution(), methodSymbol, newName, default(OptionSet), c),
diagnostic.Id + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out ConditionalExpressionSyntax conditionalExpression))
{
return;
}
Document document = context.Document;
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.ParenthesizeConditionInConditionalExpression:
{
CodeAction codeAction = CodeAction.Create(
"Wrap condition in parentheses",
cancellationToken => ParenthesizeConditionInConditionalExpressionRefactoring.RefactorAsync(document, conditionalExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseCoalesceExpressionInsteadOfConditionalExpression:
{
CodeAction codeAction = CodeAction.Create(
"Use coalesce expression",
cancellationToken =>
{
return(SimplifyNullCheckRefactoring.RefactorAsync(
document,
conditionalExpression,
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.SimplifyConditionalExpression:
case DiagnosticIdentifiers.SimplifyConditionalExpression2:
{
CodeAction codeAction = CodeAction.Create(
"Simplify conditional expression",
ct => SimplifyConditionalExpressionAsync(document, conditionalExpression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.FormatConditionalExpression:
{
CodeAction codeAction = CodeAction.Create(
"Format ? and : on next line",
cancellationToken =>
{
return(FormatConditionalExpressionRefactoring.RefactorAsync(
document,
conditionalExpression,
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseConditionalAccessInsteadOfConditionalExpression:
{
CodeAction codeAction = CodeAction.Create(
"Use conditional access",
cancellationToken =>
{
return(SimplifyNullCheckRefactoring.RefactorAsync(
document,
conditionalExpression,
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AvoidNestedConditionalOperators:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
(CodeAction codeAction, CodeAction recursiveCodeAction) = ConvertConditionalOperatorToIfElseRefactoring.ComputeRefactoring(
document,
conditionalExpression,
data: default,
recursiveData: new CodeActionData(ConvertConditionalOperatorToIfElseRefactoring.Title, GetEquivalenceKey(diagnostic)),
semanticModel,
context.CancellationToken);
if (recursiveCodeAction != null)
{
context.RegisterCodeFix(recursiveCodeAction, diagnostic);
}
break;
}
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out BinaryExpressionSyntax binaryExpression))
{
return;
}
Document document = context.Document;
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.ConstantValuesShouldBePlacedOnRightSideOfComparisons:
{
CodeAction codeAction = CodeAction.Create(
"Swap operands",
ct => document.ReplaceNodeAsync(binaryExpression, SyntaxRefactorings.SwapBinaryOperands(binaryExpression), ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseStringIsNullOrEmptyMethod:
{
CodeAction codeAction = CodeAction.Create(
"Use 'string.IsNullOrEmpty' method",
ct => UseStringIsNullOrEmptyMethodAsync(document, binaryExpression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.SimplifyCoalesceExpression:
{
ExpressionSyntax expression = binaryExpression.Left;
if (expression == null ||
!context.Span.Contains(expression.Span))
{
expression = binaryExpression.Right;
}
CodeAction codeAction = CodeAction.Create(
"Simplify coalesce expression",
ct => SimplifyCoalesceExpressionRefactoring.RefactorAsync(document, binaryExpression, expression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.RemoveRedundantAsOperator:
{
CodeAction codeAction = CodeAction.Create(
"Remove redundant 'as' operator",
ct => RemoveRedundantAsOperatorRefactoring.RefactorAsync(document, binaryExpression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseStringLengthInsteadOfComparisonWithEmptyString:
{
CodeAction codeAction = CodeAction.Create(
"Use string.Length",
ct => UseStringLengthInsteadOfComparisonWithEmptyStringAsync(document, binaryExpression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UnconstrainedTypeParameterCheckedForNull:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(binaryExpression.Left, context.CancellationToken);
CodeAction codeAction = CodeAction.Create(
$"Use EqualityComparer<{typeSymbol.Name}>.Default",
ct => UnconstrainedTypeParameterCheckedForNullRefactoring.RefactorAsync(document, binaryExpression, typeSymbol, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ValueTypeObjectIsNeverEqualToNull:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(binaryExpression.Left, context.CancellationToken);
string title;
if (CSharpFacts.IsSimpleType(typeSymbol.SpecialType) ||
typeSymbol.ContainsMember <IMethodSymbol>(WellKnownMemberNames.EqualityOperatorName))
{
ExpressionSyntax expression = typeSymbol.GetDefaultValueSyntax(document.GetDefaultSyntaxOptions());
title = $"Replace 'null' with '{expression}'";
}
else
{
title = $"Use EqualityComparer<{SymbolDisplay.ToMinimalDisplayString(typeSymbol, semanticModel, binaryExpression.Right.SpanStart, SymbolDisplayFormats.DisplayName)}>.Default";
}
CodeAction codeAction = CodeAction.Create(
title,
ct => ValueTypeObjectIsNeverEqualToNullRefactoring.RefactorAsync(document, binaryExpression, typeSymbol, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.JoinStringExpressions:
{
CodeAction codeAction = CodeAction.Create(
"Join string expressions",
ct => JoinStringExpressionsRefactoring.RefactorAsync(document, binaryExpression, context.Span, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseExclusiveOrOperator:
{
CodeAction codeAction = CodeAction.Create(
"Use ^ operator",
ct => UseExclusiveOrOperatorRefactoring.RefactorAsync(document, binaryExpression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UnnecessaryNullCheck:
{
CodeAction codeAction = CodeAction.Create(
"Remove unnecessary null check",
ct => RemoveUnnecessaryNullCheckAsync(document, binaryExpression, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseShortCircuitingOperator:
{
SyntaxToken operatorToken = binaryExpression.OperatorToken;
SyntaxKind kind = binaryExpression.Kind();
SyntaxToken newToken = default;
if (kind == SyntaxKind.BitwiseAndExpression)
{
newToken = Token(operatorToken.LeadingTrivia, SyntaxKind.AmpersandAmpersandToken, operatorToken.TrailingTrivia);
}
else if (kind == SyntaxKind.BitwiseOrExpression)
{
newToken = Token(operatorToken.LeadingTrivia, SyntaxKind.BarBarToken, operatorToken.TrailingTrivia);
}
CodeAction codeAction = CodeAction.Create(
$"Use '{newToken.ToString()}' operator",
ct =>
{
BinaryExpressionSyntax newBinaryExpression = null;
if (kind == SyntaxKind.BitwiseAndExpression)
{
newBinaryExpression = LogicalAndExpression(binaryExpression.Left, newToken, binaryExpression.Right);
}
else if (kind == SyntaxKind.BitwiseOrExpression)
{
newBinaryExpression = LogicalOrExpression(binaryExpression.Left, newToken, binaryExpression.Right);
}
return(document.ReplaceNodeAsync(binaryExpression, newBinaryExpression, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UnnecessaryOperator:
{
CodeAction codeAction = CodeAction.Create(
"Use '==' operator",
ct =>
{
SyntaxToken operatorToken = binaryExpression.OperatorToken;
BinaryExpressionSyntax newBinaryExpression = EqualsExpression(
binaryExpression.Left,
Token(operatorToken.LeadingTrivia, SyntaxKind.EqualsEqualsToken, operatorToken.TrailingTrivia),
binaryExpression.Right);
return(document.ReplaceNodeAsync(binaryExpression, newBinaryExpression, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyEnabled(
CodeFixIdentifiers.AddOutModifierToArgument,
CodeFixIdentifiers.RemoveRefModifier,
CodeFixIdentifiers.CreateSingletonArray,
CodeFixIdentifiers.AddArgumentList,
CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out ArgumentSyntax argument))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.ArgumentMustBePassedWithRefOrOutKeyword:
{
if (!Settings.IsEnabled(CodeFixIdentifiers.AddOutModifierToArgument))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IParameterSymbol parameter = semanticModel.DetermineParameter(argument, allowCandidate: true, cancellationToken: context.CancellationToken);
if (parameter == null)
{
return;
}
SyntaxToken refOrOutKeyword = default;
if (parameter.RefKind == RefKind.Out)
{
refOrOutKeyword = Token(SyntaxKind.OutKeyword);
}
else if (parameter.RefKind == RefKind.Ref)
{
refOrOutKeyword = Token(SyntaxKind.RefKeyword);
}
else
{
return;
}
CodeAction codeAction = CodeAction.Create(
$"Add '{SyntaxFacts.GetText(refOrOutKeyword.Kind())}' modifier",
cancellationToken =>
{
ArgumentSyntax newArgument = argument
.WithRefOrOutKeyword(refOrOutKeyword)
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(argument, newArgument, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ArgumentShouldNotBePassedWithRefOrOutKeyword:
{
if (!Settings.IsEnabled(CodeFixIdentifiers.RemoveRefModifier))
{
return;
}
CodeAction codeAction = CodeAction.Create(
"Remove 'ref' modifier",
cancellationToken =>
{
ArgumentSyntax newArgument = argument
.WithRefOrOutKeyword(default(SyntaxToken))
.PrependToLeadingTrivia(argument.RefOrOutKeyword.GetAllTrivia())
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(argument, newArgument, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CannotConvertArgumentType:
{
if (Settings.IsEnabled(CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue))
{
ExpressionSyntax expression = argument.Expression;
if (expression.Kind() == SyntaxKind.NullLiteralExpression &&
argument.Parent is ArgumentListSyntax argumentList)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ImmutableArray <IParameterSymbol> parameterSymbols = FindParameters(argumentList, semanticModel, context.CancellationToken);
if (!parameterSymbols.IsDefault)
{
int index = argumentList.Arguments.IndexOf(argument);
IParameterSymbol parameterSymbol = parameterSymbols[index];
ITypeSymbol typeSymbol = parameterSymbol.Type;
if (typeSymbol.IsValueType)
{
CodeFixRegistrator.ReplaceNullWithDefaultValue(
context,
diagnostic,
expression,
typeSymbol,
CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue);
}
}
}
}
if (Settings.IsEnabled(CodeFixIdentifiers.AddArgumentList))
{
ExpressionSyntax expression = argument.Expression;
if (expression.IsKind(
SyntaxKind.IdentifierName,
SyntaxKind.GenericName,
SyntaxKind.SimpleMemberAccessExpression))
{
InvocationExpressionSyntax invocationExpression = InvocationExpression(
expression.WithoutTrailingTrivia(),
ArgumentList().WithTrailingTrivia(expression.GetTrailingTrivia()));
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetSpeculativeMethodSymbol(expression.SpanStart, invocationExpression) != null)
{
CodeAction codeAction = CodeAction.Create(
"Add argument list",
cancellationToken =>
{
ArgumentSyntax newNode = argument.WithExpression(invocationExpression);
return(context.Document.ReplaceNodeAsync(argument, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.AddArgumentList));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
if (Settings.IsEnabled(CodeFixIdentifiers.CreateSingletonArray))
{
ExpressionSyntax expression = argument.Expression;
if (expression?.IsMissing == false)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression);
if (typeSymbol?.IsErrorType() == false)
{
foreach (ITypeSymbol typeSymbol2 in DetermineParameterTypeHelper.DetermineParameterTypes(argument, semanticModel, context.CancellationToken))
{
if (!typeSymbol.Equals(typeSymbol2) &&
typeSymbol2 is IArrayTypeSymbol arrayType &&
semanticModel.IsImplicitConversion(expression, arrayType.ElementType))
{
CodeAction codeAction = CodeAction.Create(
"Create singleton array",
cancellationToken => CreateSingletonArrayRefactoring.RefactorAsync(context.Document, expression, arrayType.ElementType, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.CreateSingletonArray));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
}
break;
}
}
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out ExpressionSyntax expression))
{
return;
}
Diagnostic diagnostic = context.Diagnostics[0];
Document document = context.Document;
switch (expression)
{
case SimpleNameSyntax simpleName:
{
Debug.Assert(expression.IsKind(SyntaxKind.IdentifierName, SyntaxKind.GenericName), expression.Kind().ToString());
if (simpleName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression))
{
var memberAccessExpression = (MemberAccessExpressionSyntax)simpleName.Parent;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (memberAccessExpression.IsParentKind(SyntaxKind.InvocationExpression))
{
if (!memberAccessExpression.Parent.IsParentKind(SyntaxKind.ConditionalAccessExpression) &&
Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ReplaceInvocationWithMemberAccessOrViceVersa))
{
var invocationExpression = (InvocationExpressionSyntax)memberAccessExpression.Parent;
if (!invocationExpression.ArgumentList.Arguments.Any())
{
ReplaceInvocationWithMemberAccess(context, diagnostic, memberAccessExpression, invocationExpression, semanticModel);
}
}
}
else
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.FixMemberAccessName))
{
CodeFixRegistrationResult result = ReplaceCountWithLengthOrViceVersa(context, diagnostic, memberAccessExpression.Expression, simpleName, semanticModel);
if (result.Success)
{
break;
}
}
if (!memberAccessExpression.IsParentKind(SyntaxKind.ConditionalAccessExpression) &&
Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ReplaceInvocationWithMemberAccessOrViceVersa))
{
ReplaceMemberAccessWithInvocation(context, diagnostic, memberAccessExpression, semanticModel);
}
}
}
break;
}
case MemberBindingExpressionSyntax memberBindingExpression:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.FixMemberAccessName))
{
break;
}
if (!(memberBindingExpression.Parent is ConditionalAccessExpressionSyntax conditionalAccessExpression))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CodeFixRegistrationResult result = ReplaceCountWithLengthOrViceVersa(context, diagnostic, conditionalAccessExpression.Expression, memberBindingExpression.Name, semanticModel);
break;
}
case AwaitExpressionSyntax awaitExpression:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveAwaitKeyword))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Remove 'await'",
cancellationToken =>
{
ExpressionSyntax expression2 = awaitExpression.Expression;
SyntaxTriviaList leadingTrivia = awaitExpression
.GetLeadingTrivia()
.AddRange(awaitExpression.AwaitKeyword.TrailingTrivia.EmptyIfWhitespace())
.AddRange(expression2.GetLeadingTrivia().EmptyIfWhitespace());
ExpressionSyntax newNode = expression2.WithLeadingTrivia(leadingTrivia);
return(document.ReplaceNodeAsync(awaitExpression, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out IfStatementSyntax ifStatement))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.MergeIfStatementWithNestedIfStatement:
{
CodeAction codeAction = CodeAction.Create(
"Merge if with nested if",
cancellationToken =>
{
return(MergeIfStatementWithNestedIfStatementRefactoring.RefactorAsync(
context.Document,
ifStatement,
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ReplaceIfStatementWithAssignment:
{
CodeAction codeAction = CodeAction.Create(
"Replace if with assignment",
cancellationToken =>
{
return(ReplaceIfStatementWithAssignmentRefactoring.RefactorAsync(
context.Document,
ifStatement,
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseCoalesceExpressionInsteadOfIf:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IfRefactoring refactoring = IfRefactoring.Analyze(
ifStatement,
UseCoalesceExpressionInsteadOfIfDiagnosticAnalyzer.AnalysisOptions,
semanticModel,
context.CancellationToken).First();
CodeAction codeAction = CodeAction.Create(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.AddOutModifierToArgument,
CodeFixIdentifiers.RemoveRefModifier,
CodeFixIdentifiers.CreateSingletonArray))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
ArgumentSyntax argument = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ArgumentSyntax>();
Debug.Assert(argument != null, $"{nameof(argument)} is null");
if (argument == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.ArgumentMustBePassedWithOutKeyword:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddOutModifierToArgument))
{
return;
}
CodeAction codeAction = CodeAction.Create(
"Add 'out' modifier",
cancellationToken =>
{
ArgumentSyntax newArgument = argument
.WithRefOrOutKeyword(CSharpFactory.OutKeyword())
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(argument, newArgument, context.CancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.ArgumentMayNotBePassedWithRefKeyword:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveRefModifier))
{
return;
}
CodeAction codeAction = CodeAction.Create(
"Remove 'ref' modifier",
cancellationToken =>
{
ArgumentSyntax newArgument = argument
.WithRefOrOutKeyword(default(SyntaxToken))
.PrependToLeadingTrivia(argument.RefOrOutKeyword.GetLeadingAndTrailingTrivia())
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(argument, newArgument, context.CancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.CannotConvertArgumentType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddOutModifierToArgument))
{
return;
}
ExpressionSyntax expression = argument.Expression;
if (expression?.IsMissing == false)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression);
if (typeSymbol?.IsErrorType() == false)
{
foreach (ITypeSymbol typeSymbol2 in DetermineParameterTypeHelper.DetermineParameterTypes(argument, semanticModel, context.CancellationToken))
{
if (!typeSymbol.Equals(typeSymbol2) &&
typeSymbol2.IsArrayType())
{
var arrayType = (IArrayTypeSymbol)typeSymbol2;
if (semanticModel.IsImplicitConversion(expression, arrayType.ElementType))
{
CodeAction codeAction = CodeAction.Create(
"Create singleton array",
cancellationToken => CreateSingletonArrayRefactoring.RefactorAsync(context.Document, expression, arrayType.ElementType, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out StatementSyntax statement))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.EmptySwitchBlock:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveEmptySwitchStatement))
{
break;
}
if (!(statement is SwitchStatementSyntax switchStatement))
{
break;
}
CodeFixRegistrator.RemoveStatement(context, diagnostic, switchStatement);
break;
}
case CompilerDiagnosticIdentifiers.NoEnclosingLoopOutOfWhichToBreakOrContinue:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveJumpStatement))
{
CodeFixRegistrator.RemoveStatement(context, diagnostic, statement);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ReplaceBreakWithContinue) &&
statement.Kind() == SyntaxKind.BreakStatement)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetEnclosingSymbol(statement.SpanStart, context.CancellationToken) is IMethodSymbol methodSymbol)
{
if (methodSymbol.ReturnsVoid ||
(methodSymbol.IsAsync && methodSymbol.ReturnType.HasMetadataName(MetadataNames.System_Threading_Tasks_Task)))
{
CodeAction codeAction = CodeAction.Create(
"Replace 'break' with 'return'",
cancellationToken =>
{
var breakStatement = (BreakStatementSyntax)statement;
SyntaxToken breakKeyword = breakStatement.BreakKeyword;
ReturnStatementSyntax newStatement = SyntaxFactory.ReturnStatement(
SyntaxFactory.Token(breakKeyword.LeadingTrivia, SyntaxKind.ReturnKeyword, breakKeyword.TrailingTrivia),
null,
breakStatement.SemicolonToken);
return(context.Document.ReplaceNodeAsync(statement, newStatement, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.ReplaceBreakWithContinue));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveJumpStatement))
{
CodeFixRegistrator.RemoveStatement(context, diagnostic, statement);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ReplaceBreakWithContinue) &&
statement.Kind() == SyntaxKind.BreakStatement)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetEnclosingSymbol(statement.SpanStart, context.CancellationToken) is IMethodSymbol methodSymbol)
{
if (methodSymbol.ReturnsVoid ||
(methodSymbol.IsAsync && methodSymbol.ReturnType.HasMetadataName(MetadataNames.System_Threading_Tasks_Task)))
{
CodeAction codeAction = CodeAction.Create(
"Replace 'break' with 'return'",
cancellationToken =>
{
var breakStatement = (BreakStatementSyntax)statement;
SyntaxToken breakKeyword = breakStatement.BreakKeyword;
ReturnStatementSyntax newStatement = SyntaxFactory.ReturnStatement(
SyntaxFactory.Token(breakKeyword.LeadingTrivia, SyntaxKind.ReturnKeyword, breakKeyword.TrailingTrivia),
null,
breakStatement.SemicolonToken);
return(context.Document.ReplaceNodeAsync(statement, newStatement, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.ReplaceBreakWithContinue));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsEnabled(CodeFixIdentifiers.AddDocumentationComment) &&
!Settings.IsEnabled(CodeFixIdentifiers.ChangeMethodReturnType) &&
!Settings.IsEnabled(CodeFixIdentifiers.MemberTypeMustMatchOverriddenMemberType) &&
!Settings.IsEnabled(CodeFixIdentifiers.AddPartialModifier) &&
!Settings.IsEnabled(CodeFixIdentifiers.MakeContainingClassAbstract) &&
!Settings.IsEnabled(CodeFixIdentifiers.RemoveParametersFromStaticConstructor) &&
!Settings.IsEnabled(CodeFixIdentifiers.RemoveMemberDeclaration) &&
!Settings.IsEnabled(CodeFixIdentifiers.RenameDestructorToMatchClassName) &&
!Settings.IsEnabled(CodeFixIdentifiers.RenameTupleElement) &&
!Settings.IsEnabled(CodeFixIdentifiers.MarkDeclarationAsNonCLSCompliant))
{
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.IsEnabled(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.IsEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
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.PartialMethodsMustHaveVoidReturnType:
{
if (!Settings.IsEnabled(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.IsEnabled(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.ChangeTypeOrReturnType(context, diagnostic, memberDeclaration, typeSymbol, semanticModel);
break;
}
case CompilerDiagnosticIdentifiers.MissingPartialModifier:
case CompilerDiagnosticIdentifiers.PartialMethodMustBeDeclaredInPartialClassOrPartialStruct:
{
if (!Settings.IsEnabled(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.IsEnabled(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.IsEnabled(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.IsEnabled(CodeFixIdentifiers.RemoveMemberDeclaration))
{
break;
}
CodeFixRegistrator.RemoveMemberDeclaration(context, diagnostic, memberDeclaration);
break;
}
case CompilerDiagnosticIdentifiers.NameOfDestructorMustMatchNameOfClass:
{
if (!Settings.IsEnabled(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.IsEnabled(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;
}
case CompilerDiagnosticIdentifiers.MethodsWithVariableArgumentsAreNotCLSCompliant:
case CompilerDiagnosticIdentifiers.ArgumentTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.ReturnTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.TypeOfVariableIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.IdentifierDifferingOnlyInCaseIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.OverloadedMethodDifferingOnlyInRefOrOutOrInArrayRankIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.OverloadedMethodDifferingOnlyByUnnamedArrayTypesIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.IdentifierIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.BaseTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.ArraysAsAttributeArgumentsIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.ConstraintTypeIsNotCLSCompliant:
case CompilerDiagnosticIdentifiers.TypeIsNotCLSCompliantBecauseBaseInterfaceIsNotCLSCompliant:
{
if (!Settings.IsEnabled(CodeFixIdentifiers.MarkDeclarationAsNonCLSCompliant))
{
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;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out BinaryExpressionSyntax binaryExpression))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.SimplifyBooleanComparison:
{
CodeAction codeAction = CodeAction.Create(
"Simplify boolean comparison",
cancellationToken => SimplifyBooleanComparisonRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.CallAnyInsteadOfCount:
{
CodeAction codeAction = CodeAction.Create(
"Call 'Any' instead of 'Count'",
cancellationToken => CallAnyInsteadOfCountRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AvoidNullLiteralExpressionOnLeftSideOfBinaryExpression:
{
CodeAction codeAction = CodeAction.Create(
$"Swap '{binaryExpression.Left}' and '{binaryExpression.Right}'",
cancellationToken => SwapExpressionsInBinaryExpressionRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseStringIsNullOrEmptyMethod:
{
CodeAction codeAction = CodeAction.Create(
"Use 'string.IsNullOrEmpty' method",
cancellationToken => UseStringIsNullOrEmptyMethodRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.SimplifyCoalesceExpression:
{
ExpressionSyntax expression = binaryExpression.Left;
if (expression == null ||
!context.Span.Contains(expression.Span))
{
expression = binaryExpression.Right;
}
CodeAction codeAction = CodeAction.Create(
"Simplify coalesce expression",
cancellationToken => SimplifyCoalesceExpressionRefactoring.RefactorAsync(context.Document, binaryExpression, expression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.RemoveRedundantAsOperator:
{
CodeAction codeAction = CodeAction.Create(
"Remove redundant 'as' operator",
cancellationToken => RemoveRedundantAsOperatorRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseStringLengthInsteadOfComparisonWithEmptyString:
{
CodeAction codeAction = CodeAction.Create(
"Use string.Length",
cancellationToken => UseStringLengthInsteadOfComparisonWithEmptyStringRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UnconstrainedTypeParameterCheckedForNull:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(binaryExpression.Left, context.CancellationToken);
CodeAction codeAction = CodeAction.Create(
$"Use EqualityComparer<{typeSymbol.Name}>.Default",
cancellationToken => UnconstrainedTypeParameterCheckedForNullRefactoring.RefactorAsync(context.Document, binaryExpression, typeSymbol, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ValueTypeObjectIsNeverEqualToNull:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(binaryExpression.Left, context.CancellationToken);
string title = null;
if (typeSymbol.IsPredefinedValueType() ||
typeSymbol.ExistsMethod(WellKnownMemberNames.EqualityOperatorName))
{
ExpressionSyntax expression = typeSymbol.ToDefaultValueSyntax(semanticModel, binaryExpression.Right.SpanStart);
title = $"Replace 'null' with '{expression}'";
}
else
{
title = $"Use EqualityComparer<{SymbolDisplay.GetMinimalString(typeSymbol, semanticModel, binaryExpression.Right.SpanStart)}>.Default";
}
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => ValueTypeObjectIsNeverEqualToNullRefactoring.RefactorAsync(context.Document, binaryExpression, typeSymbol, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseIsOperatorInsteadOfAsOperator:
{
CodeAction codeAction = CodeAction.Create(
"Use is operator",
cancellationToken => UseIsOperatorInsteadOfAsOperatorRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.JoinStringExpressions:
{
CodeAction codeAction = CodeAction.Create(
"Join string expressions",
cancellationToken => JoinStringExpressionsRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseExclusiveOrOperator:
{
CodeAction codeAction = CodeAction.Create(
"Use ^ operator",
cancellationToken => UseExclusiveOrOperatorRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.SimplifyBooleanExpression:
{
CodeAction codeAction = CodeAction.Create(
"Simplify boolean expression",
cancellationToken => SimplifyBooleanExpressionRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.AddArgumentList,
CodeFixIdentifiers.ReorderModifiers))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindToken(root, context.Span.Start, out SyntaxToken token))
{
return;
}
SyntaxKind kind = token.Kind();
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.OperatorCannotBeAppliedToOperandOfType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddArgumentList))
{
break;
}
if (kind != SyntaxKind.QuestionToken)
{
break;
}
if (!token.IsParentKind(SyntaxKind.ConditionalAccessExpression))
{
break;
}
var conditionalAccess = (ConditionalAccessExpressionSyntax)token.Parent;
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(conditionalAccess.Expression, context.CancellationToken);
if (typeSymbol == null ||
typeSymbol.IsErrorType() ||
!typeSymbol.IsValueType ||
typeSymbol.IsConstructedFrom(SpecialType.System_Nullable_T))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Remove '?' operator",
cancellationToken =>
{
var textChange = new TextChange(token.Span, "");
return(context.Document.WithTextChangeAsync(textChange, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.PartialModifierCanOnlyAppearImmediatelyBeforeClassStructInterfaceOrVoid:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReorderModifiers))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Move 'partial' modifier",
cancellationToken =>
{
SyntaxNode node = token.Parent;
SyntaxNode newNode = node.RemoveModifier(token);
newNode = newNode.InsertModifier(SyntaxKind.PartialKeyword, ModifierComparer.Instance);
return(context.Document.ReplaceNodeAsync(node, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out IfStatementSyntax ifStatement))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.MergeIfWithNestedIf:
{
CodeAction codeAction = CodeAction.Create(
"Merge 'if' with nested 'if'",
ct => MergeIfWithNestedIfAsync(context.Document, ifStatement, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseCoalesceExpressionInsteadOfIf:
case DiagnosticIdentifiers.ConvertIfToReturnStatement:
case DiagnosticIdentifiers.ConvertIfToAssignment:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IfAnalysis analysis = IfAnalysis.Analyze(
ifStatement,
IfStatementAnalyzer.AnalysisOptions,
semanticModel,
context.CancellationToken)
.First();
CodeAction codeAction = CodeAction.Create(
analysis.Title,
cancellationToken => IfRefactoring.RefactorAsync(context.Document, analysis, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ReduceIfNesting:
{
CodeAction codeAction = CodeAction.Create(
"Invert if",
cancellationToken =>
{
return(ReduceIfNestingRefactoring.RefactorAsync(
context.Document,
ifStatement,
(SyntaxKind)Enum.Parse(typeof(SyntaxKind), diagnostic.Properties["JumpKind"]),
recursive: true,
cancellationToken: cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseExceptionFilter:
{
CodeAction codeAction = CodeAction.Create(
"Use exception filter",
cancellationToken =>
{
return(UseExceptionFilterAsync(
context.Document,
ifStatement,
cancellationToken: cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddReturnStatementThatReturnsDefaultValue))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
SyntaxNode node = root.FindNode(context.Span, getInnermostNodeForTie: true);
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
Diagnostic diagnostic = context.Diagnostics[0];
foreach (SyntaxNode ancestor in node.AncestorsAndSelf())
{
switch (ancestor.Kind())
{
case SyntaxKind.MethodDeclaration:
{
var methodDeclaration = (MethodDeclarationSyntax)ancestor;
if (!methodDeclaration.Modifiers.Contains(SyntaxKind.PartialKeyword))
{
ComputeCodeFix(context, diagnostic, methodDeclaration.ReturnType, methodDeclaration.Body, semanticModel);
}
return;
}
case SyntaxKind.OperatorDeclaration:
{
var operatorDeclaration = (OperatorDeclarationSyntax)ancestor;
ComputeCodeFix(context, diagnostic, operatorDeclaration.ReturnType, operatorDeclaration.Body, semanticModel);
return;
}
case SyntaxKind.ConversionOperatorDeclaration:
{
var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)ancestor;
ComputeCodeFix(context, diagnostic, conversionOperatorDeclaration.Type, conversionOperatorDeclaration.Body, semanticModel);
return;
}
case SyntaxKind.LocalFunctionStatement:
{
var localFunction = (LocalFunctionStatementSyntax)ancestor;
ComputeCodeFix(context, diagnostic, localFunction.ReturnType, localFunction.Body, semanticModel);
return;
}
case SyntaxKind.GetAccessorDeclaration:
{
var accessor = (AccessorDeclarationSyntax)ancestor;
switch (accessor.Parent.Parent.Kind())
{
case SyntaxKind.PropertyDeclaration:
{
var propertyDeclaration = (PropertyDeclarationSyntax)accessor.Parent.Parent;
ComputeCodeFix(context, diagnostic, propertyDeclaration.Type, accessor.Body, semanticModel);
break;
}
case SyntaxKind.IndexerDeclaration:
{
var indexerDeclaration = (IndexerDeclarationSyntax)accessor.Parent.Parent;
ComputeCodeFix(context, diagnostic, indexerDeclaration.Type, accessor.Body, semanticModel);
break;
}
}
return;
}
case SyntaxKind.AnonymousMethodExpression:
case SyntaxKind.SimpleLambdaExpression:
case SyntaxKind.ParenthesizedLambdaExpression:
{
var anonymousFunction = (AnonymousFunctionExpressionSyntax)ancestor;
var body = anonymousFunction.Body as BlockSyntax;
if (body?.Statements.Count > 0)
{
var methodSymbol = semanticModel.GetSymbol(anonymousFunction, context.CancellationToken) as IMethodSymbol;
if (methodSymbol?.IsErrorType() == false)
{
ComputeCodeFix(context, diagnostic, methodSymbol.ReturnType, body, semanticModel);
}
}
return;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out EnumDeclarationSyntax enumDeclaration))
{
return;
}
Document document = context.Document;
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.SortEnumMembers:
{
CodeAction codeAction = CodeAction.Create(
$"Sort '{enumDeclaration.Identifier}' members",
cancellationToken => SortEnumMembersAsync(document, enumDeclaration, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.EnumShouldDeclareExplicitValues:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, context.CancellationToken);
EnumSymbolInfo enumInfo = EnumSymbolInfo.Create(enumSymbol);
ImmutableArray <ulong> values = enumInfo
.Fields
.Where(f => f.HasValue && ((EnumMemberDeclarationSyntax)f.Symbol.GetSyntax(context.CancellationToken)).EqualsValue != null)
.Select(f => f.Value)
.ToImmutableArray();
Optional <ulong> optional = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(values);
if (!optional.HasValue ||
!ConvertHelpers.CanConvert(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType))
{
return;
}
bool isFlags = enumSymbol.HasAttribute(MetadataNames.System_FlagsAttribute);
CodeAction codeAction = CodeAction.Create(
"Declare explicit values",
ct => DeclareExplicitValueAsync(document, enumDeclaration, enumSymbol, isFlags, useBitShift: false, values, semanticModel, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
if (isFlags)
{
CodeAction codeAction2 = CodeAction.Create(
"Declare explicit values (and use '<<' operator)",
ct => DeclareExplicitValueAsync(document, enumDeclaration, enumSymbol, isFlags, useBitShift: true, values, semanticModel, ct),
GetEquivalenceKey(diagnostic, "BitShift"));
context.RegisterCodeFix(codeAction2, diagnostic);
}
break;
}
case DiagnosticIdentifiers.UseBitShiftOperator:
{
CodeAction codeAction = CodeAction.Create(
"Use '<<' operator",
ct => UseBitShiftOperatorAsync(document, enumDeclaration, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out ExpressionSyntax expression, predicate: f => f.IsKind(SyntaxKind.SimpleMemberAccessExpression, SyntaxKind.ElementAccessExpression)))
{
return;
}
if (IsPartOfLeftSideOfAssignment())
{
return;
}
if (expression
.WalkUp(f => f.IsKind(SyntaxKind.InvocationExpression, SyntaxKind.SimpleMemberAccessExpression, SyntaxKind.ElementAccessExpression, SyntaxKind.ParenthesizedExpression))
.IsParentKind(SyntaxKind.AwaitExpression))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (expression.IsInExpressionTree(semanticModel, context.CancellationToken))
{
return;
}
SyntaxKind kind = expression.Kind();
if (kind == SyntaxKind.SimpleMemberAccessExpression)
{
expression = ((MemberAccessExpressionSyntax)expression).Expression;
}
else if (kind == SyntaxKind.ElementAccessExpression)
{
expression = ((ElementAccessExpressionSyntax)expression).Expression;
}
CodeAction codeAction = CodeAction.Create(
"Use conditional access",
cancellationToken => RefactorAsync(context.Document, expression, cancellationToken),
GetEquivalenceKey(DiagnosticIdentifiers.AvoidNullReferenceException));
context.RegisterCodeFix(codeAction, context.Diagnostics);
bool IsPartOfLeftSideOfAssignment()
{
for (SyntaxNode node = expression; node != null; node = node.Parent)
{
var assignmentExpression = node.Parent as AssignmentExpressionSyntax;
if (assignmentExpression?.Left == node)
{
return(true);
}
}
return(false);
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindToken(root, context.Span.Start, out SyntaxToken token))
{
return;
}
SyntaxNode node = token.Parent;
if (!CSharpFacts.CanHaveModifiers(node.Kind()))
{
node = node.FirstAncestor(f => CSharpFacts.CanHaveModifiers(f.Kind()));
}
Debug.Assert(node != null, $"{nameof(node)} is null");
if (node == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.ModifierIsNotValidForThisItem:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
SyntaxTokenList modifiers = SyntaxInfo.ModifierListInfo(node).Modifiers;
if (modifiers.Contains(token))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, token);
break;
}
else if (IsInterfaceMemberOrExplicitInterfaceImplementation(node))
{
ModifiersCodeFixRegistrator.RemoveModifiers(context, diagnostic, node, modifiers, f =>
{
switch (f.Kind())
{
case SyntaxKind.PublicKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.PrivateKeyword:
case SyntaxKind.StaticKeyword:
case SyntaxKind.VirtualKeyword:
case SyntaxKind.OverrideKeyword:
case SyntaxKind.AbstractKeyword:
{
return(true);
}
}
return(false);
});
}
else if (node.IsKind(SyntaxKind.MethodDeclaration, SyntaxKind.PropertyDeclaration, SyntaxKind.IndexerDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.EventFieldDeclaration) &&
node.IsParentKind(SyntaxKind.StructDeclaration) &&
modifiers.Contains(SyntaxKind.VirtualKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.VirtualKeyword);
}
else if (node.IsKind(SyntaxKind.IndexerDeclaration) &&
modifiers.Contains(SyntaxKind.StaticKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.StaticKeyword);
}
else if (node.IsKind(SyntaxKind.PropertyDeclaration, SyntaxKind.IndexerDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.EventFieldDeclaration) &&
modifiers.Contains(SyntaxKind.AsyncKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.AsyncKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.MoreThanOneProtectionModifier:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, token);
}
break;
}
case CompilerDiagnosticIdentifiers.AccessibilityModifiersMayNotBeUsedOnAccessorsInInterface:
case CompilerDiagnosticIdentifiers.AccessModifiersAreNotAllowedOnStaticConstructors:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveAccessibility(context, diagnostic, node);
}
break;
}
case CompilerDiagnosticIdentifiers.ModifiersCannotBePlacedOnEventAccessorDeclarations:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifiers(context, diagnostic, node);
}
break;
}
case CompilerDiagnosticIdentifiers.OnlyMethodsClassesStructsOrInterfacesMayBePartial:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.PartialKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.ClassCannotBeBothStaticAndSealed:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.StaticKeyword, additionalKey: nameof(SyntaxKind.StaticKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.SealedKeyword, additionalKey: nameof(SyntaxKind.SealedKeyword));
break;
}
case CompilerDiagnosticIdentifiers.FieldCanNotBeBothVolatileAndReadOnly:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
var fieldDeclaration = (FieldDeclarationSyntax)node;
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, fieldDeclaration, SyntaxKind.VolatileKeyword, additionalKey: nameof(SyntaxKind.VolatileKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, fieldDeclaration, SyntaxKind.ReadOnlyKeyword, additionalKey: nameof(SyntaxKind.ReadOnlyKeyword));
break;
}
case CompilerDiagnosticIdentifiers.NewProtectedMemberDeclaredInSealedClass:
case CompilerDiagnosticIdentifiers.StaticClassesCannotContainProtectedMembers:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternalOrPrivate);
}
break;
}
case CompilerDiagnosticIdentifiers.VirtualOrAbstractMembersCannotBePrivate:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveVirtualModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.VirtualKeyword, additionalKey: nameof(SyntaxKind.VirtualKeyword));
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternalOrProtected);
}
break;
}
case CompilerDiagnosticIdentifiers.AbstractPropertiesCannotHavePrivateAccessors:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveAccessibility(context, diagnostic, node, additionalKey: CodeFixIdentifiers.RemoveInvalidModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternalOrProtected);
}
break;
}
case CompilerDiagnosticIdentifiers.StaticMemberCannotBeMarkedOverrideVirtualOrAbstract:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
if (!node.IsParentKind(SyntaxKind.ClassDeclaration) ||
!((ClassDeclarationSyntax)node.Parent).Modifiers.Contains(SyntaxKind.StaticKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.StaticKeyword, additionalKey: nameof(SyntaxKind.StaticKeyword));
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.OverrideKeyword, additionalKey: nameof(SyntaxKind.OverrideKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.VirtualKeyword, additionalKey: nameof(SyntaxKind.VirtualKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.AbstractKeyword, additionalKey: nameof(SyntaxKind.AbstractKeyword));
break;
}
case CompilerDiagnosticIdentifiers.AsyncModifierCanOnlyBeUsedInMethodsThatHaveBody:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.AsyncKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.PartialMethodCannotHaveAccessModifiersOrVirtualAbstractOverrideNewSealedOrExternModifiers:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifiers(context, diagnostic, node, f =>
{
switch (f.Kind())
{
case SyntaxKind.PublicKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.PrivateKeyword:
case SyntaxKind.VirtualKeyword:
case SyntaxKind.AbstractKeyword:
case SyntaxKind.OverrideKeyword:
case SyntaxKind.NewKeyword:
case SyntaxKind.SealedKeyword:
case SyntaxKind.ExternKeyword:
{
return(true);
}
}
return(false);
});
break;
}
case CompilerDiagnosticIdentifiers.ExtensionMethodMustBeStatic:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier))
{
AddStaticModifier(context, diagnostic, node, CodeFixIdentifiers.AddStaticModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveThisModifier))
{
var methodDeclaration = (MethodDeclarationSyntax)node;
ParameterSyntax parameter = methodDeclaration.ParameterList.Parameters[0];
SyntaxToken modifier = parameter.Modifiers.Find(SyntaxKind.ThisKeyword);
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, parameter, modifier, additionalKey: CodeFixIdentifiers.RemoveThisModifier);
}
break;
}
case CompilerDiagnosticIdentifiers.ExtensionMethodMustBeDefinedInNonGenericStaticClass:
{
if (!(node is ClassDeclarationSyntax classDeclaration))
{
return;
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier) &&
!classDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword))
{
AddStaticModifier(context, diagnostic, node, CodeFixIdentifiers.AddStaticModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveThisModifier))
{
IEnumerable <ParameterSyntax> thisParameters = classDeclaration.Members
.Where(f => f.IsKind(SyntaxKind.MethodDeclaration))
.Cast <MethodDeclarationSyntax>()
.Select(f => f.ParameterList?.Parameters.FirstOrDefault())
.Where(f => f?.Modifiers.Contains(SyntaxKind.ThisKeyword) == true);
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
thisParameters,
SyntaxKind.ThisKeyword,
title: "Remove 'this' modifier from extension methods",
additionalKey: CodeFixIdentifiers.RemoveThisModifier);
}
break;
}
case CompilerDiagnosticIdentifiers.NoDefiningDeclarationFoundForImplementingDeclarationOfPartialMethod:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.PartialKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.MethodHasParameterModifierThisWhichIsNotOnFirstParameter:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveThisModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, token.Parent, token);
}
break;
}
case CompilerDiagnosticIdentifiers.CannotDeclareInstanceMembersInStaticClass:
case CompilerDiagnosticIdentifiers.StaticClassesCannotHaveInstanceConstructors:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier))
{
AddStaticModifier(context, diagnostic, node, CodeFixIdentifiers.AddStaticModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeContainingClassNonStatic))
{
var classDeclaration = (ClassDeclarationSyntax)node.Parent;
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
classDeclaration,
classDeclaration.Modifiers.Find(SyntaxKind.StaticKeyword),
title: "Make containing class non-static",
additionalKey: CodeFixIdentifiers.MakeContainingClassNonStatic);
}
break;
}
case CompilerDiagnosticIdentifiers.ElementsDefinedInNamespaceCannotBeExplicitlyDeclaredAsPrivateProtectedOrProtectedInternal:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternal);
}
break;
}
case CompilerDiagnosticIdentifiers.NamespaceAlreadyContainsDefinition:
case CompilerDiagnosticIdentifiers.TypeAlreadyContainsDefinition:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddPartialModifier))
{
break;
}
if (!node.IsKind(
SyntaxKind.ClassDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.MethodDeclaration))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(node, context.CancellationToken);
ImmutableArray <SyntaxReference> syntaxReferences = symbol.DeclaringSyntaxReferences;
if (syntaxReferences.Length <= 1)
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
ImmutableArray.CreateRange(syntaxReferences, f => f.GetSyntax(context.CancellationToken)),
SyntaxKind.PartialKeyword);
break;
}
case CompilerDiagnosticIdentifiers.NoSuitableMethodFoundToOverride:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.OverrideKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.AsyncMethodsCannotHaveRefOrOutParameters:
case CompilerDiagnosticIdentifiers.IteratorsCannotHaveRefOrOutParameters:
case CompilerDiagnosticIdentifiers.ReadOnlyFieldCannotBePassedAsRefOrOutValue:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveRefModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.RefKeyword, additionalKey: nameof(SyntaxKind.RefKeyword));
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveOutModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.OutKeyword, additionalKey: nameof(SyntaxKind.OutKeyword));
}
break;
}
case CompilerDiagnosticIdentifiers.CannotHaveInstancePropertyOrFieldInitializersInStruct:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier))
{
AddStaticModifier(context, diagnostic, node);
}
break;
}
case CompilerDiagnosticIdentifiers.MemberMustDeclareBodyBecauseItIsNotMarkedAbstractExternOrPartial:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddModifierAbstract) &&
node.Kind() == SyntaxKind.MethodDeclaration &&
(node.Parent as ClassDeclarationSyntax)?.Modifiers.Contains(SyntaxKind.AbstractKeyword) == true)
{
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.AbstractKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.NewVirtualMemberInSealedClass:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveVirtualModifier))
{
if (node is AccessorDeclarationSyntax &&
SyntaxInfo.ModifierListInfo(node.Parent.Parent).IsVirtual)
{
node = node.Parent.Parent;
}
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
node,
SyntaxKind.VirtualKeyword,
additionalKey: CodeFixIdentifiers.RemoveVirtualModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeContainingClassUnsealed) &&
node.Parent is ClassDeclarationSyntax classDeclaration)
{
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
classDeclaration,
SyntaxKind.SealedKeyword,
title: "Make containing class unsealed",
additionalKey: CodeFixIdentifiers.MakeContainingClassUnsealed);
}
break;
}
case CompilerDiagnosticIdentifiers.InstanceFieldsOfReadOnlyStructsMustBeReadOnly:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeMemberReadOnly))
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.ReadOnlyKeyword);
break;
}
case CompilerDiagnosticIdentifiers.MemberCannotBeSealedBecauseItIsNotOverride:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveSealedModifier))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetDiagnostic(
CompilerDiagnosticIdentifiers.MemberHidesInheritedMemberToMakeCurrentMethodOverrideThatImplementationAddOverrideKeyword,
CSharpUtility.GetIdentifier(node).Span,
context.CancellationToken) != null)
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.SealedKeyword);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeTypeOfLocalVariable))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
VariableDeclaratorSyntax variableDeclarator = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <VariableDeclaratorSyntax>();
Debug.Assert(variableDeclarator != null, $"{nameof(variableDeclarator)} is null");
if (variableDeclarator == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotAssignMethodGroupToImplicitlyTypedVariable:
case CompilerDiagnosticIdentifiers.NoOverloadMatchesDelegate:
case CompilerDiagnosticIdentifiers.MethodHasWrongReturnType:
{
if (!variableDeclarator.IsParentKind(SyntaxKind.VariableDeclaration))
{
break;
}
var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent;
ExpressionSyntax value = variableDeclarator.Initializer?.Value;
if (value == null)
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(value, context.CancellationToken);
if (symbolInfo.Symbol != null)
{
ComputeCodeFix(context, diagnostic, variableDeclarator, symbolInfo.Symbol, semanticModel);
}
else
{
foreach (ISymbol candidateSymbol in symbolInfo.CandidateSymbols)
{
ComputeCodeFix(context, diagnostic, variableDeclarator, candidateSymbol, semanticModel);
}
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsAnyCodeFixEnabled(
CodeFixIdentifiers.UseYieldReturnInsteadOfReturn,
CodeFixIdentifiers.RemoveReturnKeyword,
CodeFixIdentifiers.RemoveReturnExpression))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
ReturnStatementSyntax returnStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ReturnStatementSyntax>();
Debug.Assert(returnStatement != null, $"{nameof(returnStatement)} is null");
if (returnStatement == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CannotReturnValueFromIterator:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.UseYieldReturnInsteadOfReturn))
{
break;
}
ExpressionSyntax expression = returnStatement.Expression;
if (expression != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol containingSymbol = semanticModel.GetEnclosingSymbol(returnStatement.SpanStart, context.CancellationToken);
if (containingSymbol?.IsKind(SymbolKind.Method) == true)
{
var methodSymbol = (IMethodSymbol)containingSymbol;
ITypeSymbol returnType = methodSymbol.ReturnType;
var replacementKind = SyntaxKind.None;
if (returnType.SpecialType == SpecialType.System_Collections_IEnumerable)
{
if (semanticModel
.GetTypeSymbol(expression, context.CancellationToken)
.IsIEnumerableOrConstructedFromIEnumerableOfT())
{
replacementKind = SyntaxKind.ForEachStatement;
}
else
{
replacementKind = SyntaxKind.YieldReturnStatement;
}
}
else if (returnType.IsNamedType())
{
var namedTypeSymbol = (INamedTypeSymbol)returnType;
if (namedTypeSymbol.IsConstructedFromIEnumerableOfT())
{
if (semanticModel.IsImplicitConversion(expression, namedTypeSymbol.TypeArguments[0]))
{
replacementKind = SyntaxKind.YieldReturnStatement;
}
else
{
replacementKind = SyntaxKind.ForEachStatement;
}
}
}
if (replacementKind == SyntaxKind.YieldReturnStatement ||
(replacementKind == SyntaxKind.ForEachStatement && !returnStatement.SpanContainsDirectives()))
{
CodeAction codeAction = CodeAction.Create(
"Use yield return instead of return",
cancellationToken => UseYieldReturnInsteadOfReturnRefactoring.RefactorAsync(context.Document, returnStatement, replacementKind, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
break;
}
case CompilerDiagnosticIdentifiers.SinceMethodReturnsVoidReturnKeywordMustNotBeFollowedByObjectExpression:
case CompilerDiagnosticIdentifiers.SinceMethodIsAsyncMethodThatReturnsTaskReturnKeywordMustNotBeFollowedByObjectExpression:
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveReturnExpression))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetEnclosingSymbol(returnStatement.SpanStart, context.CancellationToken);
if (symbol?.IsMethod() == true)
{
var methodSymbol = (IMethodSymbol)symbol;
if (methodSymbol.ReturnsVoid ||
methodSymbol.ReturnType.Equals(semanticModel.GetTypeByMetadataName(MetadataNames.System_Threading_Tasks_Task)))
{
CodeAction codeAction = CodeAction.Create(
"Remove return expression",
cancellationToken =>
{
ReturnStatementSyntax newNode = returnStatement
.WithExpression(null)
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.RemoveReturnExpression));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveReturnKeyword))
{
ExpressionSyntax expression = returnStatement.Expression;
if (expression.IsKind(
SyntaxKind.InvocationExpression,
SyntaxKind.ObjectCreationExpression,
SyntaxKind.PreDecrementExpression,
SyntaxKind.PreIncrementExpression,
SyntaxKind.PostDecrementExpression,
SyntaxKind.PostIncrementExpression) ||
expression is AssignmentExpressionSyntax)
{
CodeAction codeAction = CodeAction.Create(
"Remove 'return'",
cancellationToken =>
{
SyntaxTriviaList leadingTrivia = returnStatement
.GetLeadingTrivia()
.AddRange(returnStatement.ReturnKeyword.TrailingTrivia.EmptyIfWhitespace())
.AddRange(expression.GetLeadingTrivia().EmptyIfWhitespace());
ExpressionStatementSyntax newNode = SyntaxFactory.ExpressionStatement(
expression.WithLeadingTrivia(leadingTrivia),
returnStatement.SemicolonToken);
return(context.Document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic, CodeFixIdentifiers.RemoveReturnKeyword));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out ClassDeclarationSyntax classDeclaration))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.MakeClassStatic:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken);
ImmutableArray <SyntaxReference> syntaxReferences = symbol.DeclaringSyntaxReferences;
if (!syntaxReferences.Any())
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
ImmutableArray.CreateRange(syntaxReferences, f => f.GetSyntax()),
SyntaxKind.StaticKeyword,
title: "Make class static");
break;
}
case DiagnosticIdentifiers.AddStaticModifierToAllPartialClassDeclarations:
{
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, classDeclaration, SyntaxKind.StaticKeyword);
break;
}
case DiagnosticIdentifiers.ImplementExceptionConstructors:
{
CodeAction codeAction = CodeAction.Create(
"Generate exception constructors",
cancellationToken =>
{
return(ImplementExceptionConstructorsRefactoring.RefactorAsync(
context.Document,
classDeclaration,
cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseAttributeUsageAttribute:
{
CodeAction codeAction = CodeAction.Create(
"Use AttributeUsageAttribute",
cancellationToken => UseAttributeUsageAttributeAsync(context.Document, classDeclaration, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.MakeClassSealed:
{
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
classDeclaration,
SyntaxKind.SealedKeyword);
break;
}
}
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindNode(root, context.Span, out SyntaxNode node))
{
return;
}
if (node is not SimpleNameSyntax simpleName)
{
return;
}
Document document = context.Document;
Diagnostic diagnostic = context.Diagnostics[0];
string diagnosticId = diagnostic.Id;
if (diagnosticId == CompilerDiagnosticIdentifiers.CS0428_CannotConvertMethodGroupToNonDelegateType ||
diagnosticId == CompilerDiagnosticIdentifiers.CS0119_NameIsNotValidInGivenContext)
{
if (!IsEnabled(diagnosticId, CodeFixIdentifiers.AddArgumentList, document, root.SyntaxTree))
{
return;
}
if (!simpleName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
var memberAccess = (MemberAccessExpressionSyntax)simpleName.Parent;
CodeAction codeAction = CodeAction.Create(
"Add argument list",
ct =>
{
InvocationExpressionSyntax invocationExpression = InvocationExpression(
memberAccess.WithoutTrailingTrivia(),
ArgumentList().WithTrailingTrivia(memberAccess.GetTrailingTrivia()));
return(document.ReplaceNodeAsync(memberAccess, invocationExpression, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
else if (diagnosticId == CompilerDiagnosticIdentifiers.CS0246_TypeOrNamespaceNameCouldNotBeFound)
{
if (IsEnabled(diagnosticId, CodeFixIdentifiers.ChangeArrayType, document, root.SyntaxTree) &&
(simpleName.Parent is ArrayTypeSyntax arrayType) &&
(arrayType.Parent is ArrayCreationExpressionSyntax arrayCreation) &&
object.ReferenceEquals(simpleName, arrayType.ElementType))
{
ExpressionSyntax expression = arrayCreation.Initializer?.Expressions.FirstOrDefault();
if (expression != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (typeSymbol?.SupportsExplicitDeclaration() == true)
{
TypeSyntax newType = typeSymbol.ToTypeSyntax()
.WithSimplifierAnnotation()
.WithTriviaFrom(simpleName);
CodeAction codeAction = CodeAction.Create(
$"Change element type to '{SymbolDisplay.ToMinimalDisplayString(typeSymbol, semanticModel, simpleName.SpanStart, SymbolDisplayFormats.DisplayName)}'",
ct => document.ReplaceNodeAsync(simpleName, newType, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
return;
}
}
}
if (IsEnabled(diagnosticId, CodeFixIdentifiers.ChangeMemberTypeAccordingToReturnExpression, document, root.SyntaxTree))
{
ExpressionSyntax expression = GetReturnExpression(simpleName);
if (expression != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ChangeMemberTypeRefactoring.ComputeCodeFix(context, diagnostic, expression, semanticModel);
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out SyntaxNode node, predicate: f => f.IsKind(
SyntaxKind.EqualsExpression,
SyntaxKind.NotEqualsExpression,
SyntaxKind.InvocationExpression)))
{
return;
}
Diagnostic diagnostic = context.Diagnostics[0];
switch (node.Kind())
{
case SyntaxKind.EqualsExpression:
case SyntaxKind.NotEqualsExpression:
{
var binaryExpression = (BinaryExpressionSyntax)node;
MemberInvocationExpressionInfo invocationInfo = SyntaxInfo.MemberInvocationExpressionInfo(binaryExpression.Left.WalkDownParentheses());
if (!invocationInfo.Success)
{
invocationInfo = SyntaxInfo.MemberInvocationExpressionInfo((InvocationExpressionSyntax)binaryExpression.Right.WalkDownParentheses());
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol comparisonSymbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_StringComparison);
if (!invocationInfo.NameText.EndsWith("Invariant", StringComparison.Ordinal) ||
!RegisterCodeFix(context, diagnostic, binaryExpression, comparisonSymbol, "InvariantCultureIgnoreCase"))
{
RegisterCodeFix(context, diagnostic, binaryExpression, comparisonSymbol, "OrdinalIgnoreCase");
RegisterCodeFix(context, diagnostic, binaryExpression, comparisonSymbol, "CurrentCultureIgnoreCase");
}
break;
}
case SyntaxKind.InvocationExpression:
{
var invocationExpression = (InvocationExpressionSyntax)node;
MemberInvocationExpressionInfo invocationInfo = SyntaxInfo.MemberInvocationExpressionInfo(invocationExpression);
SeparatedSyntaxList <ArgumentSyntax> arguments = invocationInfo.Arguments;
InvocationExpressionSyntax invocationExpression2;
if (arguments.Count == 1)
{
invocationExpression2 = (InvocationExpressionSyntax)invocationInfo.Expression;
}
else
{
invocationExpression2 = (arguments[0].Expression.WalkDownParentheses() as InvocationExpressionSyntax)
?? (InvocationExpressionSyntax)arguments[1].Expression.WalkDownParentheses();
}
MemberInvocationExpressionInfo invocationInfo2 = SyntaxInfo.MemberInvocationExpressionInfo(invocationExpression2);
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol comparisonSymbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_StringComparison);
if (!invocationInfo2.NameText.EndsWith("Invariant", StringComparison.Ordinal) ||
!RegisterCodeFix(context, diagnostic, invocationInfo, comparisonSymbol, "InvariantCultureIgnoreCase"))
{
RegisterCodeFix(context, diagnostic, invocationInfo, comparisonSymbol, "OrdinalIgnoreCase");
RegisterCodeFix(context, diagnostic, invocationInfo, comparisonSymbol, "CurrentCultureIgnoreCase");
}
break;
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out SyntaxNode node, predicate: f => f.IsKind(SyntaxKind.MethodDeclaration, SyntaxKind.LocalFunctionStatement)))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.BodyCannotBeIteratorBlockBecauseTypeIsNotIteratorInterfaceType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeMethodReturnType))
{
break;
}
BlockSyntax body = (node is MethodDeclarationSyntax methodDeclaration)
? methodDeclaration.Body
: ((LocalFunctionStatementSyntax)node).Body;
Debug.Assert(body != null, node.ToString());
if (body == null)
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = null;
HashSet <ITypeSymbol> typeSymbols = null;
INamedTypeSymbol ienumerableOfTSymbol = null;
foreach (SyntaxNode descendant in body.DescendantNodes(descendIntoChildren: f => !CSharpFacts.IsFunction(f.Kind())))
{
if (!descendant.IsKind(SyntaxKind.YieldReturnStatement))
{
continue;
}
var yieldReturn = (YieldStatementSyntax)descendant;
ExpressionSyntax expression = yieldReturn.Expression;
if (expression == null)
{
continue;
}
var namedTypeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken) as INamedTypeSymbol;
if (namedTypeSymbol?.IsErrorType() != false)
{
continue;
}
if (typeSymbol == null)
{
typeSymbol = namedTypeSymbol;
}
else
{
if (typeSymbols == null)
{
typeSymbols = new HashSet <ITypeSymbol>()
{
typeSymbol
};
}
if (!typeSymbols.Add(namedTypeSymbol))
{
continue;
}
}
if (ienumerableOfTSymbol == null)
{
ienumerableOfTSymbol = semanticModel.GetTypeByMetadataName(MetadataNames.System_Collections_Generic_IEnumerable_T);
}
CodeFixRegistrator.ChangeReturnType(
context,
diagnostic,
node,
ienumerableOfTSymbol.Construct(namedTypeSymbol),
semanticModel,
additionalKey: SymbolDisplay.ToMinimalDisplayString(namedTypeSymbol, semanticModel, node.SpanStart, SymbolDisplayFormats.Default));
}
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out BinaryExpressionSyntax binaryExpression))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.SimplifyBooleanComparison:
{
CodeAction codeAction = CodeAction.Create(
"Simplify boolean comparison",
cancellationToken => SimplifyBooleanComparisonRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.CallSkipAndAnyInsteadOfCount:
{
CodeAction codeAction = CodeAction.Create(
"Call 'Skip' and 'Any' instead of 'Count'",
cancellationToken => CallSkipAndAnyInsteadOfCountRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.AvoidNullLiteralExpressionOnLeftSideOfBinaryExpression:
{
CodeAction codeAction = CodeAction.Create(
"Swap operands",
cancellationToken => CommonRefactorings.SwapBinaryOperandsAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseStringIsNullOrEmptyMethod:
{
CodeAction codeAction = CodeAction.Create(
"Use 'string.IsNullOrEmpty' method",
cancellationToken => UseStringIsNullOrEmptyMethodRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.SimplifyCoalesceExpression:
{
ExpressionSyntax expression = binaryExpression.Left;
if (expression == null ||
!context.Span.Contains(expression.Span))
{
expression = binaryExpression.Right;
}
CodeAction codeAction = CodeAction.Create(
"Simplify coalesce expression",
cancellationToken => SimplifyCoalesceExpressionRefactoring.RefactorAsync(context.Document, binaryExpression, expression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.RemoveRedundantAsOperator:
{
CodeAction codeAction = CodeAction.Create(
"Remove redundant 'as' operator",
cancellationToken => RemoveRedundantAsOperatorRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseStringLengthInsteadOfComparisonWithEmptyString:
{
CodeAction codeAction = CodeAction.Create(
"Use string.Length",
cancellationToken => UseStringLengthInsteadOfComparisonWithEmptyStringRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UnconstrainedTypeParameterCheckedForNull:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(binaryExpression.Left, context.CancellationToken);
CodeAction codeAction = CodeAction.Create(
$"Use EqualityComparer<{typeSymbol.Name}>.Default",
cancellationToken => UnconstrainedTypeParameterCheckedForNullRefactoring.RefactorAsync(context.Document, binaryExpression, typeSymbol, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ValueTypeObjectIsNeverEqualToNull:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(binaryExpression.Left, context.CancellationToken);
string title;
if (CSharpFacts.IsSimpleType(typeSymbol.SpecialType) ||
typeSymbol.ContainsMember <IMethodSymbol>(WellKnownMemberNames.EqualityOperatorName))
{
ExpressionSyntax expression = typeSymbol.GetDefaultValueSyntax(semanticModel, binaryExpression.Right.SpanStart);
title = $"Replace 'null' with '{expression}'";
}
else
{
title = $"Use EqualityComparer<{SymbolDisplay.ToMinimalDisplayString(typeSymbol, semanticModel, binaryExpression.Right.SpanStart, SymbolDisplayFormats.Default)}>.Default";
}
CodeAction codeAction = CodeAction.Create(
title,
cancellationToken => ValueTypeObjectIsNeverEqualToNullRefactoring.RefactorAsync(context.Document, binaryExpression, typeSymbol, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.JoinStringExpressions:
{
CodeAction codeAction = CodeAction.Create(
"Join string expressions",
cancellationToken => JoinStringExpressionsRefactoring.RefactorAsync(context.Document, binaryExpression, context.Span, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseExclusiveOrOperator:
{
CodeAction codeAction = CodeAction.Create(
"Use ^ operator",
cancellationToken => UseExclusiveOrOperatorRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.SimplifyBooleanExpression:
{
CodeAction codeAction = CodeAction.Create(
"Simplify boolean expression",
cancellationToken => SimplifyBooleanExpressionRefactoring.RefactorAsync(context.Document, binaryExpression, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ExpressionIsAlwaysEqualToTrueOrFalse:
{
LiteralExpressionSyntax newNode = BooleanLiteralExpression(binaryExpression.IsKind(SyntaxKind.GreaterThanOrEqualExpression, SyntaxKind.LessThanOrEqualExpression));
CodeAction codeAction = CodeAction.Create(
$"Replace expression with '{newNode}'",
cancellationToken => context.Document.ReplaceNodeAsync(binaryExpression, newNode.WithTriviaFrom(binaryExpression), cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}