New Mojom parser: Fix up error messages for lexing errors.

mojom/mojom_parser/parser/parsing.go

 package parser
 
 import (
         "fmt"
         "math"
         "mojom/mojom_parser/lexer"
         "mojom/mojom_parser/mojom"
         "strconv"
 )
 
@@ skipping 299 matching lines @@
                 attributes.List = append(attributes.List, mojom.MojomAttribute{key, value})
 
                 nextToken = p.peekNextToken("I was reading an attributes section.")
                 if !p.OK() {
                         return
                 }
                 p.consumeNextToken()
                 if nextToken.Kind != lexer.RBracket && nextToken.Kind != lexer.Comma {
                         switch nextToken.Kind {
                         case lexer.Module, lexer.Interface, lexer.Struct, lexer.Union, lexer.Enum:
-                                message := fmt.Sprintf("The attribute section is missing a closing ] before %s.", nextToken)
+                                message := fmt.Sprintf("Error: The attribute section is missing a closing ] before %s.", nextToken)
                                 p.parseErrorT(ParserErrorCodeUnexpectedToken, message, nextToken)
                                 return
                         default:
                                 p.unexpectedTokenError(nextToken, "comma or ]")
                                 return
                         }
                 }
         }
 
         return
@@ skipping 590 matching lines @@
         firstValue := true
         for attributes := p.parseAttributes(); !rbraceFound; attributes = p.parseAttributes() {
                 if !p.OK() {
                         return false
                 }
                 nextToken := p.peekNextToken("I was parsing an enum body.")
                 var duplicateNameError error = nil
                 switch nextToken.Kind {
                 case lexer.Name:
                         if !firstValue && !trailingCommaFound {
-                                message := fmt.Sprintf("Expecting a comma after %s before the next value %s.",
+                                message := fmt.Sprintf("Error: Expecting a comma after %s before the next value %s.",
                                         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) {
@@ skipping 79 matching lines @@
         assigneeSpec := mojom.AssigneeSpec{
                 name,
                 declaredType,
         }
         value := p.parseValue(assigneeSpec)
         if !p.OK() {
                 return
         }
 
         if !declaredType.MarkUsedAsConstantType() {
-                message := fmt.Sprintf("The type %s is not allowed as the type of a declared constant. "+
+                message := fmt.Sprintf("Error: The type %s is not allowed as the type of a declared constant. "+
                         "Only simple types, strings and enum types may be the types of constants.", declaredType)
                 p.parseErrorT(ParserErrorCodeUnexpectedToken, message, declaredTypeToken)
                 return
         }
 
         constant = mojom.NewUserDefinedConstant(p.DeclData(name, nameToken, attributes), declaredType, value)
         p.matchSemicolon()
 
         if !constant.ValidateValue() {
                 valueString := fmt.Sprintf("%v", value)
@@ skipping 210 matching lines @@
                 if p.tryMatch(lexer.LAngle) {
                         handleType := p.readText(lexer.Name)
                         if !p.OK() {
                                 token := p.lastSeen
                                 p.unexpectedTokenError(token, "a type of handle")
                                 return nil
                         }
                         if p.match(lexer.RAngle) {
                                 typeName = fmt.Sprintf("%s<%s>", typeName, handleType)
                                 if builtInType = mojom.BuiltInType(typeName); builtInType == nil {
-                                        message := fmt.Sprintf("Unrecognized type of handle: %s.", typeName)
+                                        message := fmt.Sprintf("Error: Unrecognized type of handle: %s.", typeName)
                                         p.parseErrorT(ParserErrorCodeUnexpectedToken, message, typeNameToken)
                                         return nil
                                 }
                         }
                 }
                 if !p.OK() {
                         return nil
                 }
         }
 
         // Check for nullable marker
         if p.tryMatch(lexer.Qstn) {
                 if builtInType = mojom.BuiltInType(typeName + "?"); builtInType == nil {
-                        message := fmt.Sprintf("The type %s? is invalid because the type %s may not be made nullable.",
+                        message := fmt.Sprintf("Error: The type %s? is invalid because the type %s may not be made nullable.",
                                 typeName, typeName)
                         p.parseErrorT(ParserErrorCodeUnexpectedToken, message, typeNameToken)
                         return nil
                 }
         }
 
         return builtInType
 }
 
 // ARRAY_TYPE  -> array langle TYPE [comma int_const_dec] rangle [qstn]
@@ skipping 53 matching lines @@
         keyToken := p.peekNextToken("Trying to read a type.")
         keyType := p.parseType()
         p.match(lexer.Comma)
         valueType := p.parseType()
         if !p.match(lexer.RAngle) {
                 return nil
         }
         nullable := p.tryMatch(lexer.Qstn)
 
         if !keyType.MarkUsedAsMapKey() {
-                message := fmt.Sprintf("The type %s is not allowed as the key type of a map. "+
+                message := fmt.Sprintf("Error: The type %s is not allowed as the key type of a map. "+
                         "Only simple types, strings and enum types may be map keys.", keyType)
                 p.parseErrorT(ParserErrorCodeUnexpectedToken, message, keyToken)
                 return nil
         }
 
         return mojom.NewMapTypeRef(keyType, valueType, nullable)
 }
 
 // TYPE_REFERENCE   -> INTERFACE_TYPE | STRUCT_TYPE | UNION_TYPE | ENUM_TYPE
 // INTERFACE_TYPE   -> IDENTIFIER [amp] [qstn] {{where IDENTIFIER resolves to an interface}}
@@ skipping 89 matching lines @@
         p.consumeNextToken()
         intText := p.lastConsumed.Text
 
         // Set the base to 10 or 16.
         base := 10
         switch nextToken.Kind {
         case lexer.IntConstDec:
                 break
         case lexer.IntConstHex:
                 if !acceptHex {
-                        message := fmt.Sprintf("Illegal value %s. Only a decimal integer literal is allowed here. "+
+                        message := fmt.Sprintf("Illegal value: %s. Only a decimal integer literal is allowed here. "+
                                 "Hexadecimal is not valid.", nextToken)
                         p.parseErrorT(ParserErrorCodeUnexpectedToken, message, nextToken)
                         return
                 }
                 if len(intText) < 3 {
-                        message := fmt.Sprintf("Invalid hex integer literal %q.", intText)
+                        message := fmt.Sprintf("Invalid hex integer literal: %q.", intText)
                         p.parseErrorT(ParserErrorCodeIntegerParseError, message, nextToken)
                         return
                 }
                 intText = intText[2:]
                 base = 16
 
         default:
                 p.unexpectedTokenError(nextToken, "a positive integer literal")
                 return
         }
@@ skipping 102 matching lines @@
         return true
 }
 
 func (p *Parser) matchSemicolonToken(previousToken lexer.Token) bool {
         if !p.OK() {
                 return false
         }
         if p.match(lexer.Semi) {
                 return true
         }
-        message := fmt.Sprintf("Missing semicolon after %s.", previousToken)
+        message := fmt.Sprintf("Error: Missing semicolon after %s.", previousToken)
         p.parseErrorT(ParserErrorCodeUnexpectedToken, message, previousToken)
         return false
 }
 
 func (p *Parser) matchSemicolon() bool {
         return p.matchSemicolonToken(p.lastConsumed)
 }
 
 func (p *Parser) readText(kind lexer.TokenKind) (text string) {
         if !p.OK() {
@@ skipping 35 matching lines @@
 func (p *Parser) readOrdinal() (ordinalValue int64, err error) {
         ordinalValue = -1
         if !p.OK() {
                 return
         }
 
         if p.tryMatch(lexer.Ordinal) {
                 intTextToParse := p.lastConsumed.Text[1:]
                 ordinalValue, err = strconv.ParseInt(intTextToParse, 10, 64)
                 if err != nil || ordinalValue < 0 || ordinalValue >= math.MaxUint32 {
-                        err = fmt.Errorf("Invalid ordinal string following `@`: %q. Ordinals must be decimal integers between 0 and %d.",
+                        err = fmt.Errorf("Error: Invalid ordinal string following '@': %q. Ordinals must be decimal integers between 0 and %d.",
                                 intTextToParse, math.MaxUint32-1)
                         return
                 }
         }
         return
 }
 
 func (p *Parser) DeclData(name string, nameToken lexer.Token, attributes *mojom.Attributes) mojom.DeclarationData {
         return mojom.DeclData(name, p.mojomFile, nameToken, attributes)
 }
@@ skipping 31 matching lines @@
 // unexpectedTokenError() sets the parser's current error to a ParseError
 // with error code |ParserErrorCodeUnexpectedToken| and an error message
 // of the form:
 //
 //    Unexpected '}'. Expecting a semicolon.
 //
 // |expected| should be a noun-phrase such as "a semicolon".
 func (p *Parser) unexpectedTokenError(token lexer.Token, expected string) {
         var message string
         switch token.Kind {
-        case lexer.ErrorUnknown, lexer.ErrorIllegalChar,
-                lexer.ErrorUnterminatedStringLiteral,
-                lexer.ErrorUnterminatedComment:
-                message = fmt.Sprintf("%s. Expecting %s.", token, expected)
+        case lexer.ErrorUnterminatedStringLiteral, lexer.ErrorUnterminatedComment:
+                message = fmt.Sprintf("Error: %s", token)
         default:
-                message = fmt.Sprintf("Unexpected %s. Expecting %s.", token, expected)
+                message = fmt.Sprintf("Error: Unexpected %s. Expecting %s.", token, expected)
         }
         p.parseErrorT(ParserErrorCodeUnexpectedToken, message, token)
 }