private bool RegisterCodeFix(
CodeFixContext context,
Diagnostic diagnostic,
SimpleMemberInvocationExpressionInfo invocationInfo,
INamedTypeSymbol comparisonSymbol,
string comparisonName)
{
if (!comparisonSymbol.ContainsMember <IFieldSymbol>(comparisonName))
{
return(false);
}
CodeAction codeAction = CodeAction.Create(
GetTitle(comparisonName),
cancellationToken => UseStringComparisonRefactoring.RefactorAsync(context.Document, invocationInfo, comparisonName, cancellationToken),
GetEquivalenceKey(DiagnosticIdentifiers.UseStringComparison, comparisonName));
context.RegisterCodeFix(codeAction, diagnostic);
return(true);
}
private bool RegisterCodeFix(
CodeFixContext context,
Diagnostic diagnostic,
BinaryExpressionSyntax binaryExpression,
INamedTypeSymbol comparisonSymbol,
string comparisonName)
{
if (!comparisonSymbol.ContainsMember <IFieldSymbol>(comparisonName))
{
return(false);
}
CodeAction codeAction = CodeAction.Create(
GetTitle(comparisonName),
ct => RefactorAsync(context.Document, binaryExpression, comparisonName, ct),
GetEquivalenceKey(diagnostic, (comparisonName != "InvariantCultureIgnoreCase") ? comparisonName : null));
context.RegisterCodeFix(codeAction, diagnostic);
return(true);
}
private static bool ContainsMemberWithZeroValue(INamedTypeSymbol namedTypeSymbol)
{
SpecialType specialType = namedTypeSymbol.EnumUnderlyingType.SpecialType;
if (specialType == SpecialType.System_Int32)
{
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((int)0)));
}
switch (specialType)
{
case SpecialType.System_SByte:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((sbyte)0)));
case SpecialType.System_Byte:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((byte)0)));
case SpecialType.System_Int16:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((short)0)));
case SpecialType.System_UInt16:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((ushort)0)));
case SpecialType.System_UInt32:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((uint)0)));
case SpecialType.System_Int64:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((long)0)));
case SpecialType.System_UInt64:
return(namedTypeSymbol.ContainsMember <IFieldSymbol>(f => f.HasConstantValue((ulong)0)));
default:
{
Debug.Fail(specialType.ToString());
return(false);
}
}
}
private bool RegisterCodeFix(
CodeFixContext context,
Diagnostic diagnostic,
SimpleMemberInvocationExpressionInfo invocationInfo,
INamedTypeSymbol comparisonSymbol,
string comparisonName,
SemanticModel semanticModel)
{
if (!comparisonSymbol.ContainsMember <IFieldSymbol>(comparisonName))
{
return(false);
}
CodeAction codeAction = CodeAction.Create(
GetTitle(comparisonName),
cancellationToken => RefactorAsync(context.Document, invocationInfo, comparisonName, semanticModel, cancellationToken),
GetEquivalenceKey(diagnostic, (comparisonName != "InvariantCultureIgnoreCase") ? comparisonName : null));
context.RegisterCodeFix(codeAction, diagnostic);
return(true);
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EventFieldDeclarationSyntax eventFieldDeclaration)
{
if (eventFieldDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
{
return;
}
VariableDeclarationSyntax variableDeclaration = eventFieldDeclaration.Declaration;
if (variableDeclaration == null)
{
return;
}
SemanticModel semanticModel = null;
foreach (VariableDeclaratorSyntax variableDeclarator in variableDeclaration.Variables)
{
if (!context.Span.IsContainedInSpanOrBetweenSpans(variableDeclarator.Identifier))
{
continue;
}
semanticModel = semanticModel ?? await context.GetSemanticModelAsync().ConfigureAwait(false);
var eventSymbol = semanticModel.GetDeclaredSymbol(variableDeclarator, context.CancellationToken) as IEventSymbol;
if (eventSymbol?.IsStatic != false)
{
continue;
}
INamedTypeSymbol containingType = eventSymbol.ContainingType;
if (containingType == null)
{
return;
}
if (!(eventSymbol.Type is INamedTypeSymbol eventHandlerType))
{
continue;
}
ITypeSymbol eventArgsSymbol = GetEventArgsSymbol(eventHandlerType, semanticModel);
if (eventArgsSymbol == null)
{
continue;
}
string methodName = "On" + eventSymbol.Name;
if (containingType.ContainsMember <IMethodSymbol>(
$"On{eventSymbol.Name}",
methodSymbol => eventArgsSymbol.Equals(methodSymbol.Parameters.SingleOrDefault(shouldThrow: false)?.Type)))
{
continue;
}
methodName = NameGenerator.Default.EnsureUniqueMemberName(methodName, containingType);
context.RegisterRefactoring(
$"Generate '{methodName}' method",
cancellationToken =>
{
return(RefactorAsync(
context.Document,
eventFieldDeclaration,
eventSymbol,
eventArgsSymbol,
context.SupportsCSharp6,
cancellationToken));
});
}
}