/// <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 bool GetIsUnsafe(IEventSymbol @event)
 {
     return GetIsUnsafe(GetInfo(@event));
 }

 public static void Attach(IEventSymbol @event, bool isUnsafe)
 {
     var info = new CodeGenerationEventInfo(isUnsafe);
     s_eventToInfoMap.Add(@event, info);
 }

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

 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 bool HaveSameSignature(IEventSymbol event1, IEventSymbol event2, bool caseSensitive)
 {
     return IdentifiersMatch(event1.Name, event2.Name, caseSensitive);
 }

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

 private bool HaveSameReturnType(IEventSymbol ev1, IEventSymbol ev2)
 {
     return this.SignatureTypeEquivalenceComparer.Equals(ev1.Type, ev2.Type);
 }

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

 public static void Create(IEventSymbol symbol, SymbolKeyWriter visitor)
 {
     visitor.WriteString(symbol.MetadataName);
     visitor.WriteSymbolKey(symbol.ContainingType);
 }

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