protected SourceEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, DiagnosticBag diagnostics)
     : base(containingEnum, syntax.Identifier.ValueText, syntax.GetReference(), syntax.Identifier.GetLocation())
 {
     if (this.Name == WellKnownMemberNames.EnumBackingFieldName)
     {
         diagnostics.Add(ErrorCode.ERR_ReservedEnumerator, this.Location, WellKnownMemberNames.EnumBackingFieldName);
     }
 }

 public static SourceEnumConstantSymbol CreateExplicitValuedConstant(
     SourceMemberContainerTypeSymbol containingEnum,
     EnumMemberDeclarationSyntax syntax,
     DiagnosticBag diagnostics)
 {
     var initializer = syntax.EqualsValue;
     Debug.Assert(initializer != null);
     return new ExplicitValuedEnumConstantSymbol(containingEnum, syntax, initializer, diagnostics);
 }

        public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
        {
            var symbol = model.GetDeclaredSymbol(node);
            this.declaredItems.Add(new DeclaredItemDocument
            {
                Name = symbol.Name,
                Location = this.model.SyntaxTree.GetLineSpan(node.Span, false).StartLinePosition.Line,
                Identifier = symbol.ToDisplayString(),
                Type = "EnumMember"

            });
            base.VisitEnumMemberDeclaration(node);
        }

 public static SourceEnumConstantSymbol CreateImplicitValuedConstant(
     SourceMemberContainerTypeSymbol containingEnum,
     EnumMemberDeclarationSyntax syntax,
     SourceEnumConstantSymbol otherConstant,
     int otherConstantOffset,
     DiagnosticBag diagnostics)
 {
     if ((object)otherConstant == null)
     {
         Debug.Assert(otherConstantOffset == 0);
         return new ZeroValuedEnumConstantSymbol(containingEnum, syntax, diagnostics);
     }
     else
     {
         Debug.Assert(otherConstantOffset > 0);
         return new ImplicitValuedEnumConstantSymbol(containingEnum, syntax, otherConstant, (uint)otherConstantOffset, diagnostics);
     }
 }

        public override SyntaxNode VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
        {
            if (node.EqualsValue == null)
            {
                lastValue++;
                return node.WithEqualsValue(Syntax.EqualsValueClause(Syntax.Token(SyntaxKind.EqualsToken),
                    Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(lastValue))
                    ));
            }
            else
            {
                ExpressionSyntax expr = node.EqualsValue.Value;
                if (expr.Kind == SyntaxKind.NumericLiteralExpression)
                {
                    lastValue = int.Parse(expr.ToString());
                    return node;
                }

                throw new NotImplementedException("enum with non-literal explicit value");
            }

            return base.VisitEnumMemberDeclaration(node);
        }

 public EnumMemberDeclarationTranslation(EnumMemberDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
 {
 }

			public override void VisitEnumMemberDeclaration (EnumMemberDeclarationSyntax node)
			{
				base.VisitEnumMemberDeclaration (node);
				Append (node);
			}

            private void ClassifyUpdate(EnumMemberDeclarationSyntax oldNode, EnumMemberDeclarationSyntax newNode)
            {
                if (!SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier))
                {
                    ReportError(RudeEditKind.Renamed);
                    return;
                }

                Debug.Assert(!SyntaxFactory.AreEquivalent(oldNode.EqualsValue, newNode.EqualsValue));
                ReportError(RudeEditKind.InitializerUpdate);
            }

 /// <summary>
 /// Traverse AST node that represents enumeration constant declaration
 /// </summary>
 /// <param name="node">AST node.</param>
 public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
 {
     try
     {
         if (!node.Identifier.Span.IsEmpty)
         {
             var symbol = _sm.GetDeclaredSymbol(node);
             if (!_defined.Contains(symbol))
             {
                 _defined.Add(symbol);
                 var def = Def.For(symbol: symbol, type: "enum field", name: symbol.Name).At(_path, node.Identifier.Span);
                 def.Exported = true;
                 AddDef(def);
             }
         }
         base.VisitEnumMemberDeclaration(node);
     }
     catch (Exception e)
     {
     }
 }

 public override IFieldSymbol GetDeclaredSymbol(EnumMemberDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
 {
     // Can't define member inside member.
     return null;
 }

 /// <summary>
 /// Given a enum member declaration, get the corresponding field symbol.
 /// </summary>
 /// <param name="declarationSyntax">The syntax node that declares an enum member.</param>
 /// <param name="cancellationToken">The cancellation token.</param>
 /// <returns>The symbol that was declared.</returns>
 public override IFieldSymbol GetDeclaredSymbol(EnumMemberDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
 {
     return (IFieldSymbol)GetDeclaredMemberSymbol(declarationSyntax);
 }

 public ExplicitValuedEnumConstantSymbol(
     SourceMemberContainerTypeSymbol containingEnum,
     EnumMemberDeclarationSyntax syntax,
     EqualsValueClauseSyntax initializer,
     DiagnosticBag diagnostics) :
     base(containingEnum, syntax, diagnostics)
 {
     this.equalsValueNodeRef = initializer.GetReference();
 }

            public void Add(EnumMemberDeclarationSyntax node)
            {
                /*        // Summary:
                //     Gets the attribute declaration list.
                public SyntaxList<AttributeListSyntax> AttributeLists { get; }
                public EqualsValueClauseSyntax EqualsValue { get; }
                //
                // Summary:
                //     Gets the identifier.
                public SyntaxToken Identifier { get; }
                 */
                // add field info

                TypeExtraInfo tei = Chunk.AddTypeExtraInfo(this.Class,Model);
                tei.AddEnumMember(node.Identifier.ToString(), node.EqualsValue != null ? node.EqualsValue.Value : null);

                /*
                // Summary:
                //     Gets the attribute declaration list.
                public override SyntaxList<AttributeListSyntax> AttributeLists { get; }
                public override VariableDeclarationSyntax Declaration { get; }
                //
                // Summary:
                //     Gets the modifier list.
                public override SyntaxTokenList Modifiers { get; }
                public override SyntaxToken SemicolonToken { get; }
                 */

                // add to metadata for runtime type building
                FlatArrayBuilder fab = new FlatArrayBuilder();

                fab.Add(FlatValue.Int32((int)ClassMemberType.StaticField));
                //TypeInfo ti = Chunk.Model.GetTypeInfo(node..Type);

                fab.Add(FlatValue.String(Class.GetFullyQualifiedName()));

                {
                    FlatArrayBuilder varList = new FlatArrayBuilder();
                    varList.Add(FlatValue.String(node.Identifier.ToString()));
                    fab.Add(varList.GetFlatValue());
                }
                {
                    FlatArrayBuilder valueList = new FlatArrayBuilder();
                    if (node.EqualsValue != null)
                    {
                        if (node.EqualsValue.Value.Kind == SyntaxKind.NumericLiteralExpression)
                        {
                            valueList.Add(FlatValue.Int32(int.Parse(node.EqualsValue.Value.ToString())));
                        }
                        else
                        {
                            throw new NotImplementedException("Enum member without numeric literal expression");
                        }
                    }
                    else
                    {
                        throw new NotImplementedException("Enum member without numeric literal expression");
                    }

                    fab.Add(valueList.GetFlatValue());
                }

                Members.Add(fab.GetFlatValue());
            }

 public ZeroValuedEnumConstantSymbol(
     SourceMemberContainerTypeSymbol containingEnum,
     EnumMemberDeclarationSyntax syntax,
     DiagnosticBag diagnostics)
     : base(containingEnum, syntax, diagnostics)
 {
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="EnumMemberDeclaration"/> class.
 /// </summary>
 /// <param name="enumMemberDeclarationNode"></param>
 /// <param name="semanticModel"></param>
 public EnumMemberDeclaration(EnumMemberDeclarationSyntax enumMemberDeclarationNode, SemanticModel semanticModel)
     : base(enumMemberDeclarationNode, semanticModel)
 {
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="node"></param>
        public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
        {
            var enumMemberTranslationUnit = new EnumMemberTranslationUnitFactory(node, this.semanticModel).Create();
            this.enumDeclaration.AddMember(enumMemberTranslationUnit);

            this.InvokeEnumMemberVisited(this, new WalkerEventArgs());
        }

 public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
 {
     CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
 }

            public ImplicitValuedEnumConstantSymbol(
                SourceMemberContainerTypeSymbol containingEnum,
                EnumMemberDeclarationSyntax syntax,
                SourceEnumConstantSymbol otherConstant,
                uint otherConstantOffset,
                DiagnosticBag diagnostics) :
                base(containingEnum, syntax, diagnostics)
            {
                Debug.Assert((object)otherConstant != null);
                Debug.Assert(otherConstantOffset > 0);

                this.otherConstant = otherConstant;
                this.otherConstantOffset = otherConstantOffset;
            }

        private string GetVariablePrototype(EnumMemberDeclarationSyntax node, IFieldSymbol 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.
                return GetNodeKey(node).Name;
            }

            var builder = new StringBuilder();

            AppendVariablePrototype(builder, symbol, flags, GetName(node));

            if ((flags & PrototypeFlags.Initializer) != 0 &&
                node.EqualsValue != null &&
                node.EqualsValue.Value != null &&
                !node.EqualsValue.Value.IsMissing)
            {
                builder.Append(" = ");
                builder.Append(node.EqualsValue.Value);
            }

            return builder.ToString();
        }

 public static string EnumMemberDeclaration(EnumMemberDeclarationSyntax declaration)
 {
     var output = declaration.Identifier.Text;
     if (declaration.EqualsValue != null)
     {
         output += " " + SyntaxNode(declaration.EqualsValue);
     }
     return output;
 }