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