New Mojom parser: Fix error message for invalid enum value initailizers.

mojom/mojom_parser/parser/parsing.go

 package parser
 
 import (
         "fmt"
         "math"
         "mojom/mojom_parser/lexer"
         "mojom/mojom_parser/mojom"
         "strconv"
 )
 
@@ skipping 921 matching lines @@
                                         p.lastConsumed, nextToken)
                                 p.parseErrorT(ParserErrorCodeUnexpectedToken, message, p.lastConsumed)
                                 return false
                         }
                         firstValue = false
                         name := p.readName()
                         p.attachToken()
                         nameToken := p.lastConsumed
                         var valueRef mojom.ValueRef
                         if p.tryMatch(lexer.Equals) {
-                                valueRef = p.parseEnumValueInitializer(mojomEnum)
+                                valueRef = p.parseEnumValueInitializer(mojomEnum, name)
                         }
                         declData := p.DeclData(name, nameToken, attributes)
                         duplicateNameError = mojomEnum.AddEnumValue(declData, valueRef)
                         trailingCommaFound = p.tryMatch(lexer.Comma)
                 case lexer.RBrace:
                         rbraceFound = true
                         if attributes != nil {
                                 message := "Enum body ends with extraneouss attributes."
                                 p.parseError(ParserErrorCodeBadAttributeLocation, message)
                         }
                         break
                 case lexer.Comma:
                         break
                 default:
                         p.unexpectedTokenError(nextToken, "either another enum value or }")
                         return false
                 }
                 if p.OK() && duplicateNameError != nil {
                         p.err = duplicateNameError
                         return false
                 }
         }
         return p.OK()
 }
 
 // ENUM_VAL_INITIALIZER -> INTEGER_LITERAL | ENUM_VALUE_REF
 // ENUM_VALUE_REF       -> IDENTIFIER {{that resolves to a declared enum value}}
-func (p *Parser) parseEnumValueInitializer(mojoEnum *mojom.MojomEnum) mojom.ValueRef {
+func (p *Parser) parseEnumValueInitializer(mojoEnum *mojom.MojomEnum, valueName string) mojom.ValueRef {
         if !p.OK() {
                 return nil
         }
         p.pushChildNode("enumValueInitializer")
         defer p.popNode()
 
         // We need to manufacture an instance of Type to act as the "assigneeType"
         // for the new ValueSpec we are creating. This is because unlike
         // other types of value assignment, an enum value initializer is not
         // preceded by a type reference for the assignee. Rather the type of
         // the assignee is implicit in the scope.
         enumType := mojom.NewResolvedUserTypeRef(mojoEnum.FullyQualifiedName(), mojoEnum)
 
         valueToken := p.peekNextToken("Parsing an enum value initializer type.")
-        valueRef := p.parseValue(mojom.AssigneeSpec{"enum value", enumType})
+        valueRef := p.parseValue(mojom.AssigneeSpec{valueName, enumType})
         if valueRef == nil {
                 return nil
         }
         if !valueRef.MarkUsedAsEnumValueInitializer() {
                 message := fmt.Sprintf("Illegal value: %s. An enum value initializer must be a signed 32-bit integer value.",
                         valueToken)
                 p.parseErrorT(ParserErrorCodeUnexpectedToken, message, valueToken)
                 return nil
         }
 
@@ skipping 698 matching lines @@
 func (p *Parser) unexpectedTokenError(token lexer.Token, expected string) {
         var message string
         switch token.Kind {
         case lexer.ErrorUnterminatedStringLiteral, lexer.ErrorUnterminatedComment:
                 message = fmt.Sprintf("%s", token)
         default:
                 message = fmt.Sprintf("Unexpected %s. Expecting %s.", token, expected)
         }
         p.parseErrorT(ParserErrorCodeUnexpectedToken, message, token)
 }