Use message.yaml in parser.

pkg/front_end/lib/src/fasta/scanner/error_token.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style licenset hat can be found in the LICENSE file.
 
 library dart_scanner.error_token;
 
-// TODO(ahe): ErrorKind doesn't belong in dart_parser. Move to compiler_util or
-// this package?
-import '../parser/error_kind.dart' show ErrorKind;
+import '../fasta_codes.dart'
+    show
+        FastaCode,
+        codeAsciiControlCharacter,
+        codeEncoding,
+        codeExpectedHexDigit,
+        codeMissingExponent,
+        codeNonAsciiIdentifier,
+        codeNonAsciiWhitespace,
+        codeUnexpectedDollarInString,
+        codeUnmatchedToken,
+        codeUnterminatedComment,
+        codeUnterminatedString,
+        codeUnterminatedToken;
 
 import '../scanner.dart'
     show BeginGroupToken, Token, unicodeReplacementCharacter;
 
 import 'precedence.dart' show BAD_INPUT_INFO, PrecedenceInfo;
 
-export '../parser/error_kind.dart' show ErrorKind;
-
 ErrorToken buildUnexpectedCharacterToken(int character, int charOffset) {
   if (character < 0x1f) {
     return new AsciiControlCharacterToken(character, charOffset);
   }
   switch (character) {
     case unicodeReplacementCharacter:
       return new EncodingErrorToken(charOffset);
 
     /// See [General Punctuation]
     /// (http://www.unicode.org/charts/PDF/U2000.pdf).
@@ skipping 35 matching lines @@
   PrecedenceInfo get info => BAD_INPUT_INFO;
 
   String get lexeme => throw assertionMessage;
 
   String get stringValue => null;
 
   bool isIdentifier() => false;
 
   String get assertionMessage;
 
-  ErrorKind get errorCode;
+  FastaCode get errorCode;
 
   int get character => null;
 
   String get start => null;
 
   int get endOffset => null;
 
   BeginGroupToken get begin => null;
 
   @override
   Token copyWithoutComments() {
     throw 'unsupported operation';
   }
 }
 
 /// Represents an encoding error.
 class EncodingErrorToken extends ErrorToken {
   EncodingErrorToken(int charOffset) : super(charOffset);
 
   String toString() => "EncodingErrorToken()";
 
   String get assertionMessage => "Unable to decode bytes as UTF-8.";
 
-  ErrorKind get errorCode => ErrorKind.Encoding;
+  FastaCode get errorCode => codeEncoding;
 }
 
 /// Represents a non-ASCII character outside a string or comment.
 class NonAsciiIdentifierToken extends ErrorToken {
   final int character;
 
   NonAsciiIdentifierToken(this.character, int charOffset) : super(charOffset);
 
   String toString() => "NonAsciiIdentifierToken($character)";
 
   String get assertionMessage {
     String c = new String.fromCharCodes([character]);
     String hex = character.toRadixString(16);
     String padding = "0000".substring(hex.length);
     hex = "$padding$hex";
     return "The non-ASCII character '$c' (U+$hex) can't be used in identifiers,"
         " only in strings and comments.\n"
         "Try using an US-ASCII letter, a digit, '_' (an underscore),"
         " or '\$' (a dollar sign).";
   }
 
-  ErrorKind get errorCode => ErrorKind.NonAsciiIdentifier;
+  FastaCode get errorCode => codeNonAsciiIdentifier;
 }
 
 /// Represents a non-ASCII whitespace outside a string or comment.
 class NonAsciiWhitespaceToken extends ErrorToken {
   final int character;
 
   NonAsciiWhitespaceToken(this.character, int charOffset) : super(charOffset);
 
   String toString() => "NonAsciiWhitespaceToken($character)";
 
   String get assertionMessage {
     String hex = character.toRadixString(16);
     return "The non-ASCII space character U+$hex can only be used in strings "
         "and comments.";
   }
 
-  ErrorKind get errorCode => ErrorKind.NonAsciiWhitespace;
+  FastaCode get errorCode => codeNonAsciiWhitespace;
 }
 
 /// Represents an ASCII control character outside a string or comment.
 class AsciiControlCharacterToken extends ErrorToken {
   final int character;
 
   AsciiControlCharacterToken(this.character, int charOffset)
       : super(charOffset);
 
   String toString() => "AsciiControlCharacterToken($character)";
 
   String get assertionMessage {
     String hex = character.toRadixString(16);
     return "The control character U+$hex can only be used in strings and "
         "comments.";
   }
 
-  ErrorKind get errorCode => ErrorKind.AsciiControlCharacter;
+  FastaCode get errorCode => codeAsciiControlCharacter;
 }
 
 /// Represents an unterminated string.
 class UnterminatedToken extends ErrorToken {
   final String start;
   final int endOffset;
 
   UnterminatedToken(this.start, int charOffset, this.endOffset)
       : super(charOffset);
 
   String toString() => "UnterminatedToken($start)";
 
   String get assertionMessage => "'$start' isn't terminated.";
 
   int get charCount => endOffset - charOffset;
 
-  ErrorKind get errorCode {
+  FastaCode get errorCode {
     switch (start) {
       case '1e':
-        return ErrorKind.MissingExponent;
+        return codeMissingExponent;
 
       case '"':
       case "'":
       case '"""':
       case "'''":
       case 'r"':
       case "r'":
       case 'r"""':
       case "r'''":
-        return ErrorKind.UnterminatedString;
+        return codeUnterminatedString;
 
       case '0x':
-        return ErrorKind.ExpectedHexDigit;
+        return codeExpectedHexDigit;
 
       case r'$':
-        return ErrorKind.UnexpectedDollarInString;
+        return codeUnexpectedDollarInString;
 
       case '/*':
-        return ErrorKind.UnterminatedComment;
+        return codeUnterminatedComment;
 
       default:
-        return ErrorKind.UnterminatedToken;
+        return codeUnterminatedToken;
     }
   }
 }
 
 /// Represents an open brace without a matching close brace.
 ///
 /// In this case, brace means any of `(`, `{`, `[`, and `<`, parenthesis, curly
 /// brace, square brace, and angle brace, respectively.
 class UnmatchedToken extends ErrorToken {
   final BeginGroupToken begin;
 
   UnmatchedToken(BeginGroupToken begin)
       : this.begin = begin,
         super(begin.charOffset);
 
   String toString() => "UnmatchedToken(${begin.lexeme})";
 
   String get assertionMessage => "'$begin' isn't closed.";
 
-  ErrorKind get errorCode => ErrorKind.UnmatchedToken;
+  FastaCode get errorCode => codeUnmatchedToken;
 }