public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
base.VisitEventDeclaration(node);
if (node.AccessorList != null)
{
foreach (var accessor in node.AccessorList.Accessors)
{
_members.Add(accessor);
}
}
}
public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node)
{
base.VisitEventDeclaration(node);
if (node.Parent is InterfaceDeclarationSyntax)
return node;
var symbol = semanticModel.GetDeclaredSymbol(node);
var type = symbol.ContainingType;
if (type == null)
return node;
var faceMembers = symbol.ImplementedInterfaceMember();
if (faceMembers.Count() != 1)
return node;
var interfaceNode = faceMembers.Single().GetSyntaxNodes().Single().Parent.Parent;
if (interfaceNode.GetDocumentationCommentText() == "" ||
interfaceNode.GetDocumentationCommentText().Equals(node.GetDocumentationCommentText()))
return node;
return node.WithDocumentationComment(interfaceNode.GetDocumentationCommentText());
}
public static SyntaxNode RemoveModifierFromNode(SyntaxNode node, SyntaxKind modifier)
{
//there seem to be no base classes to support WithModifiers.
//dynamic modifiersNode = node;
//return modifiersNode.WithModifiers(SyntaxFactory.TokenList(modifiersNode.Modifiers.Where(m => !m.IsKind(SyntaxKind.PrivateKeyword))));
MethodDeclarationSyntax methodNode = node as MethodDeclarationSyntax;
if (methodNode != null)
{
return(methodNode.WithModifiers(SyntaxFactory.TokenList(methodNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(methodNode.GetLeadingTrivia()));
}
FieldDeclarationSyntax fieldNode = node as FieldDeclarationSyntax;
if (fieldNode != null)
{
return(fieldNode.WithModifiers(SyntaxFactory.TokenList(fieldNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(fieldNode.GetLeadingTrivia()));
}
PropertyDeclarationSyntax propertyNode = node as PropertyDeclarationSyntax;
if (propertyNode != null)
{
return(propertyNode.WithModifiers(SyntaxFactory.TokenList(propertyNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(propertyNode.GetLeadingTrivia()));
}
IndexerDeclarationSyntax indexerNode = node as IndexerDeclarationSyntax;
if (indexerNode != null)
{
return(indexerNode.WithModifiers(SyntaxFactory.TokenList(indexerNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(indexerNode.GetLeadingTrivia()));
}
EventDeclarationSyntax eventNode = node as EventDeclarationSyntax;
if (eventNode != null)
{
return(eventNode.WithModifiers(SyntaxFactory.TokenList(eventNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(eventNode.GetLeadingTrivia()));
}
ConstructorDeclarationSyntax ctrNode = node as ConstructorDeclarationSyntax;
if (ctrNode != null)
{
return(ctrNode.WithModifiers(SyntaxFactory.TokenList(ctrNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(ctrNode.GetLeadingTrivia()));
}
OperatorDeclarationSyntax opNode = node as OperatorDeclarationSyntax;
if (opNode != null)
{
return(opNode.WithModifiers(SyntaxFactory.TokenList(opNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(opNode.GetLeadingTrivia()));
}
ClassDeclarationSyntax classNode = node as ClassDeclarationSyntax;
if (classNode != null)
{
return(classNode.WithModifiers(SyntaxFactory.TokenList(classNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(classNode.GetLeadingTrivia()));
}
InterfaceDeclarationSyntax interfaceNode = node as InterfaceDeclarationSyntax;
if (interfaceNode != null)
{
return(interfaceNode.WithModifiers(SyntaxFactory.TokenList(interfaceNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(interfaceNode.GetLeadingTrivia()));
}
StructDeclarationSyntax structNode = node as StructDeclarationSyntax;
if (structNode != null)
{
return(structNode.WithModifiers(SyntaxFactory.TokenList(structNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(structNode.GetLeadingTrivia()));
}
var enumNode = node as EnumDeclarationSyntax;
if (enumNode != null)
{
return(enumNode.WithModifiers(SyntaxFactory.TokenList(enumNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(enumNode.GetLeadingTrivia()));
}
var delegateNode = node as DelegateDeclarationSyntax;
if (delegateNode != null)
{
return(delegateNode.WithModifiers(SyntaxFactory.TokenList(delegateNode.Modifiers.Where(m => !m.IsKind(modifier))))
.WithLeadingTrivia(delegateNode.GetLeadingTrivia()));
}
return(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitEventDeclaration(EventDeclarationSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitEventDeclaration(node);
}
private void AppendParameters(EventDeclarationSyntax syntax, StringBuilder builder)
{
builder.Append("(");
var symbol = ModelExtensions.GetSymbolInfo(_semanticModel, syntax.Type).Symbol as ITypeSymbol;
if (symbol != null)
{
var typeName = ResolveTypeName(symbol);
builder.Append(typeName);
}
builder.Append(")");
}
/// <summary>
/// Add the field and respect StyleCop ordering.
/// </summary>
/// <param name="editor">The <see cref="DocumentEditor"/>.</param>
/// <param name="containingType">The containing type.</param>
/// <param name="event">The <see cref="EventDeclarationSyntax"/>.</param>
/// <param name="comparer">The <see cref="IComparer{MemberDeclarationSyntax}"/>. If null <see cref="MemberDeclarationComparer.Default"/> is used.</param>
/// <returns>The <paramref name="editor"/>.</returns>
public static DocumentEditor AddEvent(this DocumentEditor editor, ClassDeclarationSyntax containingType, EventDeclarationSyntax @event, IComparer <MemberDeclarationSyntax>?comparer = null)
{
if (editor is null)
{
throw new System.ArgumentNullException(nameof(editor));
}
if (containingType is null)
{
throw new System.ArgumentNullException(nameof(containingType));
}
if (@event is null)
{
throw new System.ArgumentNullException(nameof(@event));
}
editor.ReplaceNode(
containingType,
node => node.AddSorted(@event, comparer));
return(editor);
}
private async Task<Document> ImplementVirtualEventPropertyAsync(Document document, EventDeclarationSyntax declaration, CancellationToken c)
{
// Need the left (IdentifierNameSyntax) of the Accessor Statement for the AssignmentExpressionSyntax
var accessor = declaration.AccessorList.Accessors.First();
var statements = accessor.Body.Statements.OfType<ExpressionStatementSyntax>();
// Need to fine where the right side of an Add statement is "value":
var eventFieldName = statements.Where(s => (s.Expression as AssignmentExpressionSyntax)?.OperatorToken.Kind() == SyntaxKind.PlusEqualsToken)
.Where(s => ((s.Expression as AssignmentExpressionSyntax)?.Right as IdentifierNameSyntax)?.Identifier.ValueText == "value")
.Select(s => ((s.Expression as AssignmentExpressionSyntax)?.Left as IdentifierNameSyntax)?.Identifier.ValueText).First();
var raiseMethod = CreateRaiseMethod(declaration.Identifier.ValueText, eventFieldName, (declaration.Type as GenericNameSyntax));
var root = await document.GetSyntaxRootAsync(c);
var newRoot = root.InsertNodesAfter(declaration, new SyntaxNode[] { raiseMethod });
// Note that we need to find the node again
declaration = newRoot.FindToken(declaration.Span.Start).Parent.AncestorsAndSelf()
.OfType<EventDeclarationSyntax>().First();
var modifiers = declaration.Modifiers;
var virtualToken = modifiers.Single(m => m.Kind() == SyntaxKind.VirtualKeyword);
var newDeclaration = declaration.ReplaceToken(virtualToken, Token(SyntaxKind.None));
newRoot = newRoot.ReplaceNode(declaration, newDeclaration
.WithTrailingTrivia(TriviaList(CarriageReturnLineFeed, CarriageReturnLineFeed)));
return document.WithSyntaxRoot(newRoot);
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
_members.Add(node);
}
public static BaseDocumentationCommentData GenerateFromBase(EventDeclarationSyntax eventDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken))
{
IEventSymbol eventSymbol = semanticModel.GetDeclaredSymbol(eventDeclaration, cancellationToken);
return(GenerateFromBase(eventSymbol, semanticModel, eventDeclaration.SpanStart, cancellationToken));
}
public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node)
{
if (node == null)
return null;
var symbol = m_model.GetDeclaredSymbol(node);
node = (EventDeclarationSyntax)base.VisitEventDeclaration(node);
if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
node = (EventDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
return node;
}
/// <inheritdoc /> public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node) => this.Next();
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
new EventDeclarationVisitor(Context).Visit(node);
}
private async static Task <Document> ImplementVirtualEventPropertyAsync(Document document, EventDeclarationSyntax declaration, CancellationToken c)
{
// Need the left (IdentifierNameSyntax) of the Accessor Statement for the AssignmentExpressionSyntax
var accessor = declaration.AccessorList.Accessors.First();
var statements = accessor.Body.Statements.OfType <ExpressionStatementSyntax>();
// Need to fine where the right side of an Add statement is "value":
var eventFieldName = statements.Where(s => (s.Expression as AssignmentExpressionSyntax)?.OperatorToken.Kind() == SyntaxKind.PlusEqualsToken)
.Where(s => ((s.Expression as AssignmentExpressionSyntax)?.Right as IdentifierNameSyntax)?.Identifier.ValueText == "value")
.Select(s => ((s.Expression as AssignmentExpressionSyntax)?.Left as IdentifierNameSyntax)?.Identifier.ValueText).First();
var raiseMethod = CreateRaiseMethod(declaration.Identifier.ValueText, eventFieldName, (declaration.Type as GenericNameSyntax));
var root = await document.GetSyntaxRootAsync(c);
var newRoot = root.InsertNodesAfter(declaration, new SyntaxNode[] { raiseMethod });
// Note that we need to find the node again
declaration = newRoot.FindToken(declaration.Span.Start).Parent.AncestorsAndSelf()
.OfType <EventDeclarationSyntax>().First();
var modifiers = declaration.Modifiers;
var virtualToken = modifiers.Single(m => m.Kind() == SyntaxKind.VirtualKeyword);
var newDeclaration = declaration.ReplaceToken(virtualToken, Token(SyntaxKind.None));
newRoot = newRoot.ReplaceNode(declaration, newDeclaration
.WithTrailingTrivia(TriviaList(CarriageReturnLineFeed, CarriageReturnLineFeed)));
return(document.WithSyntaxRoot(newRoot));
}
private static Task <Document> RemoveVirtualEventPropertyAsync(Document document, EventDeclarationSyntax declaration, CancellationToken c)
{
var modifiers = declaration.Modifiers;
var virtualToken = modifiers.Single(m => m.Kind() == SyntaxKind.VirtualKeyword);
return(RemoveVirtualTokenAsync(document, virtualToken, c));
}
public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node)
{
node = (EventDeclarationSyntax)base.VisitEventDeclaration(node);
Classes.Add(node);
return(node);
}
internal static bool TryGetEventAccessors(EventDeclarationSyntax @event, out AccessorDeclarationSyntax add, out AccessorDeclarationSyntax remove)
{
var accessors = @event.AccessorList.Accessors;
add = accessors.FirstOrDefault(ad => ad.CSharpKind() == SyntaxKind.GetAccessorDeclaration);
remove = accessors.FirstOrDefault(ad => ad.CSharpKind() == SyntaxKind.SetAccessorDeclaration);
return accessors.Count == 2 && add != null && remove != null;
}
public static void ComputeRefactoring(RefactoringContext context, EventDeclarationSyntax eventDeclaration, SemanticModel semanticModel)
{
ComputeRefactoring(context, eventDeclaration, eventDeclaration.Modifiers, eventDeclaration.ExplicitInterfaceSpecifier, semanticModel);
}
// // Summary: // Called when the visitor visits a EventDeclarationSyntax node. public virtual void VisitEventDeclaration(EventDeclarationSyntax node);
internal static Accessibility GetDeclaredAccessibility(this BasePropertyDeclarationSyntax syntax, SemanticModel semanticModel, CancellationToken cancellationToken)
{
if (syntax == null)
{
throw new ArgumentNullException(nameof(syntax));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
AccessLevel accessLevel = GetAccessLevel(syntax.Modifiers);
if (accessLevel != AccessLevel.NotSpecified)
{
return(accessLevel.ToAccessibility());
}
PropertyDeclarationSyntax propertyDeclarationSyntax = syntax as PropertyDeclarationSyntax;
if (propertyDeclarationSyntax != null)
{
if (propertyDeclarationSyntax.ExplicitInterfaceSpecifier == null)
{
return(Accessibility.Private);
}
else
{
return(Accessibility.Public);
}
}
IndexerDeclarationSyntax indexerDeclarationSyntax = syntax as IndexerDeclarationSyntax;
if (indexerDeclarationSyntax != null)
{
if (indexerDeclarationSyntax.ExplicitInterfaceSpecifier == null)
{
return(Accessibility.Private);
}
else
{
return(Accessibility.Public);
}
}
EventDeclarationSyntax eventDeclarationSyntax = syntax as EventDeclarationSyntax;
if (eventDeclarationSyntax != null)
{
if (eventDeclarationSyntax.ExplicitInterfaceSpecifier == null)
{
return(Accessibility.Private);
}
else
{
return(Accessibility.Public);
}
}
ISymbol declaredSymbol = semanticModel.GetDeclaredSymbol(syntax, cancellationToken);
return(declaredSymbol?.DeclaredAccessibility ?? Accessibility.NotApplicable);
}
public override void VisitEventDeclaration (EventDeclarationSyntax node)
{
base.VisitEventDeclaration (node);
Append (node);
}
/// <summary>
/// Same as SemanticModel.GetDeclaredSymbol but works when <paramref name="node"/> is not in the syntax tree.
/// </summary>
/// <param name="semanticModel">The <see cref="SemanticModel"/>.</param>
/// <param name="node">The <see cref="EventDeclarationSyntax"/>.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
/// <returns>An <see cref="IEventSymbol"/> or null.</returns>
public static IEventSymbol GetDeclaredSymbolSafe(this SemanticModel semanticModel, EventDeclarationSyntax node, CancellationToken cancellationToken)
{
return(semanticModel.SemanticModelFor(node)
?.GetDeclaredSymbol(node, cancellationToken));
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
}
/// <summary>
/// Try getting the <see cref="IEventSymbol"/> for the node.
/// Gets the semantic model for the tree if the node is not in the tree corresponding to <paramref name="semanticModel"/>.
/// </summary>
/// <param name="semanticModel">The <see cref="SemanticModel"/>.</param>
/// <param name="node">The <see cref="EventDeclarationSyntax"/>.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
/// <param name="symbol">The symbol if found.</param>
/// <returns>True if a symbol was found.</returns>
public static bool TryGetSymbol(this SemanticModel semanticModel, EventDeclarationSyntax node, CancellationToken cancellationToken, out IEventSymbol symbol)
{
symbol = GetDeclaredSymbolSafe(semanticModel, node, cancellationToken);
return(symbol != null);
}
public override IEventSymbol GetDeclaredSymbol(EventDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
// Can't define event inside member.
return null;
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, EventDeclarationSyntax eventDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MarkMemberAsStatic) &&
eventDeclaration.Span.Contains(context.Span) &&
MarkMemberAsStaticRefactoring.CanRefactor(eventDeclaration))
{
context.RegisterRefactoring(
"Mark event as static",
cancellationToken => MarkMemberAsStaticRefactoring.RefactorAsync(context.Document, eventDeclaration, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CopyDocumentationCommentFromBaseMember) &&
eventDeclaration.HeaderSpan().Contains(context.Span))
{
await CopyDocumentationCommentFromBaseMemberRefactoring.ComputeRefactoringAsync(context, eventDeclaration).ConfigureAwait(false);
}
}
private static SyntaxNode HandleEventDeclaration(EventDeclarationSyntax node)
{
SyntaxToken triviaToken = node.EventKeyword;
if (triviaToken.IsMissing)
{
return null;
}
SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref triviaToken, SyntaxKind.PrivateKeyword);
return node
.WithEventKeyword(triviaToken)
.WithModifiers(modifiers)
.WithoutFormatting();
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
}
public string Signature(bool forSorting)
{
string prefix = forSorting ? ClassPath + "." : "";
if (!forSorting && IsStatic)
{
prefix = "static ";
}
{
MethodDeclarationSyntax method = Member as MethodDeclarationSyntax;
if (method != null)
{
var signature = new System.Text.StringBuilder();
if (forSorting)
{
signature.Append($"{ClassPath}.{method.Identifier}(");
}
else
{
signature.Append($"{prefix}{method.ReturnType} {method.Identifier}(");
}
int parameterCount = method.ParameterList.Parameters.Count;
for (int i = 0; i < parameterCount; i++)
{
if (i > 0)
{
signature.Append(", ");
}
var parameter = method.ParameterList.Parameters[i];
for (int j = 0; j < parameter.Modifiers.Count; j++)
{
signature.Append(parameter.Modifiers[j].Text);
signature.Append(" ");
}
string paramType = parameter.Type.ToString();
int angleIndex = paramType.IndexOf('<');
if (angleIndex > 0)
{
string prefixType = paramType.Substring(0, angleIndex);
int prefixIndex = prefixType.LastIndexOf('.');
if (prefixIndex > 0)
{
prefixType = prefixType.Substring(prefixIndex + 1);
}
string genericType = paramType.Substring(angleIndex + 1);
int genericIndex = genericType.LastIndexOf('.');
if (genericIndex > 0)
{
genericType = genericType.Substring(genericIndex + 1);
}
paramType = prefixType + "<" + genericType;
}
else
{
int index = paramType.LastIndexOf('.');
if (index > 0)
{
paramType = paramType.Substring(index + 1);
}
}
signature.Append(paramType);
if (!forSorting)
{
signature.Append($" {parameter.Identifier}");
}
}
signature.Append(")");
return(signature.ToString());
}
}
{
PropertyDeclarationSyntax property = Member as PropertyDeclarationSyntax;
if (property != null)
{
var signature = new System.Text.StringBuilder();
if (forSorting)
{
signature.Append($"{ClassPath}.{property.Identifier}");
}
else
{
string proptype = $"{property.Type}";
int index = proptype.LastIndexOf('.');
if (index > 0)
{
proptype = proptype.Substring(index + 1);
}
signature.Append($"{prefix}{proptype} {property.Identifier}");
}
return(signature.ToString());
}
}
{
EventDeclarationSyntax evt = Member as EventDeclarationSyntax;
if (evt != null)
{
var signature = new System.Text.StringBuilder();
signature.Append($"{prefix}{evt.Identifier}");
return(signature.ToString());
}
}
{
OperatorDeclarationSyntax op = Member as OperatorDeclarationSyntax;
if (op != null)
{
var signature = new System.Text.StringBuilder();
signature.Append($"{prefix}{op.OperatorToken}");
return(signature.ToString());
}
}
{
EventFieldDeclarationSyntax eventField = Member as EventFieldDeclarationSyntax;
if (eventField != null)
{
var signature = new System.Text.StringBuilder();
string declaration = eventField.ToString();
int index = declaration.LastIndexOf(' ');
declaration = declaration.Substring(index + 1, declaration.Length - 1 - (index + 1));
signature.Append($"{prefix}{declaration}");
return(signature.ToString());
}
}
{
ConstructorDeclarationSyntax constructor = Member as ConstructorDeclarationSyntax;
if (constructor != null)
{
var signature = new System.Text.StringBuilder();
if (forSorting)
{
signature.Append($"{ClassPath}(");
}
else
{
if (IsStatic)
{
signature.Append("static ");
}
var parent = new ParsedType(Member.Parent as BaseTypeDeclarationSyntax, null);
signature.Append($"{parent.Name}(");
}
int parameterCount = constructor.ParameterList.Parameters.Count;
for (int i = 0; i < parameterCount; i++)
{
if (i > 0)
{
signature.Append(", ");
}
var parameter = constructor.ParameterList.Parameters[i];
string paramType = parameter.Type.ToString();
int angleIndex = paramType.IndexOf('<');
if (angleIndex > 0)
{
string prefixType = paramType.Substring(0, angleIndex);
int prefixIndex = prefixType.LastIndexOf('.');
if (prefixIndex > 0)
{
prefixType = prefixType.Substring(prefixIndex + 1);
}
string genericType = paramType.Substring(angleIndex + 1);
int genericIndex = genericType.LastIndexOf('.');
if (genericIndex > 0)
{
genericType = genericType.Substring(genericIndex + 1);
}
paramType = prefixType + "<" + genericType;
}
else
{
int index = paramType.LastIndexOf('.');
if (index > 0)
{
paramType = paramType.Substring(index + 1);
}
}
signature.Append(paramType);
if (!forSorting)
{
signature.Append($" {parameter.Identifier}");
}
}
signature.Append(")");
return(signature.ToString());
}
}
{
EnumMemberDeclarationSyntax enumMember = Member as EnumMemberDeclarationSyntax;
if (enumMember != null)
{
var signature = enumMember.ToString();
var items = signature.Split(new char[] { '\n' });
signature = items[items.Length - 1];
return(signature);
}
}
throw new NotImplementedException();
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
base.VisitEventDeclaration(node);
Append(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitEventDeclaration(EventDeclarationSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitEventDeclaration(node);
}
public void VisitEventDeclaration(EventDeclarationSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
WriteAttributes(
node,
_writer.Configuration.LineBreaksAndWrapping.Other.PlacePropertyIndexerEventAttributeOnSameLine
);
WriteMemberModifiers(node.Modifiers);
_writer.WriteKeyword(PrinterKeyword.Event);
_writer.WriteSpace();
node.Type.Accept(this);
_writer.WriteSpace();
if (node.ExplicitInterfaceSpecifier != null)
node.ExplicitInterfaceSpecifier.Accept(this);
_writer.WriteIdentifier(node.Identifier);
node.AccessorList.Accept(this);
WriteTrailingTrivia(node);
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
base.VisitEventDeclaration(node);
AddAccessorNode(node.AccessorList, SyntaxKind.AddAccessorDeclaration);
AddAccessorNode(node.AccessorList, SyntaxKind.RemoveAccessorDeclaration);
}
public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node)
{
if (!node.Identifier.IsMissing)
return node;
string event_name = node.Type.ToString();
string delegate_name = event_name + "_delegate";
Debug.Assert(pending_ == null);
pending_ = new ResolveEventArguments(delegate_name, ctx_, members_, node.Modifiers);
return SyntaxFactory.EventDeclaration(SyntaxFactory.IdentifierName(delegate_name), SyntaxFactory.Identifier(event_name)).
WithModifiers(node.Modifiers).
WithAccessorList(SyntaxFactory.AccessorList(SyntaxFactory.List( new AccessorDeclarationSyntax[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.AddAccessorDeclaration,
SyntaxFactory.Block(SyntaxFactory.List(new StatementSyntax[]
{
Compiler.EventAccessor(event_name, true)
}))),
SyntaxFactory.AccessorDeclaration(SyntaxKind.RemoveAccessorDeclaration,
SyntaxFactory.Block(SyntaxFactory.List(new StatementSyntax[]
{
Compiler.EventAccessor(event_name, false)
}))),
})));
}
public EventPropertyNode CreateEventPropertyNode(EventDeclarationSyntax declaration, IMemberContainer container)
{
return(new EventPropertyNodeWithSymbols(declaration, container, semanticModel));
}
private Doc PrintEventDeclarationSyntax(EventDeclarationSyntax node)
{
return(this.PrintBasePropertyDeclarationSyntax(node));
}
public static void Go(OutputWriter writer, EventDeclarationSyntax property)
{
writer.WriteLine("\r\n");
var rEf = ""; //" ref ";// ref should be used based on analysis, is the return type a single var or not
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var add =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal) SyntaxKind.AddKeyword);
var remove =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal) SyntaxKind.RemoveKeyword);
var eventSymbol = TypeProcessor.GetDeclaredSymbol(property);
var methodSymbol =
(TypeProcessor.GetDeclaredSymbol(add) ?? TypeProcessor.GetDeclaredSymbol(remove)) as IMethodSymbol;
ITypeSymbol interfaceImplemented;
ISymbol[] proxies;
;
var methodName = WriteIdentifierName.TransformIdentifier(MemberUtilities.GetMethodName(eventSymbol, ref isInterface, out interfaceImplemented, out proxies));
Action<AccessorDeclarationSyntax, bool> writeRegion = (region, get) =>
{
writer.WriteIndent();
// if (property.Modifiers.Any(SyntaxKind.PrivateKeyword))
// writer.HeaderWriter.Write("private:\n");
//
// if (property.Modifiers.Any(SyntaxKind.PublicKeyword) || property.Modifiers.Any(SyntaxKind.InternalKeyword))
// writer.HeaderWriter.Write("public ");
var typeinfo = TypeProcessor.GetTypeInfo(property.Type);
var isPtr = "";
var typeString = TypeProcessor.ConvertType(property.Type) + isPtr + " ";
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
writer.Write(" abstract ");
if (property.Modifiers.Any(SyntaxKind.OverrideKeyword))
writer.Write(" override ");
writer.Write("void ");
writer.Write(
(get ? "Add_" : "Remove_") + methodName + "( " + typeString + " value");
if (isInterface)
{
writer.WriteLine(" , " + TypeProcessor.ConvertType(interfaceImplemented) + " __ij = null");
}
writer.Write(" )");
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
writer.Write(";\r\n");
else
{
// writer.Write(";\r\n");
writer.OpenBrace();
// writer.Write(" =\r\n");
Core.WriteBlock(writer, region.Body.As<BlockSyntax>());
writer.CloseBrace();
writer.Write("\r\n");
}
};
if (add == null && remove == null)
throw new Exception("Event must have both a add and remove");
{
var name = WriteIdentifierName.TransformIdentifier(property.Identifier.Text);
var type = property.Type;
var typeinfo = TypeProcessor.GetTypeInfo(type);
var modifiers = property.Modifiers;
var typeString = TypeProcessor.ConvertType(type) + " ";
var isStatic = false;
//Handle Auto Properties
var accessors = property.AccessorList.Accessors; //.Where(o=>o.Body==null);
var accessString = "";
if (modifiers.Any(SyntaxKind.PrivateKeyword))
accessString += (" private ");
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
accessString += (" public ");
var IsStatic = "";
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
isStatic = true;
IsStatic = accessString += " static ";
// writer.HeaderWriter.Write("static ");
}
var fieldName = "__evt__" + name + (interfaceImplemented!=null?TypeProcessor.ConvertType(interfaceImplemented)
.Replace("(","_").Replace("!", "_").Replace(")", "_").Replace(".", "_") :"");
if (!(property.Parent is InterfaceDeclarationSyntax))
{
if (!isStatic)
{
writer.Write("private " + "__Event!(" + typeString + ") " + fieldName + ";\r\n");
// Internal Field used for event
writer.Write(accessString);
writer.WriteLine("__Event!(" + typeString + ") " + name + "(" + (interfaceImplemented!=null ? ( TypeProcessor.ConvertType(interfaceImplemented) + " __ij = null") :"")+") @property");
writer.OpenBrace();
writer.WriteLine("if (" + fieldName + " is null)");
writer.OpenBrace();
writer.Write(fieldName + " = new " + "__Event!(" + typeString + ")(new Action__G!(" +
typeString +
")(&Add_" + name + "),new Action__G!(" + typeString + ")(&Remove_" + name + ") );");
writer.CloseBrace();
writer.Write("return " + fieldName + ";");
writer.CloseBrace();
}
else
{
writer.Write(IsStatic);
writer.Write("__Event!(" + typeString + ") " + name + ";\r\n");
}
}
//
var isOverride = property.Modifiers.Any(SyntaxKind.NewKeyword) ||
property.Modifiers.Any(SyntaxKind.OverrideKeyword)
? " override "
: "";
var isVirtual = //property.Modifiers.Any(SyntaxKind.VirtualKeyword) ||
property.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface
? " abstract "
: "";
//Adder
if (add != null && add.Body == null)
{
writer.Write(IsStatic);
//if (property.Modifiers.Any(SyntaxKind.AbstractKeyword)||isInterface)
{
writer.WriteLine(" " + isVirtual + " void Add_" + name + "(" + typeString + " value)" +
isOverride + "" + ";");
}
// else
// writer.WriteLine(" "+isVirtual + " void Add_" + name + "(" + typeString + " value)" +
// isOverride + " {" + fieldName + " = value;}");
}
else if (add != null)
{
writer.Write(IsStatic);
writeRegion(add, true);
}
//Remover
if (remove != null && remove.Body == null)
{
writer.Write(IsStatic);
//if (property.Modifiers.Any(SyntaxKind.AbstractKeyword)||isInterface)
{
writer.WriteLine(" " + isVirtual + " void Remove_" + name + "(" + typeString + " value)" +
isOverride + "" + ";");
}
}
else if (remove != null)
{
writer.Write(IsStatic);
writeRegion(remove, false);
}
if (isStatic)
{
var staticWriter = new OutputWriter("", "", false);
staticWriter.Write(name);
staticWriter.Write(" = new " + "__Event!(" + typeString + ")(new Action__G!(" + typeString +
")(&Add_" + name + "),new Action__G!(" + typeString +
")(&Remove_" + name + ") )");
staticWriter.Write(";");
staticWriter.WriteLine();
Context.Instance.StaticInits.Add(staticWriter.ToString());
}
}
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
FindSpellingMistakesForIdentifier(node.Identifier);
base.VisitEventDeclaration(node);
}
/// <summary>
/// Given a syntax node that declares a (custom) event, get the corresponding event symbol.
/// </summary>
/// <param name="declarationSyntax">The syntax node that declares a event.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The symbol that was declared.</returns>
public override IEventSymbol GetDeclaredSymbol(EventDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetDeclaredSymbol, message: this.SyntaxTree.FilePath, cancellationToken: cancellationToken))
{
return (IEventSymbol)GetDeclaredMemberSymbol(declarationSyntax);
}
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
AddDependentType(node.Type);
base.VisitEventDeclaration(node);
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
if (!node.Identifier.Span.IsEmpty)
{
var symbol = _sm.GetDeclaredSymbol(node);
_defined.Add(symbol);
var def = Def.For(symbol: symbol, type: "event", name: symbol.Name)
.At(_path, node.Identifier.Span);
if (symbol.IsExported())
{
def.Exported = true;
}
AddDef(def);
}
base.VisitEventDeclaration(node);
}
public override SyntaxToken VisitEventDeclaration(EventDeclarationSyntax node)
{
return(node.Identifier);
}
internal SourceCustomEventSymbol(SourceMemberContainerTypeSymbol containingType, Binder binder, EventDeclarationSyntax syntax, DiagnosticBag diagnostics) :
base(containingType, syntax, syntax.Modifiers, syntax.ExplicitInterfaceSpecifier, syntax.Identifier, diagnostics)
{
ExplicitInterfaceSpecifierSyntax interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
SyntaxToken nameToken = syntax.Identifier;
bool isExplicitInterfaceImplementation = interfaceSpecifier != null;
string aliasQualifierOpt;
_name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(binder, interfaceSpecifier, nameToken.ValueText, diagnostics, out _explicitInterfaceType, out aliasQualifierOpt);
_type = BindEventType(binder, syntax.Type, diagnostics);
var explicitlyImplementedEvent = this.FindExplicitlyImplementedEvent(_explicitInterfaceType, nameToken.ValueText, interfaceSpecifier, diagnostics);
// The runtime will not treat the accessors of this event as overrides or implementations
// of those of another event unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations, we need to copy the custom
// modifiers that are in the signatures of the overridden/implemented event accessors.
// (From source, we know that there can only be one overridden/implemented event, so there
// are no conflicts.) This is unnecessary for implicit implementations because, if the custom
// modifiers don't match, we'll insert bridge methods for the accessors (explicit implementations
// that delegate to the implicit implementations) with the correct custom modifiers
// (see SourceNamedTypeSymbol.ImplementInterfaceMember).
// Note: we're checking if the syntax indicates explicit implementation rather,
// than if explicitInterfaceType is null because we don't want to look for an
// overridden event if this is supposed to be an explicit implementation.
if (!isExplicitInterfaceImplementation)
{
// If this event is an override, we may need to copy custom modifiers from
// the overridden event (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
if (this.IsOverride)
{
EventSymbol overriddenEvent = this.OverriddenEvent;
if ((object)overriddenEvent != null)
{
CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly);
}
}
}
else if ((object)explicitlyImplementedEvent != null)
{
CopyEventCustomModifiers(explicitlyImplementedEvent, ref _type, ContainingAssembly);
}
AccessorDeclarationSyntax addSyntax = null;
AccessorDeclarationSyntax removeSyntax = null;
foreach (AccessorDeclarationSyntax accessor in syntax.AccessorList.Accessors)
{
switch (accessor.Kind())
{
case SyntaxKind.AddAccessorDeclaration:
if (addSyntax == null || addSyntax.Keyword.Span.IsEmpty)
{
addSyntax = accessor;
}
break;
case SyntaxKind.RemoveAccessorDeclaration:
if (removeSyntax == null || removeSyntax.Keyword.Span.IsEmpty)
{
removeSyntax = accessor;
}
break;
}
}
_addMethod = CreateAccessorSymbol(addSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
_removeMethod = CreateAccessorSymbol(removeSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
if (containingType.IsInterfaceType())
{
if (addSyntax == null && removeSyntax == null) //NOTE: AND - different error code produced if one is present
{
// CONSIDER: we're matching dev10, but it would probably be more helpful to give
// an error like ERR_EventPropertyInInterface.
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
else
{
if (addSyntax == null || removeSyntax == null)
{
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
_explicitInterfaceImplementations =
(object)explicitlyImplementedEvent == null ?
ImmutableArray<EventSymbol>.Empty :
ImmutableArray.Create<EventSymbol>(explicitlyImplementedEvent);
}
private string GetEventDefinition(EventDeclarationSyntax node) => GetFullyQualifiedName((TypeDeclarationSyntax)node.Parent) + "." + node.Identifier.ValueText;
private Task<Document> RemoveVirtualEventPropertyAsync(Document document, EventDeclarationSyntax declaration, CancellationToken c)
{
var modifiers = declaration.Modifiers;
var virtualToken = modifiers.Single(m => m.Kind() == SyntaxKind.VirtualKeyword);
return RemoveVirtualTokenAsync(document, virtualToken, c);
}
internal SourceCustomEventSymbol(SourceMemberContainerTypeSymbol containingType, Binder binder, EventDeclarationSyntax syntax, DiagnosticBag diagnostics) :
base(containingType, syntax, syntax.Modifiers, syntax.ExplicitInterfaceSpecifier, syntax.Identifier, diagnostics)
{
ExplicitInterfaceSpecifierSyntax interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
SyntaxToken nameToken = syntax.Identifier;
bool isExplicitInterfaceImplementation = interfaceSpecifier != null;
string aliasQualifierOpt;
_name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(binder, interfaceSpecifier, nameToken.ValueText, diagnostics, out _explicitInterfaceType, out aliasQualifierOpt);
_type = BindEventType(binder, syntax.Type, diagnostics);
var explicitlyImplementedEvent = this.FindExplicitlyImplementedEvent(_explicitInterfaceType, nameToken.ValueText, interfaceSpecifier, diagnostics);
this.FindExplicitlyImplementedMemberVerification(explicitlyImplementedEvent, diagnostics);
// The runtime will not treat the accessors of this event as overrides or implementations
// of those of another event unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations, we need to copy the custom
// modifiers that are in the signatures of the overridden/implemented event accessors.
// (From source, we know that there can only be one overridden/implemented event, so there
// are no conflicts.) This is unnecessary for implicit implementations because, if the custom
// modifiers don't match, we'll insert bridge methods for the accessors (explicit implementations
// that delegate to the implicit implementations) with the correct custom modifiers
// (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
// Note: we're checking if the syntax indicates explicit implementation rather,
// than if explicitInterfaceType is null because we don't want to look for an
// overridden event if this is supposed to be an explicit implementation.
if (!isExplicitInterfaceImplementation)
{
// If this event is an override, we may need to copy custom modifiers from
// the overridden event (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
if (this.IsOverride)
{
EventSymbol overriddenEvent = this.OverriddenEvent;
if ((object)overriddenEvent != null)
{
CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly);
}
}
}
else if ((object)explicitlyImplementedEvent != null)
{
CopyEventCustomModifiers(explicitlyImplementedEvent, ref _type, ContainingAssembly);
}
AccessorDeclarationSyntax addSyntax = null;
AccessorDeclarationSyntax removeSyntax = null;
foreach (AccessorDeclarationSyntax accessor in syntax.AccessorList.Accessors)
{
switch (accessor.Kind())
{
case SyntaxKind.AddAccessorDeclaration:
if (addSyntax == null)
{
addSyntax = accessor;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.RemoveAccessorDeclaration:
if (removeSyntax == null)
{
removeSyntax = accessor;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
diagnostics.Add(ErrorCode.ERR_AddOrRemoveExpected, accessor.Keyword.GetLocation());
break;
case SyntaxKind.UnknownAccessorDeclaration:
// Don't need to handle UnknownAccessorDeclaration. An error will have
// already been produced for it in the parser.
break;
default:
throw ExceptionUtilities.UnexpectedValue(accessor.Kind());
}
}
_addMethod = CreateAccessorSymbol(addSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
_removeMethod = CreateAccessorSymbol(removeSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
if (containingType.IsInterfaceType())
{
if (addSyntax == null && removeSyntax == null) //NOTE: AND - different error code produced if one is present
{
// CONSIDER: we're matching dev10, but it would probably be more helpful to give
// an error like ERR_EventPropertyInInterface.
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
else
{
if (addSyntax == null || removeSyntax == null)
{
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
_explicitInterfaceImplementations =
(object)explicitlyImplementedEvent == null ?
ImmutableArray <EventSymbol> .Empty :
ImmutableArray.Create <EventSymbol>(explicitlyImplementedEvent);
}
internal SourceCustomEventSymbol(SourceMemberContainerTypeSymbol containingType, Binder binder, EventDeclarationSyntax syntax, DiagnosticBag diagnostics) :
base(containingType, syntax, syntax.Modifiers, isFieldLike: false,
interfaceSpecifierSyntaxOpt: syntax.ExplicitInterfaceSpecifier,
nameTokenSyntax: syntax.Identifier, diagnostics: diagnostics)
{
ExplicitInterfaceSpecifierSyntax interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
SyntaxToken nameToken = syntax.Identifier;
bool isExplicitInterfaceImplementation = interfaceSpecifier != null;
string aliasQualifierOpt;
_name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(binder, interfaceSpecifier, nameToken.ValueText, diagnostics, out _explicitInterfaceType, out aliasQualifierOpt);
_type = BindEventType(binder, syntax.Type, diagnostics);
var explicitlyImplementedEvent = this.FindExplicitlyImplementedEvent(_explicitInterfaceType, nameToken.ValueText, interfaceSpecifier, diagnostics);
this.FindExplicitlyImplementedMemberVerification(explicitlyImplementedEvent, diagnostics);
// The runtime will not treat the accessors of this event as overrides or implementations
// of those of another event unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations, we need to copy the custom
// modifiers that are in the signatures of the overridden/implemented event accessors.
// (From source, we know that there can only be one overridden/implemented event, so there
// are no conflicts.) This is unnecessary for implicit implementations because, if the custom
// modifiers don't match, we'll insert bridge methods for the accessors (explicit implementations
// that delegate to the implicit implementations) with the correct custom modifiers
// (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
// Note: we're checking if the syntax indicates explicit implementation rather,
// than if explicitInterfaceType is null because we don't want to look for an
// overridden event if this is supposed to be an explicit implementation.
if (!isExplicitInterfaceImplementation)
{
// If this event is an override, we may need to copy custom modifiers from
// the overridden event (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
if (this.IsOverride)
{
EventSymbol overriddenEvent = this.OverriddenEvent;
if ((object)overriddenEvent != null)
{
CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly);
}
}
}
else if ((object)explicitlyImplementedEvent != null)
{
CopyEventCustomModifiers(explicitlyImplementedEvent, ref _type, ContainingAssembly);
}
AccessorDeclarationSyntax addSyntax = null;
AccessorDeclarationSyntax removeSyntax = null;
if (syntax.AccessorList != null)
{
foreach (AccessorDeclarationSyntax accessor in syntax.AccessorList.Accessors)
{
bool checkBody = false;
switch (accessor.Kind())
{
case SyntaxKind.AddAccessorDeclaration:
if (addSyntax == null)
{
addSyntax = accessor;
checkBody = true;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.RemoveAccessorDeclaration:
if (removeSyntax == null)
{
removeSyntax = accessor;
checkBody = true;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
diagnostics.Add(ErrorCode.ERR_AddOrRemoveExpected, accessor.Keyword.GetLocation());
break;
case SyntaxKind.UnknownAccessorDeclaration:
// Don't need to handle UnknownAccessorDeclaration. An error will have
// already been produced for it in the parser.
break;
default:
throw ExceptionUtilities.UnexpectedValue(accessor.Kind());
}
if (checkBody && !IsAbstract && accessor.Body == null && accessor.ExpressionBody == null && accessor.SemicolonToken.Kind() == SyntaxKind.SemicolonToken)
{
diagnostics.Add(ErrorCode.ERR_AddRemoveMustHaveBody, accessor.SemicolonToken.GetLocation());
}
}
if (IsAbstract)
{
if (!syntax.AccessorList.OpenBraceToken.IsMissing)
{
diagnostics.Add(ErrorCode.ERR_AbstractEventHasAccessors, syntax.AccessorList.OpenBraceToken.GetLocation(), this);
}
}
else if ((addSyntax == null || removeSyntax == null) && (!syntax.AccessorList.OpenBraceToken.IsMissing || !isExplicitInterfaceImplementation))
{
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
else if (isExplicitInterfaceImplementation && !IsAbstract)
{
diagnostics.Add(ErrorCode.ERR_ExplicitEventFieldImpl, this.Locations[0]);
}
if (isExplicitInterfaceImplementation && IsAbstract && syntax.AccessorList == null)
{
Debug.Assert(containingType.IsInterface);
Binder.CheckFeatureAvailability(syntax, MessageID.IDS_DefaultInterfaceImplementation, diagnostics, this.Locations[0]);
if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)
{
diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, this.Locations[0]);
}
_addMethod = new SynthesizedEventAccessorSymbol(this, isAdder: true, explicitlyImplementedEvent, aliasQualifierOpt);
_removeMethod = new SynthesizedEventAccessorSymbol(this, isAdder: false, explicitlyImplementedEvent, aliasQualifierOpt);
}
else
{
_addMethod = CreateAccessorSymbol(addSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
_removeMethod = CreateAccessorSymbol(removeSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
}
_explicitInterfaceImplementations =
(object)explicitlyImplementedEvent == null ?
ImmutableArray <EventSymbol> .Empty :
ImmutableArray.Create <EventSymbol>(explicitlyImplementedEvent);
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
_members.Add(node);
}
/// <summary> /// Given a syntax node that declares a (custom) event, get the corresponding event symbol. /// </summary> /// <param name="declarationSyntax">The syntax node that declares a event.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The symbol that was declared.</returns> public abstract IEventSymbol GetDeclaredSymbol(EventDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
ConditionalStore(GetDeclaredSymbol(node), IsRemovableMember);
base.VisitEventDeclaration(node);
}
public override SyntaxNode VisitEventDeclaration(EventDeclarationSyntax node)
{
//Note:Event with body(add/remove method)
//Extend:May add support depend on template, e.g. enyo
this.AppendCompileIssue(node, IssueType.Error, IssueId.EventNotSupport);
return node;
}
private static void AppendMethodIdentifier(EventDeclarationSyntax syntax, StringBuilder builder)
{
builder.Append(syntax.Identifier.ValueText);
}
private static void AppendMethodIdentifier(EventDeclarationSyntax syntax, StringBuilder builder)
{
builder.Append(syntax.Identifier.ValueText);
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
VisitAttributeLists(node.AttributeLists);
//base.VisitEventDeclaration(node);
}
/// <summary>
/// Given a syntax node that declares a (custom) event, get the corresponding event symbol.
/// </summary>
/// <param name="declarationSyntax">The syntax node that declares a event.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The symbol that was declared.</returns>
public override IEventSymbol GetDeclaredSymbol(EventDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
return (IEventSymbol)GetDeclaredMemberSymbol(declarationSyntax);
}
public override void VisitEventDeclaration(EventDeclarationSyntax node)
{
LogicalLineCount++;
base.VisitEventDeclaration(node);
}
