public override void OnEnumDefinition(EnumDefinition node)
 {
     if (null != node.Entity)
     {
         return;
     }
     node.Entity = new InternalEnum(TypeSystemServices, node);
 }

		override public void LeaveEnumDefinition(EnumDefinition node)
		{
			_members.Clear();
			foreach (TypeMember member in node.Members)
				if (_members.ContainsKey(member.Name))
					MemberNameConflict(member);
				else
					_members[member.Name] = new List<TypeMember>() { member };
		}

        public override void LeaveEnumDefinition(EnumDefinition node)
        {
            CheckName(node,node.Name);

            foreach (EnumMember member in node.Members)
            {
                if (member.Initializer.NodeType != NodeType.IntegerLiteralExpression)
                    Errors.Add(
                        CompilerErrorFactory.EnumMemberMustBeConstant(member));
            }
        }

 public override void LeaveEnumDefinition(EnumDefinition node)
 {
     _members.Clear();
     foreach (TypeMember member in node.Members)
     {
         if (_members.ContainsKey(member.Name))
         {
             MemberNameConflict(member);
         }
         else
         {
             _members[member.Name] = member;
         }
     }
 }

		override public void OnEnumDefinition(EnumDefinition node)
		{
			long lastValue = 0;
			foreach (EnumMember member in node.Members)
			{
				if (null == member.Initializer)
				{
					member.Initializer = new IntegerLiteralExpression(lastValue);
				}
				else if (member.Initializer.NodeType == NodeType.IntegerLiteralExpression)
				{
					lastValue = ((IntegerLiteralExpression) member.Initializer).Value;
				}
				++lastValue;
			}
		}

        public override void OnEnumDefinition(EnumDefinition node)
        {
            long lastValue = 0;
            foreach (EnumMember member in node.Members)
            {
                if (null == member.Initializer)
                {
                    member.Initializer = new IntegerLiteralExpression(lastValue);
                }
                lastValue = member.Initializer.Value + 1;

                if (null == member.Entity)
                {
                    member.Entity = new InternalEnumMember(TypeSystemServices, member);
                }
            }
        }

 void EmitTypeAttributes(EnumDefinition node)
 {
     EnumBuilder builder = GetBuilder(node) as EnumBuilder;
     if (null != builder)
     {
         EmitAttributes(node, builder.SetCustomAttribute);
     }
     else //nested enum
     {
         TypeBuilder typeBuilder = GetTypeBuilder(node);
         EmitAttributes(node, typeBuilder.SetCustomAttribute);
     }
 }

 public override void OnEnumDefinition(EnumDefinition node)
 {
     base.OnEnumDefinition(node);
     _emitter.EmitTypeAttributes(node);
 }

 public override void LeaveEnumDefinition(EnumDefinition node)
 {
     LeaveTypeDefinition(node);
 }

 public override void OnEnumDefinition(EnumDefinition node)
 {
     TypeBuilder builder = GetTypeBuilder(node);
     foreach (EnumMember member in node.Members)
     {
         FieldBuilder field = builder.DefineField(member.Name, builder,
                                                  FieldAttributes.Public |
                                                  FieldAttributes.Static |
                                                  FieldAttributes.Literal);
         field.SetConstant((int)member.Initializer.Value);
         SetBuilder(member, field);
     }
 }

 internal InternalEnum(TypeSystemServices tagManager, EnumDefinition enumDefinition)
     : base(tagManager, enumDefinition)
 {
 }

        //throws RecognitionException, TokenStreamException
        protected void enum_member(
            EnumDefinition container
            )
        {
            IToken  id = null;

                EnumMember em = null;
                Expression initializer = null;

            try {      // for error handling
            attributes();
            id = LT(1);
            match(ID);
            {
                switch ( LA(1) )
                {
                case ASSIGN:
                {
                    match(ASSIGN);
                    initializer=simple_initializer();
                    break;
                }
                case EOL:
                case EOS:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            if (0==inputState.guessing)
            {

                        em = new EnumMember(ToLexicalInfo(id));
                        em.Name = id.getText();
                        em.Initializer = initializer;
                        AddAttributes(em.Attributes);
                        container.Members.Add(em);

            }
            eos();
            docstring(em);
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex);
                recover(ex,tokenSet_38_);
            }
            else
            {
                throw ex;
            }
            }
        }

 public override void OnEnumDefinition(EnumDefinition node)
 {
 }

 public override void LeaveEnumDefinition(EnumDefinition node)
 {
     CantBeMarkedAbstract(node);
     CantBeMarkedPartialIfNested(node);
     CantBeMarkedFinal(node);
     CantBeMarkedStatic(node);
 }

 private Type GetEnumUnderlyingType(EnumDefinition node)
 {
     return ((InternalEnum) node.Entity).UnderlyingType;
 }

 public override void OnEnumDefinition(EnumDefinition node)
 {
     var builder = GetBuilder(node) as EnumBuilder;
     if (null != builder)
     {
         foreach (EnumMember member in node.Members)
         {
             var field = builder.DefineLiteral(member.Name, InitializerValueOf(member, node));
             SetBuilder(member, field);
         }
     }
     else //nested enum (have to go through regular TypeBuilder
     {	 //since there is no DefineNestedEnum in SRE :-/
         TypeBuilder typeBuilder = GetTypeBuilder(node);
         foreach (EnumMember member in node.Members)
         {
             var field = typeBuilder.DefineField(member.Name, typeBuilder,
                                                 FieldAttributes.Public |
                                                 FieldAttributes.Static |
                                                 FieldAttributes.Literal);
             field.SetConstant(InitializerValueOf(member, node));
             SetBuilder(member, field);
         }
     }
 }

 public override void OnEnumDefinition(EnumDefinition node)
 {
     OnCandidatePartialDefinition(node);
 }

		override public void OnEnumDefinition(EnumDefinition node)
		{
			EnsureEntityFor(node);
		}

 public override void OnEnumDefinition(EnumDefinition node)
 {
     VisitTypeDefinition(node);
 }

 public override void OnEnumDefinition(EnumDefinition node)
 {
     AddMember(node);
 }