/// <summary>
		/// Constructor.
		/// </summary>
		/// <param name="tag">Tag</param>
		/// <param name="className">Class name</param>
		public EventInfo(CodeMemberEvent tag, string className) 
			: base(tag, className)
		{
			Trace.Assert(tag != null);
			name = tag.Name;
			lineNumber = tag.LinePragma.LineNumber;
		}

        public override CodeTypeMember ToCodeDom()
        {
            CodeMemberEvent e = new CodeMemberEvent();
            base.ToCodeDom(e);
            e.Name  = this.Conformer.NormalizeMember(this.Name,this.Attributes);
            e.Type = this.Type.TypeReference;

            return e;
        }

		public void Constructor0_Deny_Unrestricted ()
		{
			CodeMemberEvent cme = new CodeMemberEvent ();
			Assert.AreEqual (0, cme.ImplementationTypes.Count, "ImplementationTypes");
			Assert.IsNull (cme.PrivateImplementationType, "PrivateImplementationType");
			cme.PrivateImplementationType = new CodeTypeReference ("System.Int32");
			Assert.AreEqual ("System.Void", cme.Type.BaseType, "Type");
			cme.Type = new CodeTypeReference ("System.Void");
		}

        public static CodeMemberEvent Event(CodeTypeReference delegateType, MemberAttributes ma, string name)
        {
            var c = new CodeMemberEvent
            {
                Name = name,
                Attributes = ma,
                Type = delegateType,
            };

            return c;
        }

 public TypescriptMemberEvent(
     IExpressionFactory expressionFactory,
     ITypescriptTypeMapper typescriptTypeMapper,
     CodeMemberEvent member,
     CodeGeneratorOptions options)
 {
     _expressionFactory = expressionFactory;
     _typescriptTypeMapper = typescriptTypeMapper;
     _member = member;
     _options = options;
 }

 internal DesignTimeEventInfo(DesignTimeType declaringType, CodeMemberEvent codeDomEvent)
 {
     if (declaringType == null)
     {
         throw new ArgumentNullException("Declaring Type");
     }
     if (codeDomEvent == null)
     {
         throw new ArgumentNullException("codeDomEvent");
     }
     this.declaringType = declaringType;
     this.codeDomEvent = codeDomEvent;
     this.name = Helper.EnsureTypeName(codeDomEvent.Name);
     this.memberAttributes = codeDomEvent.Attributes;
     this.addMethod = null;
     this.removeMethod = null;
 }

        public System.CodeDom.CodeTypeMember Compile()
        {
            CodeMemberEvent memberEvent = new CodeMemberEvent();
            memberEvent.Type = new CodeTypeReference(type.Target);
            memberEvent.Name = name;
            memberEvent.Attributes = memberAttribute;

            for( int pos = 0; pos < comments.Count; pos++ ) {
                //  TODO loop in comments.Count
                memberEvent.Comments.Add(new CodeCommentStatement(comments[pos]));
            }
            for( int pos = 0; pos < attributes.Count; pos++ ) {
                //  TODO loop in attributes
                memberEvent.CustomAttributes.Add(new CodeAttributeDeclaration(attributes[pos].name));
            }
            return memberEvent;
        }

        public static void AddPropertyChanging(CodeTypeDeclaration declaration)
        {
            CodeMemberEvent changingEvent = new CodeMemberEvent();
            changingEvent.Name = "PropertyChanging";
            changingEvent.Type = new CodeTypeReference(typeof(PropertyChangingEventHandler));
            changingEvent.Attributes = MemberAttributes.Public;

            declaration.Members.Add(changingEvent);

            CodeMemberMethod changingMethod = new CodeMemberMethod();
            changingMethod.Name = "OnPropertyChanging";
            changingMethod.ReturnType = new CodeTypeReference(typeof(void));
            changingMethod.Attributes = MemberAttributes.Family;
            changingMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "propertyName"));
            changingMethod.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute))));

            changingMethod.Statements.Add(new CodeConditionStatement(
                    new CodeBinaryOperatorExpression(
                        new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "PropertyChanging"),
                        CodeBinaryOperatorType.IdentityInequality,
                        new CodePrimitiveExpression(null)
                    ),
                    new CodeStatement[] {
                        new CodeExpressionStatement(
                            new CodeMethodInvokeExpression(
                                new CodeThisReferenceExpression(),
                                "PropertyChanging",
                                new CodeExpression[] {
                                    new CodeThisReferenceExpression(),
                                    new CodeObjectCreateExpression(
                                        typeof(PropertyChangingEventArgs),
                                        new CodeExpression[] {
                                            new CodeArgumentReferenceExpression("propertyName")
                                        }
                                    )
                                }
                            )
                        )
                    }
                ));

            declaration.Members.Add(changingMethod);
        }

        public static CodeTypeMember CreateEventDefinition(
            this INamedTypeSymbol typeToWrap,
            WrapsAttrNameChangeView eventNameChangeView, 
            IList<string> namespaces    
        )
        {
            IEventSymbol wrappedEventInfo =
                typeToWrap.GetMembers(eventNameChangeView.Name).FirstOrDefault() as IEventSymbol;

            ITypeSymbol eventTypeSymbol = wrappedEventInfo.Type;

            CodeTypeReference eventTypeReference = eventTypeSymbol.GetTypeReference(namespaces);

            CodeMemberEvent codeEvent = new CodeMemberEvent
            {
                Name = eventNameChangeView.WrapperName,
                Type = eventTypeReference,
                Attributes = wrappedEventInfo.GetFlags(eventNameChangeView.TheEncapsulationLevel)
            };

            return codeEvent;
        }

        // Builds a codedom event and attaches it to the given type.
        // It seems that there is a codedom bug: you can't make events static.
        public static void Emit(CodeTypeDeclaration codeType, Event e)
        {
            // Create the codedom event and attach to the codedom type.
            var codeEvent = new CodeMemberEvent();
            codeType.Members.Add(codeEvent);

            // Assign a name
            codeEvent.Name = e.Name;

            // Assign the type.
            codeEvent.Type = new CodeTypeReference(e.DelegateName);

            // Translate the accessibility
            MemberAttributes memberAttributes = MemberAttributes.Public;
            switch (e.Accessibility)
            {
                case Accessibility.Internal:
                    memberAttributes = MemberAttributes.FamilyAndAssembly;
                    break;
                case Accessibility.Private:
                    memberAttributes = MemberAttributes.Private;
                    break;
                case Accessibility.Protected:
                    memberAttributes = MemberAttributes.Family;
                    break;
                case Accessibility.Public:
                    memberAttributes = MemberAttributes.Public;
                    break;
            }

            // This is bugged in codedom: no effect.
            if (e.IsShared)
                memberAttributes |= MemberAttributes.Static;

            codeEvent.Attributes = memberAttributes;
        }

        static CodeTypeMember GenerateEvent(EventDefinition eventDefinition)
        {
            var @event = new CodeMemberEvent
            {
                Name = eventDefinition.Name,
                Attributes = MemberAttributes.Public | MemberAttributes.Final,
                CustomAttributes = CreateCustomAttributes(eventDefinition),
                Type = CreateCodeTypeReference(eventDefinition.EventType)
            };

            return @event;
        }

        protected override void GenerateEvent(CodeMemberEvent e, CodeTypeDeclaration c) {
            if (IsCurrentDelegate || IsCurrentEnum) return;

            if (e.CustomAttributes.Count > 0) {
                GenerateAttributes(e.CustomAttributes);
            }

            if (e.PrivateImplementationType == null) {
                OutputMemberAccessModifier(e.Attributes);
            }
            Output.Write("event ");
            string name = e.Name;
            if (e.PrivateImplementationType != null) {
                name = e.PrivateImplementationType.BaseType + "." + name;
            }
            OutputTypeNamePair(e.Type, name);
            Output.WriteLine(";");
        }

        private void ValidateEvent(CodeMemberEvent e) {

            if (e.CustomAttributes.Count > 0) {
                ValidateAttributes(e.CustomAttributes);
            }
            if (e.PrivateImplementationType != null) {
                ValidateTypeReference(e.Type);
                ValidateIdentifier(e,"Name",e.Name);
            }

            ValidateTypeReferences(e.ImplementationTypes);
        }

		protected override void GenerateEvent (CodeMemberEvent eventRef, CodeTypeDeclaration declaration)
		{
			if (IsCurrentDelegate || IsCurrentEnum) {
				return;
			}

			OutputAttributes (eventRef.CustomAttributes, null, false);

			if (eventRef.PrivateImplementationType == null) {
				OutputMemberAccessModifier (eventRef.Attributes);
			}

			Output.Write ("event ");

			if (eventRef.PrivateImplementationType != null) {
				OutputTypeNamePair (eventRef.Type,
					eventRef.PrivateImplementationType.BaseType + "." + 
					eventRef.Name);
			} else {
				OutputTypeNamePair (eventRef.Type, GetSafeName (eventRef.Name));
			}
			Output.WriteLine (';');
		}

		protected override void GenerateEvent(CodeMemberEvent e, CodeTypeDeclaration c)
		{
			Output.WriteLine("[CodeMemberEvent: {0}]", e.ToString());
		}

 protected override void GenerateEvent(CodeMemberEvent e, CodeTypeDeclaration c)
 {
     if (!base.IsCurrentDelegate && !base.IsCurrentEnum)
     {
         if (e.CustomAttributes.Count > 0)
         {
             this.OutputAttributes(e.CustomAttributes, false);
         }
         string name = e.Name;
         if (e.PrivateImplementationType != null)
         {
             string str2 = this.GetBaseTypeOutput(e.PrivateImplementationType).Replace('.', '_');
             e.Name = str2 + "_" + e.Name;
         }
         this.OutputMemberAccessModifier(e.Attributes);
         base.Output.Write("Event ");
         this.OutputTypeNamePair(e.Type, e.Name);
         if (e.ImplementationTypes.Count > 0)
         {
             base.Output.Write(" Implements ");
             bool flag = true;
             foreach (CodeTypeReference reference in e.ImplementationTypes)
             {
                 if (flag)
                 {
                     flag = false;
                 }
                 else
                 {
                     base.Output.Write(" , ");
                 }
                 this.OutputType(reference);
                 base.Output.Write(".");
                 this.OutputIdentifier(name);
             }
         }
         else if (e.PrivateImplementationType != null)
         {
             base.Output.Write(" Implements ");
             this.OutputType(e.PrivateImplementationType);
             base.Output.Write(".");
             this.OutputIdentifier(name);
         }
         base.Output.WriteLine("");
     }
 }

		protected override void GenerateEvent (CodeMemberEvent eventRef, CodeTypeDeclaration declaration)
		{
			if (IsCurrentDelegate || IsCurrentEnum)
				return;

			TextWriter output = Output;

			OutputAttributes (eventRef.CustomAttributes, null,
				LineHandling.ContinueLine);

			OutputMemberAccessModifier (eventRef.Attributes);

			output.Write ("Event ");
			OutputTypeNamePair (eventRef.Type, GetEventName(eventRef));

			if (eventRef.ImplementationTypes.Count > 0) {
				OutputImplementationTypes (eventRef.ImplementationTypes, eventRef.Name);
			} else if (eventRef.PrivateImplementationType != null) {
				output.Write (" Implements ");
				OutputType (eventRef.PrivateImplementationType);
				output.Write ('.');
				output.Write (eventRef.Name);
			}

			output.WriteLine ();
		}

		protected abstract void GenerateEvent (CodeMemberEvent ev, CodeTypeDeclaration d);

 public override void EnterEvent_([NotNull] XSharpParser.Event_Context context)
 {
     CodeMemberEvent evt = new CodeMemberEvent();
     evt.Name = context.Id.GetText();
     evt.Attributes = MemberAttributes.Public;
     evt.Type = new CodeTypeReference(context.Type.GetText());
     //
     if (context.Modifiers != null)
     {
         // Get standard Visibilities
         evt.Attributes = ContextToEventModifiers(context.Modifiers);
         if (context.Modifiers.NEW().Length > 0)
             evt.Attributes |= MemberAttributes.New;
         if (context.Modifiers.STATIC().Length > 0)
             evt.Attributes |= MemberAttributes.Static;
         if (context.Modifiers.VIRTUAL().Length > 0)
         {
             // According to MSDN, The absence of the Final flag makes a member virtual in C#, same for us
             evt.Attributes &= ~MemberAttributes.Final;
         }
         else
         {
             // Other cases = FINAL
             evt.Attributes |= MemberAttributes.Final;
         }
     }
     //
     this.CurrentClass.Members.Add(evt);
 }

			public void Visit (CodeMemberEvent o)
			{
				g.GenerateEvent (o, g.CurrentClass);
			}