public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
EventFieldDeclarationSyntax eventFieldDeclaration = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <EventFieldDeclarationSyntax>();
if (eventFieldDeclaration == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
"Split declaration into multiple declarations",
cancellationToken =>
{
return(SplitVariablesIntoMultipleDeclarationsAsync(
context.Document,
eventFieldDeclaration,
cancellationToken));
},
DiagnosticIdentifiers.SplitDeclarationIntoMultipleDeclarations + EquivalenceKeySuffix),
context.Diagnostics);
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
var docComment = node.GetLeadingTrivia().Select(i => i.GetStructure()).OfType <DocumentationCommentTriviaSyntax>().FirstOrDefault();
_parsedMembers.Add(new ParsedMember(node, docComment));
base.VisitEventFieldDeclaration(node);
}
/// <summary>
/// Called when the visitor visits a EventFieldDeclarationSyntax node.
/// </summary>
/// <param name="node">The visited node.</param>
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
foreach (var eventDeclaration in node.Declaration.Variables)
{
VisitMemberDeclaration <EventNodeContainer>(eventDeclaration, _events);
}
}
public override IEnumerable <IModel> VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
foreach (var variable in node.Declaration.Variables)
{
yield return(CreateSymbolic <EventDeclaration, EventDefinition>(variable));
}
}
public static async Task <Document> ExpandAsync(
Document document,
EventFieldDeclarationSyntax eventDeclaration,
CancellationToken cancellationToken)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (eventDeclaration == null)
{
throw new ArgumentNullException(nameof(eventDeclaration));
}
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
EventDeclarationSyntax newNode = Expand(eventDeclaration)
.WithTriviaFrom(eventDeclaration)
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(eventDeclaration, newNode);
return(document.WithSyntaxRoot(newRoot));
}
private static string _BuildEventName(EventFieldDeclarationSyntax eventSyntax)
{
var eventName = string.Join("_", eventSyntax.Declaration.Variables);
var interfaceSyntax = eventSyntax.Parent as InterfaceDeclarationSyntax;
return($"{interfaceSyntax.Identifier}_{eventName}");
}
private string AddRemoveAccessor(EventFieldDeclarationSyntax node, string backingFieldVar, bool isStatic, SyntaxNode declaringType, string eventType)
{
if (node.Declaration.Variables.Count > 1)
{
throw new NotSupportedException($"Only one event per declaration is supported.");
}
var decl = node.Declaration.Variables[0];
var removeMethodVar = TempLocalVar($"{decl.Identifier.Text}_remove");
var isInterfaceDef = declaringType.IsKind(SyntaxKind.InterfaceDeclaration);
var accessorModifiers = AccessModifiersForEventAccessors(node, isInterfaceDef);
var removeMethodExps = CecilDefinitionsFactory.Method(Context, removeMethodVar, $"remove_{decl.Identifier.Text}", accessorModifiers, Context.TypeResolver.ResolvePredefinedType("Void"), Array.Empty <TypeParameterSyntax>());
var paramsExps = AddParameterTo(removeMethodVar, eventType);
removeMethodExps = removeMethodExps.Concat(paramsExps);
if (!isInterfaceDef)
{
var localVarsExps = CreateLocalVarsForAddMethod(removeMethodVar, backingFieldVar);
var bodyExps = RemoveMethodBody(node, backingFieldVar, removeMethodVar, node.Declaration.Type, isStatic);
removeMethodExps = removeMethodExps.Concat(bodyExps).Concat(localVarsExps);
}
foreach (var exp in removeMethodExps)
{
WriteCecilExpression(Context, exp);
}
return(removeMethodVar);
}
private static void WriteThreadStatic(OutputWriter writer, VariableDeclaratorSyntax declaration,
EventFieldDeclarationSyntax field)
{
var type = TypeProcessor.ConvertType(field.Declaration.Type);
throw new NotImplementedException("ThreadStatic");
}
private static Func <SyntaxNode, Scope, SyntaxNode> EventDeclaration(IEnumerable <SyntaxToken> args)
{
return((node, scope) =>
{
EventFieldDeclarationSyntax @event = (EventFieldDeclarationSyntax)node;
ParameterListSyntax @params = CSharp.ParseParameterList(RoslynCompiler.TokensToString(args));
var variable = @event
.Declaration
.Variables[0];
var delegateName = variable.Identifier.ToString() + "_delegate"; //td: unique ids
var delegateDecl = CSharp.DelegateDeclaration(RoslynCompiler.@void, delegateName)
.WithParameterList(@params)
.WithModifiers(@event.Modifiers);
//add the delegate
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
document.change(@event.Parent, RoslynCompiler.AddMember(delegateDecl));
return @event
.WithDeclaration(@event.Declaration
.WithType(CSharp.ParseTypeName(delegateName)));
});
}
private static IEnumerable <EventFieldDeclarationSyntax> SplitEventFieldDeclaration(EventFieldDeclarationSyntax fieldDeclaration)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = fieldDeclaration.Declaration.Variables;
EventFieldDeclarationSyntax fieldDeclaration2 = fieldDeclaration.WithoutTrivia();
for (int i = 0; i < variables.Count; i++)
{
EventFieldDeclarationSyntax newDeclaration = EventFieldDeclaration(
fieldDeclaration2.AttributeLists,
fieldDeclaration2.Modifiers,
VariableDeclaration(
fieldDeclaration2.Declaration.Type,
SingletonSeparatedList(variables[i])));
if (i == 0)
{
newDeclaration = newDeclaration.WithLeadingTrivia(fieldDeclaration.GetLeadingTrivia());
}
if (i == variables.Count - 1)
{
newDeclaration = newDeclaration.WithTrailingTrivia(fieldDeclaration.GetTrailingTrivia());
}
yield return(newDeclaration.WithFormatterAnnotation());
}
}
public override SyntaxNode VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
//Note:Simple Event declare(no body)
//Extend:May add support depend on template, e.g. enyo
this.AppendCompileIssue(node, IssueType.Error, IssueId.EventNotSupport);
return(node);
}
private Task <Document> RemoveVirtualEventFieldAsync(Document document, EventFieldDeclarationSyntax declaration, CancellationToken c)
{
var modifiers = declaration.Modifiers;
var virtualToken = modifiers.Single(m => m.Kind() == SyntaxKind.VirtualKeyword);
return(RemoveVirtualTokenAsync(document, virtualToken, c));
}
private void HandleEventFieldDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.GetDocumentationMode() != DocumentationMode.Diagnose)
{
return;
}
EventFieldDeclarationSyntax declaration = context.Node as EventFieldDeclarationSyntax;
SyntaxKind defaultVisibility = SyntaxKind.PrivateKeyword;
if (this.IsInterfaceMemberDeclaration(declaration))
{
defaultVisibility = SyntaxKind.PublicKeyword;
}
var variableDeclaration = declaration?.Declaration;
if (variableDeclaration != null && this.NeedsComment(declaration.Modifiers, defaultVisibility))
{
if (!XmlCommentHelper.HasDocumentation(declaration))
{
var locations = variableDeclaration.Variables.Select(v => v.Identifier.GetLocation());
foreach (var location in locations)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
}
}
}
}
public static void HandleEventFieldDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
{
if (context.GetDocumentationMode() == DocumentationMode.None)
{
return;
}
EventFieldDeclarationSyntax declaration = (EventFieldDeclarationSyntax)context.Node;
VariableDeclarationSyntax variableDeclaration = declaration.Declaration;
Accessibility declaredAccessibility = declaration.GetDeclaredAccessibility(context.SemanticModel, context.CancellationToken);
Accessibility effectiveAccessibility = declaration.GetEffectiveAccessibility(context.SemanticModel, context.CancellationToken);
if (variableDeclaration != null && NeedsComment(settings.DocumentationRules, declaration.Kind(), declaration.Parent.Kind(), declaredAccessibility, effectiveAccessibility))
{
if (!XmlCommentHelper.HasDocumentation(declaration))
{
var locations = variableDeclaration.Variables.Select(v => v.Identifier.GetLocation());
foreach (var location in locations)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
}
}
}
}
public void InternalConstructorSetsAllNeededData_When_EventIsField()
{
EventFieldDeclarationSyntax decl = GetNode <EventFieldDeclarationSyntax>("class Test { event System.Action e1, e2 }");
const int index = 1;
VariableDeclaratorSyntax var = decl.Declaration.Variables[index];
SemanticModel semanticModel = Compilation.CurrentCompilation.GetSemanticModel(decl.SyntaxTree);
IEventSymbol symbol = (semanticModel.GetDeclaredSymbol(var) as IEventSymbol) !;
Data.EventData data = new(symbol, Compilation);
Location location = decl.GetLocation();
Assert.True(
data.SemanticModel is not null &&
data.SemanticModel.SyntaxTree.IsEquivalentTo(semanticModel.SyntaxTree) &&
data.Symbol is not null &&
SymbolEqualityComparer.Default.Equals(data.Symbol, symbol) &&
data.Location is not null &&
data.Location == location &&
data.Declaration is not null &&
data.Declaration.IsEquivalentTo(decl) &&
data.ParentCompilation is not null &&
data.ParentCompilation == Compilation &&
data.AsProperty is null &&
data.AsField is not null &&
data.AsField.IsEquivalentTo(decl) &&
data.Variable is not null &&
data.Variable.IsEquivalentTo(var) &&
data.Index == index
);
}
internal static async Task <ImmutableArray <SyntaxNode> > GetSelectedDeclarationsOrVariablesAsync(CodeRefactoringContext context)
{
var(document, span, cancellationToken) = context;
if (span.IsEmpty)
{
// if the span is empty then we are only selecting one "member" (which could include a field which declared multiple actual members)
// Consider:
// MemberDeclaration: member that can be declared in type (those are the ones we can pull up)
// VariableDeclaratorSyntax: for fields the MemberDeclaration can actually represent multiple declarations, e.g. `int a = 0, b = 1;`.
// ..Since the user might want to select & pull up only one of them (e.g. `int a = 0, [|b = 1|];` we also look for closest VariableDeclaratorSyntax.
var memberDeclaration = await context.TryGetRelevantNodeAsync <MemberDeclarationSyntax>().ConfigureAwait(false);
if (memberDeclaration == null)
{
// could not find a member, we may be directly on a variable declaration
var varDeclarator = await context.TryGetRelevantNodeAsync <VariableDeclaratorSyntax>().ConfigureAwait(false);
return(varDeclarator == null
? ImmutableArray <SyntaxNode> .Empty
: ImmutableArray.Create <SyntaxNode>(varDeclarator));
}
else
{
return(memberDeclaration switch
{
FieldDeclarationSyntax fieldDeclaration => fieldDeclaration.Declaration.Variables.AsImmutable <SyntaxNode>(),
EventFieldDeclarationSyntax eventFieldDeclaration => eventFieldDeclaration.Declaration.Variables.AsImmutable <SyntaxNode>(),
IncompleteMemberSyntax or GlobalStatementSyntax => ImmutableArray <SyntaxNode> .Empty,
_ => ImmutableArray.Create <SyntaxNode>(memberDeclaration),
});
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol,
INamedTypeSymbol stubbedInterface)
{
// only handle EventAdd and ignore EventRemove because we only need to stub the event once
if (!methodSymbol.IsEventAdd())
{
return(classDclr);
}
// add the event implementation to the stub
IEventSymbol eventSymbol = (IEventSymbol)methodSymbol.AssociatedSymbol;
EventFieldDeclarationSyntax eventDclr = ToEventDclr(eventSymbol);
classDclr = classDclr.AddMembers(eventDclr);
string eventName = eventSymbol.Name;
ParameterSyntax[] parameters = GetEventParameters(eventSymbol);
string onEventArgs = "sender";
string eventTriggerArgs = "sender";
if (parameters.Count() == 2)
{
onEventArgs += ", args";
eventTriggerArgs += ", args";
}
else if (parameters.Count() == 1)
{
onEventArgs += ", null";
}
string eventType = GetEventType(eventSymbol);
string onEventMethodName = "On_" + eventName;
// Create OnEvent method
MethodDeclarationSyntax onEventMethodDclr = SF.MethodDeclaration(SF.ParseTypeName("void"), onEventMethodName)
.AddModifiers(SF.Token(SyntaxKind.ProtectedKeyword))
.AddParameterListParameters(parameters)
.WithBody(SF.Block(
SF.ParseStatement($"{eventType} handler = {eventName};\n"),
SF.ParseStatement($"if (handler != null) {{ handler({onEventArgs}); }}\n")
));
classDclr = classDclr.AddMembers(onEventMethodDclr);
// Create event trigger method
string eventTriggerMethodName = eventName + "_Raise";
MethodDeclarationSyntax eventTriggerMethod = SF.MethodDeclaration(SF.ParseTypeName("void"),
eventTriggerMethodName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddParameterListParameters(parameters)
.WithBody(SF.Block(
SF.ParseStatement($"{onEventMethodName}({eventTriggerArgs});\n")
));
classDclr = classDclr.AddMembers(eventTriggerMethod);
return(classDclr);
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, EventFieldDeclarationSyntax eventFieldDeclaration)
{
SemanticModel semanticModel = null;
VariableDeclarationSyntax variableDeclaration = eventFieldDeclaration.Declaration;
if (variableDeclaration != null)
{
foreach (VariableDeclaratorSyntax variableDeclarator in variableDeclaration.Variables)
{
if (context.Span.IsContainedInSpanOrBetweenSpans(variableDeclarator.Identifier))
{
semanticModel = semanticModel ?? await context.GetSemanticModelAsync().ConfigureAwait(false);
var eventSymbol = semanticModel.GetDeclaredSymbol(variableDeclarator, context.CancellationToken) as IEventSymbol;
if (eventSymbol?.IsStatic == false)
{
INamedTypeSymbol containingType = eventSymbol.ContainingType;
if (containingType?.IsInterface() == false)
{
var eventHandlerType = eventSymbol.Type as INamedTypeSymbol;
if (eventHandlerType != null)
{
ITypeSymbol eventArgsSymbol = GetEventArgsSymbol(eventHandlerType, semanticModel);
if (eventArgsSymbol != null)
{
string methodName = "On" + eventSymbol.Name;
if (!containingType.ExistsMethod(
$"On{eventSymbol.Name}",
methodSymbol => eventArgsSymbol.Equals(methodSymbol.SingleParameterOrDefault()?.Type)))
{
methodName = NameGenerator.Default.EnsureUniqueMemberName(methodName, containingType);
context.RegisterRefactoring(
$"Generate '{methodName}' method",
cancellationToken =>
{
return(RefactorAsync(
context.Document,
eventFieldDeclaration,
eventSymbol,
eventArgsSymbol,
context.SupportsCSharp6,
cancellationToken));
});
}
}
}
}
}
}
}
}
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
base.VisitEventFieldDeclaration(node);
foreach (var v in node.Declaration.Variables)
{
Append(v);
}
}
public EventNodeWithSymbols(
EventFieldDeclarationSyntax declaration,
IBasicMemberContainer container,
SemanticModel semanticModel)
: base(declaration, container)
{
this.semanticModel = semanticModel;
}
public void CanHandleDeclarationWithSingleField()
{
EventFieldDeclarationSyntax field = GetNode <EventFieldDeclarationSyntax>("class Test { event System.Action e; }");
Data.EventData data = new(field, Compilation);
Assert.True(data.Symbol is not null && data.Declaration is not null);
}
private static EventFieldDeclarationSyntax CreateImplementation([NotNull] EventFieldDeclarationSyntax member)
{
var variables = member.Declaration.Variables.Select(v => SyntaxFactory.VariableDeclarator(v.Identifier.Text)).ToArray();
var declaration = SyntaxFactory.EventFieldDeclaration(SyntaxFactory.VariableDeclaration(member.Declaration.Type).AddVariables(variables))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
return(declaration);
}
private static bool IsThreadStatic(this EventFieldDeclarationSyntax field)
{
return(field.AttributeLists.Any(
l =>
l.Attributes.Any(
a => a.Name is QualifiedNameSyntax ? (a.Name.As <QualifiedNameSyntax>().Right.Identifier.Text == "ThreadStatic") :
a.Name is IdentifierNameSyntax && a.Name.As <IdentifierNameSyntax>().Identifier.Text == "ThreadStatic")));
}
public void VariableIsSetThroughConstructor_When_EventIsField_And_CalledConstructorWithIndex()
{
EventFieldDeclarationSyntax field = GetNode <EventFieldDeclarationSyntax>("class Test { event System.Action e1, e2; }");
Data.EventData data = new(field, Compilation, 1);
Assert.True(data.Variable is not null && data.Variable.IsEquivalentTo(field.Declaration.Variables[1]));
}
public void IndexIsSetThroughConstructor_When_EventIsField()
{
EventFieldDeclarationSyntax field = GetNode <EventFieldDeclarationSyntax>("class Test { event System.Action e1, e2; }");
Data.EventData data = new(field, Compilation, 1);
Assert.True(data.Index == 1);
}
public void AsFieldIsSet_And_AsPropertyIsNull_When_EventIsField()
{
EventFieldDeclarationSyntax field = GetNode <EventFieldDeclarationSyntax>("class Test { event System.Action e; }");
Data.EventData data = new(field, Compilation);
Assert.True(data.AsField is not null && data.AsField.IsEquivalentTo(field) && data.AsProperty is null);
}
public static int GetModifierInsertIndex(EventFieldDeclarationSyntax eventFieldDeclaration, SyntaxKind modifierKind)
{
if (eventFieldDeclaration == null)
{
throw new ArgumentNullException(nameof(eventFieldDeclaration));
}
return(GetModifierInsertIndex(eventFieldDeclaration.Modifiers, modifierKind));
}
public static SyntaxTriviaList Generate(EventFieldDeclarationSyntax eventFieldDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (eventFieldDeclaration == null)
{
throw new ArgumentNullException(nameof(eventFieldDeclaration));
}
return(Generate(settings: settings));
}
public static EventFieldDeclarationSyntax InsertModifier(EventFieldDeclarationSyntax eventFieldDeclaration, SyntaxKind modifierKind)
{
if (eventFieldDeclaration == null)
{
throw new ArgumentNullException(nameof(eventFieldDeclaration));
}
return(eventFieldDeclaration.WithModifiers(InsertModifier(eventFieldDeclaration.Modifiers, modifierKind)));
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
var type = new PythonType("List", "typing")
{
TypeParameters = { _typeConverter.GetType(node.Declaration.Type) }
};
VisitField(node, type);
}
public override SyntaxNode VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
base.VisitEventFieldDeclaration(node);
if (node.Parent is InterfaceDeclarationSyntax)
return node;
var symbol = semanticModel.GetDeclaredSymbol((node as EventFieldDeclarationSyntax).Declaration.Variables[0]);
var type = symbol.ContainingType;
if (type == null)
return node;
var faceMembers = symbol.ImplementedInterfaceMember();
if (faceMembers.Count() != 1)
return node;
var facenode = faceMembers.Single().GetSyntaxNodes().Single().Parent.Parent;
if (facenode.GetDocumentationCommentText().Length == 0 ||
node.GetDocumentationCommentText().WithoutIndentation() == facenode.GetDocumentationCommentText().WithoutIndentation())
return node;
return node.WithDocumentationComment(facenode.GetDocumentationCommentText());
}
public virtual void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
DefaultVisit(node);
}
public static EventFieldDeclarationSyntax EventFieldDeclaration(IEnumerable<AttributeListSyntax> attributeLists = null, Modifiers modifiers = default(Modifiers), VariableDeclarationSyntax declaration = null)
{
var result = new EventFieldDeclarationSyntax();
if (attributeLists != null)
result.AttributeLists.AddRange(attributeLists);
result.Modifiers = modifiers;
result.Declaration = declaration;
return result;
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
base.VisitEventFieldDeclaration(node);
}
public static EventFieldDeclarationSyntax EventFieldDeclaration(VariableDeclarationSyntax declaration = null)
{
var result = new EventFieldDeclarationSyntax();
result.Declaration = declaration;
return result;
}
public void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
VisitBaseFieldDeclaration(node);
}
