/// <summary> /// Creates an event symbol that can be used to describe an event declaration. /// </summary> public static IEventSymbol CreateEventSymbol( IList<AttributeData> attributes, Accessibility accessibility, DeclarationModifiers modifiers, ITypeSymbol type, IEventSymbol explicitInterfaceSymbol, string name, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null, IMethodSymbol raiseMethod = null) { var result = new CodeGenerationEventSymbol(null, attributes, accessibility, modifiers, type, explicitInterfaceSymbol, name, addMethod, removeMethod, raiseMethod); CodeGenerationEventInfo.Attach(result, modifiers.IsUnsafe); return result; }
protected override void ReadSymbol(IEventSymbol eventSymbol) { var @event = new Event(eventSymbol.Type, eventSymbol.Name) { IsAbstract = eventSymbol.IsAbstract, IsOverride = eventSymbol.IsOverride, IsInternal = eventSymbol.DeclaredAccessibility.HasFlag(Accessibility.Internal), Documentation = new DocumentationComment(eventSymbol.GetDocumentationCommentXml()) }; _events.AddEvent(@event); }
public override void VisitEvent(IEventSymbol symbol) { if (_finished || _symbolPredicate == null || _symbolPredicate(symbol)) { AddDocumentForMember(symbol, true, new[] { Metadata.Create(MetadataKeys.SpecificKind, (k, m) => symbol.Kind.ToString()), Metadata.Create(MetadataKeys.Type, DocumentFor(symbol.Type)), Metadata.Create(MetadataKeys.Overridden, DocumentFor(symbol.OverriddenEvent)) }); } }
private SDEvent GetParsedEvent(IEventSymbol eve) { var sdEvent = new SDEvent(eve.GetIdentifier()) { Name = eve.Name, DeclaringType = _typeRefParser.GetParsedTypeReference(eve.ContainingType), Accessibility = eve.DeclaredAccessibility.ToString().ToLower(), Documentations = DocumentationParser.ParseDocumentation(eve) }; ParserOptions.SDRepository.AddMember(sdEvent); return sdEvent; }
internal static CompilationUnitSyntax AddEventTo( CompilationUnitSyntax destination, IEventSymbol @event, CodeGenerationOptions options, IList<bool> availableIndices) { var declaration = GenerateEventDeclaration(@event, CodeGenerationDestination.CompilationUnit, options); // Place the event depending on its shape. Field style events go with fields, property // style events go with properties. If there var members = Insert(destination.Members, declaration, options, availableIndices, after: list => AfterMember(list, declaration), before: list => BeforeMember(list, declaration)); return destination.WithMembers(members.ToSyntaxList()); }
internal static TypeDeclarationSyntax AddEventTo( TypeDeclarationSyntax destination, IEventSymbol @event, CodeGenerationOptions options, IList<bool> availableIndices) { var declaration = GenerateEventDeclaration(@event, GetDestination(destination), options); var members = Insert(destination.Members, declaration, options, availableIndices, after: list => AfterMember(list, declaration), before: list => BeforeMember(list, declaration)); // Find the best place to put the field. It should go after the last field if we already // have fields, or at the beginning of the file if we don't. return AddMembersTo(destination, members); }
private SDEvent GetParsedEvent(IEventSymbol eve) { var syntaxReference = eve.DeclaringSyntaxReferences.Any() ? eve.DeclaringSyntaxReferences.Single() : null; var sdEvent = new SDEvent(eve.GetIdentifier()) { Name = eve.Name, DeclaringType = _typeRefParser.GetParsedTypeReference(eve.ContainingType), Accessibility = eve.DeclaredAccessibility.ToString().ToLower(), Documentations = DocumentationParser.ParseDocumentation(eve), Region = syntaxReference != null ? new SDRegion { Start = syntaxReference.Span.Start, StartLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).StartLinePosition.Line + 1, EndLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).EndLinePosition.Line + 1, End = syntaxReference.Span.End, FilePath = syntaxReference.SyntaxTree.FilePath, Filename = Path.GetFileName(syntaxReference.SyntaxTree.FilePath) } : null }; ParserOptions.SDRepository.AddMember(sdEvent); return sdEvent; }
public static void Attach(IEventSymbol @event, bool isUnsafe) { var info = new CodeGenerationEventInfo(isUnsafe); s_eventToInfoMap.Add(@event, info); }
public static bool Equals(IEventSymbol _, IEventSymbol __) => throw new InvalidOperationException("This is hidden so that it is not called by accident.");
internal bool IsCs2DslSymbol(IEventSymbol sym) { return(sym.ContainingAssembly == m_AssemblySymbol && !m_ExternTypes.ContainsKey(ClassInfo.SpecialGetFullTypeName(sym.ContainingType, true))); }
private static async Task <GraphNode> GetOrCreateNodeForEventAsync(Graph graph, IEventSymbol eventSymbol, Solution solution, CancellationToken cancellationToken) { var id = await GraphNodeIdCreation.GetIdForMemberAsync(eventSymbol, solution, cancellationToken).ConfigureAwait(false); var node = graph.Nodes.GetOrCreate(id); node.AddCategory(CodeNodeCategories.Event); node[DgmlNodeProperties.Icon] = IconHelper.GetIconName("Event", eventSymbol.DeclaredAccessibility); node[RoslynGraphProperties.TypeKind] = eventSymbol.ContainingType.TypeKind; return(node); }
private string GetEventSyntax(IEventSymbol symbol, IFilterVisitor filterVisitor) { ExplicitInterfaceSpecifierSyntax eii = null; if (symbol.ExplicitInterfaceImplementations.Length > 0) { eii = SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.ParseName(GetEiiContainerTypeName(symbol, filterVisitor))); } return RemoveBraces( SyntaxFactory.EventDeclaration( GetAttributes(symbol, filterVisitor), SyntaxFactory.TokenList(GetMemberModifiers(symbol)), SyntaxFactory.Token(SyntaxKind.EventKeyword), GetTypeSyntax(symbol.Type), eii, SyntaxFactory.Identifier(GetMemberName(symbol, filterVisitor)), SyntaxFactory.AccessorList() ).NormalizeWhitespace().ToString() ); }
internal static IEventSymbol CreateEventSymbol( IEventSymbol @event, IList<AttributeData> attributes = null, Accessibility? accessibility = null, DeclarationModifiers? modifiers = null, IEventSymbol explicitInterfaceSymbol = null, string name = null, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null) { return CodeGenerationSymbolFactory.CreateEventSymbol( attributes, accessibility ?? @event.DeclaredAccessibility, modifiers ?? @event.GetSymbolModifiers(), @event.Type, explicitInterfaceSymbol, name ?? @event.Name, addMethod, removeMethod); }
public WrappedEventSymbol(IEventSymbol eventSymbol, bool canImplementImplicitly, IDocumentationCommentFormattingService docCommentFormattingService) : base(eventSymbol, canImplementImplicitly, docCommentFormattingService) { _symbol = eventSymbol; }
public abstract SyntaxNode CreateEventDeclaration(IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options);
private static IEnumerable<SyntaxToken> GetMemberModifiers(IEventSymbol symbol) { if (symbol.ContainingType.TypeKind != TypeKind.Interface) { switch (symbol.DeclaredAccessibility) { case Accessibility.Protected: case Accessibility.ProtectedOrInternal: yield return SyntaxFactory.Token(SyntaxKind.ProtectedKeyword); break; case Accessibility.Public: yield return SyntaxFactory.Token(SyntaxKind.PublicKeyword); break; case Accessibility.ProtectedAndInternal: case Accessibility.Internal: case Accessibility.Private: default: break; } } if (symbol.IsStatic) { yield return SyntaxFactory.Token(SyntaxKind.StaticKeyword); } if (symbol.IsAbstract && symbol.ContainingType.TypeKind != TypeKind.Interface) { yield return SyntaxFactory.Token(SyntaxKind.AbstractKeyword); } if (symbol.IsVirtual) { yield return SyntaxFactory.Token(SyntaxKind.VirtualKeyword); } if (symbol.IsOverride) { yield return SyntaxFactory.Token(SyntaxKind.OverrideKeyword); } if (symbol.IsSealed) { yield return SyntaxFactory.Token(SyntaxKind.SealedKeyword); } }
private string GetEventPrototype(IEventSymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. flags = PrototypeFlags.FullName | PrototypeFlags.Type; } var builder = new StringBuilder(); AppendEventPrototype(builder, symbol, flags, symbol.Name); return builder.ToString(); }
private static string GetEiiContainerTypeName(IEventSymbol symbol, IFilterVisitor filterVisitor) { if (symbol.ExplicitInterfaceImplementations.Length == 0) { return null; } for (int i = 0; i < symbol.ExplicitInterfaceImplementations.Length; i++) { if (filterVisitor.CanVisitApi(symbol.ExplicitInterfaceImplementations[i])) { return NameVisitorCreator.GetCSharp(NameOptions.UseAlias | NameOptions.WithGenericParameter).GetName(symbol.ExplicitInterfaceImplementations[i].ContainingType); } } Debug.Fail("Should not be here!"); return null; }
private void AppendEventPrototype(StringBuilder builder, IEventSymbol symbol, PrototypeFlags flags, string baseName) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.Type)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype(builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype(builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: builder.Append(baseName); break; } }
public override SyntaxNode CreateEventDeclaration( IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options) { return(EventGenerator.GenerateEventDeclaration(@event, destination, options)); }
/// <summary> /// Field-like events can be used as fields in types that can access private /// members of the declaring type of the event. /// </summary> public new bool IsEventUsableAsField(int position, IEventSymbol eventSymbol) { var csymbol = (EventSymbol)eventSymbol; return !ReferenceEquals(eventSymbol, null) && csymbol.HasAssociatedField && this.IsAccessible(position, csymbol.AssociatedField); //calls CheckAndAdjustPosition }
public bool IsMatch(IEventSymbol symbol) { return(GetReason(symbol) == SymbolFilterReason.None); }
protected sealed override bool IsEventUsableAsFieldCore(int position, IEventSymbol symbol) { return this.IsEventUsableAsField(position, symbol.EnsureCSharpSymbolOrNull<IEventSymbol, EventSymbol>("symbol")); }
internal EventSymbolKey(IEventSymbol symbol, Visitor visitor) { this.containerKey = GetOrCreate(symbol.ContainingType, visitor); this.metadataName = symbol.MetadataName; }
private static bool CheckTypeParameterInEvent(ITypeParameterSymbol typeParameter, VarianceKind variance, IEventSymbol @event) { return CanTypeParameterBeVariant( typeParameter, variance, @event.Type, false, true, @event); }
public static bool GetIsUnsafe(IEventSymbol @event) { return GetIsUnsafe(GetInfo(@event)); }
/// <summary> /// Field-like events can be used as fields in types that can access private /// members of the declaring type of the event. /// </summary> /// <remarks> /// Always false for VB events. /// </remarks> public bool IsEventUsableAsField(int position, IEventSymbol eventSymbol) { return IsEventUsableAsFieldCore(position, eventSymbol); }
public static bool GetIsUnsafe(IEventSymbol @event) { return(GetIsUnsafe(GetInfo(@event))); }
/// <summary> /// Field-like events can be used as fields in types that can access private /// members of the declaring type of the event. /// </summary> /// <remarks> /// Always false for VB events. /// </remarks> protected abstract bool IsEventUsableAsFieldCore(int position, IEventSymbol eventSymbol);
protected abstract TDeclarationNode AddEvent <TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions options, IList <bool> availableIndices) where TDeclarationNode : SyntaxNode;
public override IEntity VisitEvent(IEventSymbol symbol) => Event.Create(cx, symbol);
/// <summary> /// Create a new solution where the declaration of the destination symbol has an additional event of the same signature as the specified event symbol. /// Returns the document in the new solution where the destination symbol is declared. /// </summary> public static Task <Document> AddEventDeclarationAsync(Solution solution, INamedTypeSymbol destination, IEventSymbol @event, CodeGenerationOptions options = default(CodeGenerationOptions), CancellationToken cancellationToken = default(CancellationToken)) { return(GetCodeGenerationService(solution.Workspace, destination.Language).AddEventAsync(solution, destination, @event, options, cancellationToken)); }
public override void GenerateEvent(IEventSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter) { base.GenerateEvent(symbol, item, adapter); var modifiers = new List<string>(); if (symbol.ContainingType.TypeKind != TypeKind.Interface) { var visiblity = GetVisiblity(symbol.DeclaredAccessibility); if (visiblity != null) { modifiers.Add(visiblity); } if (symbol.IsStatic) { modifiers.Add("static"); } if (symbol.IsAbstract) { modifiers.Add("abstract"); } if (symbol.IsOverride) { modifiers.Add("override"); } if (symbol.IsVirtual && symbol.IsSealed) { } else if (symbol.IsVirtual) { modifiers.Add("virtual"); } else if (symbol.IsSealed) { modifiers.Add("sealed"); } } item.Modifiers[SyntaxLanguage.CSharp] = modifiers; }
/// <summary> /// Returns a newly created event declaration node from the provided event. /// </summary> public static SyntaxNode CreateEventDeclaration(IEventSymbol @event, Workspace workspace, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified, CodeGenerationOptions options = null) { return(GetCodeGenerationService(workspace, @event.Language).CreateEventDeclaration(@event, destination, options)); }
private static string GetMemberName(IEventSymbol symbol, IFilterVisitor filterVisitor) { string name = symbol.Name; if (symbol.ExplicitInterfaceImplementations.Length == 0) { return symbol.Name; } for (int i = 0; i < symbol.ExplicitInterfaceImplementations.Length; i++) { if (filterVisitor.CanVisitApi(symbol.ExplicitInterfaceImplementations[i])) { return symbol.ExplicitInterfaceImplementations[i].Name; } } Debug.Fail("Should not be here!"); return symbol.Name; }
/// <summary> /// Create a new declaration node with an event declaration of the same signature as the specified symbol added to it. /// </summary> public static TDeclarationNode AddEventDeclaration <TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, Workspace workspace, CodeGenerationOptions options = default(CodeGenerationOptions)) where TDeclarationNode : SyntaxNode { return(GetCodeGenerationService(workspace, destination.Language).AddEvent(destination, @event, options)); }
private int CombineHashCodes(IEventSymbol x, int currentHash) { return (Hash.Combine(x.Name, GetHashCode(x.ContainingSymbol, currentHash))); }
public Task <Document> AddEventAsync(Solution solution, INamedTypeSymbol destination, IEventSymbol @event, CodeGenerationOptions options, CancellationToken cancellationToken) { return(GetEditAsync( solution, destination, (t, opts, ai) => AddEvent(t, @event, opts, ai), options, new[] { @event }, cancellationToken)); }
protected abstract void BuildEventDeclaration(IEventSymbol eventSymbol, _VSOBJDESCOPTIONS options);
private bool HaveSameReturnType(IEventSymbol ev1, IEventSymbol ev2) { return(this.SignatureTypeEquivalenceComparer.Equals(ev1.Type, ev2.Type)); }
protected override TDeclarationNode AddEvent <TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions options, IList <bool> availableIndices) { CheckDeclarationNode <TypeDeclarationSyntax>(destination); return(Cast <TDeclarationNode>(EventGenerator.AddEventTo(Cast <TypeDeclarationSyntax>(destination), @event, options, availableIndices))); }
private bool HaveSameSignature(IEventSymbol event1, IEventSymbol event2, bool caseSensitive) { return(IdentifiersMatch(event1.Name, event2.Name, caseSensitive)); }
public override object VisitEvent(IEventSymbol eventSymbol) { WriteType(SymbolKeyType.Event); EventSymbolKey.Create(eventSymbol, this); return(null); }
// public TooltipInformation GetAliasedNamespaceTooltip (AliasNamespaceResolveResult resolveResult) // { // var result = new TooltipInformation (); // result.SignatureMarkup = GetMarkup (resolveResult.Namespace); // result.AddCategory (GettextCatalog.GetString ("Alias information"), GettextCatalog.GetString ("Resolved using alias '{0}'", resolveResult.Alias)); // return result; // } // // public TooltipInformation GetAliasedTypeTooltip (AliasTypeResolveResult resolveResult) // { // var result = new TooltipInformation (); // result.SignatureMarkup = GetTypeMarkup (resolveResult.Type, true); // result.AddCategory (GettextCatalog.GetString ("Alias information"), GettextCatalog.GetString ("Resolved using alias '{0}'", resolveResult.Alias)); // return result; // } string GetEventMarkup (IEventSymbol evt) { if (evt == null) throw new ArgumentNullException ("evt"); var result = new StringBuilder (); AppendModifiers (result, evt); result.Append (Highlight ("event ", colorStyle.KeywordModifiers)); result.Append (GetTypeReferenceString (evt.Type)); if (BreakLineAfterReturnType) { result.AppendLine (); } else { result.Append (" "); } AppendExplicitInterfaces (result, evt.ExplicitInterfaceImplementations.Cast<ISymbol> ()); result.Append (HighlightSemantically (FilterEntityName (evt.Name), colorStyle.UserEventDeclaration)); return result.ToString (); }
public override void VisitEventDeclaration(EventDeclarationSyntax node) { var ci = m_ClassInfoStack.Peek(); IEventSymbol declSym = m_Model.GetDeclaredSymbol(node); if (null != declSym) { string require = ClassInfo.GetAttributeArgument <string>(declSym, "Cs2Lua.RequireAttribute", 0); if (!string.IsNullOrEmpty(require)) { SymbolTable.Instance.AddRequire(ci.Key, require); } if (ClassInfo.HasAttribute(declSym, "Cs2Lua.IgnoreAttribute")) { return; } if (declSym.IsAbstract) { return; } } StringBuilder curBuilder = ci.CurrentCodeBuilder; if (declSym.IsStatic) { ci.CurrentCodeBuilder = ci.StaticFunctionCodeBuilder; } else { ci.CurrentCodeBuilder = ci.InstanceFunctionCodeBuilder; } foreach (var accessor in node.AccessorList.Accessors) { var sym = m_Model.GetDeclaredSymbol(accessor); if (null != sym) { var mi = new MethodInfo(); mi.Init(sym, accessor); m_MethodInfoStack.Push(mi); string manglingName = NameMangling(sym); string keyword = accessor.Keyword.Text; string paramStr = string.Join(", ", mi.ParamNames.ToArray()); if (!declSym.IsStatic) { if (string.IsNullOrEmpty(paramStr)) { paramStr = "this"; } else { paramStr = "this, " + paramStr; } } CodeBuilder.AppendFormat("{0}{1} = function({2})", GetIndentString(), manglingName, paramStr); CodeBuilder.AppendLine(); ++m_Indent; bool isStatic = declSym.IsStatic; string luaModule = ClassInfo.GetAttributeArgument <string>(sym, "Cs2Lua.TranslateToAttribute", 0); string luaFuncName = ClassInfo.GetAttributeArgument <string>(sym, "Cs2Lua.TranslateToAttribute", 1); if (!string.IsNullOrEmpty(luaModule) || !string.IsNullOrEmpty(luaFuncName)) { if (!string.IsNullOrEmpty(luaModule)) { SymbolTable.Instance.AddRequire(ci.Key, luaModule); } if (sym.ReturnsVoid && mi.ReturnParamNames.Count <= 0) { CodeBuilder.AppendFormat("{0}{1}({2}", GetIndentString(), luaFuncName, isStatic ? string.Empty : "this"); } else { CodeBuilder.AppendFormat("{0}return {1}({2}", GetIndentString(), luaFuncName, isStatic ? string.Empty : "this"); } if (mi.ParamNames.Count > 0) { if (!isStatic) { CodeBuilder.Append(", "); } CodeBuilder.Append(string.Join(", ", mi.ParamNames.ToArray())); } CodeBuilder.AppendLine(");"); } else if (null != accessor.Body) { if (mi.ValueParams.Count > 0) { OutputWrapValueParams(CodeBuilder, mi); } VisitBlock(accessor.Body); } --m_Indent; CodeBuilder.AppendFormat("{0}end,", GetIndentString()); CodeBuilder.AppendLine(); m_MethodInfoStack.Pop(); } } ci.CurrentCodeBuilder = curBuilder; CodeBuilder.AppendFormat("{0}{1} = {{", GetIndentString(), SymbolTable.GetEventName(declSym)); CodeBuilder.AppendLine(); ++m_Indent; foreach (var accessor in node.AccessorList.Accessors) { var sym = m_Model.GetDeclaredSymbol(accessor); if (null != sym) { string manglingName = NameMangling(sym); string keyword = accessor.Keyword.Text; CodeBuilder.AppendFormat("{0}{1} = {2}.{3},", GetIndentString(), keyword, declSym.IsStatic ? "static_methods" : "instance_methods", manglingName); CodeBuilder.AppendLine(); } } --m_Indent; CodeBuilder.AppendFormat("{0}", GetIndentString()); CodeBuilder.AppendLine("},"); }
public virtual void VisitEvent(IEventSymbol symbol) { DefaultVisit(symbol); }
public virtual TResult?VisitEvent(IEventSymbol symbol) { return(DefaultVisit(symbol)); }
private bool HaveSameReturnType(IEventSymbol ev1, IEventSymbol ev2) { return this.SignatureTypeEquivalenceComparer.Equals(ev1.Type, ev2.Type); }
public static IEventSymbol OverrideEvent( this SyntaxGenerator codeFactory, IEventSymbol overriddenEvent, DeclarationModifiers modifiers, INamedTypeSymbol newContainingType) { return CodeGenerationSymbolFactory.CreateEventSymbol( overriddenEvent, attributes: null, accessibility: overriddenEvent.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, explicitInterfaceSymbol: null, name: overriddenEvent.Name); }
private bool HaveSameSignature(IEventSymbol event1, IEventSymbol event2, bool caseSensitive) { return IdentifiersMatch(event1.Name, event2.Name, caseSensitive); }
private static CodeGenerationEventInfo GetInfo(IEventSymbol @event) { CodeGenerationEventInfo info; s_eventToInfoMap.TryGetValue(@event, out info); return info; }
public static void Create(IEventSymbol symbol, SymbolKeyWriter visitor) { visitor.WriteString(symbol.MetadataName); visitor.WriteSymbolKey(symbol.ContainingType); }
public sealed override void VisitEvent(IEventSymbol symbol) { Visit(symbol.Type); Visit(symbol.ContainingSymbol); }
private static CodeGenerationEventInfo GetInfo(IEventSymbol @event) { s_eventToInfoMap.TryGetValue(@event, out var info); return(info); }
private bool EventsAreEquivalent(IEventSymbol x, IEventSymbol y, Dictionary <INamedTypeSymbol, INamedTypeSymbol> equivalentTypesWithDifferingAssemblies) { return (x.Name == y.Name && AreEquivalent(x.ContainingSymbol, y.ContainingSymbol, equivalentTypesWithDifferingAssemblies)); }
public override void VisitEvent(IEventSymbol symbol) { if (_finished || _symbolPredicate == null || _symbolPredicate(symbol)) { AddDocumentForMember(symbol, true, new MetadataItems { new MetadataItem(CodeAnalysisKeys.SpecificKind, (k, m) => symbol.Kind.ToString()), new MetadataItem(CodeAnalysisKeys.Type, DocumentFor(symbol.Type)), new MetadataItem(CodeAnalysisKeys.OverriddenMethod, DocumentFor(symbol.OverriddenEvent)), new MetadataItem(CodeAnalysisKeys.Accessibility, (k, m) => symbol.DeclaredAccessibility.ToString()) }); } }
public TDeclarationNode AddEvent <TDeclarationNode>(TDeclarationNode destination, IEventSymbol @event, CodeGenerationOptions options, CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode { return(AddEvent(destination, @event, options ?? CodeGenerationOptions.Default, GetAvailableInsertionIndices(destination, cancellationToken))); }