public static void Go(OutputWriter writer, EventFieldDeclarationSyntax field)
{
foreach (var declaration in field.Declaration.Variables)
{
Go(writer, field, field.Modifiers,
WriteIdentifierName.TransformIdentifier(declaration.Identifier.Text),
field.Declaration.Type, declaration.Initializer,field.IsThreadStatic());
}
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
var eventDeclaration = node.Declaration;
var @event = new Event(
(ITypeSymbol)_semantic.GetSymbolInfo(eventDeclaration.Type).Symbol,
eventDeclaration.Variables.ToString())
{
IsOverride = node.Modifiers.Any(x => x.IsKind(SyntaxKind.OverrideKeyword)),
IsAbstract = node.Modifiers.Any(x => x.IsKind(SyntaxKind.AbstractKeyword))
};
_events.AddEvent(@event);
}
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 async Task<Document> ImplementVirtualRaiseEventFieldAsync(Document document, EventFieldDeclarationSyntax declaration, CancellationToken c)
{
var eventName = declaration.Declaration.Variables.Single().Identifier.ValueText;
var raiseMethod = CreateRaiseMethod(eventName, eventName,
(declaration.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<EventFieldDeclarationSyntax>().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 void WriteThreadStatic(OutputWriter writer, VariableDeclaratorSyntax declaration,
EventFieldDeclarationSyntax field)
{
var type = TypeProcessor.ConvertType(field.Declaration.Type);
throw new NotImplementedException("ThreadStatic");
}
public override void VisitEventFieldDeclaration (EventFieldDeclarationSyntax node)
{
base.VisitEventFieldDeclaration (node);
foreach (var v in node.Declaration.Variables)
Append (v);
}
public void Add(EventFieldDeclarationSyntax node)
{
/*
// Summary:
// Gets the attribute declaration list.
public override SyntaxList<AttributeListSyntax> AttributeLists { get; }
public override VariableDeclarationSyntax Declaration { get; }
public SyntaxToken EventKeyword { get; }
//
// Summary:
// Gets the modifier list.
public override SyntaxTokenList Modifiers { get; }
public override SyntaxToken SemicolonToken { get; }
*/
// add field info
Add(node.Modifiers, node.Declaration);
/*
// Summary:
// Gets the attribute declaration list.
public override SyntaxList<AttributeListSyntax> AttributeLists { get; }
public override VariableDeclarationSyntax Declaration { get; }
//
// Summary:
// Gets the modifier list.
public override SyntaxTokenList Modifiers { get; }
public override SyntaxToken SemicolonToken { get; }
*/
// add to metadata for runtime type building
FlatArrayBuilder fab = new FlatArrayBuilder();
fab.Add(FlatValue.Int32(node.Modifiers.ToString().Contains("static") ? (int)ClassMemberType.StaticField : (int)ClassMemberType.Field));
TypeInfo ti = Model.GetTypeInfo(node.Declaration.Type);
fab.Add(FlatValue.String(ti.ConvertedType.GetFullyQualifiedName()));
{
FlatArrayBuilder varList = new FlatArrayBuilder();
foreach (VariableDeclaratorSyntax vds in node.Declaration.Variables)
{
if (vds.ArgumentList != null)
{
throw new NotImplementedException("VariableDeclaratorSyntax with ArgumentList");
}
varList.Add(FlatValue.String(vds.Identifier.ToString()));
}
fab.Add(varList.GetFlatValue());
}
Members.Add(fab.GetFlatValue());
}
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;
}
public override SyntaxNode VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
if (node == null)
return null;
//var symbol = m_model.GetDeclaredSymbol(node);
var symbol = m_model.GetDeclaredSymbol(node.Declaration.Variables.First());
node = (EventFieldDeclarationSyntax)base.VisitEventFieldDeclaration(node);
if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
node = (EventFieldDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
return node;
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
if (IsIgnoreMember(node.Modifiers)) { return; }
var modifiers = GetMemberModifiersText(node.Modifiers);
var name = string.Join(",", node.Declaration.Variables.Select(v => v.Identifier));
var typeName = node.Declaration.Type.ToString();
WriteLine($"{modifiers} <<{node.EventKeyword}>> {name} : {typeName} ");
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
base.VisitEventFieldDeclaration(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitEventFieldDeclaration(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitEventFieldDeclaration(node);
}
private static EventNode GetEventNode(EventFieldDeclarationSyntax evnt)
{
EventNode eventnode = new EventNode();
eventnode.Name = evnt.EventKeyword.ToString();
eventnode.Modifier = evnt.Modifiers.ToString();
return eventnode;
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node.Declaration.Variables.FirstOrDefault()));
}
public override VisualBasicSyntaxNode VisitEventFieldDeclaration(CSS.EventFieldDeclarationSyntax node)
{
return(base.VisitEventFieldDeclaration(node));
}
private static Document GetTransformedDocumentForEventFieldDeclaration(Document document, Diagnostic diagnostic, SyntaxNode root, SemanticModel semanticModel, EventFieldDeclarationSyntax eventFieldDeclaration, CancellationToken cancellationToken)
{
if (!eventFieldDeclaration.Modifiers.Any(SyntaxKind.OverrideKeyword))
{
ISymbol declaredSymbol = null;
VariableDeclaratorSyntax firstVariable = eventFieldDeclaration.Declaration?.Variables.FirstOrDefault();
if (firstVariable != null)
{
declaredSymbol = semanticModel.GetDeclaredSymbol(firstVariable, cancellationToken);
}
if (declaredSymbol == null || !NamedTypeHelpers.IsImplementingAnInterfaceMember(declaredSymbol))
{
return document;
}
}
return InsertInheritdocComment(document, diagnostic, root, eventFieldDeclaration, cancellationToken);
}
public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
Debug.Assert(currentScope == null);
DeclarationScope initScope = node.Modifiers.Any(SyntaxKind.StaticKeyword) ? staticInitScope : instanceInitScope;
foreach (VariableDeclaratorSyntax declarator in node.Declaration.Variables)
{
currentScope = initScope ?? new DeclarationScope(null);
Visit(declarator.Initializer);
currentScope = null;
}
}
private static SyntaxNode HandleEventFieldDeclaration(EventFieldDeclarationSyntax 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 VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
{
AsChild(node, node.Declaration.Variables.First().Identifier.Text, node.Declaration.Variables.First().Identifier.GetLocation());
}
