public override void LeaveEvent(Event node)
 {
     if (IsInterfaceMember(node))
         node.Modifiers = TypeMemberModifiers.Public | TypeMemberModifiers.Abstract;
     else if (!node.IsVisibilitySet)
         node.Modifiers |= Context.Parameters.DefaultEventVisibility;
     LeaveMember(node);
 }

 public override void LeaveEvent(Event node)
 {
     if (!node.IsVisibilitySet)
     {
         node.Modifiers |= TypeMemberModifiers.Public;
     }
     if (IsInterface(node.DeclaringType))
     {
         node.Modifiers |= TypeMemberModifiers.Abstract;
     }
     LeaveMember(node);
 }

        void BindEvent(Event node)
        {
            EnsureEntityFor(node);

            IType type = GetType(node.Type);
            IType declaringType = GetType(node.DeclaringType);
            bool typeIsCallable = type is ICallableType;
            if (!typeIsCallable)
            {
                Errors.Add(
                    CompilerErrorFactory.EventTypeIsNotCallable(node.Type,
                    type.ToString()));
            }

            if (declaringType.IsInterface)
            {
                BindInterfaceEvent(node);
            }
            else
            {
                BindClassEvent(node, type, typeIsCallable);
            }
        }

 public override void LeaveEvent(Event node)
 {
     CheckName(node,node.Name);
 }

	protected void event_declaration(
		TypeMemberCollection container
	) //throws RecognitionException, TokenStreamException
{
		
		IToken  t = null;
		IToken  id = null;
		
				Event e = null;
				TypeReference tr = null;
			
		
		try {      // for error handling
			t = LT(1);
			match(EVENT);
			id = LT(1);
			match(ID);
			match(AS);
			tr=type_reference();
			eos();
			if (0==inputState.guessing)
			{
				
						e = new Event(ToLexicalInfo(id), id.getText(), tr);
						e.Modifiers = _modifiers;
						AddAttributes(e.Attributes);
						container.Add(e);
					
			}
			docstring(e);
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "event_declaration");
				recover(ex,tokenSet_55_);
			}
			else
			{
				throw ex;
			}
		}
	}

 public override void OnEvent(Event node)
 {
     _emitter.EmitEventAttributes(node);
 }

        void DefineEvent(TypeBuilder typeBuilder, Event node)
        {
            EventBuilder builder = typeBuilder.DefineEvent(node.Name,
                                                           EventAttributes.None,
                                                           GetSystemType(node.Type));
            //MethodAttributes attribs = GetPropertyMethodAttributes(node);
            MethodAttributes baseAttributes = MethodAttributes.SpecialName;
            builder.SetAddOnMethod(DefineMethod(typeBuilder, node.Add, baseAttributes|GetMethodAttributes(node.Add)));
            builder.SetRemoveOnMethod(DefineMethod(typeBuilder, node.Remove, baseAttributes|GetMethodAttributes(node.Remove)));

            if (null != node.Raise)
            {
                builder.SetRaiseMethod(DefineMethod(typeBuilder, node.Raise, baseAttributes|GetMethodAttributes(node.Raise)));
            }

            SetBuilder(node, builder);
        }

 public override void LeaveEvent(Event node)
 {
     LeaveMember(node);
 }

 Method CreateInterfaceEventRemoveMethod(Event node)
 {
     return CreateInterfaceEventMethod(node, "remove_");
 }

		void DefineEvent(TypeBuilder typeBuilder, Event node)
		{
			var builder = typeBuilder.DefineEvent(node.Name, EventAttributes.None, GetSystemType(node.Type));
			builder.SetAddOnMethod(DefineEventMethod(typeBuilder, node.Add));
			builder.SetRemoveOnMethod(DefineEventMethod(typeBuilder, node.Remove));
			if (node.Raise != null)
				builder.SetRaiseMethod(DefineEventMethod(typeBuilder, node.Raise));
			SetBuilder(node, builder);
		}

		void EmitEventAttributes(Event node, TypeCreator knownTypes)
		{
			EventBuilder builder = (EventBuilder)GetBuilder(node);
			EmitAttributes(node, builder.SetCustomAttribute, knownTypes);
		}

			public override void OnEvent(Event node)
			{
				_emitter.EmitEventAttributes(node, this._knownTypes);
			}

 public InternalEvent(TypeSystemServices tagManager, Event event_)
 {
     _event = event_;
 }

		public object VisitEventDeclaration(EventDeclaration eventDeclaration, object data)
		{
			B.Event m = new B.Event(GetLexicalInfo(eventDeclaration));
			m.Name = eventDeclaration.Name;
			m.Modifiers = ConvertModifier(eventDeclaration, B.TypeMemberModifiers.Private);
			ConvertAttributes(eventDeclaration.Attributes, m.Attributes);
			if (currentType != null) currentType.Members.Add(m);
			m.EndSourceLocation = GetLocation(eventDeclaration.EndLocation);
			m.Type = ConvertTypeReference(eventDeclaration.TypeReference);
			if (eventDeclaration.InterfaceImplementations.Count > 0) {
				AddError(eventDeclaration, "Explicit interface implementation is not supported for events.");
			}
			if (eventDeclaration.Parameters.Count > 0) {
				AddError(eventDeclaration, "Events with parameters are not supported.");
			}
			if (eventDeclaration.HasAddRegion) {
				m.Add = new B.Method(GetLexicalInfo(eventDeclaration.AddRegion));
				ConvertAttributes(eventDeclaration.AddRegion.Attributes, m.Add.Attributes);
				m.Modifiers = ConvertModifier(eventDeclaration.AddRegion, m.Visibility);
				m.Add.Body = ConvertMethodBlock(eventDeclaration.AddRegion.Block);
			}
			if (eventDeclaration.HasRemoveRegion) {
				m.Remove = new B.Method(GetLexicalInfo(eventDeclaration.RemoveRegion));
				ConvertAttributes(eventDeclaration.RemoveRegion.Attributes, m.Remove.Attributes);
				m.Modifiers = ConvertModifier(eventDeclaration.RemoveRegion, m.Visibility);
				m.Remove.Body = ConvertMethodBlock(eventDeclaration.RemoveRegion.Block);
			}
			if (eventDeclaration.HasRaiseRegion) {
				m.Raise = new B.Method(GetLexicalInfo(eventDeclaration.RaiseRegion));
				ConvertAttributes(eventDeclaration.RaiseRegion.Attributes, m.Raise.Attributes);
				m.Modifiers = ConvertModifier(eventDeclaration.RaiseRegion, m.Visibility);
				m.Raise.Body = ConvertMethodBlock(eventDeclaration.RaiseRegion.Block);
			}
			return m;
		}

 private void BindInterfaceEvent(Event node)
 {
     if (null == node.Add)
         node.Add = CreateInterfaceEventAddMethod(node);
     if (null == node.Remove)
         node.Remove = CreateInterfaceEventRemoveMethod(node);
 }

 Method CreateInterfaceEventAddMethod(Event node)
 {
     return CreateInterfaceEventMethod(node, "add_");
 }

 Method CreateInterfaceEventMethod(Event node, string prefix)
 {
     Method method = CodeBuilder.CreateMethod(prefix + node.Name,
         TypeSystemServices.VoidType,
         TypeMemberModifiers.Public | TypeMemberModifiers.Virtual | TypeMemberModifiers.Abstract);
     method.Parameters.Add(
         CodeBuilder.CreateParameterDeclaration(
         CodeBuilder.GetFirstParameterIndex(node),
         "handler",
         GetType(node.Type)));
     return method;
 }

 public override void OnEvent(Event node)
 {
     _events.Add(node);
 }

        private void BindClassEvent(Event node, IType type, bool typeIsCallable)
        {
            Field backingField = CodeBuilder.CreateField("___" + node.Name, type);
            if (node.IsTransient)
            {
                backingField.Modifiers |= TypeMemberModifiers.Transient;
            }
            if (node.IsStatic)
            {
                backingField.Modifiers |= TypeMemberModifiers.Static;
            }
            node.DeclaringType.Members.Add(backingField);

            ((InternalEvent)node.Entity).BackingField = (InternalField)backingField.Entity;

            if (null == node.Add)
            {
                node.Add = CreateEventAddMethod(node, backingField);
            }
            else
            {
                Visit(node.Add);
            }

            if (null == node.Remove)
            {
                node.Remove = CreateEventRemoveMethod(node, backingField);
            }
            else
            {
                Visit(node.Remove);
            }

            if (null == node.Raise)
            {
                if (typeIsCallable)
                {
                    node.Raise = CreateEventRaiseMethod(node, backingField);
                }
            }
            else
            {
                Visit(node.Raise);
            }
        }

        void BindEvent(Event node)
        {
            if (null == node.Entity)
            {
                node.Entity = new InternalEvent(TypeSystemServices, node);
            }

            IType type = GetType(node.Type);
            IType declaringType = GetType(node.DeclaringType);
            bool typeIsCallable = type is ICallableType;
            if (!typeIsCallable)
            {
                Errors.Add(
                    CompilerErrorFactory.EventTypeIsNotCallable(node.Type,
                    type.ToString()));
            }

            if (declaringType.IsInterface)
            {
                BindInterfaceEvent(node);
            }
            else
            {
                BindClassEvent(node, type, typeIsCallable);
            }
        }