Split MessageKind into a MessageKind key and a MessageTemplate.

pkg/compiler/lib/src/warnings.dart

 // Copyright (c) 2011, 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 license that can be found in the LICENSE file.
 
-part of dart2js;
-
-const DONT_KNOW_HOW_TO_FIX = "Computer says no!";
 
 /**
  * The messages in this file should meet the following guide lines:
  *
  * 1. The message should be a complete sentence starting with an uppercase
  * letter, and ending with a period.
  *
  * 2. Reserved words and embedded identifiers should be in single quotes, so
  * prefer double quotes for the complete message. For example, "The
  * class '#{className}' can't use 'super'." Notice that the word 'class' in the
@@ skipping 38 matching lines @@
  * An INFO message should always be preceded by a non-INFO message, and the
  * INFO messages are additional details about the preceding non-INFO
  * message. For example, consider duplicated elements. First report a WARNING
  * or ERROR about the duplicated element, and then report an INFO about the
  * location of the existing element.
  *
  * Generally, we want to provide messages that consists of three sentences:
  * 1. what is wrong, 2. why is it wrong, 3. how do I fix it. However, we
  * combine the first two in [template] and the last in [howToFix].
  */
+
+library dart2js.messages;
+
+import 'dart2jslib.dart';
+import 'scanner/scannerlib.dart';
+
+const DONT_KNOW_HOW_TO_FIX = "Computer says no!";
+
+/// Keys for the [MessageTemplate]s.
+enum MessageKind {
+  ABSTRACT_CLASS_INSTANTIATION,

[karlklose, 2015/07/23 11:04:00]

The style guide changed to 'In new code, use lowerCamelCase for constant
variables, including enum values.' and we already comply to this in other parts
of the compiler (for example JsBuiltin, but not JsGetName).

Consider changing the style.

[Johnni Winther, 2015/07/23 12:34:46]

Acknowledged.

+  ABSTRACT_GETTER,
+  ABSTRACT_METHOD,
+  ABSTRACT_SETTER,
+  ACCESSED_IN_CLOSURE,
+  ACCESSED_IN_CLOSURE_HERE,
+  ADDITIONAL_ARGUMENT,
+  ADDITIONAL_TYPE_ARGUMENT,
+  ALREADY_INITIALIZED,
+  AMBIGUOUS_LOCATION,
+  AMBIGUOUS_REEXPORT,
+  ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
+  ASSIGNING_METHOD,
+  ASSIGNING_METHOD_IN_SUPER,
+  ASSIGNING_TYPE,
+  ASYNC_KEYWORD_AS_IDENTIFIER,
+  ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
+  ASYNC_MODIFIER_ON_CONSTRUCTOR,
+  ASYNC_MODIFIER_ON_SETTER,
+  AWAIT_MEMBER_NOT_FOUND,
+  AWAIT_MEMBER_NOT_FOUND_IN_CLOSURE,
+  BAD_INPUT_CHARACTER,
+  BEFORE_TOP_LEVEL,
+  BINARY_OPERATOR_BAD_ARITY,
+  BODY_EXPECTED,
+  CALL_NOT_SUPPORTED_ON_NATIVE_CLASS,
+  CANNOT_EXTEND,
+  CANNOT_EXTEND_ENUM,
+  CANNOT_EXTEND_MALFORMED,
+  CANNOT_FIND_CONSTRUCTOR,
+  CANNOT_IMPLEMENT,
+  CANNOT_IMPLEMENT_ENUM,
+  CANNOT_IMPLEMENT_MALFORMED,
+  CANNOT_INSTANTIATE_ENUM,
+  CANNOT_INSTANTIATE_TYPE_VARIABLE,
+  CANNOT_INSTANTIATE_TYPEDEF,
+  CANNOT_MIXIN,
+  CANNOT_MIXIN_ENUM,
+  CANNOT_MIXIN_MALFORMED,
+  CANNOT_OVERRIDE_FIELD_WITH_METHOD,
+  CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT,
+  CANNOT_OVERRIDE_GETTER_WITH_METHOD,
+  CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT,
+  CANNOT_OVERRIDE_METHOD_WITH_FIELD,
+  CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT,
+  CANNOT_OVERRIDE_METHOD_WITH_GETTER,
+  CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT,
+  CANNOT_RESOLVE,
+  CANNOT_RESOLVE_AWAIT,
+  CANNOT_RESOLVE_AWAIT_IN_CLOSURE,
+  CANNOT_RESOLVE_CONSTRUCTOR,
+  CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT,
+  CANNOT_RESOLVE_GETTER,
+  CANNOT_RESOLVE_IN_INITIALIZER,
+  CANNOT_RESOLVE_SETTER,
+  CANNOT_RESOLVE_TYPE,
+  CANNOT_RETURN_FROM_CONSTRUCTOR,
+  CLASS_NAME_EXPECTED,
+  COMPILER_CRASHED,
+  COMPLEX_RETURNING_NSM,
+  COMPLEX_THROWING_NSM,
+  CONSIDER_ANALYZE_ALL,
+  CONST_CALLS_NON_CONST,
+  CONST_CALLS_NON_CONST_FOR_IMPLICIT,
+  CONST_CONSTRUCTOR_HAS_BODY,
+  CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
+  CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
+  CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
+  CONST_MAP_KEY_OVERRIDES_EQUALS,
+  CONST_WITHOUT_INITIALIZER,
+  CONSTRUCTOR_CALL_EXPECTED,
+  CONSTRUCTOR_IS_NOT_CONST,
+  CONSTRUCTOR_WITH_RETURN_TYPE,
+  CYCLIC_CLASS_HIERARCHY,
+  CYCLIC_COMPILE_TIME_CONSTANTS,
+  CYCLIC_REDIRECTING_FACTORY,
+  CYCLIC_TYPE_VARIABLE,
+  CYCLIC_TYPEDEF,
+  CYCLIC_TYPEDEF_ONE,
+  DART_EXT_NOT_SUPPORTED,
+  DEFERRED_COMPILE_TIME_CONSTANT,
+  DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION,
+  DEFERRED_LIBRARY_DART_2_DART,
+  DEFERRED_LIBRARY_DUPLICATE_PREFIX,
+  DEFERRED_LIBRARY_WITHOUT_PREFIX,
+  DEFERRED_OLD_SYNTAX,
+  DEFERRED_TYPE_ANNOTATION,
+  DEPRECATED_TYPEDEF_MIXIN_SYNTAX,
+  DIRECTLY_THROWING_NSM,
+  DUPLICATE_DEFINITION,
+  DUPLICATE_EXPORT,
+  DUPLICATE_EXPORT_CONT,
+  DUPLICATE_EXPORT_DECL,
+  DUPLICATE_EXTENDS_IMPLEMENTS,
+  DUPLICATE_IMPLEMENTS,
+  DUPLICATE_IMPORT,
+  DUPLICATE_INITIALIZER,
+  DUPLICATE_LABEL,
+  DUPLICATE_SUPER_INITIALIZER,
+  DUPLICATE_TYPE_VARIABLE_NAME,
+  DUPLICATED_LIBRARY_NAME,
+  DUPLICATED_LIBRARY_RESOURCE,
+  DUPLICATED_PART_OF,
+  DUPLICATED_RESOURCE,
+  EMPTY_CATCH_DECLARATION,
+  EMPTY_ENUM_DECLARATION,
+  EQUAL_MAP_ENTRY_KEY,
+  EXISTING_DEFINITION,
+  EXISTING_LABEL,
+  EXPECTED_IDENTIFIER_NOT_RESERVED_WORD,
+  EXPONENT_MISSING,
+  EXPORT_BEFORE_PARTS,
+  EXTERNAL_WITH_BODY,
+  EXTRA_CATCH_DECLARATION,
+  EXTRA_FORMALS,
+  EXTRANEOUS_MODIFIER,
+  EXTRANEOUS_MODIFIER_REPLACE,
+  FACTORY_REDIRECTION_IN_NON_FACTORY,
+  FINAL_FUNCTION_TYPE_PARAMETER,
+  FINAL_WITHOUT_INITIALIZER,
+  FORMAL_DECLARED_CONST,
+  FORMAL_DECLARED_STATIC,
+  FUNCTION_TYPE_FORMAL_WITH_DEFAULT,
+  FUNCTION_WITH_INITIALIZER,
+  GENERIC,
+  GETTER_MISMATCH,
+  GETTER_NOT_FOUND,
+  HEX_DIGIT_EXPECTED,
+  HIDDEN_HINTS,
+  HIDDEN_IMPLICIT_IMPORT,
+  HIDDEN_IMPORT,
+  HIDDEN_WARNINGS,
+  HIDDEN_WARNINGS_HINTS,
+  IF_NULL_ASSIGNING_TYPE,
+  ILLEGAL_CONST_FIELD_MODIFIER,
+  ILLEGAL_CONSTRUCTOR_MODIFIERS,
+  ILLEGAL_FINAL_METHOD_MODIFIER,
+  ILLEGAL_MIXIN_APPLICATION_MODIFIERS,
+  ILLEGAL_MIXIN_CONSTRUCTOR,
+  ILLEGAL_MIXIN_CYCLE,
+  ILLEGAL_MIXIN_OBJECT,
+  ILLEGAL_MIXIN_SUPER_USE,
+  ILLEGAL_MIXIN_SUPERCLASS,
+  ILLEGAL_MIXIN_WITH_SUPER,
+  ILLEGAL_SETTER_FORMALS,
+  ILLEGAL_STATIC,
+  ILLEGAL_SUPER_SEND,
+  IMPORT_BEFORE_PARTS,
+  IMPORT_EXPERIMENTAL_MIRRORS,
+  IMPORT_PART_OF,
+  IMPORTED_HERE,
+  INHERIT_GETTER_AND_METHOD,
+  INHERITED_EXPLICIT_GETTER,
+  INHERITED_IMPLICIT_GETTER,
+  INHERITED_METHOD,
+  INIT_STATIC_FIELD,
+  INITIALIZING_FORMAL_NOT_ALLOWED,
+  INSTANCE_STATIC_SAME_NAME,
+  INSTANCE_STATIC_SAME_NAME_CONT,
+  INTERNAL_LIBRARY,
+  INTERNAL_LIBRARY_FROM,
+  INVALID_ARGUMENT_AFTER_NAMED,
+  INVALID_AWAIT_FOR,
+  INVALID_BREAK,
+  INVALID_CASE_DEFAULT,
+  INVALID_CONSTRUCTOR_ARGUMENTS,
+  INVALID_CONSTRUCTOR_NAME,
+  INVALID_CONTINUE,
+  INVALID_FOR_IN,
+  INVALID_INITIALIZER,
+  INVALID_OVERRIDDEN_FIELD,
+  INVALID_OVERRIDDEN_GETTER,
+  INVALID_OVERRIDDEN_METHOD,
+  INVALID_OVERRIDDEN_SETTER,
+  INVALID_OVERRIDE_FIELD,
+  INVALID_OVERRIDE_FIELD_WITH_GETTER,
+  INVALID_OVERRIDE_FIELD_WITH_SETTER,
+  INVALID_OVERRIDE_GETTER,
+  INVALID_OVERRIDE_GETTER_WITH_FIELD,
+  INVALID_OVERRIDE_METHOD,
+  INVALID_OVERRIDE_SETTER,
+  INVALID_OVERRIDE_SETTER_WITH_FIELD,
+  INVALID_PACKAGE_URI,
+  INVALID_PARAMETER,
+  INVALID_RECEIVER_IN_INITIALIZER,
+  INVALID_SOURCE_FILE_LOCATION,
+  INVALID_SYMBOL,
+  INVALID_SYNC_MODIFIER,
+  INVALID_TYPE_VARIABLE_BOUND,
+  INVALID_UNNAMED_CONSTRUCTOR_NAME,
+  INVALID_URI,
+  INVALID_USE_OF_SUPER,
+  LIBRARY_NAME_MISMATCH,
+  LIBRARY_NOT_FOUND,
+  LIBRARY_TAG_MUST_BE_FIRST,
+  MAIN_NOT_A_FUNCTION,
+  MAIN_WITH_EXTRA_PARAMETER,
+  MALFORMED_STRING_LITERAL,
+  MEMBER_NOT_FOUND,
+  MEMBER_NOT_STATIC,
+  MEMBER_USES_CLASS_NAME,
+  METHOD_NOT_FOUND,
+  MINUS_OPERATOR_BAD_ARITY,
+  MIRROR_BLOAT,
+  MIRROR_IMPORT,
+  MIRROR_IMPORT_NO_USAGE,
+  MIRRORS_CANNOT_FIND_IN_ELEMENT,
+  MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY,
+  MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
+  MIRRORS_EXPECTED_STRING,
+  MIRRORS_EXPECTED_STRING_OR_LIST,
+  MIRRORS_EXPECTED_STRING_OR_TYPE,
+  MIRRORS_EXPECTED_STRING_TYPE_OR_LIST,
+  MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND,
+  MISSING_ARGUMENT,
+  MISSING_ENUM_CASES,
+  MISSING_FACTORY_KEYWORD,
+  MISSING_FORMALS,
+  MISSING_LIBRARY_NAME,
+  MISSING_MAIN,
+  MISSING_PART_OF_TAG,
+  MISSING_TOKEN_AFTER_THIS,
+  MISSING_TOKEN_BEFORE_THIS,
+  MISSING_TYPE_ARGUMENT,
+  MULTI_INHERITANCE,
+  NAMED_ARGUMENT_NOT_FOUND,
+  NAMED_FUNCTION_EXPRESSION,
+  NAMED_PARAMETER_WITH_EQUALS,
+  NATIVE_NOT_SUPPORTED,
+  NO_BREAK_TARGET,
+  NO_CATCH_NOR_FINALLY,
+  NO_CONTINUE_TARGET,
+  NO_INSTANCE_AVAILABLE,
+  NO_MATCHING_CONSTRUCTOR,
+  NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT,
+  NO_STATIC_OVERRIDE,
+  NO_STATIC_OVERRIDE_CONT,
+  NO_SUCH_LIBRARY_MEMBER,
+  NO_SUCH_METHOD_IN_NATIVE,
+  NO_SUCH_SUPER_MEMBER,
+  NO_SUPER_IN_STATIC,
+  NO_THIS_AVAILABLE,
+  NON_CONST_BLOAT,
+  NOT_A_COMPILE_TIME_CONSTANT,
+  NOT_A_FIELD,
+  NOT_A_PREFIX,
+  NOT_A_TYPE,
+  NOT_ASSIGNABLE,
+  NOT_CALLABLE,
+  NOT_INSTANCE_FIELD,
+  NOT_MORE_SPECIFIC,
+  NOT_MORE_SPECIFIC_SUBTYPE,
+  NOT_MORE_SPECIFIC_SUGGESTION,
+  NULL_NOT_ALLOWED,
+  ONLY_ONE_LIBRARY_TAG,
+  OPERATOR_NAMED_PARAMETERS,
+  OPERATOR_NOT_FOUND,
+  OPERATOR_OPTIONAL_PARAMETERS,
+  OPTIONAL_PARAMETER_IN_CATCH,
+  OVERRIDE_EQUALS_NOT_HASH_CODE,
+  PARAMETER_NAME_EXPECTED,
+  PARAMETER_WITH_MODIFIER_IN_CATCH,
+  PARAMETER_WITH_TYPE_IN_CATCH,
+  PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION,
+  PATCH_NO_GETTER,
+  PATCH_NO_SETTER,
+  PATCH_NON_CLASS,
+  PATCH_NON_CONSTRUCTOR,
+  PATCH_NON_EXISTING,
+  PATCH_NON_EXTERNAL,
+  PATCH_NON_FUNCTION,
+  PATCH_NON_GETTER,
+  PATCH_NON_SETTER,
+  PATCH_NONPATCHABLE,
+  PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH,
+  PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH,
+  PATCH_PARAMETER_MISMATCH,
+  PATCH_PARAMETER_TYPE_MISMATCH,
+  PATCH_POINT_TO_CLASS,
+  PATCH_POINT_TO_CONSTRUCTOR,
+  PATCH_POINT_TO_FUNCTION,
+  PATCH_POINT_TO_GETTER,
+  PATCH_POINT_TO_PARAMETER,
+  PATCH_POINT_TO_SETTER,
+  PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH,
+  PATCH_RETURN_TYPE_MISMATCH,
+  PLEASE_REPORT_THE_CRASH,
+  POSITIONAL_PARAMETER_WITH_EQUALS,
+  POTENTIAL_MUTATION,
+  POTENTIAL_MUTATION_HERE,
+  POTENTIAL_MUTATION_IN_CLOSURE,
+  POTENTIAL_MUTATION_IN_CLOSURE_HERE,
+  PREAMBLE,
+  PREFIX_AS_EXPRESSION,
+  PRIVATE_ACCESS,
+  PRIVATE_IDENTIFIER,
+  PRIVATE_NAMED_PARAMETER,
+  READ_SCRIPT_ERROR,
+  READ_SELF_ERROR,
+  REDIRECTING_CONSTRUCTOR_CYCLE,
+  REDIRECTING_CONSTRUCTOR_HAS_BODY,
+  REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER,
+  REDIRECTING_FACTORY_WITH_DEFAULT,
+  REFERENCE_IN_INITIALIZATION,
+  REQUIRED_PARAMETER_WITH_DEFAULT,
+  RETURN_IN_GENERATOR,
+  RETURN_NOTHING,
+  RETURN_VALUE_IN_VOID,
+  SETTER_MISMATCH,
+  SETTER_NOT_FOUND,
+  SETTER_NOT_FOUND_IN_SUPER,
+  STATIC_FUNCTION_BLOAT,
+  STRING_EXPECTED,
+  SUPER_INITIALIZER_IN_OBJECT,
+  SWITCH_CASE_FORBIDDEN,
+  SWITCH_CASE_TYPES_NOT_EQUAL,
+  SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
+  SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
+  TERNARY_OPERATOR_BAD_ARITY,
+  THIS_IS_THE_DECLARATION,
+  THIS_IS_THE_METHOD,
+  THIS_IS_THE_PART_OF_TAG,
+  THIS_PROPERTY,
+  THROW_WITHOUT_EXPRESSION,
+  TOP_LEVEL_VARIABLE_DECLARED_STATIC,
+  TYPE_ARGUMENT_COUNT_MISMATCH,
+  TYPE_VARIABLE_IN_CONSTANT,
+  TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
+  TYPEDEF_FORMAL_WITH_DEFAULT,
+  UNARY_OPERATOR_BAD_ARITY,
+  UNBOUND_LABEL,
+  UNIMPLEMENTED_EXPLICIT_GETTER,
+  UNIMPLEMENTED_EXPLICIT_SETTER,
+  UNIMPLEMENTED_GETTER,
+  UNIMPLEMENTED_GETTER_ONE,
+  UNIMPLEMENTED_IMPLICIT_GETTER,
+  UNIMPLEMENTED_IMPLICIT_SETTER,
+  UNIMPLEMENTED_METHOD,
+  UNIMPLEMENTED_METHOD_CONT,
+  UNIMPLEMENTED_METHOD_ONE,
+  UNIMPLEMENTED_SETTER,
+  UNIMPLEMENTED_SETTER_ONE,
+  UNMATCHED_TOKEN,
+  UNSUPPORTED_BANG_EQ_EQ,
+  UNSUPPORTED_EQ_EQ_EQ,
+  UNSUPPORTED_LITERAL_SYMBOL,
+  UNSUPPORTED_PREFIX_PLUS,
+  UNSUPPORTED_THROW_WITHOUT_EXP,
+  UNTERMINATED_COMMENT,
+  UNTERMINATED_STRING,
+  UNTERMINATED_TOKEN,
+  UNUSED_CLASS,
+  UNUSED_LABEL,
+  UNUSED_METHOD,
+  UNUSED_TYPEDEF,
+  VAR_FUNCTION_TYPE_PARAMETER,
+  VOID_EXPRESSION,
+  VOID_NOT_ALLOWED,
+  VOID_VARIABLE,
+  WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT,
+  WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
+  YIELDING_MODIFIER_ON_ARROW_BODY,
+}
+
+/// A message template for an error, warning, hint or info message generated
+/// by the compiler. Each template is associated with a [MessageKind] that
+/// uniquely identifies the message template.
 // TODO(johnnniwinther): For Infos, consider adding a reference to the
 // error/warning/hint that they belong to.
-class MessageKind {
+class MessageTemplate {
+  final MessageKind kind;
+
   /// Should describe what is wrong and why.
   final String template;
 
   /// Should describe how to fix the problem. Elided when using --terse option.
   final String howToFix;
 
   /**
    *  Examples will be checked by
    *  tests/compiler/dart2js/message_kind_test.dart.
    *
    *  An example is either a String containing the example source code or a Map
    *  from filenames to source code. In the latter case, the filename for the
    *  main library code must be 'main.dart'.
    */
   final List examples;
 
   /// Additional options needed for the examples to work.
   final List<String> options;
 
-  const MessageKind(this.template,
-                    {this.howToFix,
-                     this.examples,
-                     this.options: const <String>[]});
+  const MessageTemplate(
+      this.kind,
+      this.template,
+      {this.howToFix,
+       this.examples,
+       this.options: const <String>[]});
 
-  /// Do not use this. It is here for legacy and debugging. It violates item 4
-  /// above.
-  static const MessageKind GENERIC = const MessageKind('#{text}');
+  /// All templates used by the compiler.
+  ///
+  /// The map is complete mapping from [MessageKind] to their corresponding
+  /// [MessageTemplate].
+  static const Map<MessageKind, MessageTemplate> TEMPLATES =
+    const <MessageKind, MessageTemplate>{
+      /// Do not use this. It is here for legacy and debugging. It violates item
+      /// 4 above.

[karlklose, 2015/07/23 11:04:00]

'above' -> 'of the guide lines for error messages in the beginning of the file'?

[Johnni Winther, 2015/07/23 12:34:46]

Done.

+      MessageKind.GENERIC:
+        const MessageTemplate(MessageKind.GENERIC, '#{text}'),
 
-  static const MessageKind NOT_ASSIGNABLE = const MessageKind(
-      "'#{fromType}' is not assignable to '#{toType}'.");
+      MessageKind.NOT_ASSIGNABLE:
+        const MessageTemplate(MessageKind.NOT_ASSIGNABLE,
+          "'#{fromType}' is not assignable to '#{toType}'."),
 
-  static const MessageKind VOID_EXPRESSION = const MessageKind(
-      "Expression does not yield a value.");
+      MessageKind.VOID_EXPRESSION:
+        const MessageTemplate(MessageKind.VOID_EXPRESSION,
+          "Expression does not yield a value."),
 
-  static const MessageKind VOID_VARIABLE = const MessageKind(
-      "Variable cannot be of type void.");
+      MessageKind.VOID_VARIABLE:
+        const MessageTemplate(MessageKind.VOID_VARIABLE,
+          "Variable cannot be of type void."),
 
-  static const MessageKind RETURN_VALUE_IN_VOID = const MessageKind(
-      "Cannot return value from void function.");
+      MessageKind.RETURN_VALUE_IN_VOID:
+        const MessageTemplate(MessageKind.RETURN_VALUE_IN_VOID,
+          "Cannot return value from void function."),
 
-  static const MessageKind RETURN_NOTHING = const MessageKind(
-      "Value of type '#{returnType}' expected.");
+      MessageKind.RETURN_NOTHING:
+        const MessageTemplate(MessageKind.RETURN_NOTHING,
+          "Value of type '#{returnType}' expected."),
 
-  static const MessageKind MISSING_ARGUMENT = const MessageKind(
-      "Missing argument of type '#{argumentType}'.");
+      MessageKind.MISSING_ARGUMENT:
+        const MessageTemplate(MessageKind.MISSING_ARGUMENT,
+          "Missing argument of type '#{argumentType}'."),
 
-  static const MessageKind ADDITIONAL_ARGUMENT = const MessageKind(
-      "Additional argument.");
+      MessageKind.ADDITIONAL_ARGUMENT:
+        const MessageTemplate(MessageKind.ADDITIONAL_ARGUMENT,
+          "Additional argument."),
 
-  static const MessageKind NAMED_ARGUMENT_NOT_FOUND = const MessageKind(
-      "No named argument '#{argumentName}' found on method.");
+      MessageKind.NAMED_ARGUMENT_NOT_FOUND:
+        const MessageTemplate(MessageKind.NAMED_ARGUMENT_NOT_FOUND,
+          "No named argument '#{argumentName}' found on method."),
 
-  static const MessageKind MEMBER_NOT_FOUND = const MessageKind(
-      "No member named '#{memberName}' in class '#{className}'.");
+      MessageKind.MEMBER_NOT_FOUND:
+        const MessageTemplate(MessageKind.MEMBER_NOT_FOUND,
+          "No member named '#{memberName}' in class '#{className}'."),
 
-  static const MessageKind AWAIT_MEMBER_NOT_FOUND = const MessageKind(
-      "No member named 'await' in class '#{className}'.",
-      howToFix: "Did you mean to add the 'async' marker "
-                "to '#{functionName}'?",
-      examples: const ["""
+      MessageKind.AWAIT_MEMBER_NOT_FOUND:
+        const MessageTemplate(MessageKind.AWAIT_MEMBER_NOT_FOUND,
+          "No member named 'await' in class '#{className}'.",
+          howToFix: "Did you mean to add the 'async' marker "
+                    "to '#{functionName}'?",
+          examples: const ["""
 class A {
   m() => await -3;
 }
 main() => new A().m();
-"""]);
+"""]),
 
-  static const MessageKind AWAIT_MEMBER_NOT_FOUND_IN_CLOSURE =
-      const MessageKind("No member named 'await' in class '#{className}'.",
-      howToFix: "Did you mean to add the 'async' marker "
-                "to the enclosing function?",
-      examples: const ["""
+      MessageKind.AWAIT_MEMBER_NOT_FOUND_IN_CLOSURE:
+        const MessageTemplate(MessageKind.AWAIT_MEMBER_NOT_FOUND_IN_CLOSURE,
+          "No member named 'await' in class '#{className}'.",
+          howToFix: "Did you mean to add the 'async' marker "
+                    "to the enclosing function?",
+          examples: const ["""
 class A {
   m() => () => await -3;
 }
 main() => new A().m();
-"""]);
+"""]),
 
-  static const MessageKind METHOD_NOT_FOUND = const MessageKind(
-      "No method named '#{memberName}' in class '#{className}'.");
+      MessageKind.METHOD_NOT_FOUND:
+        const MessageTemplate(MessageKind.METHOD_NOT_FOUND,
+          "No method named '#{memberName}' in class '#{className}'."),
 
-  static const MessageKind OPERATOR_NOT_FOUND = const MessageKind(
-      "No operator '#{memberName}' in class '#{className}'.");
+      MessageKind.OPERATOR_NOT_FOUND:
+        const MessageTemplate(MessageKind.OPERATOR_NOT_FOUND,
+          "No operator '#{memberName}' in class '#{className}'."),
 
-  static const MessageKind SETTER_NOT_FOUND = const MessageKind(
-      "No setter named '#{memberName}' in class '#{className}'.");
+      MessageKind.SETTER_NOT_FOUND:
+        const MessageTemplate(MessageKind.SETTER_NOT_FOUND,
+          "No setter named '#{memberName}' in class '#{className}'."),
 
-  static const MessageKind SETTER_NOT_FOUND_IN_SUPER = const MessageKind(
-      "No setter named '#{name}' in superclass of '#{className}'.");
+      MessageKind.SETTER_NOT_FOUND_IN_SUPER:
+        const MessageTemplate(MessageKind.SETTER_NOT_FOUND_IN_SUPER,
+          "No setter named '#{name}' in superclass of '#{className}'."),
 
-  static const MessageKind GETTER_NOT_FOUND = const MessageKind(
-      "No getter named '#{memberName}' in class '#{className}'.");
+      MessageKind.GETTER_NOT_FOUND:
+        const MessageTemplate(MessageKind.GETTER_NOT_FOUND,
+          "No getter named '#{memberName}' in class '#{className}'."),
 
-  static const MessageKind NOT_CALLABLE = const MessageKind(
-      "'#{elementName}' is not callable.");
+      MessageKind.NOT_CALLABLE:
+        const MessageTemplate(MessageKind.NOT_CALLABLE,
+          "'#{elementName}' is not callable."),
 
-  static const MessageKind MEMBER_NOT_STATIC = const MessageKind(
-      "'#{className}.#{memberName}' is not static.");
+      MessageKind.MEMBER_NOT_STATIC:
+        const MessageTemplate(MessageKind.MEMBER_NOT_STATIC,
+          "'#{className}.#{memberName}' is not static."),
 
-  static const MessageKind NO_INSTANCE_AVAILABLE = const MessageKind(
-      "'#{name}' is only available in instance methods.");
+      MessageKind.NO_INSTANCE_AVAILABLE:
+        const MessageTemplate(MessageKind.NO_INSTANCE_AVAILABLE,
+          "'#{name}' is only available in instance methods."),
 
-  static const MessageKind NO_THIS_AVAILABLE = const MessageKind(
-      "'this' is only available in instance methods.");
+      MessageKind.NO_THIS_AVAILABLE:
+        const MessageTemplate(MessageKind.NO_THIS_AVAILABLE,
+          "'this' is only available in instance methods."),
 
-  static const MessageKind PRIVATE_ACCESS = const MessageKind(
-      "'#{name}' is declared private within library "
-      "'#{libraryName}'.");
+      MessageKind.PRIVATE_ACCESS:
+        const MessageTemplate(MessageKind.PRIVATE_ACCESS,
+          "'#{name}' is declared private within library "
+          "'#{libraryName}'."),
 
-  static const MessageKind THIS_IS_THE_DECLARATION = const MessageKind(
-      "This is the declaration of '#{name}'.");
+      MessageKind.THIS_IS_THE_DECLARATION:
+        const MessageTemplate(MessageKind.THIS_IS_THE_DECLARATION,
+          "This is the declaration of '#{name}'."),
 
-  static const MessageKind THIS_IS_THE_METHOD = const MessageKind(
-      "This is the method declaration.");
+      MessageKind.THIS_IS_THE_METHOD:
+        const MessageTemplate(MessageKind.THIS_IS_THE_METHOD,
+          "This is the method declaration."),
 
-  static const MessageKind CANNOT_RESOLVE = const MessageKind(
-      "Cannot resolve '#{name}'.");
+      MessageKind.CANNOT_RESOLVE:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE,
+          "Cannot resolve '#{name}'."),
 
-  static const MessageKind CANNOT_RESOLVE_AWAIT = const MessageKind(
-      "Cannot resolve '#{name}'.",
-      howToFix: "Did you mean to add the 'async' marker "
-                "to '#{functionName}'?",
-      examples: const [
-          "main() => await -3;",
-          "foo() => await -3; main() => foo();"
-      ]);
+      MessageKind.CANNOT_RESOLVE_AWAIT:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_AWAIT,
+          "Cannot resolve '#{name}'.",
+          howToFix: "Did you mean to add the 'async' marker "
+                    "to '#{functionName}'?",
+          examples: const [
+              "main() => await -3;",
+              "foo() => await -3; main() => foo();"
+          ]),
 
-  static const MessageKind CANNOT_RESOLVE_AWAIT_IN_CLOSURE = const MessageKind(
-      "Cannot resolve '#{name}'.",
-      howToFix: "Did you mean to add the 'async' marker "
-                "to the enclosing function?",
-      examples: const [
-          "main() { (() => await -3)(); }",
-      ]);
+      MessageKind.CANNOT_RESOLVE_AWAIT_IN_CLOSURE:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_AWAIT_IN_CLOSURE,
+          "Cannot resolve '#{name}'.",
+          howToFix: "Did you mean to add the 'async' marker "
+                    "to the enclosing function?",
+          examples: const [
+              "main() { (() => await -3)(); }",
+          ]),
 
-  static const MessageKind CANNOT_RESOLVE_IN_INITIALIZER = const MessageKind(
-      "Cannot resolve '#{name}'. It would be implicitly looked up on this "
-      "instance, but instances are not available in initializers.",
-      howToFix: "Try correcting the unresolved reference or move the "
-          "initialization to a constructor body.",
-      examples: const ["""
+      MessageKind.CANNOT_RESOLVE_IN_INITIALIZER:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_IN_INITIALIZER,
+          "Cannot resolve '#{name}'. It would be implicitly looked up on this "
+          "instance, but instances are not available in initializers.",
+          howToFix: "Try correcting the unresolved reference or move the "
+              "initialization to a constructor body.",
+          examples: const ["""
 class A {
   var test = unresolvedName;
 }
 main() => new A();
-"""]);
+"""]),
 
-  static const MessageKind CANNOT_RESOLVE_CONSTRUCTOR = const MessageKind(
-      "Cannot resolve constructor '#{constructorName}'.");
+      MessageKind.CANNOT_RESOLVE_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_CONSTRUCTOR,
+          "Cannot resolve constructor '#{constructorName}'."),
 
-  static const MessageKind CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT =
-      const MessageKind("cannot resolve constructor '#{constructorName}'"
-          " for implicit super call.",
-      howToFix: "Try explicitly invoking a constructor of the super class",
-      examples: const ["""
+      MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT,
+          "cannot resolve constructor '#{constructorName}' "
+          "for implicit super call.",
+          howToFix: "Try explicitly invoking a constructor of the super class",
+          examples: const ["""
 class A {
   A.foo() {}
 }
 class B extends A {
   B();
 }
 main() => new B();
-"""]);
+"""]),
 
-  static const MessageKind INVALID_UNNAMED_CONSTRUCTOR_NAME = const MessageKind(
-      "Unnamed constructor name must be '#{name}'.");
+      MessageKind.INVALID_UNNAMED_CONSTRUCTOR_NAME:
+        const MessageTemplate(MessageKind.INVALID_UNNAMED_CONSTRUCTOR_NAME,
+          "Unnamed constructor name must be '#{name}'."),
 
-  static const MessageKind INVALID_CONSTRUCTOR_NAME = const MessageKind(
-      "Constructor name must start with '#{name}'.");
+      MessageKind.INVALID_CONSTRUCTOR_NAME:
+        const MessageTemplate(MessageKind.INVALID_CONSTRUCTOR_NAME,
+          "Constructor name must start with '#{name}'."),
 
-  static const MessageKind CANNOT_RESOLVE_TYPE = const MessageKind(
-      "Cannot resolve type '#{typeName}'.");
+      MessageKind.CANNOT_RESOLVE_TYPE:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_TYPE,
+          "Cannot resolve type '#{typeName}'."),
 
-  static const MessageKind DUPLICATE_DEFINITION = const MessageKind(
-      "Duplicate definition of '#{name}'.",
-      howToFix: "Try to rename or remove this definition.",
-      examples: const ["""
+      MessageKind.DUPLICATE_DEFINITION:
+        const MessageTemplate(MessageKind.DUPLICATE_DEFINITION,
+          "Duplicate definition of '#{name}'.",
+          howToFix: "Try to rename or remove this definition.",
+          examples: const ["""
 class C {
   void f() {}
   int get f => 1;
 }
 
 main() {
   new C();
 }
 
-"""]);
+"""]),
 
-  static const MessageKind EXISTING_DEFINITION = const MessageKind(
-      "Existing definition of '#{name}'.");
+      MessageKind.EXISTING_DEFINITION:
+        const MessageTemplate(MessageKind.EXISTING_DEFINITION,
+          "Existing definition of '#{name}'."),
 
-  static const MessageKind DUPLICATE_IMPORT = const MessageKind(
-      "Duplicate import of '#{name}'.");
+      MessageKind.DUPLICATE_IMPORT:
+        const MessageTemplate(MessageKind.DUPLICATE_IMPORT,
+          "Duplicate import of '#{name}'."),
 
-  static const MessageKind HIDDEN_IMPORT = const MessageKind(
-      "'#{name}' from library '#{hiddenUri}' is hidden by '#{name}' "
-      "from library '#{hidingUri}'.",
-      howToFix: "Try adding 'hide #{name}' to the import of '#{hiddenUri}'.",
-      examples: const [
-          const {
+      MessageKind.HIDDEN_IMPORT:
+        const MessageTemplate(MessageKind.HIDDEN_IMPORT,
+          "'#{name}' from library '#{hiddenUri}' is hidden by '#{name}' "
+          "from library '#{hidingUri}'.",
+          howToFix: "Try adding 'hide #{name}' to the import of '#{hiddenUri}'.",
+          examples: const [
+              const {
 'main.dart':
 """
 import 'dart:async'; // This imports a class Future.
 import 'future.dart';
 
 void main() => new Future();""",
 
 'future.dart':
 """
 library future;
@@ skipping 39 matching lines @@
 """
 import 'future.dart' as prefix;
 import 'dart:async' as prefix; // This imports a class Future.
 
 void main() => new prefix.Future();""",
 
 'future.dart':
 """
 library future;
 
-class Future {}"""}]);
+class Future {}"""}]),
 
 
-  static const MessageKind HIDDEN_IMPLICIT_IMPORT = const MessageKind(
-      "'#{name}' from library '#{hiddenUri}' is hidden by '#{name}' "
-      "from library '#{hidingUri}'.",
-      howToFix: "Try adding an explicit "
-                "'import \"#{hiddenUri}\" hide #{name}'.",
-      examples: const [
-          const {
+      MessageKind.HIDDEN_IMPLICIT_IMPORT:
+        const MessageTemplate(MessageKind.HIDDEN_IMPLICIT_IMPORT,
+          "'#{name}' from library '#{hiddenUri}' is hidden by '#{name}' "
+          "from library '#{hidingUri}'.",
+          howToFix: "Try adding an explicit "
+                    "'import \"#{hiddenUri}\" hide #{name}'.",
+          examples: const [
+              const {
 'main.dart':
 """
 // This hides the implicit import of class Type from dart:core.
 import 'type.dart';
 
 void main() => new Type();""",
 
 'type.dart':
 """
 library type;
@@ skipping 21 matching lines @@
 'main.dart':
 r"""
 library testDartConflicts;
 
 import 'conflictsWithDart.dart';
 import 'conflictsWithDartAsWell.dart';
 
 main() {
   print("Hail Caesar ${Duration.x}");
 }
-"""}]);
+"""}]),
 
-  static const MessageKind DUPLICATE_EXPORT = const MessageKind(
-      "Duplicate export of '#{name}'.",
-      howToFix: "Trying adding 'hide #{name}' to one of the exports.",
-      examples: const [const {
+      MessageKind.DUPLICATE_EXPORT:
+        const MessageTemplate(MessageKind.DUPLICATE_EXPORT,
+          "Duplicate export of '#{name}'.",
+          howToFix: "Trying adding 'hide #{name}' to one of the exports.",
+          examples: const [const {
 'main.dart': """
 export 'decl1.dart';
 export 'decl2.dart';
 
 main() {}""",
 'decl1.dart': "class Class {}",
-'decl2.dart': "class Class {}"}]);
+'decl2.dart': "class Class {}"}]),
 
-  static const MessageKind DUPLICATE_EXPORT_CONT = const MessageKind(
-      "This is another export of '#{name}'.");
+      MessageKind.DUPLICATE_EXPORT_CONT:
+        const MessageTemplate(MessageKind.DUPLICATE_EXPORT_CONT,
+          "This is another export of '#{name}'."),
 
-  static const MessageKind DUPLICATE_EXPORT_DECL = const MessageKind(
-      "The exported '#{name}' from export #{uriString} is defined here.");
+      MessageKind.DUPLICATE_EXPORT_DECL:
+        const MessageTemplate(MessageKind.DUPLICATE_EXPORT_DECL,
+          "The exported '#{name}' from export #{uriString} is defined here."),
 
-  static const MessageKind NOT_A_TYPE = const MessageKind(
-      "'#{node}' is not a type.");
+      MessageKind.NOT_A_TYPE:
+        const MessageTemplate(MessageKind.NOT_A_TYPE,
+          "'#{node}' is not a type."),
 
-  static const MessageKind NOT_A_PREFIX = const MessageKind(
-      "'#{node}' is not a prefix.");
+      MessageKind.NOT_A_PREFIX:
+        const MessageTemplate(MessageKind.NOT_A_PREFIX,
+          "'#{node}' is not a prefix."),
 
-  static const MessageKind PREFIX_AS_EXPRESSION = const MessageKind(
-      "Library prefix '#{prefix}' is not a valid expression.");
+      MessageKind.PREFIX_AS_EXPRESSION:
+        const MessageTemplate(MessageKind.PREFIX_AS_EXPRESSION,
+          "Library prefix '#{prefix}' is not a valid expression."),
 
-  static const MessageKind CANNOT_FIND_CONSTRUCTOR = const MessageKind(
-      "Cannot find constructor '#{constructorName}'.");
+      MessageKind.CANNOT_FIND_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.CANNOT_FIND_CONSTRUCTOR,
+          "Cannot find constructor '#{constructorName}'."),
 
-  static const MessageKind CYCLIC_CLASS_HIERARCHY = const MessageKind(
-      "'#{className}' creates a cycle in the class hierarchy.");
+      MessageKind.CYCLIC_CLASS_HIERARCHY:
+        const MessageTemplate(MessageKind.CYCLIC_CLASS_HIERARCHY,
+          "'#{className}' creates a cycle in the class hierarchy."),
 
-  static const MessageKind CYCLIC_REDIRECTING_FACTORY = const MessageKind(
-      'Redirecting factory leads to a cyclic redirection.');
+      MessageKind.CYCLIC_REDIRECTING_FACTORY:
+        const MessageTemplate(MessageKind.CYCLIC_REDIRECTING_FACTORY,
+          'Redirecting factory leads to a cyclic redirection.'),
 
-  static const MessageKind INVALID_RECEIVER_IN_INITIALIZER = const MessageKind(
-      "Field initializer expected.");
+      MessageKind.INVALID_RECEIVER_IN_INITIALIZER:
+        const MessageTemplate(MessageKind.INVALID_RECEIVER_IN_INITIALIZER,
+          "Field initializer expected."),
 
-  static const MessageKind NO_SUPER_IN_STATIC = const MessageKind(
-      "'super' is only available in instance methods.");
+      MessageKind.NO_SUPER_IN_STATIC:
+        const MessageTemplate(MessageKind.NO_SUPER_IN_STATIC,
+          "'super' is only available in instance methods."),
 
-  static const MessageKind DUPLICATE_INITIALIZER = const MessageKind(
-      "Field '#{fieldName}' is initialized more than once.");
+      MessageKind.DUPLICATE_INITIALIZER:
+        const MessageTemplate(MessageKind.DUPLICATE_INITIALIZER,
+          "Field '#{fieldName}' is initialized more than once."),
 
-  static const MessageKind ALREADY_INITIALIZED = const MessageKind(
-      "'#{fieldName}' was already initialized here.");
+      MessageKind.ALREADY_INITIALIZED:
+        const MessageTemplate(MessageKind.ALREADY_INITIALIZED,
+          "'#{fieldName}' was already initialized here."),
 
-  static const MessageKind INIT_STATIC_FIELD = const MessageKind(
-      "Cannot initialize static field '#{fieldName}'.");
+      MessageKind.INIT_STATIC_FIELD:
+        const MessageTemplate(MessageKind.INIT_STATIC_FIELD,
+          "Cannot initialize static field '#{fieldName}'."),
 
-  static const MessageKind NOT_A_FIELD = const MessageKind(
-      "'#{fieldName}' is not a field.");
+      MessageKind.NOT_A_FIELD:
+        const MessageTemplate(MessageKind.NOT_A_FIELD,
+          "'#{fieldName}' is not a field."),
 
-  static const MessageKind CONSTRUCTOR_CALL_EXPECTED = const MessageKind(
-      "only call to 'this' or 'super' constructor allowed.");
+      MessageKind.CONSTRUCTOR_CALL_EXPECTED:
+        const MessageTemplate(MessageKind.CONSTRUCTOR_CALL_EXPECTED,
+          "only call to 'this' or 'super' constructor allowed."),
 
-  static const MessageKind INVALID_FOR_IN = const MessageKind(
-      "Invalid for-in variable declaration.");
+      MessageKind.INVALID_FOR_IN:
+        const MessageTemplate(MessageKind.INVALID_FOR_IN,
+          "Invalid for-in variable declaration."),
 
-  static const MessageKind INVALID_INITIALIZER = const MessageKind(
-      "Invalid initializer.");
+      MessageKind.INVALID_INITIALIZER:
+        const MessageTemplate(MessageKind.INVALID_INITIALIZER,
+          "Invalid initializer."),
 
-  static const MessageKind FUNCTION_WITH_INITIALIZER = const MessageKind(
-      "Only constructors can have initializers.");
+      MessageKind.FUNCTION_WITH_INITIALIZER:
+        const MessageTemplate(MessageKind.FUNCTION_WITH_INITIALIZER,
+          "Only constructors can have initializers."),
 
-  static const MessageKind REDIRECTING_CONSTRUCTOR_CYCLE = const MessageKind(
-      "Cyclic constructor redirection.");
+      MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE:
+        const MessageTemplate(MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE,
+          "Cyclic constructor redirection."),
 
-  static const MessageKind REDIRECTING_CONSTRUCTOR_HAS_BODY = const MessageKind(
-      "Redirecting constructor can't have a body.");
+      MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY:
+        const MessageTemplate(MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY,
+          "Redirecting constructor can't have a body."),
 
-  static const MessageKind CONST_CONSTRUCTOR_HAS_BODY = const MessageKind(
-      "Const constructor or factory can't have a body.",
-      howToFix: "Remove the 'const' keyword or the body",
-      examples: const ["""
+      MessageKind.CONST_CONSTRUCTOR_HAS_BODY:
+        const MessageTemplate(MessageKind.CONST_CONSTRUCTOR_HAS_BODY,
+          "Const constructor or factory can't have a body.",
+          howToFix: "Remove the 'const' keyword or the body",
+          examples: const ["""
 class C {
   const C() {}
 }
 
-main() => new C();"""]);
+main() => new C();"""]),
 
-  static const MessageKind REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER =
-      const MessageKind(
-          "Redirecting constructor cannot have other initializers.");
+      MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER:
+        const MessageTemplate(MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER,

[karlklose, 2015/07/23 11:04:00]

Long line (here and multiple others below).

[Johnni Winther, 2015/07/23 12:34:46]

Done.

+              "Redirecting constructor cannot have other initializers."),
 
-  static const MessageKind SUPER_INITIALIZER_IN_OBJECT = const MessageKind(
-      "'Object' cannot have a super initializer.");
+      MessageKind.SUPER_INITIALIZER_IN_OBJECT:
+        const MessageTemplate(MessageKind.SUPER_INITIALIZER_IN_OBJECT,
+          "'Object' cannot have a super initializer."),
 
-  static const MessageKind DUPLICATE_SUPER_INITIALIZER = const MessageKind(
-      "Cannot have more than one super initializer.");
+      MessageKind.DUPLICATE_SUPER_INITIALIZER:
+        const MessageTemplate(MessageKind.DUPLICATE_SUPER_INITIALIZER,
+          "Cannot have more than one super initializer."),
 
-  static const MessageKind INVALID_CONSTRUCTOR_ARGUMENTS = const MessageKind(
-      "Arguments do not match the expected parameters of constructor "
-      "'#{constructorName}'.");
+      MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS:
+        const MessageTemplate(MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
+          "Arguments do not match the expected parameters of constructor "
+          "'#{constructorName}'."),
 
-  static const MessageKind NO_MATCHING_CONSTRUCTOR = const MessageKind(
-      "'super' call arguments and constructor parameters do not match.");
+      MessageKind.NO_MATCHING_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.NO_MATCHING_CONSTRUCTOR,
+          "'super' call arguments and constructor parameters do not match."),
 
-  static const MessageKind NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT =
-      const MessageKind(
-          "Implicit 'super' call arguments and constructor parameters "
-          "do not match.");
+      MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT:
+        const MessageTemplate(MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT,
+              "Implicit 'super' call arguments and constructor parameters "
+              "do not match."),
 
-  static const MessageKind CONST_CALLS_NON_CONST = const MessageKind(
-      "'const' constructor cannot call a non-const constructor.");
+      MessageKind.CONST_CALLS_NON_CONST:
+        const MessageTemplate(MessageKind.CONST_CALLS_NON_CONST,
+          "'const' constructor cannot call a non-const constructor."),
 
-  static const MessageKind CONST_CALLS_NON_CONST_FOR_IMPLICIT =
-      const MessageKind(
-          "'const' constructor cannot call a non-const constructor. "
-          "This constructor has an implicit call to a "
-          "super non-const constructor.",
-          howToFix: "Try making the super constructor const.",
-          examples: const ["""
+      MessageKind.CONST_CALLS_NON_CONST_FOR_IMPLICIT:
+        const MessageTemplate(MessageKind.CONST_CALLS_NON_CONST_FOR_IMPLICIT,
+              "'const' constructor cannot call a non-const constructor. "
+              "This constructor has an implicit call to a "
+              "super non-const constructor.",
+              howToFix: "Try making the super constructor const.",
+              examples: const ["""
 class C {
   C(); // missing const
 }
 class D extends C {
   final d;
   const D(this.d);
 }
-main() => new D(0);"""]);
+main() => new D(0);"""]),
 
-  static const MessageKind CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS =
-      const MessageKind(
+      MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS:
+        const MessageTemplate(MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
           "Can't declare constructor 'const' on class #{className} "
           "because the class contains non-final instance fields.",
           howToFix: "Try making all fields final.",
           examples: const ["""
 class C {
   // 'a' must be declared final to allow for the const constructor.
   var a;
   const C(this.a);
 }
 
-main() => new C(0);"""]);
+main() => new C(0);"""]),
 
-  static const MessageKind CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD =
-      const MessageKind("This non-final field prevents using const "
-                        "constructors.");
+      MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD:
+        const MessageTemplate(MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
+                            "This non-final field prevents using const "
+                            "constructors."),
 
-  static const MessageKind CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR =
-      const MessageKind("This const constructor is not allowed due to "
-                        "non-final fields.");
+      MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
+                            "This const constructor is not allowed due to "
+                            "non-final fields."),
 
 
-  static const MessageKind INITIALIZING_FORMAL_NOT_ALLOWED = const MessageKind(
-      "Initializing formal parameter only allowed in generative "
-      "constructor.");
+      MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED:
+        const MessageTemplate(MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED,
+          "Initializing formal parameter only allowed in generative "
+          "constructor."),
 
-  static const MessageKind INVALID_PARAMETER = const MessageKind(
-      "Cannot resolve parameter.");
+      MessageKind.INVALID_PARAMETER:
+        const MessageTemplate(MessageKind.INVALID_PARAMETER,
+          "Cannot resolve parameter."),
 
-  static const MessageKind NOT_INSTANCE_FIELD = const MessageKind(
-      "'#{fieldName}' is not an instance field.");
+      MessageKind.NOT_INSTANCE_FIELD:
+        const MessageTemplate(MessageKind.NOT_INSTANCE_FIELD,
+          "'#{fieldName}' is not an instance field."),
 
-  static const MessageKind THIS_PROPERTY = const MessageKind(
-      "Expected an identifier.");
+      MessageKind.THIS_PROPERTY:
+        const MessageTemplate(MessageKind.THIS_PROPERTY,
+          "Expected an identifier."),
 
-  static const MessageKind NO_CATCH_NOR_FINALLY = const MessageKind(
-      "Expected 'catch' or 'finally'.");
+      MessageKind.NO_CATCH_NOR_FINALLY:
+        const MessageTemplate(MessageKind.NO_CATCH_NOR_FINALLY,
+          "Expected 'catch' or 'finally'."),
 
-  static const MessageKind EMPTY_CATCH_DECLARATION = const MessageKind(
-      "Expected an identifier in catch declaration.");
+      MessageKind.EMPTY_CATCH_DECLARATION:
+        const MessageTemplate(MessageKind.EMPTY_CATCH_DECLARATION,
+          "Expected an identifier in catch declaration."),
 
-  static const MessageKind EXTRA_CATCH_DECLARATION = const MessageKind(
-      "Extra parameter in catch declaration.");
+      MessageKind.EXTRA_CATCH_DECLARATION:
+        const MessageTemplate(MessageKind.EXTRA_CATCH_DECLARATION,
+          "Extra parameter in catch declaration."),
 
-  static const MessageKind PARAMETER_WITH_TYPE_IN_CATCH = const MessageKind(
-      "Cannot use type annotations in catch.");
+      MessageKind.PARAMETER_WITH_TYPE_IN_CATCH:
+        const MessageTemplate(MessageKind.PARAMETER_WITH_TYPE_IN_CATCH,
+          "Cannot use type annotations in catch."),
 
-  static const MessageKind PARAMETER_WITH_MODIFIER_IN_CATCH = const MessageKind(
-      "Cannot use modifiers in catch.");
+      MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH:
+        const MessageTemplate(MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH,
+          "Cannot use modifiers in catch."),
 
-  static const MessageKind OPTIONAL_PARAMETER_IN_CATCH = const MessageKind(
-      "Cannot use optional parameters in catch.");
+      MessageKind.OPTIONAL_PARAMETER_IN_CATCH:
+        const MessageTemplate(MessageKind.OPTIONAL_PARAMETER_IN_CATCH,
+          "Cannot use optional parameters in catch."),
 
-  static const MessageKind THROW_WITHOUT_EXPRESSION = const MessageKind(
-      "Cannot use re-throw outside of catch block "
-      "(expression expected after 'throw').");
+      MessageKind.THROW_WITHOUT_EXPRESSION:
+        const MessageTemplate(MessageKind.THROW_WITHOUT_EXPRESSION,
+          "Cannot use re-throw outside of catch block "
+          "(expression expected after 'throw')."),
 
-  static const MessageKind UNBOUND_LABEL = const MessageKind(
-      "Cannot resolve label '#{labelName}'.");
+      MessageKind.UNBOUND_LABEL:
+        const MessageTemplate(MessageKind.UNBOUND_LABEL,
+          "Cannot resolve label '#{labelName}'."),
 
-  static const MessageKind NO_BREAK_TARGET = const MessageKind(
-      "'break' statement not inside switch or loop.");
+      MessageKind.NO_BREAK_TARGET:
+        const MessageTemplate(MessageKind.NO_BREAK_TARGET,
+          "'break' statement not inside switch or loop."),
 
-  static const MessageKind NO_CONTINUE_TARGET = const MessageKind(
-      "'continue' statement not inside loop.");
+      MessageKind.NO_CONTINUE_TARGET:
+        const MessageTemplate(MessageKind.NO_CONTINUE_TARGET,
+          "'continue' statement not inside loop."),
 
-  static const MessageKind EXISTING_LABEL = const MessageKind(
-      "Original declaration of duplicate label '#{labelName}'.");
+      MessageKind.EXISTING_LABEL:
+        const MessageTemplate(MessageKind.EXISTING_LABEL,
+          "Original declaration of duplicate label '#{labelName}'."),
 
-  static const MessageKind DUPLICATE_LABEL = const MessageKind(
-      "Duplicate declaration of label '#{labelName}'.");
+      MessageKind.DUPLICATE_LABEL:
+        const MessageTemplate(MessageKind.DUPLICATE_LABEL,
+          "Duplicate declaration of label '#{labelName}'."),
 
-  static const MessageKind UNUSED_LABEL = const MessageKind(
-      "Unused label '#{labelName}'.");
+      MessageKind.UNUSED_LABEL:
+        const MessageTemplate(MessageKind.UNUSED_LABEL,
+          "Unused label '#{labelName}'."),
 
-  static const MessageKind INVALID_CONTINUE = const MessageKind(
-      "Target of continue is not a loop or switch case.");
+      MessageKind.INVALID_CONTINUE:
+        const MessageTemplate(MessageKind.INVALID_CONTINUE,
+          "Target of continue is not a loop or switch case."),
 
-  static const MessageKind INVALID_BREAK = const MessageKind(
-      "Target of break is not a statement.");
+      MessageKind.INVALID_BREAK:
+        const MessageTemplate(MessageKind.INVALID_BREAK,
+          "Target of break is not a statement."),
 
-  static const MessageKind DUPLICATE_TYPE_VARIABLE_NAME = const MessageKind(
-      "Type variable '#{typeVariableName}' already declared.");
+      MessageKind.DUPLICATE_TYPE_VARIABLE_NAME:
+        const MessageTemplate(MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
+          "Type variable '#{typeVariableName}' already declared."),
 
-  static const MessageKind TYPE_VARIABLE_WITHIN_STATIC_MEMBER =
-      const MessageKind(
-          "Cannot refer to type variable '#{typeVariableName}' "
-          "within a static member.");
+      MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER:
+        const MessageTemplate(MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
+              "Cannot refer to type variable '#{typeVariableName}' "
+              "within a static member."),
 
-  static const MessageKind TYPE_VARIABLE_IN_CONSTANT = const MessageKind(
-      "Constant expressions can't refer to type variables.",
-      howToFix: "Try removing the type variable or replacing it with a "
-                "concrete type.",
-      examples: const ["""
+      MessageKind.TYPE_VARIABLE_IN_CONSTANT:
+        const MessageTemplate(MessageKind.TYPE_VARIABLE_IN_CONSTANT,
+          "Constant expressions can't refer to type variables.",
+          howToFix: "Try removing the type variable or replacing it with a "
+                    "concrete type.",
+          examples: const ["""
 class C<T> {
   const C();
 
   m(T t) => const C<T>();
 }
 
 void main() => new C().m(null);
 """
-]);
+]),
 
-
-  static const MessageKind INVALID_TYPE_VARIABLE_BOUND = const MessageKind(
-      "'#{typeArgument}' is not a subtype of bound '#{bound}' for "
-      "type variable '#{typeVariable}' of type '#{thisType}'.",
-      howToFix: "Try to change or remove the type argument.",
-      examples: const ["""
+      MessageKind.INVALID_TYPE_VARIABLE_BOUND:
+        const MessageTemplate(MessageKind.INVALID_TYPE_VARIABLE_BOUND,
+          "'#{typeArgument}' is not a subtype of bound '#{bound}' for "
+          "type variable '#{typeVariable}' of type '#{thisType}'.",
+          howToFix: "Try to change or remove the type argument.",
+          examples: const ["""
 class C<T extends num> {}
 
 // 'String' is not a valid instantiation of T with bound num.'.
 main() => new C<String>();
-"""]);
+"""]),
 
-  static const MessageKind INVALID_USE_OF_SUPER = const MessageKind(
-      "'super' not allowed here.");
+      MessageKind.INVALID_USE_OF_SUPER:
+        const MessageTemplate(MessageKind.INVALID_USE_OF_SUPER,
+          "'super' not allowed here."),
 
-  static const MessageKind INVALID_CASE_DEFAULT = const MessageKind(
-      "'default' only allowed on last case of a switch.");
+      MessageKind.INVALID_CASE_DEFAULT:
+        const MessageTemplate(MessageKind.INVALID_CASE_DEFAULT,
+          "'default' only allowed on last case of a switch."),
 
-  static const MessageKind SWITCH_CASE_TYPES_NOT_EQUAL = const MessageKind(
-      "'case' expressions do not all have type '#{type}'.");
+      MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL:
+        const MessageTemplate(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
+          "'case' expressions do not all have type '#{type}'."),
 
-  static const MessageKind SWITCH_CASE_TYPES_NOT_EQUAL_CASE = const MessageKind(
-      "'case' expression of type '#{type}'.");
+      MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE:
+        const MessageTemplate(MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
+          "'case' expression of type '#{type}'."),
 
-  static const MessageKind SWITCH_CASE_FORBIDDEN = const MessageKind(
-      "'case' expression may not be of type '#{type}'.");
+      MessageKind.SWITCH_CASE_FORBIDDEN:
+        const MessageTemplate(MessageKind.SWITCH_CASE_FORBIDDEN,
+          "'case' expression may not be of type '#{type}'."),
 
-  static const MessageKind SWITCH_CASE_VALUE_OVERRIDES_EQUALS =
-      const MessageKind(
-          "'case' expression type '#{type}' overrides 'operator =='.");
+      MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS:
+        const MessageTemplate(MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
+              "'case' expression type '#{type}' overrides 'operator =='."),
 
-  static const MessageKind INVALID_ARGUMENT_AFTER_NAMED = const MessageKind(
-      "Unnamed argument after named argument.");
+      MessageKind.INVALID_ARGUMENT_AFTER_NAMED:
+        const MessageTemplate(MessageKind.INVALID_ARGUMENT_AFTER_NAMED,
+          "Unnamed argument after named argument."),
 
-  static const MessageKind NOT_A_COMPILE_TIME_CONSTANT = const MessageKind(
-      "Not a compile-time constant.");
+      MessageKind.NOT_A_COMPILE_TIME_CONSTANT:
+        const MessageTemplate(MessageKind.NOT_A_COMPILE_TIME_CONSTANT,
+          "Not a compile-time constant."),
 
-  static const MessageKind DEFERRED_COMPILE_TIME_CONSTANT = const MessageKind(
-      "A deferred value cannot be used as a compile-time constant.");
+      MessageKind.DEFERRED_COMPILE_TIME_CONSTANT:
+        const MessageTemplate(MessageKind.DEFERRED_COMPILE_TIME_CONSTANT,
+          "A deferred value cannot be used as a compile-time constant."),
 
-  static const MessageKind DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION =
-      const MessageKind(
-          "A deferred class cannot be used to create a "
-          "compile-time constant.");
+      MessageKind.DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION:
+        const MessageTemplate(MessageKind.DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION,
+              "A deferred class cannot be used to create a "
+              "compile-time constant."),
 
-  static const MessageKind CYCLIC_COMPILE_TIME_CONSTANTS = const MessageKind(
-      "Cycle in the compile-time constant computation.");
+      MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS:
+        const MessageTemplate(MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS,
+          "Cycle in the compile-time constant computation."),
 
-  static const MessageKind CONSTRUCTOR_IS_NOT_CONST = const MessageKind(
-      "Constructor is not a 'const' constructor.");
+      MessageKind.CONSTRUCTOR_IS_NOT_CONST:
+        const MessageTemplate(MessageKind.CONSTRUCTOR_IS_NOT_CONST,
+          "Constructor is not a 'const' constructor."),
 
-  static const MessageKind CONST_MAP_KEY_OVERRIDES_EQUALS =
-      const MessageKind(
-          "Const-map key type '#{type}' overrides 'operator =='.");
+      MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS:
+        const MessageTemplate(MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
+              "Const-map key type '#{type}' overrides 'operator =='."),
 
-  static const MessageKind NO_SUCH_LIBRARY_MEMBER = const MessageKind(
-      "'#{libraryName}' has no member named '#{memberName}'.");
+      MessageKind.NO_SUCH_LIBRARY_MEMBER:
+        const MessageTemplate(MessageKind.NO_SUCH_LIBRARY_MEMBER,
+          "'#{libraryName}' has no member named '#{memberName}'."),
 
-  static const MessageKind CANNOT_INSTANTIATE_TYPEDEF = const MessageKind(
-      "Cannot instantiate typedef '#{typedefName}'.");
+      MessageKind.CANNOT_INSTANTIATE_TYPEDEF:
+        const MessageTemplate(MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
+          "Cannot instantiate typedef '#{typedefName}'."),
 
-  static const MessageKind REQUIRED_PARAMETER_WITH_DEFAULT = const MessageKind(
-      "Non-optional parameters can't have a default value.",
-      howToFix:
-        "Try removing the default value or making the parameter optional.",
-      examples: const ["""
+      MessageKind.REQUIRED_PARAMETER_WITH_DEFAULT:
+        const MessageTemplate(MessageKind.REQUIRED_PARAMETER_WITH_DEFAULT,
+          "Non-optional parameters can't have a default value.",
+          howToFix:
+            "Try removing the default value or making the parameter optional.",
+          examples: const ["""
 main() {
   foo(a: 1) => print(a);
   foo(2);
 }""", """
 main() {
   foo(a = 1) => print(a);
   foo(2);
-}"""]);
+}"""]),
 
-  static const MessageKind NAMED_PARAMETER_WITH_EQUALS = const MessageKind(
-      "Named optional parameters can't use '=' to specify a default "
-      "value.",
-      howToFix: "Try replacing '=' with ':'.",
-      examples: const ["""
+      MessageKind.NAMED_PARAMETER_WITH_EQUALS:
+        const MessageTemplate(MessageKind.NAMED_PARAMETER_WITH_EQUALS,
+          "Named optional parameters can't use '=' to specify a default "
+          "value.",
+          howToFix: "Try replacing '=' with ':'.",
+          examples: const ["""
 main() {
   foo({a = 1}) => print(a);
   foo(a: 2);
-}"""]);
+}"""]),
 
-  static const MessageKind POSITIONAL_PARAMETER_WITH_EQUALS = const MessageKind(
-      "Positional optional parameters can't use ':' to specify a "
-      "default value.",
-      howToFix: "Try replacing ':' with '='.",
-      examples: const ["""
+      MessageKind.POSITIONAL_PARAMETER_WITH_EQUALS:
+        const MessageTemplate(MessageKind.POSITIONAL_PARAMETER_WITH_EQUALS,
+          "Positional optional parameters can't use ':' to specify a "
+          "default value.",
+          howToFix: "Try replacing ':' with '='.",
+          examples: const ["""
 main() {
   foo([a: 1]) => print(a);
   foo(2);
-}"""]);
+}"""]),
 
-  static const MessageKind TYPEDEF_FORMAL_WITH_DEFAULT = const MessageKind(
-      "A parameter of a typedef can't specify a default value.",
-      howToFix:
-        "Try removing the default value.",
-      examples: const ["""
+      MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT:
+        const MessageTemplate(MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT,
+          "A parameter of a typedef can't specify a default value.",
+          howToFix:
+            "Try removing the default value.",
+          examples: const ["""
 typedef void F([int arg = 0]);
 
 main() {
   F f;
 }""", """
 typedef void F({int arg: 0});
 
 main() {
   F f;
-}"""]);
+}"""]),
 
-  static const MessageKind FUNCTION_TYPE_FORMAL_WITH_DEFAULT = const MessageKind(
-      "A function type parameter can't specify a default value.",
-      howToFix:
-        "Try removing the default value.",
-      examples: const ["""
+      MessageKind.FUNCTION_TYPE_FORMAL_WITH_DEFAULT:
+        const MessageTemplate(MessageKind.FUNCTION_TYPE_FORMAL_WITH_DEFAULT,
+          "A function type parameter can't specify a default value.",
+          howToFix:
+            "Try removing the default value.",
+          examples: const ["""
 foo(f(int i, [a = 1])) {}
 
 main() {
   foo(1, 2);
 }""", """
 foo(f(int i, {a: 1})) {}
 
 main() {
   foo(1, a: 2);
-}"""]);
+}"""]),
 
-  static const MessageKind REDIRECTING_FACTORY_WITH_DEFAULT = const MessageKind(
-      "A parameter of a redirecting factory constructor can't specify a "
-      "default value.",
-      howToFix:
-        "Try removing the default value.",
-      examples: const ["""
+      MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT:
+        const MessageTemplate(MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT,
+          "A parameter of a redirecting factory constructor can't specify a "
+          "default value.",
+          howToFix:
+            "Try removing the default value.",
+          examples: const ["""
 class A {
   A([a]);
   factory A.foo([a = 1]) = A;
 }
 
 main() {
   new A.foo(1);
 }""", """
 class A {
   A({a});
   factory A.foo({a: 1}) = A;
 }
 
 main() {
   new A.foo(a: 1);
-}"""]);
+}"""]),
 
-  static const MessageKind FORMAL_DECLARED_CONST = const MessageKind(
-      "A formal parameter can't be declared const.",
-      howToFix: "Try removing 'const'.",
-      examples: const ["""
+      MessageKind.FORMAL_DECLARED_CONST:
+        const MessageTemplate(MessageKind.FORMAL_DECLARED_CONST,
+          "A formal parameter can't be declared const.",
+          howToFix: "Try removing 'const'.",
+          examples: const ["""
 foo(const x) {}
 main() => foo(42);
 """, """
 foo({const x}) {}
 main() => foo(42);
 """, """
 foo([const x]) {}
 main() => foo(42);
-"""]);
+"""]),
 
-  static const MessageKind FORMAL_DECLARED_STATIC = const MessageKind(
-      "A formal parameter can't be declared static.",
-      howToFix: "Try removing 'static'.",
-      examples: const ["""
+      MessageKind.FORMAL_DECLARED_STATIC:
+        const MessageTemplate(MessageKind.FORMAL_DECLARED_STATIC,
+          "A formal parameter can't be declared static.",
+          howToFix: "Try removing 'static'.",
+          examples: const ["""
 foo(static x) {}
 main() => foo(42);
 """, """
 foo({static x}) {}
 main() => foo(42);
 """, """
 foo([static x]) {}
 main() => foo(42);
-"""]);
+"""]),
 
-  static const MessageKind FINAL_FUNCTION_TYPE_PARAMETER = const MessageKind(
-      "A function type parameter can't be declared final.",
-      howToFix: "Try removing 'final'.",
-      examples: const ["""
+      MessageKind.FINAL_FUNCTION_TYPE_PARAMETER:
+        const MessageTemplate(MessageKind.FINAL_FUNCTION_TYPE_PARAMETER,
+          "A function type parameter can't be declared final.",
+          howToFix: "Try removing 'final'.",
+          examples: const ["""
 foo(final int x(int a)) {}
 main() => foo((y) => 42);
 """, """
 foo({final int x(int a)}) {}
 main() => foo((y) => 42);
 """, """
 foo([final int x(int a)]) {}
 main() => foo((y) => 42);
-"""]);
+"""]),
 
-  static const MessageKind VAR_FUNCTION_TYPE_PARAMETER = const MessageKind(
-      "A function type parameter can't be declared with 'var'.",
-      howToFix: "Try removing 'var'.",
-      examples: const ["""
+      MessageKind.VAR_FUNCTION_TYPE_PARAMETER:
+        const MessageTemplate(MessageKind.VAR_FUNCTION_TYPE_PARAMETER,
+          "A function type parameter can't be declared with 'var'.",
+          howToFix: "Try removing 'var'.",
+          examples: const ["""
 foo(var int x(int a)) {}
 main() => foo((y) => 42);
 """, """
 foo({var int x(int a)}) {}
 main() => foo((y) => 42);
 """, """
 foo([var int x(int a)]) {}
 main() => foo((y) => 42);
-"""]);
+"""]),
 
-  static const MessageKind CANNOT_INSTANTIATE_TYPE_VARIABLE = const MessageKind(
-      "Cannot instantiate type variable '#{typeVariableName}'.");
+      MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE:
+        const MessageTemplate(MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
+          "Cannot instantiate type variable '#{typeVariableName}'."),
 
-  static const MessageKind CYCLIC_TYPE_VARIABLE = const MessageKind(
-      "Type variable '#{typeVariableName}' is a supertype of itself.");
+      MessageKind.CYCLIC_TYPE_VARIABLE:
+        const MessageTemplate(MessageKind.CYCLIC_TYPE_VARIABLE,
+          "Type variable '#{typeVariableName}' is a supertype of itself."),
 
-  static const CYCLIC_TYPEDEF = const MessageKind(
-      "A typedef can't refer to itself.",
-      howToFix: "Try removing all references to '#{typedefName}' "
-                "in the definition of '#{typedefName}'.",
-      examples: const ["""
+      MessageKind.CYCLIC_TYPEDEF:
+        const MessageTemplate(MessageKind.CYCLIC_TYPEDEF,
+          "A typedef can't refer to itself.",
+          howToFix: "Try removing all references to '#{typedefName}' "
+                    "in the definition of '#{typedefName}'.",
+          examples: const ["""
 typedef F F(); // The return type 'F' is a self-reference.
-main() { F f = null; }"""]);
+main() { F f = null; }"""]),
 
-  static const CYCLIC_TYPEDEF_ONE = const MessageKind(
-      "A typedef can't refer to itself through another typedef.",
-      howToFix: "Try removing all references to "
-                "'#{otherTypedefName}' in the definition of '#{typedefName}'.",
-      examples: const ["""
+      MessageKind.CYCLIC_TYPEDEF_ONE:
+        const MessageTemplate(MessageKind.CYCLIC_TYPEDEF_ONE,
+          "A typedef can't refer to itself through another typedef.",
+          howToFix: "Try removing all references to "
+                    "'#{otherTypedefName}' in the definition of '#{typedefName}'.",
+          examples: const ["""
 typedef G F(); // The return type 'G' is a self-reference through typedef 'G'.
 typedef F G(); // The return type 'F' is a self-reference through typedef 'F'.
 main() { F f = null; }""",
 """
 typedef G F(); // The return type 'G' creates a self-reference.
 typedef H G(); // The return type 'H' creates a self-reference.
 typedef H(F f); // The argument type 'F' creates a self-reference.
-main() { F f = null; }"""]);
+main() { F f = null; }"""]),
 
-  static const MessageKind CLASS_NAME_EXPECTED = const MessageKind(
-      "Class name expected.");
+      MessageKind.CLASS_NAME_EXPECTED:
+        const MessageTemplate(MessageKind.CLASS_NAME_EXPECTED,
+          "Class name expected."),
 
-  static const MessageKind CANNOT_EXTEND = const MessageKind(
-      "'#{type}' cannot be extended.");
+      MessageKind.CANNOT_EXTEND:
+        const MessageTemplate(MessageKind.CANNOT_EXTEND,
+          "'#{type}' cannot be extended."),
 
-  static const MessageKind CANNOT_IMPLEMENT = const MessageKind(
-      "'#{type}' cannot be implemented.");
+      MessageKind.CANNOT_IMPLEMENT:
+        const MessageTemplate(MessageKind.CANNOT_IMPLEMENT,
+          "'#{type}' cannot be implemented."),
 
-  // TODO(johnnwinther): Split messages into reasons for malformedness.
-  static const MessageKind CANNOT_EXTEND_MALFORMED = const MessageKind(
-      "Class '#{className}' can't extend the type '#{malformedType}' because "
-      "it is malformed.",
-      howToFix: "Try correcting the malformed type annotation or removing the "
-        "'extends' clause.",
-      examples: const ["""
+      // TODO(johnnwinther): Split messages into reasons for malformedness.
+      MessageKind.CANNOT_EXTEND_MALFORMED:
+        const MessageTemplate(MessageKind.CANNOT_EXTEND_MALFORMED,
+          "Class '#{className}' can't extend the type '#{malformedType}' because "
+          "it is malformed.",
+          howToFix: "Try correcting the malformed type annotation or removing the "
+            "'extends' clause.",
+          examples: const ["""
 class A extends Malformed {}
-main() => new A();"""]);
+main() => new A();"""]),
 
-  static const MessageKind CANNOT_IMPLEMENT_MALFORMED = const MessageKind(
-      "Class '#{className}' can't implement the type '#{malformedType}' "
-      "because it is malformed.",
-      howToFix: "Try correcting the malformed type annotation or removing the "
-        "type from the 'implements' clause.",
-      examples: const ["""
+      MessageKind.CANNOT_IMPLEMENT_MALFORMED:
+        const MessageTemplate(MessageKind.CANNOT_IMPLEMENT_MALFORMED,
+          "Class '#{className}' can't implement the type '#{malformedType}' "
+          "because it is malformed.",
+          howToFix: "Try correcting the malformed type annotation or removing the "
+            "type from the 'implements' clause.",
+          examples: const ["""
 class A implements Malformed {}
-main() => new A();"""]);
+main() => new A();"""]),
 
-  static const MessageKind CANNOT_MIXIN_MALFORMED = const MessageKind(
-      "Class '#{className}' can't mixin the type '#{malformedType}' because it "
-      "is malformed.",
-      howToFix: "Try correcting the malformed type annotation or removing the "
-        "type from the 'with' clause.",
-      examples: const ["""
+      MessageKind.CANNOT_MIXIN_MALFORMED:
+        const MessageTemplate(MessageKind.CANNOT_MIXIN_MALFORMED,
+          "Class '#{className}' can't mixin the type '#{malformedType}' because it "
+          "is malformed.",
+          howToFix: "Try correcting the malformed type annotation or removing the "
+            "type from the 'with' clause.",
+          examples: const ["""
 class A extends Object with Malformed {}
-main() => new A();"""]);
+main() => new A();"""]),
 
-  static const MessageKind CANNOT_MIXIN = const MessageKind(
-      "The type '#{type}' can't be mixed in.",
-      howToFix: "Try removing '#{type}' from the 'with' clause.",
-      examples: const ["""
+      MessageKind.CANNOT_MIXIN:
+        const MessageTemplate(MessageKind.CANNOT_MIXIN,
+          "The type '#{type}' can't be mixed in.",
+          howToFix: "Try removing '#{type}' from the 'with' clause.",
+          examples: const ["""
 class C extends Object with String {}
 
 main() => new C();
 """, """
 typedef C = Object with String;
 
 main() => new C();
-"""]);
+"""]),
 
-  static const MessageKind CANNOT_EXTEND_ENUM = const MessageKind(
-      "Class '#{className}' can't extend the type '#{enumType}' because "
-      "it is declared by an enum.",
-      howToFix: "Try making '#{enumType}' a normal class or removing the "
-        "'extends' clause.",
-      examples: const ["""
+      MessageKind.CANNOT_EXTEND_ENUM:
+        const MessageTemplate(MessageKind.CANNOT_EXTEND_ENUM,
+          "Class '#{className}' can't extend the type '#{enumType}' because "
+          "it is declared by an enum.",
+          howToFix: "Try making '#{enumType}' a normal class or removing the "
+            "'extends' clause.",
+          examples: const ["""
 enum Enum { A }
 class B extends Enum {}
-main() => new B();"""]);
+main() => new B();"""]),
 
-  static const MessageKind CANNOT_IMPLEMENT_ENUM = const MessageKind(
-      "Class '#{className}' can't implement the type '#{enumType}' "
-      "because it is declared by an enum.",
-      howToFix: "Try making '#{enumType}' a normal class or removing the "
-        "type from the 'implements' clause.",
-      examples: const ["""
+      MessageKind.CANNOT_IMPLEMENT_ENUM:
+        const MessageTemplate(MessageKind.CANNOT_IMPLEMENT_ENUM,
+          "Class '#{className}' can't implement the type '#{enumType}' "
+          "because it is declared by an enum.",
+          howToFix: "Try making '#{enumType}' a normal class or removing the "
+            "type from the 'implements' clause.",
+          examples: const ["""
 enum Enum { A }
 class B implements Enum {}
-main() => new B();"""]);
+main() => new B();"""]),
 
-  static const MessageKind CANNOT_MIXIN_ENUM = const MessageKind(
-      "Class '#{className}' can't mixin the type '#{enumType}' because it "
-      "is declared by an enum.",
-      howToFix: "Try making '#{enumType}' a normal class or removing the "
-        "type from the 'with' clause.",
-      examples: const ["""
+      MessageKind.CANNOT_MIXIN_ENUM:
+        const MessageTemplate(MessageKind.CANNOT_MIXIN_ENUM,
+          "Class '#{className}' can't mixin the type '#{enumType}' because it "
+          "is declared by an enum.",
+          howToFix: "Try making '#{enumType}' a normal class or removing the "
+            "type from the 'with' clause.",
+          examples: const ["""
 enum Enum { A }
 class B extends Object with Enum {}
-main() => new B();"""]);
+main() => new B();"""]),
 
-  static const MessageKind CANNOT_INSTANTIATE_ENUM = const MessageKind(
-      "Enum type '#{enumName}' cannot be instantiated.",
-      howToFix: "Try making '#{enumType}' a normal class or use an enum "
-                "constant.",
-      examples: const ["""
+      MessageKind.CANNOT_INSTANTIATE_ENUM:
+        const MessageTemplate(MessageKind.CANNOT_INSTANTIATE_ENUM,
+          "Enum type '#{enumName}' cannot be instantiated.",
+          howToFix: "Try making '#{enumType}' a normal class or use an enum "
+                    "constant.",
+          examples: const ["""
 enum Enum { A }
 main() => new Enum(0);""", """
 enum Enum { A }
-main() => const Enum(0);"""]);
+main() => const Enum(0);"""]),
 
-  static const MessageKind EMPTY_ENUM_DECLARATION = const MessageKind(
-      "Enum '#{enumName}' must contain at least one value.",
-      howToFix: "Try adding an enum constant or making #{enumName} a "
-                "normal class.",
-      examples: const ["""
+      MessageKind.EMPTY_ENUM_DECLARATION:
+        const MessageTemplate(MessageKind.EMPTY_ENUM_DECLARATION,
+          "Enum '#{enumName}' must contain at least one value.",
+          howToFix: "Try adding an enum constant or making #{enumName} a "
+                    "normal class.",
+          examples: const ["""
 enum Enum {}
-main() { Enum e; }"""]);
+main() { Enum e; }"""]),
 
-  static const MessageKind MISSING_ENUM_CASES = const MessageKind(
-      "Missing enum constants in switch statement: #{enumValues}.",
-      howToFix: "Try adding the missing constants or a default case.",
-      examples: const ["""
+      MessageKind.MISSING_ENUM_CASES:
+        const MessageTemplate(MessageKind.MISSING_ENUM_CASES,
+          "Missing enum constants in switch statement: #{enumValues}.",
+          howToFix: "Try adding the missing constants or a default case.",
+          examples: const ["""
 enum Enum { A, B }
 main() {
   switch (Enum.A) {
   case Enum.B: break;
   }
 }""", """
 enum Enum { A, B, C }
 main() {
   switch (Enum.A) {
   case Enum.B: break;
   }
-}"""]);
-
-  static const MessageKind DUPLICATE_EXTENDS_IMPLEMENTS = const MessageKind(
-      "'#{type}' can not be both extended and implemented.");
-
-  static const MessageKind DUPLICATE_IMPLEMENTS = const MessageKind(
-      "'#{type}' must not occur more than once "
-      "in the implements clause.");
-
-  static const MessageKind MULTI_INHERITANCE = const MessageKind(
-      "Dart2js does not currently support inheritance of the same class with "
-      "different type arguments: Both #{firstType} and #{secondType} are "
-      "supertypes of #{thisType}.");
-
-  static const MessageKind ILLEGAL_SUPER_SEND = const MessageKind(
-      "'#{name}' cannot be called on super.");
-
-  static const MessageKind NO_SUCH_SUPER_MEMBER = const MessageKind(
-      "Cannot resolve '#{memberName}' in a superclass of '#{className}'.");
-
-  static const MessageKind ADDITIONAL_TYPE_ARGUMENT = const MessageKind(
-      "Additional type argument.");
-
-  static const MessageKind MISSING_TYPE_ARGUMENT = const MessageKind(
-      "Missing type argument.");
-
-  // TODO(johnniwinther): Use ADDITIONAL_TYPE_ARGUMENT or MISSING_TYPE_ARGUMENT
-  // instead.
-  static const MessageKind TYPE_ARGUMENT_COUNT_MISMATCH = const MessageKind(
-      "Incorrect number of type arguments on '#{type}'.");
-
-  static const MessageKind GETTER_MISMATCH = const MessageKind(
-      "Setter disagrees on: '#{modifiers}'.");
-
-  static const MessageKind SETTER_MISMATCH = const MessageKind(
-      "Getter disagrees on: '#{modifiers}'.");
-
-  static const MessageKind ILLEGAL_SETTER_FORMALS = const MessageKind(
-      "A setter must have exactly one argument.");
-
-  static const MessageKind NO_STATIC_OVERRIDE = const MessageKind(
-      "Static member cannot override instance member '#{memberName}' of "
-      "'#{className}'.");
-
-  static const MessageKind NO_STATIC_OVERRIDE_CONT = const MessageKind(
-      "This is the instance member that cannot be overridden "
-      "by a static member.");
-
-  static const MessageKind INSTANCE_STATIC_SAME_NAME = const MessageKind(
-      "Instance member '#{memberName}' and static member of "
-      "superclass '#{className}' have the same name.");
-
-  static const MessageKind INSTANCE_STATIC_SAME_NAME_CONT = const MessageKind(
-      "This is the static member with the same name.");
-
-  static const MessageKind INVALID_OVERRIDE_METHOD = const MessageKind(
-      "The type '#{declaredType}' of method '#{name}' declared in "
-      "'#{class}' is not a subtype of the overridden method type "
-      "'#{inheritedType}' inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDDEN_METHOD = const MessageKind(
-      "This is the overridden method '#{name}' declared in class "
-      "'#{class}'.");
-
-  static const MessageKind INVALID_OVERRIDE_GETTER = const MessageKind(
-      "The type '#{declaredType}' of getter '#{name}' declared in "
-      "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-      "overridden getter inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDDEN_GETTER = const MessageKind(
-      "This is the overridden getter '#{name}' declared in class "
-      "'#{class}'.");
-
-  static const MessageKind INVALID_OVERRIDE_GETTER_WITH_FIELD =
-      const MessageKind(
+}"""]),
+
+      MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS:
+        const MessageTemplate(MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
+          "'#{type}' can not be both extended and implemented."),
+
+      MessageKind.DUPLICATE_IMPLEMENTS:
+        const MessageTemplate(MessageKind.DUPLICATE_IMPLEMENTS,
+          "'#{type}' must not occur more than once "
+          "in the implements clause."),
+
+      MessageKind.MULTI_INHERITANCE:
+        const MessageTemplate(MessageKind.MULTI_INHERITANCE,
+          "Dart2js does not currently support inheritance of the same class with "
+          "different type arguments: Both #{firstType} and #{secondType} are "
+          "supertypes of #{thisType}."),
+
+      MessageKind.ILLEGAL_SUPER_SEND:
+        const MessageTemplate(MessageKind.ILLEGAL_SUPER_SEND,
+          "'#{name}' cannot be called on super."),
+
+      MessageKind.NO_SUCH_SUPER_MEMBER:
+        const MessageTemplate(MessageKind.NO_SUCH_SUPER_MEMBER,
+          "Cannot resolve '#{memberName}' in a superclass of '#{className}'."),
+
+      MessageKind.ADDITIONAL_TYPE_ARGUMENT:
+        const MessageTemplate(MessageKind.ADDITIONAL_TYPE_ARGUMENT,
+          "Additional type argument."),
+
+      MessageKind.MISSING_TYPE_ARGUMENT:
+        const MessageTemplate(MessageKind.MISSING_TYPE_ARGUMENT,
+          "Missing type argument."),
+
+      // TODO(johnniwinther): Use ADDITIONAL_TYPE_ARGUMENT or MISSING_TYPE_ARGUMENT
+      // instead.
+      MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH:
+        const MessageTemplate(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
+          "Incorrect number of type arguments on '#{type}'."),
+
+      MessageKind.GETTER_MISMATCH:
+        const MessageTemplate(MessageKind.GETTER_MISMATCH,
+          "Setter disagrees on: '#{modifiers}'."),
+
+      MessageKind.SETTER_MISMATCH:
+        const MessageTemplate(MessageKind.SETTER_MISMATCH,
+          "Getter disagrees on: '#{modifiers}'."),
+
+      MessageKind.ILLEGAL_SETTER_FORMALS:
+        const MessageTemplate(MessageKind.ILLEGAL_SETTER_FORMALS,
+          "A setter must have exactly one argument."),
+
+      MessageKind.NO_STATIC_OVERRIDE:
+        const MessageTemplate(MessageKind.NO_STATIC_OVERRIDE,
+          "Static member cannot override instance member '#{memberName}' of "
+          "'#{className}'."),
+
+      MessageKind.NO_STATIC_OVERRIDE_CONT:
+        const MessageTemplate(MessageKind.NO_STATIC_OVERRIDE_CONT,
+          "This is the instance member that cannot be overridden "
+          "by a static member."),
+
+      MessageKind.INSTANCE_STATIC_SAME_NAME:
+        const MessageTemplate(MessageKind.INSTANCE_STATIC_SAME_NAME,
+          "Instance member '#{memberName}' and static member of "
+          "superclass '#{className}' have the same name."),
+
+      MessageKind.INSTANCE_STATIC_SAME_NAME_CONT:
+        const MessageTemplate(MessageKind.INSTANCE_STATIC_SAME_NAME_CONT,
+          "This is the static member with the same name."),
+
+      MessageKind.INVALID_OVERRIDE_METHOD:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_METHOD,
+          "The type '#{declaredType}' of method '#{name}' declared in "
+          "'#{class}' is not a subtype of the overridden method type "
+          "'#{inheritedType}' inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDDEN_METHOD:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDDEN_METHOD,
+          "This is the overridden method '#{name}' declared in class "
+          "'#{class}'."),
+
+      MessageKind.INVALID_OVERRIDE_GETTER:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_GETTER,
+          "The type '#{declaredType}' of getter '#{name}' declared in "
+          "'#{class}' is not assignable to the type '#{inheritedType}' of the "
+          "overridden getter inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDDEN_GETTER:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDDEN_GETTER,
+          "This is the overridden getter '#{name}' declared in class "
+          "'#{class}'."),
+
+      MessageKind.INVALID_OVERRIDE_GETTER_WITH_FIELD:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_GETTER_WITH_FIELD,
+              "The type '#{declaredType}' of field '#{name}' declared in "
+              "'#{class}' is not assignable to the type '#{inheritedType}' of the "
+              "overridden getter inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDE_FIELD_WITH_GETTER:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_FIELD_WITH_GETTER,
+              "The type '#{declaredType}' of getter '#{name}' declared in "
+              "'#{class}' is not assignable to the type '#{inheritedType}' of the "
+              "overridden field inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDE_SETTER:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_SETTER,
+          "The type '#{declaredType}' of setter '#{name}' declared in "
+          "'#{class}' is not assignable to the type '#{inheritedType}' of the "
+          "overridden setter inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDDEN_SETTER:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDDEN_SETTER,
+          "This is the overridden setter '#{name}' declared in class "
+          "'#{class}'."),
+
+      MessageKind.INVALID_OVERRIDE_SETTER_WITH_FIELD:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_SETTER_WITH_FIELD,
+              "The type '#{declaredType}' of field '#{name}' declared in "
+              "'#{class}' is not assignable to the type '#{inheritedType}' of the "
+              "overridden setter inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDE_FIELD_WITH_SETTER:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_FIELD_WITH_SETTER,
+              "The type '#{declaredType}' of setter '#{name}' declared in "
+              "'#{class}' is not assignable to the type '#{inheritedType}' of the "
+              "overridden field inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDE_FIELD:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDE_FIELD,
           "The type '#{declaredType}' of field '#{name}' declared in "
           "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-          "overridden getter inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDE_FIELD_WITH_GETTER =
-      const MessageKind(
-          "The type '#{declaredType}' of getter '#{name}' declared in "
-          "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-          "overridden field inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDE_SETTER = const MessageKind(
-      "The type '#{declaredType}' of setter '#{name}' declared in "
-      "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-      "overridden setter inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDDEN_SETTER = const MessageKind(
-      "This is the overridden setter '#{name}' declared in class "
-      "'#{class}'.");
-
-  static const MessageKind INVALID_OVERRIDE_SETTER_WITH_FIELD =
-      const MessageKind(
-          "The type '#{declaredType}' of field '#{name}' declared in "
-          "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-          "overridden setter inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDE_FIELD_WITH_SETTER =
-      const MessageKind(
-          "The type '#{declaredType}' of setter '#{name}' declared in "
-          "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-          "overridden field inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDE_FIELD = const MessageKind(
-      "The type '#{declaredType}' of field '#{name}' declared in "
-      "'#{class}' is not assignable to the type '#{inheritedType}' of the "
-      "overridden field inherited from '#{inheritedClass}'.");
-
-  static const MessageKind INVALID_OVERRIDDEN_FIELD = const MessageKind(
-      "This is the overridden field '#{name}' declared in class "
-      "'#{class}'.");
-
-  static const MessageKind CANNOT_OVERRIDE_FIELD_WITH_METHOD =
-      const MessageKind(
-          "Method '#{name}' in '#{class}' can't override field from "
-          "'#{inheritedClass}'.");
-
-  static const MessageKind CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT =
-      const MessageKind(
-          "This is the field that cannot be overridden by a method.");
-
-  static const MessageKind CANNOT_OVERRIDE_METHOD_WITH_FIELD =
-      const MessageKind(
-          "Field '#{name}' in '#{class}' can't override method from "
-          "'#{inheritedClass}'.");
-
-  static const MessageKind CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT =
-      const MessageKind(
-          "This is the method that cannot be overridden by a field.");
-
-  static const MessageKind CANNOT_OVERRIDE_GETTER_WITH_METHOD =
-      const MessageKind(
-          "Method '#{name}' in '#{class}' can't override getter from "
-          "'#{inheritedClass}'.");
-
-  static const MessageKind CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT =
-      const MessageKind(
-          "This is the getter that cannot be overridden by a method.");
-
-  static const MessageKind CANNOT_OVERRIDE_METHOD_WITH_GETTER =
-      const MessageKind(
-          "Getter '#{name}' in '#{class}' can't override method from "
-          "'#{inheritedClass}'.");
-
-  static const MessageKind CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT =
-      const MessageKind(
-          "This is the method that cannot be overridden by a getter.");
-
-  static const MessageKind MISSING_FORMALS = const MessageKind(
-      "Formal parameters are missing.");
-
-  static const MessageKind EXTRA_FORMALS = const MessageKind(
-      "Formal parameters are not allowed here.");
-
-  static const MessageKind UNARY_OPERATOR_BAD_ARITY = const MessageKind(
-      "Operator '#{operatorName}' must have no parameters.");
-
-  static const MessageKind MINUS_OPERATOR_BAD_ARITY = const MessageKind(
-      "Operator '-' must have 0 or 1 parameters.");
-
-  static const MessageKind BINARY_OPERATOR_BAD_ARITY = const MessageKind(
-      "Operator '#{operatorName}' must have exactly 1 parameter.");
-
-  static const MessageKind TERNARY_OPERATOR_BAD_ARITY = const MessageKind(
-      "Operator '#{operatorName}' must have exactly 2 parameters.");
-
-  static const MessageKind OPERATOR_OPTIONAL_PARAMETERS = const MessageKind(
-      "Operator '#{operatorName}' cannot have optional parameters.");
-
-  static const MessageKind OPERATOR_NAMED_PARAMETERS = const MessageKind(
-      "Operator '#{operatorName}' cannot have named parameters.");
-
-  static const MessageKind CONSTRUCTOR_WITH_RETURN_TYPE = const MessageKind(
-      "Cannot have return type for constructor.");
-
-  static const MessageKind CANNOT_RETURN_FROM_CONSTRUCTOR = const MessageKind(
-      "Constructors can't return values.",
-      howToFix: "Remove the return statement or use a factory constructor.",
-      examples: const ["""
+          "overridden field inherited from '#{inheritedClass}'."),
+
+      MessageKind.INVALID_OVERRIDDEN_FIELD:
+        const MessageTemplate(MessageKind.INVALID_OVERRIDDEN_FIELD,
+          "This is the overridden field '#{name}' declared in class "
+          "'#{class}'."),
+
+      MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
+              "Method '#{name}' in '#{class}' can't override field from "
+              "'#{inheritedClass}'."),
+
+      MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT,
+              "This is the field that cannot be overridden by a method."),
+
+      MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD,
+              "Field '#{name}' in '#{class}' can't override method from "
+              "'#{inheritedClass}'."),
+
+      MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT,
+              "This is the method that cannot be overridden by a field."),
+
+      MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD,
+              "Method '#{name}' in '#{class}' can't override getter from "
+              "'#{inheritedClass}'."),
+
+      MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT,
+              "This is the getter that cannot be overridden by a method."),
+
+      MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER,
+              "Getter '#{name}' in '#{class}' can't override method from "
+              "'#{inheritedClass}'."),
+
+      MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT:
+        const MessageTemplate(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT,
+              "This is the method that cannot be overridden by a getter."),
+
+      MessageKind.MISSING_FORMALS:
+        const MessageTemplate(MessageKind.MISSING_FORMALS,
+          "Formal parameters are missing."),
+
+      MessageKind.EXTRA_FORMALS:
+        const MessageTemplate(MessageKind.EXTRA_FORMALS,
+          "Formal parameters are not allowed here."),
+
+      MessageKind.UNARY_OPERATOR_BAD_ARITY:
+        const MessageTemplate(MessageKind.UNARY_OPERATOR_BAD_ARITY,
+          "Operator '#{operatorName}' must have no parameters."),
+
+      MessageKind.MINUS_OPERATOR_BAD_ARITY:
+        const MessageTemplate(MessageKind.MINUS_OPERATOR_BAD_ARITY,
+          "Operator '-' must have 0 or 1 parameters."),
+
+      MessageKind.BINARY_OPERATOR_BAD_ARITY:
+        const MessageTemplate(MessageKind.BINARY_OPERATOR_BAD_ARITY,
+          "Operator '#{operatorName}' must have exactly 1 parameter."),
+
+      MessageKind.TERNARY_OPERATOR_BAD_ARITY:
+        const MessageTemplate(MessageKind.TERNARY_OPERATOR_BAD_ARITY,
+          "Operator '#{operatorName}' must have exactly 2 parameters."),
+
+      MessageKind.OPERATOR_OPTIONAL_PARAMETERS:
+        const MessageTemplate(MessageKind.OPERATOR_OPTIONAL_PARAMETERS,
+          "Operator '#{operatorName}' cannot have optional parameters."),
+
+      MessageKind.OPERATOR_NAMED_PARAMETERS:
+        const MessageTemplate(MessageKind.OPERATOR_NAMED_PARAMETERS,
+          "Operator '#{operatorName}' cannot have named parameters."),
+
+      MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE:
+        const MessageTemplate(MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE,
+          "Cannot have return type for constructor."),
+
+      MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR,
+          "Constructors can't return values.",
+          howToFix: "Remove the return statement or use a factory constructor.",
+          examples: const ["""
 class C {
   C() {
     return 1;
   }
 }
 
-main() => new C();"""]);
-
-  static const MessageKind ILLEGAL_FINAL_METHOD_MODIFIER = const MessageKind(
-      "Cannot have final modifier on method.");
-
-  static const MessageKind ILLEGAL_CONST_FIELD_MODIFIER = const MessageKind(
-      "Cannot have const modifier on non-static field.",
-      howToFix: "Try adding a static modifier, or removing the const modifier.",
-      examples: const ["""
+main() => new C();"""]),
+
+      MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER:
+        const MessageTemplate(MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER,
+          "Cannot have final modifier on method."),
+
+      MessageKind.ILLEGAL_CONST_FIELD_MODIFIER:
+        const MessageTemplate(MessageKind.ILLEGAL_CONST_FIELD_MODIFIER,
+          "Cannot have const modifier on non-static field.",
+          howToFix: "Try adding a static modifier, or removing the const modifier.",
+          examples: const ["""
 class C {
   const int a = 1;
 }
 
-main() => new C();"""]);
-
-  static const MessageKind ILLEGAL_CONSTRUCTOR_MODIFIERS = const MessageKind(
-      "Illegal constructor modifiers: '#{modifiers}'.");
-
-  static const MessageKind ILLEGAL_MIXIN_APPLICATION_MODIFIERS =
-      const MessageKind(
-          "Illegal mixin application modifiers: '#{modifiers}'.");
-
-  static const MessageKind ILLEGAL_MIXIN_SUPERCLASS = const MessageKind(
-      "Class used as mixin must have Object as superclass.");
-
-  static const MessageKind ILLEGAL_MIXIN_OBJECT = const MessageKind(
-      "Cannot use Object as mixin.");
-
-  static const MessageKind ILLEGAL_MIXIN_CONSTRUCTOR = const MessageKind(
-      "Class used as mixin cannot have non-factory constructor.");
-
-  static const MessageKind ILLEGAL_MIXIN_CYCLE = const MessageKind(
-      "Class used as mixin introduces mixin cycle: "
-      "'#{mixinName1}' <-> '#{mixinName2}'.");
-
-  static const MessageKind ILLEGAL_MIXIN_WITH_SUPER = const MessageKind(
-      "Cannot use class '#{className}' as a mixin because it uses "
-      "'super'.");
-
-  static const MessageKind ILLEGAL_MIXIN_SUPER_USE = const MessageKind(
-      "Use of 'super' in class used as mixin.");
-
-  static const MessageKind PARAMETER_NAME_EXPECTED = const MessageKind(
-      "parameter name expected.");
-
-  static const MessageKind CANNOT_RESOLVE_GETTER = const MessageKind(
-      "Cannot resolve getter.");
-
-  static const MessageKind CANNOT_RESOLVE_SETTER = const MessageKind(
-      "Cannot resolve setter.");
-
-  static const MessageKind ASSIGNING_METHOD = const MessageKind(
-      "Cannot assign a value to a method.");
-
-  static const MessageKind ASSIGNING_METHOD_IN_SUPER = const MessageKind(
-      "Cannot assign a value to method '#{name}' "
-      "in superclass '#{superclassName}'.");
-
-  static const MessageKind ASSIGNING_TYPE = const MessageKind(
-      "Cannot assign a value to a type.");
-
-  static const MessageKind IF_NULL_ASSIGNING_TYPE = const MessageKind(
-      "Cannot assign a value to a type. Note that types are never null, "
-      "so this ??= assignment has no effect.",
-      howToFix: "Try removing the '??=' assignment.",
-      examples: const [
-          "class A {} main() { print(A ??= 3);}",
-      ]);
-
-  static const MessageKind VOID_NOT_ALLOWED = const MessageKind(
-      "Type 'void' can't be used here because it isn't a return type.",
-      howToFix: "Try removing 'void' keyword or replace it with 'var', 'final',"
-          " or a type.",
-      examples: const [
-          "void x; main() {}",
-          "foo(void x) {} main() { foo(null); }",
-      ]);
-
-  static const MessageKind NULL_NOT_ALLOWED = const MessageKind(
-      "`null` can't be used here.");
-
-  static const MessageKind BEFORE_TOP_LEVEL = const MessageKind(
-      "Part header must come before top-level definitions.");
-
-  static const MessageKind IMPORT_PART_OF = const MessageKind(
-      "The imported library must not have a 'part-of' directive.",
-      howToFix: "Try removing the 'part-of' directive or replacing the "
-                "import of the library with a 'part' directive.",
-      examples: const [const {
+main() => new C();"""]),
+
+      MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS:
+        const MessageTemplate(MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
+          "Illegal constructor modifiers: '#{modifiers}'."),
+
+      MessageKind.ILLEGAL_MIXIN_APPLICATION_MODIFIERS:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_APPLICATION_MODIFIERS,
+              "Illegal mixin application modifiers: '#{modifiers}'."),
+
+      MessageKind.ILLEGAL_MIXIN_SUPERCLASS:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_SUPERCLASS,
+          "Class used as mixin must have Object as superclass."),
+
+      MessageKind.ILLEGAL_MIXIN_OBJECT:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_OBJECT,
+          "Cannot use Object as mixin."),
+
+      MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR,
+          "Class used as mixin cannot have non-factory constructor."),
+
+      MessageKind.ILLEGAL_MIXIN_CYCLE:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_CYCLE,
+          "Class used as mixin introduces mixin cycle: "
+          "'#{mixinName1}' <-> '#{mixinName2}'."),
+
+      MessageKind.ILLEGAL_MIXIN_WITH_SUPER:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_WITH_SUPER,
+          "Cannot use class '#{className}' as a mixin because it uses "
+          "'super'."),
+
+      MessageKind.ILLEGAL_MIXIN_SUPER_USE:
+        const MessageTemplate(MessageKind.ILLEGAL_MIXIN_SUPER_USE,
+          "Use of 'super' in class used as mixin."),
+
+      MessageKind.PARAMETER_NAME_EXPECTED:
+        const MessageTemplate(MessageKind.PARAMETER_NAME_EXPECTED,
+          "parameter name expected."),
+
+      MessageKind.CANNOT_RESOLVE_GETTER:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_GETTER,
+          "Cannot resolve getter."),
+
+      MessageKind.CANNOT_RESOLVE_SETTER:
+        const MessageTemplate(MessageKind.CANNOT_RESOLVE_SETTER,
+          "Cannot resolve setter."),
+
+      MessageKind.ASSIGNING_METHOD:
+        const MessageTemplate(MessageKind.ASSIGNING_METHOD,
+          "Cannot assign a value to a method."),
+
+      MessageKind.ASSIGNING_METHOD_IN_SUPER:
+        const MessageTemplate(MessageKind.ASSIGNING_METHOD_IN_SUPER,
+          "Cannot assign a value to method '#{name}' "
+          "in superclass '#{superclassName}'."),
+
+      MessageKind.ASSIGNING_TYPE:
+        const MessageTemplate(MessageKind.ASSIGNING_TYPE,
+          "Cannot assign a value to a type."),
+
+      MessageKind.IF_NULL_ASSIGNING_TYPE:
+        const MessageTemplate(MessageKind.IF_NULL_ASSIGNING_TYPE,
+          "Cannot assign a value to a type. Note that types are never null, "
+          "so this ??= assignment has no effect.",
+          howToFix: "Try removing the '??=' assignment.",
+          examples: const [
+              "class A {} main() { print(A ??= 3);}",
+          ]),
+
+      MessageKind.VOID_NOT_ALLOWED:
+        const MessageTemplate(MessageKind.VOID_NOT_ALLOWED,
+          "Type 'void' can't be used here because it isn't a return type.",
+          howToFix: "Try removing 'void' keyword or replace it with 'var', 'final',"
+              " or a type.",
+          examples: const [
+              "void x; main() {}",
+              "foo(void x) {} main() { foo(null); }",
+          ]),
+
+      MessageKind.NULL_NOT_ALLOWED:
+        const MessageTemplate(MessageKind.NULL_NOT_ALLOWED,
+          "`null` can't be used here."),
+
+      MessageKind.BEFORE_TOP_LEVEL:
+        const MessageTemplate(MessageKind.BEFORE_TOP_LEVEL,
+          "Part header must come before top-level definitions."),
+
+      MessageKind.IMPORT_PART_OF:
+        const MessageTemplate(MessageKind.IMPORT_PART_OF,
+          "The imported library must not have a 'part-of' directive.",
+          howToFix: "Try removing the 'part-of' directive or replacing the "
+                    "import of the library with a 'part' directive.",
+          examples: const [const {
 'main.dart': """
 library library;
 
 import 'part.dart';
 
 main() {}
 """,
 
 'part.dart': """
 part of library;
-"""}]);
+"""}]),
 
-  static const MessageKind LIBRARY_NAME_MISMATCH = const MessageKind(
-      "Expected part of library name '#{libraryName}'.",
-      howToFix: "Try changing the directive to 'part of #{libraryName};'.",
-      examples: const [const {
+      MessageKind.LIBRARY_NAME_MISMATCH:
+        const MessageTemplate(MessageKind.LIBRARY_NAME_MISMATCH,
+          "Expected part of library name '#{libraryName}'.",
+          howToFix: "Try changing the directive to 'part of #{libraryName};'.",
+          examples: const [const {
 'main.dart': """
 library lib.foo;
 
 part 'part.dart';
 
 main() {}
 """,
 
 'part.dart': """
 part of lib.bar;
-"""}]);
+"""}]),
 
-  static const MessageKind MISSING_LIBRARY_NAME = const MessageKind(
-      "Library has no name. Part directive expected library name "
-      "to be '#{libraryName}'.",
-      howToFix: "Try adding 'library #{libraryName};' to the library.",
-      examples: const [const {
+      MessageKind.MISSING_LIBRARY_NAME:
+        const MessageTemplate(MessageKind.MISSING_LIBRARY_NAME,
+          "Library has no name. Part directive expected library name "
+          "to be '#{libraryName}'.",
+          howToFix: "Try adding 'library #{libraryName};' to the library.",
+          examples: const [const {
 'main.dart': """
 part 'part.dart';
 
 main() {}
 """,
 
 'part.dart': """
 part of lib.foo;
-"""}]);
+"""}]),
 
-  static const MessageKind THIS_IS_THE_PART_OF_TAG = const MessageKind(
-      "This is the part of directive.");
+      MessageKind.THIS_IS_THE_PART_OF_TAG:
+        const MessageTemplate(MessageKind.THIS_IS_THE_PART_OF_TAG,
+          "This is the part of directive."),
 
-  static const MessageKind MISSING_PART_OF_TAG = const MessageKind(
-      "This file has no part-of tag, but it is being used as a part.");
+      MessageKind.MISSING_PART_OF_TAG:
+        const MessageTemplate(MessageKind.MISSING_PART_OF_TAG,
+          "This file has no part-of tag, but it is being used as a part."),
 
-  static const MessageKind DUPLICATED_PART_OF = const MessageKind(
-      "Duplicated part-of directive.");
+      MessageKind.DUPLICATED_PART_OF:
+        const MessageTemplate(MessageKind.DUPLICATED_PART_OF,
+          "Duplicated part-of directive."),
 
-  static const MessageKind DUPLICATED_LIBRARY_NAME = const MessageKind(
-      "Duplicated library name '#{libraryName}'.");
+      MessageKind.DUPLICATED_LIBRARY_NAME:
+        const MessageTemplate(MessageKind.DUPLICATED_LIBRARY_NAME,
+          "Duplicated library name '#{libraryName}'."),
 
-  static const MessageKind DUPLICATED_RESOURCE = const MessageKind(
-      "The resource '#{resourceUri}' is loaded through both "
-      "'#{canonicalUri1}' and '#{canonicalUri2}'.");
+      MessageKind.DUPLICATED_RESOURCE:
+        const MessageTemplate(MessageKind.DUPLICATED_RESOURCE,
+          "The resource '#{resourceUri}' is loaded through both "
+          "'#{canonicalUri1}' and '#{canonicalUri2}'."),
 
-  static const MessageKind DUPLICATED_LIBRARY_RESOURCE =
-      const MessageKind(
-          "The library '#{libraryName}' in '#{resourceUri}' is loaded through "
-          "both '#{canonicalUri1}' and '#{canonicalUri2}'.");
+      MessageKind.DUPLICATED_LIBRARY_RESOURCE:
+        const MessageTemplate(MessageKind.DUPLICATED_LIBRARY_RESOURCE,
+              "The library '#{libraryName}' in '#{resourceUri}' is loaded through "
+              "both '#{canonicalUri1}' and '#{canonicalUri2}'."),
 
-  // This is used as an exception.
-  static const MessageKind INVALID_SOURCE_FILE_LOCATION = const MessageKind('''
+      // This is used as an exception.
+      MessageKind.INVALID_SOURCE_FILE_LOCATION:
+        const MessageTemplate(MessageKind.INVALID_SOURCE_FILE_LOCATION, '''
 Invalid offset (#{offset}) in source map.
 File: #{fileName}
-Length: #{length}''');
+Length: #{length}'''),
 
-  static const MessageKind TOP_LEVEL_VARIABLE_DECLARED_STATIC =
-      const MessageKind(
-          "Top-level variable cannot be declared static.");
+      MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC:
+        const MessageTemplate(MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC,
+              "Top-level variable cannot be declared static."),
 
-  static const MessageKind REFERENCE_IN_INITIALIZATION = const MessageKind(
-       "Variable '#{variableName}' is referenced during its "
-       "initialization.",
-       howToFix: "If you are trying to reference a shadowed variable, rename"
-         " one of the variables.",
-       examples: const ["""
+      MessageKind.REFERENCE_IN_INITIALIZATION:
+        const MessageTemplate(MessageKind.REFERENCE_IN_INITIALIZATION,
+           "Variable '#{variableName}' is referenced during its "
+           "initialization.",
+           howToFix: "If you are trying to reference a shadowed variable, rename"
+             " one of the variables.",
+           examples: const ["""
 foo(t) {
   var t = t;
   return t;
 }
 
 main() => foo(1);
-"""]);
+"""]),
 
-  static const MessageKind CONST_WITHOUT_INITIALIZER = const MessageKind(
-      "A constant variable must be initialized.",
-      howToFix: "Try adding an initializer or "
-                "removing the 'const' modifier.",
-      examples: const ["""
+      MessageKind.CONST_WITHOUT_INITIALIZER:
+        const MessageTemplate(MessageKind.CONST_WITHOUT_INITIALIZER,
+          "A constant variable must be initialized.",
+          howToFix: "Try adding an initializer or "
+                    "removing the 'const' modifier.",
+          examples: const ["""
 void main() {
   const c; // This constant variable must be initialized.
-}"""]);
+}"""]),
 
-  static const MessageKind FINAL_WITHOUT_INITIALIZER = const MessageKind(
-      "A final variable must be initialized.",
-      howToFix: "Try adding an initializer or "
-                "removing the 'final' modifier.",
-      examples: const [
-          "class C { static final field; } main() => C.field;"]);
+      MessageKind.FINAL_WITHOUT_INITIALIZER:
+        const MessageTemplate(MessageKind.FINAL_WITHOUT_INITIALIZER,
+          "A final variable must be initialized.",
+          howToFix: "Try adding an initializer or "
+                    "removing the 'final' modifier.",
+          examples: const [
+              "class C { static final field; } main() => C.field;"]),
 
-  static const MessageKind MEMBER_USES_CLASS_NAME = const MessageKind(
-      "Member variable can't have the same name as the class it is "
-      "declared in.",
-      howToFix: "Try renaming the variable.",
-      examples: const ["""
+      MessageKind.MEMBER_USES_CLASS_NAME:
+        const MessageTemplate(MessageKind.MEMBER_USES_CLASS_NAME,
+          "Member variable can't have the same name as the class it is "
+          "declared in.",
+          howToFix: "Try renaming the variable.",
+          examples: const ["""
 class A { var A; }
 main() {
   var a = new A();
   a.A = 1;
 }
 """, """
 class A { static var A; }
 main() => A.A = 1;
-"""]);
+"""]),
 
-  static const MessageKind WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT =
-      const MessageKind(
-          "Wrong number of arguments to assert. Should be 1, but given "
-          "#{argumentCount}.");
+      MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT:
+        const MessageTemplate(MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
+              "Wrong number of arguments to assert. Should be 1, but given "
+              "#{argumentCount}."),
 
-  static const MessageKind ASSERT_IS_GIVEN_NAMED_ARGUMENTS = const MessageKind(
-      "'assert' takes no named arguments, but given #{argumentCount}.");
+      MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS:
+        const MessageTemplate(MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
+          "'assert' takes no named arguments, but given #{argumentCount}."),
 
-  static const MessageKind FACTORY_REDIRECTION_IN_NON_FACTORY =
-      const MessageKind(
-          "Factory redirection only allowed in factories.");
+      MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY:
+        const MessageTemplate(MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY,
+              "Factory redirection only allowed in factories."),
 
-  static const MessageKind MISSING_FACTORY_KEYWORD = const MessageKind(
-      "Did you forget a factory keyword here?");
+      MessageKind.MISSING_FACTORY_KEYWORD:
+        const MessageTemplate(MessageKind.MISSING_FACTORY_KEYWORD,
+          "Did you forget a factory keyword here?"),
 
-  static const MessageKind NO_SUCH_METHOD_IN_NATIVE =
-      const MessageKind(
-          "'NoSuchMethod' is not supported for classes that extend native "
-          "classes.");
+      MessageKind.NO_SUCH_METHOD_IN_NATIVE:
+        const MessageTemplate(MessageKind.NO_SUCH_METHOD_IN_NATIVE,
+              "'NoSuchMethod' is not supported for classes that extend native "
+              "classes."),
 
-  static const MessageKind DEFERRED_LIBRARY_DART_2_DART =
-      const MessageKind(
-          "Deferred loading is not supported by the dart backend yet. "
-          "The output will not be split.");
+      MessageKind.DEFERRED_LIBRARY_DART_2_DART:
+        const MessageTemplate(MessageKind.DEFERRED_LIBRARY_DART_2_DART,
+              "Deferred loading is not supported by the dart backend yet. "
+              "The output will not be split."),
 
-  static const MessageKind DEFERRED_LIBRARY_WITHOUT_PREFIX =
-      const MessageKind(
-          "This import is deferred but there is no prefix keyword.",
+      MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX:
+        const MessageTemplate(MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX,
+              "This import is deferred but there is no prefix keyword.",
+              howToFix:
+                "Try adding a prefix to the import."),
+
+      MessageKind.DEFERRED_OLD_SYNTAX:
+        const MessageTemplate(MessageKind.DEFERRED_OLD_SYNTAX,
+              "The DeferredLibrary annotation is obsolete.",
+              howToFix:
+                "Use the \"import 'lib.dart' deferred as prefix\" syntax instead."),
+
+      MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX:
+        const MessageTemplate(MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX,
+              "The prefix of this deferred import is not unique.",
+              howToFix:
+                "Try changing the import prefix."),
+
+      MessageKind.DEFERRED_TYPE_ANNOTATION:
+        const MessageTemplate(MessageKind.DEFERRED_TYPE_ANNOTATION,
+              "The type #{node} is deferred. "
+              "Deferred types are not valid as type annotations.",
+              howToFix:
+                "Try using a non-deferred abstract class as an interface."),
+
+      MessageKind.ILLEGAL_STATIC:
+        const MessageTemplate(MessageKind.ILLEGAL_STATIC,
+          "Modifier static is only allowed on functions declared in "
+          "a class."),
+
+      MessageKind.STATIC_FUNCTION_BLOAT:
+        const MessageTemplate(MessageKind.STATIC_FUNCTION_BLOAT,
+          "Using '#{class}.#{name}' may lead to unnecessarily large "
+          "generated code.",
           howToFix:
-            "Try adding a prefix to the import.");
+              "Try adding '@MirrorsUsed(...)' as described at "
+              "https://goo.gl/Akrrog."),
 
-  static const MessageKind DEFERRED_OLD_SYNTAX =
-      const MessageKind(
-          "The DeferredLibrary annotation is obsolete.",
+      MessageKind.NON_CONST_BLOAT:
+        const MessageTemplate(MessageKind.NON_CONST_BLOAT,
+          "Using 'new #{name}' may lead to unnecessarily large generated "
+          "code.",
           howToFix:
-            "Use the \"import 'lib.dart' deferred as prefix\" syntax instead.");
+              "Try using 'const #{name}' or adding '@MirrorsUsed(...)' as "
+              "described at https://goo.gl/Akrrog."),
 
-  static const MessageKind DEFERRED_LIBRARY_DUPLICATE_PREFIX =
-      const MessageKind(
-          "The prefix of this deferred import is not unique.",
-          howToFix:
-            "Try changing the import prefix.");
+      MessageKind.STRING_EXPECTED:
+        const MessageTemplate(MessageKind.STRING_EXPECTED,
+          "Expected a 'String', but got an instance of '#{type}'."),
 
-  static const MessageKind DEFERRED_TYPE_ANNOTATION =
-      const MessageKind(
-          "The type #{node} is deferred. "
-          "Deferred types are not valid as type annotations.",
-          howToFix:
-            "Try using a non-deferred abstract class as an interface.");
+      MessageKind.PRIVATE_IDENTIFIER:
+        const MessageTemplate(MessageKind.PRIVATE_IDENTIFIER,
+          "'#{value}' is not a valid Symbol name because it starts with "
+          "'_'."),
 
-  static const MessageKind ILLEGAL_STATIC = const MessageKind(
-      "Modifier static is only allowed on functions declared in "
-      "a class.");
+      MessageKind.PRIVATE_NAMED_PARAMETER:
+        const MessageTemplate(MessageKind.PRIVATE_NAMED_PARAMETER,
+          "Named optional parameter can't have a library private name.",
+          howToFix: "Try removing the '_' or making the parameter positional or "
+            "required.",
+          examples: const ["""foo({int _p}) {} main() => foo();"""]),
 
-  static const MessageKind STATIC_FUNCTION_BLOAT = const MessageKind(
-      "Using '#{class}.#{name}' may lead to unnecessarily large "
-      "generated code.",
-      howToFix:
-          "Try adding '@MirrorsUsed(...)' as described at "
-          "https://goo.gl/Akrrog.");
+      MessageKind.UNSUPPORTED_LITERAL_SYMBOL:
+        const MessageTemplate(MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
+          "Symbol literal '##{value}' is currently unsupported by dart2js."),
 
-  static const MessageKind NON_CONST_BLOAT = const MessageKind(
-      "Using 'new #{name}' may lead to unnecessarily large generated "
-      "code.",
-      howToFix:
-          "Try using 'const #{name}' or adding '@MirrorsUsed(...)' as "
-          "described at https://goo.gl/Akrrog.");
-
-  static const MessageKind STRING_EXPECTED = const MessageKind(
-      "Expected a 'String', but got an instance of '#{type}'.");
-
-  static const MessageKind PRIVATE_IDENTIFIER = const MessageKind(
-      "'#{value}' is not a valid Symbol name because it starts with "
-      "'_'.");
-
-  static const MessageKind PRIVATE_NAMED_PARAMETER = const MessageKind(
-      "Named optional parameter can't have a library private name.",
-      howToFix: "Try removing the '_' or making the parameter positional or "
-        "required.",
-      examples: const ["""foo({int _p}) {} main() => foo();"""]
-      );
-
-  static const MessageKind UNSUPPORTED_LITERAL_SYMBOL = const MessageKind(
-      "Symbol literal '##{value}' is currently unsupported by dart2js.");
-
-  static const MessageKind INVALID_SYMBOL = const MessageKind('''
+      MessageKind.INVALID_SYMBOL:
+        const MessageTemplate(MessageKind.INVALID_SYMBOL, '''
 '#{value}' is not a valid Symbol name because is not:
  * an empty String,
  * a user defined operator,
  * a qualified non-private identifier optionally followed by '=', or
  * a qualified non-private identifier followed by '.' and a user-defined '''
-"operator.");
+"operator."),
 
-  static const MessageKind AMBIGUOUS_REEXPORT = const MessageKind(
-      "'#{name}' is (re)exported by multiple libraries.");
+      MessageKind.AMBIGUOUS_REEXPORT:
+        const MessageTemplate(MessageKind.AMBIGUOUS_REEXPORT,
+          "'#{name}' is (re)exported by multiple libraries."),
 
-  static const MessageKind AMBIGUOUS_LOCATION = const MessageKind(
-      "'#{name}' is defined here.");
+      MessageKind.AMBIGUOUS_LOCATION:
+        const MessageTemplate(MessageKind.AMBIGUOUS_LOCATION,
+          "'#{name}' is defined here."),
 
-  static const MessageKind IMPORTED_HERE = const MessageKind(
-      "'#{name}' is imported here.");
+      MessageKind.IMPORTED_HERE:
+        const MessageTemplate(MessageKind.IMPORTED_HERE,
+          "'#{name}' is imported here."),
 
-  static const MessageKind OVERRIDE_EQUALS_NOT_HASH_CODE = const MessageKind(
-      "The class '#{class}' overrides 'operator==', "
-      "but not 'get hashCode'.");
+      MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE:
+        const MessageTemplate(MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
+          "The class '#{class}' overrides 'operator==', "
+          "but not 'get hashCode'."),
 
-  static const MessageKind INTERNAL_LIBRARY_FROM = const MessageKind(
-      "Internal library '#{resolvedUri}' is not accessible from "
-      "'#{importingUri}'.");
+      MessageKind.INTERNAL_LIBRARY_FROM:
+        const MessageTemplate(MessageKind.INTERNAL_LIBRARY_FROM,
+          "Internal library '#{resolvedUri}' is not accessible from "
+          "'#{importingUri}'."),
 
-  static const MessageKind INTERNAL_LIBRARY = const MessageKind(
-      "Internal library '#{resolvedUri}' is not accessible.");
+      MessageKind.INTERNAL_LIBRARY:
+        const MessageTemplate(MessageKind.INTERNAL_LIBRARY,
+          "Internal library '#{resolvedUri}' is not accessible."),
 
-  static const MessageKind LIBRARY_NOT_FOUND = const MessageKind(
-      "Library not found '#{resolvedUri}'.");
+      MessageKind.LIBRARY_NOT_FOUND:
+        const MessageTemplate(MessageKind.LIBRARY_NOT_FOUND,
+          "Library not found '#{resolvedUri}'."),
 
-  static const MessageKind UNSUPPORTED_EQ_EQ_EQ = const MessageKind(
-      "'===' is not an operator. "
-      "Did you mean '#{lhs} == #{rhs}' or 'identical(#{lhs}, #{rhs})'?");
+      MessageKind.UNSUPPORTED_EQ_EQ_EQ:
+        const MessageTemplate(MessageKind.UNSUPPORTED_EQ_EQ_EQ,
+          "'===' is not an operator. "
+          "Did you mean '#{lhs} == #{rhs}' or 'identical(#{lhs}, #{rhs})'?"),
 
-  static const MessageKind UNSUPPORTED_BANG_EQ_EQ = const MessageKind(
-      "'!==' is not an operator. "
-      "Did you mean '#{lhs} != #{rhs}' or '!identical(#{lhs}, #{rhs})'?");
+      MessageKind.UNSUPPORTED_BANG_EQ_EQ:
+        const MessageTemplate(MessageKind.UNSUPPORTED_BANG_EQ_EQ,
+          "'!==' is not an operator. "
+          "Did you mean '#{lhs} != #{rhs}' or '!identical(#{lhs}, #{rhs})'?"),
 
-  static const MessageKind UNSUPPORTED_PREFIX_PLUS = const MessageKind(
-      "'+' is not a prefix operator. ",
-      howToFix: "Try removing '+'.",
-      examples: const [
-          "main() => +2;  // No longer a valid way to write '2'"
-      ]);
+      MessageKind.UNSUPPORTED_PREFIX_PLUS:
+        const MessageTemplate(MessageKind.UNSUPPORTED_PREFIX_PLUS,
+          "'+' is not a prefix operator. ",
+          howToFix: "Try removing '+'.",
+          examples: const [
+              "main() => +2;  // No longer a valid way to write '2'"
+          ]),
 
-  static const MessageKind UNSUPPORTED_THROW_WITHOUT_EXP = const MessageKind(
-      "No expression after 'throw'. "
-      "Did you mean 'rethrow'?");
+      MessageKind.UNSUPPORTED_THROW_WITHOUT_EXP:
+        const MessageTemplate(MessageKind.UNSUPPORTED_THROW_WITHOUT_EXP,
+          "No expression after 'throw'. "
+          "Did you mean 'rethrow'?"),
 
-  static const MessageKind DEPRECATED_TYPEDEF_MIXIN_SYNTAX = const MessageKind(
-      "'typedef' not allowed here. ",
-      howToFix: "Try replacing 'typedef' with 'class'.",
-      examples: const [
-          """
+      MessageKind.DEPRECATED_TYPEDEF_MIXIN_SYNTAX:
+        const MessageTemplate(MessageKind.DEPRECATED_TYPEDEF_MIXIN_SYNTAX,
+          "'typedef' not allowed here. ",
+          howToFix: "Try replacing 'typedef' with 'class'.",
+          examples: const [
+              """
 class B { }
 class M1 {  }
 typedef C = B with M1;  // Need to replace 'typedef' with 'class'.
 main() { new C(); }
-"""]
-);
+"""]),
 
-  static const MessageKind MIRRORS_EXPECTED_STRING = const MessageKind(
-      "Can't use '#{name}' here because it's an instance of '#{type}' "
-      "and a 'String' value is expected.",
-      howToFix: "Did you forget to add quotes?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_EXPECTED_STRING:
+        const MessageTemplate(MessageKind.MIRRORS_EXPECTED_STRING,
+          "Can't use '#{name}' here because it's an instance of '#{type}' "
+          "and a 'String' value is expected.",
+          howToFix: "Did you forget to add quotes?",
+          examples: const [
+              """
 // 'Foo' is a type literal, not a string.
 @MirrorsUsed(symbols: const [Foo])
 import 'dart:mirrors';
 
 class Foo {}
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind MIRRORS_EXPECTED_STRING_OR_TYPE = const MessageKind(
-      "Can't use '#{name}' here because it's an instance of '#{type}' "
-      "and a 'String' or 'Type' value is expected.",
-      howToFix: "Did you forget to add quotes?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_EXPECTED_STRING_OR_TYPE:
+        const MessageTemplate(MessageKind.MIRRORS_EXPECTED_STRING_OR_TYPE,
+          "Can't use '#{name}' here because it's an instance of '#{type}' "
+          "and a 'String' or 'Type' value is expected.",
+          howToFix: "Did you forget to add quotes?",
+          examples: const [
+              """
 // 'main' is a method, not a class.
 @MirrorsUsed(targets: const [main])
 import 'dart:mirrors';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind MIRRORS_EXPECTED_STRING_OR_LIST = const MessageKind(
-      "Can't use '#{name}' here because it's an instance of '#{type}' "
-      "and a 'String' or 'List' value is expected.",
-      howToFix: "Did you forget to add quotes?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST:
+        const MessageTemplate(MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST,
+          "Can't use '#{name}' here because it's an instance of '#{type}' "
+          "and a 'String' or 'List' value is expected.",
+          howToFix: "Did you forget to add quotes?",
+          examples: const [
+              """
 // 'Foo' is not a string.
 @MirrorsUsed(symbols: Foo)
 import 'dart:mirrors';
 
 class Foo {}
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind MIRRORS_EXPECTED_STRING_TYPE_OR_LIST =
-      const MessageKind(
-      "Can't use '#{name}' here because it's an instance of '#{type}' "
-      "but a 'String', 'Type', or 'List' value is expected.",
-      howToFix: "Did you forget to add quotes?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST:
+        const MessageTemplate(MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST,
+          "Can't use '#{name}' here because it's an instance of '#{type}' "
+          "but a 'String', 'Type', or 'List' value is expected.",
+          howToFix: "Did you forget to add quotes?",
+          examples: const [
+              """
 // '1' is not a string.
 @MirrorsUsed(targets: 1)
 import 'dart:mirrors';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY =
-      const MessageKind(
-      "Can't find '#{name}' in the current library.",
-      // TODO(ahe): The closest identifiers in edit distance would be nice.
-      howToFix: "Did you forget to add an import?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY:
+        const MessageTemplate(MessageKind.MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY,
+          "Can't find '#{name}' in the current library.",
+          // TODO(ahe): The closest identifiers in edit distance would be nice.
+          howToFix: "Did you forget to add an import?",
+          examples: const [
+              """
 // 'window' is not in scope because dart:html isn't imported.
 @MirrorsUsed(targets: 'window')
 import 'dart:mirrors';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind MIRRORS_CANNOT_RESOLVE_IN_LIBRARY =
-      const MessageKind(
-      "Can't find '#{name}' in the library '#{library}'.",
-      // TODO(ahe): The closest identifiers in edit distance would be nice.
-      howToFix: "Is '#{name}' spelled right?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY:
+        const MessageTemplate(MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
+          "Can't find '#{name}' in the library '#{library}'.",
+          // TODO(ahe): The closest identifiers in edit distance would be nice.
+          howToFix: "Is '#{name}' spelled right?",
+          examples: const [
+              """
 // 'List' is misspelled.
 @MirrorsUsed(targets: 'dart.core.Lsit')
 import 'dart:mirrors';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind MIRRORS_CANNOT_FIND_IN_ELEMENT =
-      const MessageKind(
-      "Can't find '#{name}' in '#{element}'.",
-      // TODO(ahe): The closest identifiers in edit distance would be nice.
-      howToFix: "Is '#{name}' spelled right?",
-      examples: const [
-          """
+      MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT:
+        const MessageTemplate(MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT,
+          "Can't find '#{name}' in '#{element}'.",
+          // TODO(ahe): The closest identifiers in edit distance would be nice.
+          howToFix: "Is '#{name}' spelled right?",
+          examples: const [
+              """
 // 'addAll' is misspelled.
 @MirrorsUsed(targets: 'dart.core.List.addAl')
 import 'dart:mirrors';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind INVALID_URI = const MessageKind(
-      "'#{uri}' is not a valid URI.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const [
-        """
+      MessageKind.INVALID_URI:
+        const MessageTemplate(MessageKind.INVALID_URI,
+          "'#{uri}' is not a valid URI.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const [
+            """
 // can't have a '[' in a URI
 import '../../Udyn[mic ils/expect.dart';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind INVALID_PACKAGE_URI = const MessageKind(
-      "'#{uri}' is not a valid package URI (#{exception}).",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const [
-        """
+      MessageKind.INVALID_PACKAGE_URI:
+        const MessageTemplate(MessageKind.INVALID_PACKAGE_URI,
+          "'#{uri}' is not a valid package URI (#{exception}).",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const [
+            """
 // can't have a 'top level' package URI
 import 'package:foo.dart';
 
 main() {}
 """, """
 // can't have 2 slashes
 import 'package://foo/foo.dart';
 
 main() {}
 """, """
 // package name must be valid
 import 'package:not\valid/foo.dart';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind READ_SCRIPT_ERROR = const MessageKind(
-      "Can't read '#{uri}' (#{exception}).",
-      // Don't know how to fix since the underlying error is unknown.
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const [
-          """
+      MessageKind.READ_SCRIPT_ERROR:
+        const MessageTemplate(MessageKind.READ_SCRIPT_ERROR,
+          "Can't read '#{uri}' (#{exception}).",
+          // Don't know how to fix since the underlying error is unknown.
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const [
+              """
 // 'foo.dart' does not exist.
 import 'foo.dart';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind READ_SELF_ERROR = const MessageKind(
-      "#{exception}",
-      // Don't know how to fix since the underlying error is unknown.
-      howToFix: DONT_KNOW_HOW_TO_FIX);
+      MessageKind.READ_SELF_ERROR:
+        const MessageTemplate(MessageKind.READ_SELF_ERROR,
+          "#{exception}",
+          // Don't know how to fix since the underlying error is unknown.
+          howToFix: DONT_KNOW_HOW_TO_FIX),
 
-  static const MessageKind EXTRANEOUS_MODIFIER = const MessageKind(
-      "Can't have modifier '#{modifier}' here.",
-      howToFix: "Try removing '#{modifier}'.",
-      examples: const [
-          "var String foo; main(){}",
-          // "var get foo; main(){}",
-          "var set foo; main(){}",
-          "var final foo; main(){}",
-          "var var foo; main(){}",
-          "var const foo; main(){}",
-          "var abstract foo; main(){}",
-          "var static foo; main(){}",
-          "var external foo; main(){}",
-          "get var foo; main(){}",
-          "set var foo; main(){}",
-          "final var foo; main(){}",
-          "var var foo; main(){}",
-          "const var foo; main(){}",
-          "abstract var foo; main(){}",
-          "static var foo; main(){}",
-          "external var foo; main(){}"]);
+      MessageKind.EXTRANEOUS_MODIFIER:
+        const MessageTemplate(MessageKind.EXTRANEOUS_MODIFIER,
+          "Can't have modifier '#{modifier}' here.",
+          howToFix: "Try removing '#{modifier}'.",
+          examples: const [
+              "var String foo; main(){}",
+              // "var get foo; main(){}",
+              "var set foo; main(){}",
+              "var final foo; main(){}",
+              "var var foo; main(){}",
+              "var const foo; main(){}",
+              "var abstract foo; main(){}",
+              "var static foo; main(){}",
+              "var external foo; main(){}",
+              "get var foo; main(){}",
+              "set var foo; main(){}",
+              "final var foo; main(){}",
+              "var var foo; main(){}",
+              "const var foo; main(){}",
+              "abstract var foo; main(){}",
+              "static var foo; main(){}",
+              "external var foo; main(){}"]),
 
-  static const MessageKind EXTRANEOUS_MODIFIER_REPLACE = const MessageKind(
-      "Can't have modifier '#{modifier}' here.",
-      howToFix: "Try replacing modifier '#{modifier}' with 'var', 'final',"
-          " or a type.",
-      examples: const [
-          // "get foo; main(){}",
-          "set foo; main(){}",
-          "abstract foo; main(){}",
-          "static foo; main(){}",
-          "external foo; main(){}"]);
+      MessageKind.EXTRANEOUS_MODIFIER_REPLACE:
+        const MessageTemplate(MessageKind.EXTRANEOUS_MODIFIER_REPLACE,
+          "Can't have modifier '#{modifier}' here.",
+          howToFix: "Try replacing modifier '#{modifier}' with 'var', 'final',"
+              " or a type.",
+          examples: const [
+              // "get foo; main(){}",
+              "set foo; main(){}",
+              "abstract foo; main(){}",
+              "static foo; main(){}",
+              "external foo; main(){}"]),
 
-  static const MessageKind ABSTRACT_CLASS_INSTANTIATION = const MessageKind(
-      "Can't instantiate abstract class.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const ["abstract class A {} main() { new A(); }"]);
+      MessageKind.ABSTRACT_CLASS_INSTANTIATION:
+        const MessageTemplate(MessageKind.ABSTRACT_CLASS_INSTANTIATION,
+          "Can't instantiate abstract class.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const ["abstract class A {} main() { new A(); }"]),
 
-  static const MessageKind BODY_EXPECTED = const MessageKind(
-      "Expected a function body or '=>'.",
-      // TODO(ahe): In some scenarios, we can suggest removing the 'static'
-      // keyword.
-      howToFix: "Try adding {}.",
-      examples: const [
-          "main();"]);
+      MessageKind.BODY_EXPECTED:
+        const MessageTemplate(MessageKind.BODY_EXPECTED,
+          "Expected a function body or '=>'.",
+          // TODO(ahe): In some scenarios, we can suggest removing the 'static'
+          // keyword.
+          howToFix: "Try adding {}.",
+          examples: const [
+              "main();"]),
 
-  static const MessageKind MIRROR_BLOAT = const MessageKind(
-      "#{count} methods retained for use by dart:mirrors out of #{total}"
-      " total methods (#{percentage}%).");
+      MessageKind.MIRROR_BLOAT:
+        const MessageTemplate(MessageKind.MIRROR_BLOAT,
+          "#{count} methods retained for use by dart:mirrors out of #{total}"
+          " total methods (#{percentage}%)."),
 
-  static const MessageKind MIRROR_IMPORT = const MessageKind(
-      "Import of 'dart:mirrors'.");
+      MessageKind.MIRROR_IMPORT:
+        const MessageTemplate(MessageKind.MIRROR_IMPORT,
+          "Import of 'dart:mirrors'."),
 
-  static const MessageKind MIRROR_IMPORT_NO_USAGE = const MessageKind(
-      "This import is not annotated with @MirrorsUsed, which may lead to "
-      "unnecessarily large generated code.",
-      howToFix:
-          "Try adding '@MirrorsUsed(...)' as described at "
-          "https://goo.gl/Akrrog.");
+      MessageKind.MIRROR_IMPORT_NO_USAGE:
+        const MessageTemplate(MessageKind.MIRROR_IMPORT_NO_USAGE,
+          "This import is not annotated with @MirrorsUsed, which may lead to "
+          "unnecessarily large generated code.",
+          howToFix:
+              "Try adding '@MirrorsUsed(...)' as described at "
+              "https://goo.gl/Akrrog."),
 
-  static const MessageKind WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT =
-      const MessageKind(
-      "Argument for 'JS_INTERCEPTOR_CONSTANT' must be a type constant.");
+      MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT:
+        const MessageTemplate(MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT,
+          "Argument for 'JS_INTERCEPTOR_CONSTANT' must be a type constant."),
 
-  static const MessageKind EXPECTED_IDENTIFIER_NOT_RESERVED_WORD =
-      const MessageKind(
-          "'#{keyword}' is a reserved word and can't be used here.",
-          howToFix: "Try using a different name.",
-          examples: const ["do() {} main() {}"]);
+      MessageKind.EXPECTED_IDENTIFIER_NOT_RESERVED_WORD:
+        const MessageTemplate(MessageKind.EXPECTED_IDENTIFIER_NOT_RESERVED_WORD,
+              "'#{keyword}' is a reserved word and can't be used here.",
+              howToFix: "Try using a different name.",
+              examples: const ["do() {} main() {}"]),
 
-  static const MessageKind  NAMED_FUNCTION_EXPRESSION =
-      const MessageKind("Function expression '#{name}' cannot be named.",
-          howToFix: "Try removing the name.",
-          examples: const ["main() { var f = func() {}; }"]);
+      MessageKind. NAMED_FUNCTION_EXPRESSION:
+        const MessageTemplate(MessageKind. NAMED_FUNCTION_EXPRESSION, "Function expression '#{name}' cannot be named.",
+              howToFix: "Try removing the name.",
+              examples: const ["main() { var f = func() {}; }"]),
 
-  static const MessageKind UNUSED_METHOD = const MessageKind(
-      "The method '#{name}' is never called.",
-      howToFix: "Consider deleting it.",
-      examples: const ["deadCode() {} main() {}"]);
+      MessageKind.UNUSED_METHOD:
+        const MessageTemplate(MessageKind.UNUSED_METHOD,
+          "The method '#{name}' is never called.",
+          howToFix: "Consider deleting it.",
+          examples: const ["deadCode() {} main() {}"]),
 
-  static const MessageKind UNUSED_CLASS = const MessageKind(
-      "The class '#{name}' is never used.",
-      howToFix: "Consider deleting it.",
-      examples: const ["class DeadCode {} main() {}"]);
+      MessageKind.UNUSED_CLASS:
+        const MessageTemplate(MessageKind.UNUSED_CLASS,
+          "The class '#{name}' is never used.",
+          howToFix: "Consider deleting it.",
+          examples: const ["class DeadCode {} main() {}"]),
 
-  static const MessageKind UNUSED_TYPEDEF = const MessageKind(
-      "The typedef '#{name}' is never used.",
-      howToFix: "Consider deleting it.",
-      examples: const ["typedef DeadCode(); main() {}"]);
+      MessageKind.UNUSED_TYPEDEF:
+        const MessageTemplate(MessageKind.UNUSED_TYPEDEF,
+          "The typedef '#{name}' is never used.",
+          howToFix: "Consider deleting it.",
+          examples: const ["typedef DeadCode(); main() {}"]),
 
-  static const MessageKind ABSTRACT_METHOD = const MessageKind(
-      "The method '#{name}' has no implementation in "
-      "class '#{class}'.",
-      howToFix: "Try adding a body to '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.ABSTRACT_METHOD:
+        const MessageTemplate(MessageKind.ABSTRACT_METHOD,
+          "The method '#{name}' has no implementation in "
+          "class '#{class}'.",
+          howToFix: "Try adding a body to '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 class Class {
   method();
 }
 main() => new Class().method();
-"""]);
+"""]),
 
-  static const MessageKind ABSTRACT_GETTER = const MessageKind(
-      "The getter '#{name}' has no implementation in "
-      "class '#{class}'.",
-      howToFix: "Try adding a body to '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.ABSTRACT_GETTER:
+        const MessageTemplate(MessageKind.ABSTRACT_GETTER,
+          "The getter '#{name}' has no implementation in "
+          "class '#{class}'.",
+          howToFix: "Try adding a body to '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 class Class {
   get getter;
 }
 main() => new Class();
-"""]);
+"""]),
 
-  static const MessageKind ABSTRACT_SETTER = const MessageKind(
-      "The setter '#{name}' has no implementation in "
-      "class '#{class}'.",
-      howToFix: "Try adding a body to '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.ABSTRACT_SETTER:
+        const MessageTemplate(MessageKind.ABSTRACT_SETTER,
+          "The setter '#{name}' has no implementation in "
+          "class '#{class}'.",
+          howToFix: "Try adding a body to '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 class Class {
   set setter(_);
 }
 main() => new Class();
-"""]);
+"""]),
 
-  static const MessageKind INHERIT_GETTER_AND_METHOD = const MessageKind(
-      "The class '#{class}' can't inherit both getters and methods "
-      "by the named '#{name}'.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const ["""
+      MessageKind.INHERIT_GETTER_AND_METHOD:
+        const MessageTemplate(MessageKind.INHERIT_GETTER_AND_METHOD,
+          "The class '#{class}' can't inherit both getters and methods "
+          "by the named '#{name}'.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const ["""
 class A {
   get member => null;
 }
 class B {
   member() {}
 }
 class Class implements A, B {
 }
 main() => new Class();
-"""]);
+"""]),
 
-  static const MessageKind INHERITED_METHOD = const MessageKind(
-      "The inherited method '#{name}' is declared here in class "
-      "'#{class}'.");
+      MessageKind.INHERITED_METHOD:
+        const MessageTemplate(MessageKind.INHERITED_METHOD,
+          "The inherited method '#{name}' is declared here in class "
+          "'#{class}'."),
 
-  static const MessageKind INHERITED_EXPLICIT_GETTER = const MessageKind(
-      "The inherited getter '#{name}' is declared here in class "
-      "'#{class}'.");
+      MessageKind.INHERITED_EXPLICIT_GETTER:
+        const MessageTemplate(MessageKind.INHERITED_EXPLICIT_GETTER,
+          "The inherited getter '#{name}' is declared here in class "
+          "'#{class}'."),
 
-  static const MessageKind INHERITED_IMPLICIT_GETTER = const MessageKind(
-      "The inherited getter '#{name}' is implicitly declared by this "
-      "field in class '#{class}'.");
+      MessageKind.INHERITED_IMPLICIT_GETTER:
+        const MessageTemplate(MessageKind.INHERITED_IMPLICIT_GETTER,
+          "The inherited getter '#{name}' is implicitly declared by this "
+          "field in class '#{class}'."),
 
-  static const MessageKind UNIMPLEMENTED_METHOD_ONE = const MessageKind(
-      "'#{class}' doesn't implement '#{method}' "
-      "declared in '#{declarer}'.",
-      howToFix: "Try adding an implementation of '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.UNIMPLEMENTED_METHOD_ONE:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_METHOD_ONE,
+          "'#{class}' doesn't implement '#{method}' "
+          "declared in '#{declarer}'.",
+          howToFix: "Try adding an implementation of '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 abstract class I {
   m();
 }
 class C implements I {}
 main() => new C();
 """, """
 abstract class I {
   m();
 }
 class C extends I {}
 main() => new C();
-"""]);
+"""]),
 
-  static const MessageKind UNIMPLEMENTED_METHOD = const MessageKind(
-      "'#{class}' doesn't implement '#{method}'.",
-      howToFix: "Try adding an implementation of '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.UNIMPLEMENTED_METHOD:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_METHOD,
+          "'#{class}' doesn't implement '#{method}'.",
+          howToFix: "Try adding an implementation of '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 abstract class I {
   m();
 }
 
 abstract class J {
   m();
 }
 
 class C implements I, J {}
 
 main() {
  new C();
 }
 """, """
 abstract class I {
   m();
 }
 
 abstract class J {
   m();
 }
 
 class C extends I implements J {}
 
 main() {
  new C();
 }
-"""]);
+"""]),
 
-  static const MessageKind UNIMPLEMENTED_METHOD_CONT = const MessageKind(
-      "The method '#{name}' is declared here in class '#{class}'.");
+      MessageKind.UNIMPLEMENTED_METHOD_CONT:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_METHOD_CONT,
+          "The method '#{name}' is declared here in class '#{class}'."),
 
-  static const MessageKind UNIMPLEMENTED_SETTER_ONE = const MessageKind(
-      "'#{class}' doesn't implement the setter '#{name}' "
-      "declared in '#{declarer}'.",
-      howToFix: "Try adding an implementation of '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.UNIMPLEMENTED_SETTER_ONE:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_SETTER_ONE,
+          "'#{class}' doesn't implement the setter '#{name}' "
+          "declared in '#{declarer}'.",
+          howToFix: "Try adding an implementation of '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 abstract class I {
   set m(_);
 }
 class C implements I {}
 class D implements I {
   set m(_) {}
 }
 main() {
  new D().m = 0;
  new C();
 }
-"""]);
+"""]),
 
-  static const MessageKind UNIMPLEMENTED_SETTER = const MessageKind(
-      "'#{class}' doesn't implement the setter '#{name}'.",
-      howToFix: "Try adding an implementation of '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.UNIMPLEMENTED_SETTER:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_SETTER,
+          "'#{class}' doesn't implement the setter '#{name}'.",
+          howToFix: "Try adding an implementation of '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 abstract class I {
   set m(_);
 }
 abstract class J {
   set m(_);
 }
 class C implements I, J {}
 main() => new C();
 """, """
 abstract class I {
   set m(_);
 }
 abstract class J {
   set m(_);
 }
 class C extends I implements J {}
 main() => new C();
-"""]);
+"""]),
 
-  static const MessageKind UNIMPLEMENTED_EXPLICIT_SETTER = const MessageKind(
-      "The setter '#{name}' is declared here in class '#{class}'.");
+      MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER,
+          "The setter '#{name}' is declared here in class '#{class}'."),
 
-  static const MessageKind UNIMPLEMENTED_IMPLICIT_SETTER = const MessageKind(
-      "The setter '#{name}' is implicitly declared by this field "
-      "in class '#{class}'.");
+      MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER,
+          "The setter '#{name}' is implicitly declared by this field "
+          "in class '#{class}'."),
 
-  static const MessageKind UNIMPLEMENTED_GETTER_ONE = const MessageKind(
-      "'#{class}' doesn't implement the getter '#{name}' "
-      "declared in '#{declarer}'.",
-      howToFix: "Try adding an implementation of '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.UNIMPLEMENTED_GETTER_ONE:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_GETTER_ONE,
+          "'#{class}' doesn't implement the getter '#{name}' "
+          "declared in '#{declarer}'.",
+          howToFix: "Try adding an implementation of '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 abstract class I {
   get m;
 }
 class C implements I {}
 main() => new C();
 """, """
 abstract class I {
   get m;
 }
 class C extends I {}
 main() => new C();
-"""]);
+"""]),
 
-  static const MessageKind UNIMPLEMENTED_GETTER = const MessageKind(
-      "'#{class}' doesn't implement the getter '#{name}'.",
-      howToFix: "Try adding an implementation of '#{name}' or declaring "
-                "'#{class}' to be 'abstract'.",
-      examples: const ["""
+      MessageKind.UNIMPLEMENTED_GETTER:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_GETTER,
+          "'#{class}' doesn't implement the getter '#{name}'.",
+          howToFix: "Try adding an implementation of '#{name}' or declaring "
+                    "'#{class}' to be 'abstract'.",
+          examples: const ["""
 abstract class I {
   get m;
 }
 abstract class J {
   get m;
 }
 class C implements I, J {}
 main() => new C();
 """, """
 abstract class I {
   get m;
 }
 abstract class J {
   get m;
 }
 class C extends I implements J {}
 main() => new C();
-"""]);
+"""]),
 
-  static const MessageKind UNIMPLEMENTED_EXPLICIT_GETTER = const MessageKind(
-      "The getter '#{name}' is declared here in class '#{class}'.");
+      MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER,
+          "The getter '#{name}' is declared here in class '#{class}'."),
 
-  static const MessageKind UNIMPLEMENTED_IMPLICIT_GETTER = const MessageKind(
-      "The getter '#{name}' is implicitly declared by this field "
-      "in class '#{class}'.");
+      MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER:
+        const MessageTemplate(MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER,
+          "The getter '#{name}' is implicitly declared by this field "
+          "in class '#{class}'."),
 
-  static const MessageKind EQUAL_MAP_ENTRY_KEY = const MessageKind(
-      "An entry with the same key already exists in the map.",
-      howToFix: "Try removing the previous entry or changing the key in one "
-                "of the entries.",
-      examples: const ["""
+      MessageKind.EQUAL_MAP_ENTRY_KEY:
+        const MessageTemplate(MessageKind.EQUAL_MAP_ENTRY_KEY,
+          "An entry with the same key already exists in the map.",
+          howToFix: "Try removing the previous entry or changing the key in one "
+                    "of the entries.",
+          examples: const ["""
 main() {
   var m = const {'foo': 1, 'foo': 2};
-}"""]);
+}"""]),
 
-  static const MessageKind BAD_INPUT_CHARACTER = const MessageKind(
-      "Character U+#{characterHex} isn't allowed here.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const ["""
+      MessageKind.BAD_INPUT_CHARACTER:
+        const MessageTemplate(MessageKind.BAD_INPUT_CHARACTER,
+          "Character U+#{characterHex} isn't allowed here.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const ["""
 main() {
   String x = ç;
 }
-"""]);
+"""]),
 
-  static const MessageKind UNTERMINATED_STRING = const MessageKind(
-      "String must end with #{quote}.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const ["""
+      MessageKind.UNTERMINATED_STRING:
+        const MessageTemplate(MessageKind.UNTERMINATED_STRING,
+          "String must end with #{quote}.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const ["""
 main() {
   return '
 ;
 }
 """,
 """
 main() {
   return \"
 ;
 }
@@ skipping 14 matching lines @@
 main() => '''
 """,
 """
 main() => \"\"\"
 """,
 """
 main() => r'''
 """,
 """
 main() => r\"\"\"
-"""]);
+"""]),
 
-  static const MessageKind UNMATCHED_TOKEN = const MessageKind(
-      "Can't find '#{end}' to match '#{begin}'.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const[
-          "main(",
-          "main(){",
-          "main(){]}",
-        ]);
+      MessageKind.UNMATCHED_TOKEN:
+        const MessageTemplate(MessageKind.UNMATCHED_TOKEN,
+          "Can't find '#{end}' to match '#{begin}'.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const[
+              "main(",
+              "main(){",
+              "main(){]}",
+            ]),
 
-  static const MessageKind UNTERMINATED_TOKEN = const MessageKind(
-      // This is a fall-back message that shouldn't happen.
-      "Incomplete token.");
+      MessageKind.UNTERMINATED_TOKEN:
+        const MessageTemplate(MessageKind.UNTERMINATED_TOKEN,
+          // This is a fall-back message that shouldn't happen.
+          "Incomplete token."),
 
-  static const MessageKind EXPONENT_MISSING = const MessageKind(
-      "Numbers in exponential notation should always contain an exponent"
-      " (an integer number with an optional sign).",
-      howToFix: "Make sure there is an exponent, and remove any whitespace "
-      "before it.",
-      examples: const ["""
+      MessageKind.EXPONENT_MISSING:
+        const MessageTemplate(MessageKind.EXPONENT_MISSING,
+          "Numbers in exponential notation should always contain an exponent"
+          " (an integer number with an optional sign).",
+          howToFix: "Make sure there is an exponent, and remove any whitespace "
+          "before it.",
+          examples: const ["""
 main() {
   var i = 1e;
 }
-"""]);
+"""]),
 
-  static const MessageKind HEX_DIGIT_EXPECTED = const MessageKind(
-      "A hex digit (0-9 or A-F) must follow '0x'.",
-      howToFix: DONT_KNOW_HOW_TO_FIX, // Seems obvious from the error message.
-      examples: const ["""
+      MessageKind.HEX_DIGIT_EXPECTED:
+        const MessageTemplate(MessageKind.HEX_DIGIT_EXPECTED,
+          "A hex digit (0-9 or A-F) must follow '0x'.",
+          howToFix: DONT_KNOW_HOW_TO_FIX, // Seems obvious from the error message.
+          examples: const ["""
 main() {
   var i = 0x;
 }
-"""]);
+"""]),
 
-  static const MessageKind MALFORMED_STRING_LITERAL = const MessageKind(
-      r"A '$' has special meaning inside a string, and must be followed by an"
-      " identifier or an expression in curly braces ({}).",
-      howToFix: r"Try adding a backslash (\) to escape the '$'.",
-      examples: const [r"""
+      MessageKind.MALFORMED_STRING_LITERAL:
+        const MessageTemplate(MessageKind.MALFORMED_STRING_LITERAL,
+          r"A '$' has special meaning inside a string, and must be followed by an"
+          " identifier or an expression in curly braces ({}).",
+          howToFix: r"Try adding a backslash (\) to escape the '$'.",
+          examples: const [r"""
 main() {
   return '$';
 }
 """,
 r'''
 main() {
   return "$";
 }
 ''',
 r"""
 main() {
   return '''$''';
 }
 """,
 r'''
 main() {
   return """$""";
 }
-''']);
+''']),
 
-  static const MessageKind UNTERMINATED_COMMENT = const MessageKind(
-      "Comment starting with '/*' must end with '*/'.",
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const [r"""
+      MessageKind.UNTERMINATED_COMMENT:
+        const MessageTemplate(MessageKind.UNTERMINATED_COMMENT,
+          "Comment starting with '/*' must end with '*/'.",
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const [r"""
 main() {
 }
-/*"""]);
+/*"""]),
 
-  static const MessageKind MISSING_TOKEN_BEFORE_THIS = const MessageKind(
-      "Expected '#{token}' before this.",
-      // Consider the second example below: the parser expects a ')' before
-      // 'y', but a ',' would also have worked. We don't have enough
-      // information to give a good suggestion.
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const [
-          "main() => true ? 1;",
-          "main() => foo(x: 1 y: 2);",
-        ]);
+      MessageKind.MISSING_TOKEN_BEFORE_THIS:
+        const MessageTemplate(MessageKind.MISSING_TOKEN_BEFORE_THIS,
+          "Expected '#{token}' before this.",
+          // Consider the second example below: the parser expects a ')' before
+          // 'y', but a ',' would also have worked. We don't have enough
+          // information to give a good suggestion.
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const [
+              "main() => true ? 1;",
+              "main() => foo(x: 1 y: 2);",
+            ]),
 
-  static const MessageKind MISSING_TOKEN_AFTER_THIS = const MessageKind(
-      "Expected '#{token}' after this.",
-      // See [MISSING_TOKEN_BEFORE_THIS], we don't have enough information to
-      // give a good suggestion.
-      howToFix: DONT_KNOW_HOW_TO_FIX,
-      examples: const [
-          "main(x) {x}",
+      MessageKind.MISSING_TOKEN_AFTER_THIS:
+        const MessageTemplate(MessageKind.MISSING_TOKEN_AFTER_THIS,
+          "Expected '#{token}' after this.",
+          // See [MISSING_TOKEN_BEFORE_THIS], we don't have enough information to
+          // give a good suggestion.
+          howToFix: DONT_KNOW_HOW_TO_FIX,
+          examples: const [
+              "main(x) {x}",
 """
 class S1 {}
 class S2 {}
 class S3 {}
 class A = S1 with S2, S3
 main() => new A();
 """
-]);
+]),
 
-  static const MessageKind CONSIDER_ANALYZE_ALL = const MessageKind(
-      "Could not find '#{main}'.  Nothing will be analyzed.",
-      howToFix: "Try using '--analyze-all' to analyze everything.",
-      examples: const ['']);
+      MessageKind.CONSIDER_ANALYZE_ALL:
+        const MessageTemplate(MessageKind.CONSIDER_ANALYZE_ALL,
+          "Could not find '#{main}'.  Nothing will be analyzed.",
+          howToFix: "Try using '--analyze-all' to analyze everything.",
+          examples: const ['']),
 
-  static const MessageKind MISSING_MAIN = const MessageKind(
-      "Could not find '#{main}'.",
-      howToFix: "Try adding a method named '#{main}' to your program."
-      /* No example, test uses '--analyze-only' which will produce the above
-       * message [CONSIDER_ANALYZE_ALL].  An example for a human operator would
-       * be an empty file. */);
+      MessageKind.MISSING_MAIN:
+        const MessageTemplate(MessageKind.MISSING_MAIN,
+          "Could not find '#{main}'.",
+          howToFix: "Try adding a method named '#{main}' to your program."
+          /* No example, test uses '--analyze-only' which will produce the above
+           * message [CONSIDER_ANALYZE_ALL].  An example for a human operator would
+           * be an empty file. */),
 
-  static const MessageKind MAIN_NOT_A_FUNCTION = const MessageKind(
-      "'#{main}' is not a function.",
-      howToFix: DONT_KNOW_HOW_TO_FIX, /* Don't state the obvious. */
-      examples: const ['var main;']);
+      MessageKind.MAIN_NOT_A_FUNCTION:
+        const MessageTemplate(MessageKind.MAIN_NOT_A_FUNCTION,
+          "'#{main}' is not a function.",
+          howToFix: DONT_KNOW_HOW_TO_FIX, /* Don't state the obvious. */
+          examples: const ['var main;']),
 
-  static const MessageKind MAIN_WITH_EXTRA_PARAMETER = const MessageKind(
-      "'#{main}' cannot have more than two parameters.",
-      howToFix: DONT_KNOW_HOW_TO_FIX, /* Don't state the obvious. */
-      examples: const ['main(a, b, c) {}']);
+      MessageKind.MAIN_WITH_EXTRA_PARAMETER:
+        const MessageTemplate(MessageKind.MAIN_WITH_EXTRA_PARAMETER,
+          "'#{main}' cannot have more than two parameters.",
+          howToFix: DONT_KNOW_HOW_TO_FIX, /* Don't state the obvious. */
+          examples: const ['main(a, b, c) {}']),
 
-  static const MessageKind COMPILER_CRASHED = const MessageKind(
-      "The compiler crashed when compiling this element.");
+      MessageKind.COMPILER_CRASHED:
+        const MessageTemplate(MessageKind.COMPILER_CRASHED,
+          "The compiler crashed when compiling this element."),
 
-  static const MessageKind PLEASE_REPORT_THE_CRASH = const MessageKind('''
+      MessageKind.PLEASE_REPORT_THE_CRASH:
+        const MessageTemplate(MessageKind.PLEASE_REPORT_THE_CRASH, '''
 The compiler is broken.
 
 When compiling the above element, the compiler crashed. It is not
 possible to tell if this is caused by a problem in your program or
 not. Regardless, the compiler should not crash.
 
 The Dart team would greatly appreciate if you would take a moment to
 report this problem at http://dartbug.com/new.
 
 Please include the following information:
 
 * the name and version of your operating system,
 
 * the Dart SDK build number (#{buildId}), and
 
 * the entire message you see here (including the full stack trace
   below as well as the source location above).
-''');
+'''),
 
-  static const MessageKind POTENTIAL_MUTATION = const MessageKind(
-      "Variable '#{variableName}' is not known to be of type "
-      "'#{shownType}' because it is potentially mutated in the scope for "
-      "promotion.");
+      MessageKind.POTENTIAL_MUTATION:
+        const MessageTemplate(MessageKind.POTENTIAL_MUTATION,
+          "Variable '#{variableName}' is not known to be of type "
+          "'#{shownType}' because it is potentially mutated in the scope for "
+          "promotion."),
 
-  static const MessageKind POTENTIAL_MUTATION_HERE = const MessageKind(
-      "Variable '#{variableName}' is potentially mutated here.");
+      MessageKind.POTENTIAL_MUTATION_HERE:
+        const MessageTemplate(MessageKind.POTENTIAL_MUTATION_HERE,
+          "Variable '#{variableName}' is potentially mutated here."),
 
-  static const MessageKind POTENTIAL_MUTATION_IN_CLOSURE = const MessageKind(
-      "Variable '#{variableName}' is not known to be of type "
-      "'#{shownType}' because it is potentially mutated within a closure.");
+      MessageKind.POTENTIAL_MUTATION_IN_CLOSURE:
+        const MessageTemplate(MessageKind.POTENTIAL_MUTATION_IN_CLOSURE,
+          "Variable '#{variableName}' is not known to be of type "
+          "'#{shownType}' because it is potentially mutated within a closure."),
 
-  static const MessageKind POTENTIAL_MUTATION_IN_CLOSURE_HERE =
-      const MessageKind(
-          "Variable '#{variableName}' is potentially mutated in a "
-          "closure here.");
+      MessageKind.POTENTIAL_MUTATION_IN_CLOSURE_HERE:
+        const MessageTemplate(MessageKind.POTENTIAL_MUTATION_IN_CLOSURE_HERE,
+              "Variable '#{variableName}' is potentially mutated in a "
+              "closure here."),
 
-  static const MessageKind ACCESSED_IN_CLOSURE = const MessageKind(
-      "Variable '#{variableName}' is not known to be of type "
-      "'#{shownType}' because it is accessed by a closure in the scope for "
-      "promotion and potentially mutated in the scope of '#{variableName}'.");
+      MessageKind.ACCESSED_IN_CLOSURE:
+        const MessageTemplate(MessageKind.ACCESSED_IN_CLOSURE,
+          "Variable '#{variableName}' is not known to be of type "
+          "'#{shownType}' because it is accessed by a closure in the scope for "
+          "promotion and potentially mutated in the scope of '#{variableName}'."),
 
-  static const MessageKind ACCESSED_IN_CLOSURE_HERE = const MessageKind(
-      "Variable '#{variableName}' is accessed in a closure here.");
+      MessageKind.ACCESSED_IN_CLOSURE_HERE:
+        const MessageTemplate(MessageKind.ACCESSED_IN_CLOSURE_HERE,
+          "Variable '#{variableName}' is accessed in a closure here."),
 
-  static const MessageKind NOT_MORE_SPECIFIC = const MessageKind(
-      "Variable '#{variableName}' is not shown to have type "
-      "'#{shownType}' because '#{shownType}' is not more specific than the "
-      "known type '#{knownType}' of '#{variableName}'.");
+      MessageKind.NOT_MORE_SPECIFIC:
+        const MessageTemplate(MessageKind.NOT_MORE_SPECIFIC,
+          "Variable '#{variableName}' is not shown to have type "
+          "'#{shownType}' because '#{shownType}' is not more specific than the "
+          "known type '#{knownType}' of '#{variableName}'."),
 
-  static const MessageKind NOT_MORE_SPECIFIC_SUBTYPE = const MessageKind(
-      "Variable '#{variableName}' is not shown to have type "
-      "'#{shownType}' because '#{shownType}' is not a subtype of the "
-      "known type '#{knownType}' of '#{variableName}'.");
+      MessageKind.NOT_MORE_SPECIFIC_SUBTYPE:
+        const MessageTemplate(MessageKind.NOT_MORE_SPECIFIC_SUBTYPE,
+          "Variable '#{variableName}' is not shown to have type "
+          "'#{shownType}' because '#{shownType}' is not a subtype of the "
+          "known type '#{knownType}' of '#{variableName}'."),
 
-  static const MessageKind NOT_MORE_SPECIFIC_SUGGESTION = const MessageKind(
-      "Variable '#{variableName}' is not shown to have type "
-      "'#{shownType}' because '#{shownType}' is not more specific than the "
-      "known type '#{knownType}' of '#{variableName}'.",
-      howToFix: "Try replacing '#{shownType}' with '#{shownTypeSuggestion}'.");
+      MessageKind.NOT_MORE_SPECIFIC_SUGGESTION:
+        const MessageTemplate(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
+          "Variable '#{variableName}' is not shown to have type "
+          "'#{shownType}' because '#{shownType}' is not more specific than the "
+          "known type '#{knownType}' of '#{variableName}'.",
+          howToFix: "Try replacing '#{shownType}' with '#{shownTypeSuggestion}'."),
 
-  static const MessageKind HIDDEN_WARNINGS_HINTS = const MessageKind(
-      "#{warnings} warning(s) and #{hints} hint(s) suppressed in #{uri}.");
+      MessageKind.HIDDEN_WARNINGS_HINTS:
+        const MessageTemplate(MessageKind.HIDDEN_WARNINGS_HINTS,
+          "#{warnings} warning(s) and #{hints} hint(s) suppressed in #{uri}."),
 
-  static const MessageKind HIDDEN_WARNINGS = const MessageKind(
-      "#{warnings} warning(s) suppressed in #{uri}.");
+      MessageKind.HIDDEN_WARNINGS:
+        const MessageTemplate(MessageKind.HIDDEN_WARNINGS,
+          "#{warnings} warning(s) suppressed in #{uri}."),
 
-  static const MessageKind HIDDEN_HINTS = const MessageKind(
-      "#{hints} hint(s) suppressed in #{uri}.");
+      MessageKind.HIDDEN_HINTS:
+        const MessageTemplate(MessageKind.HIDDEN_HINTS,
+          "#{hints} hint(s) suppressed in #{uri}."),
 
-  static const MessageKind PREAMBLE = const MessageKind(
-    "When run on the command-line, the compiled output might"
-    " require a preamble file located in:\n"
-    "  <sdk>/lib/_internal/js_runtime/lib/preambles.");
+      MessageKind.PREAMBLE:
+        const MessageTemplate(MessageKind.PREAMBLE,
+        "When run on the command-line, the compiled output might"
+        " require a preamble file located in:\n"
+        "  <sdk>/lib/_internal/js_runtime/lib/preambles."),
 
-  static const MessageKind INVALID_SYNC_MODIFIER = const MessageKind(
-      "Invalid modifier 'sync'.",
-      options: const ['--enable-async'],
-      howToFix: "Try replacing 'sync' with 'sync*'.",
-      examples: const [
-        "main() sync {}"
-      ]);
+      MessageKind.INVALID_SYNC_MODIFIER:
+        const MessageTemplate(MessageKind.INVALID_SYNC_MODIFIER,
+          "Invalid modifier 'sync'.",
+          options: const ['--enable-async'],
+          howToFix: "Try replacing 'sync' with 'sync*'.",
+          examples: const [
+            "main() sync {}"
+          ]),
 
-  static const MessageKind INVALID_AWAIT_FOR = const MessageKind(
-      "'await' is only supported on for-in loops.",
-      options: const ['--enable-async'],
-      howToFix: "Try rewriting the loop as a for-in loop or removing the "
-                "'await' keyword.",
-      examples: const ["""
+      MessageKind.INVALID_AWAIT_FOR:
+        const MessageTemplate(MessageKind.INVALID_AWAIT_FOR,
+          "'await' is only supported on for-in loops.",
+          options: const ['--enable-async'],
+          howToFix: "Try rewriting the loop as a for-in loop or removing the "
+                    "'await' keyword.",
+          examples: const ["""
 main() async* {
   await for (int i = 0; i < 10; i++) {}
 }
-"""]);
+"""]),
 
-  static const MessageKind ASYNC_MODIFIER_ON_ABSTRACT_METHOD =
-      const MessageKind(
-          "The modifier '#{modifier}' is not allowed on an abstract method.",
-          options: const ['--enable-async'],
-          howToFix: "Try removing the '#{modifier}' modifier or adding a "
-                    "body to the method.",
-          examples: const ["""
+      MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD:
+        const MessageTemplate(MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
+              "The modifier '#{modifier}' is not allowed on an abstract method.",
+              options: const ['--enable-async'],
+              howToFix: "Try removing the '#{modifier}' modifier or adding a "
+                        "body to the method.",
+              examples: const ["""
 abstract class A {
   method() async;
 }
 class B extends A {
   method() {}
 }
 main() {
   A a = new B();
   a.method();
 }
-"""]);
+"""]),
 
-  static const MessageKind ASYNC_MODIFIER_ON_CONSTRUCTOR =
-      const MessageKind(
-          "The modifier '#{modifier}' is not allowed on constructors.",
-          options: const ['--enable-async'],
-          howToFix: "Try removing the '#{modifier}' modifier.",
-          examples: const ["""
+      MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
+              "The modifier '#{modifier}' is not allowed on constructors.",
+              options: const ['--enable-async'],
+              howToFix: "Try removing the '#{modifier}' modifier.",
+              examples: const ["""
 class A {
   A() async;
 }
 main() => new A();""",
 
 """
 class A {
   A();
   factory A.a() async* {}
 }
-main() => new A.a();"""]);
+main() => new A.a();"""]),
 
-  static const MessageKind ASYNC_MODIFIER_ON_SETTER =
-      const MessageKind(
-          "The modifier '#{modifier}' is not allowed on setters.",
-          options: const ['--enable-async'],
-          howToFix: "Try removing the '#{modifier}' modifier.",
-          examples: const ["""
+      MessageKind.ASYNC_MODIFIER_ON_SETTER:
+        const MessageTemplate(MessageKind.ASYNC_MODIFIER_ON_SETTER,
+              "The modifier '#{modifier}' is not allowed on setters.",
+              options: const ['--enable-async'],
+              howToFix: "Try removing the '#{modifier}' modifier.",
+              examples: const ["""
 class A {
   set foo(v) async {}
 }
-main() => new A().foo = 0;"""]);
+main() => new A().foo = 0;"""]),
 
-  static const MessageKind YIELDING_MODIFIER_ON_ARROW_BODY =
-      const MessageKind(
-          "The modifier '#{modifier}' is not allowed on methods implemented "
-          "using '=>'.",
+      MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY:
+        const MessageTemplate(MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
+              "The modifier '#{modifier}' is not allowed on methods implemented "
+              "using '=>'.",
+              options: const ['--enable-async'],
+              howToFix: "Try removing the '#{modifier}' modifier or implementing "
+                        "the method body using a block: '{ ... }'.",
+              examples: const ["main() sync* => null;", "main() async* => null;"]),
+
+      // TODO(johnniwinther): Check for 'async' as identifier.
+      MessageKind.ASYNC_KEYWORD_AS_IDENTIFIER:
+        const MessageTemplate(MessageKind.ASYNC_KEYWORD_AS_IDENTIFIER,
+          "'#{keyword}' cannot be used as an identifier in a function body marked "
+          "with '#{modifier}'.",
           options: const ['--enable-async'],
-          howToFix: "Try removing the '#{modifier}' modifier or implementing "
-                    "the method body using a block: '{ ... }'.",
-          examples: const ["main() sync* => null;", "main() async* => null;"]);
-
-  // TODO(johnniwinther): Check for 'async' as identifier.
-  static const MessageKind ASYNC_KEYWORD_AS_IDENTIFIER = const MessageKind(
-      "'#{keyword}' cannot be used as an identifier in a function body marked "
-      "with '#{modifier}'.",
-      options: const ['--enable-async'],
-      howToFix: "Try removing the '#{modifier}' modifier or renaming the "
-                "identifier.",
-      examples: const ["""
+          howToFix: "Try removing the '#{modifier}' modifier or renaming the "
+                    "identifier.",
+          examples: const ["""
 main() async {
  var await;
 }""",
 """
 main() async* {
  var yield;
 }""",
 """
 main() sync* {
  var yield;
-}"""]);
+}"""]),
 
-  static const MessageKind RETURN_IN_GENERATOR =
-      const MessageKind(
-          "'return' with a value is not allowed in a method body using the "
-          "'#{modifier}' modifier.",
-          howToFix: "Try removing the value, replacing 'return' with 'yield' "
-                    "or changing the method body modifier.",
-          examples: const [
+      MessageKind.RETURN_IN_GENERATOR:
+        const MessageTemplate(MessageKind.RETURN_IN_GENERATOR,
+              "'return' with a value is not allowed in a method body using the "
+              "'#{modifier}' modifier.",
+              howToFix: "Try removing the value, replacing 'return' with 'yield' "
+                        "or changing the method body modifier.",
+              examples: const [
 """
 foo() async* { return 0; }
 main() => foo();
 """,
 
 """
 foo() sync* { return 0; }
 main() => foo();
-"""]);
+"""]),
 
-  static const MessageKind NATIVE_NOT_SUPPORTED = const MessageKind(
-      "'native' modifier is not supported.",
-      howToFix: "Try removing the 'native' implementation or analyzing the "
-                "code with the --allow-native-extensions option.",
-      examples: const ["""
+      MessageKind.NATIVE_NOT_SUPPORTED:
+        const MessageTemplate(MessageKind.NATIVE_NOT_SUPPORTED,
+          "'native' modifier is not supported.",
+          howToFix: "Try removing the 'native' implementation or analyzing the "
+                    "code with the --allow-native-extensions option.",
+          examples: const ["""
 main() native "Main";
-"""]);
+"""]),
 
-  static const MessageKind DART_EXT_NOT_SUPPORTED = const MessageKind(
-      "The 'dart-ext' scheme is not supported.",
-      howToFix: "Try analyzing the code with the --allow-native-extensions "
-                "option.",
-      examples: const ["""
+      MessageKind.DART_EXT_NOT_SUPPORTED:
+        const MessageTemplate(MessageKind.DART_EXT_NOT_SUPPORTED,
+          "The 'dart-ext' scheme is not supported.",
+          howToFix: "Try analyzing the code with the --allow-native-extensions "
+                    "option.",
+          examples: const ["""
 import 'dart-ext:main';
 
 main() {}
-"""]);
+"""]),
 
-  static const MessageKind LIBRARY_TAG_MUST_BE_FIRST = const MessageKind(
-      "The library declaration should come before other declarations.",
-      howToFix: "Try moving the declaration to the top of the file.",
-      examples: const [
+      MessageKind.LIBRARY_TAG_MUST_BE_FIRST:
+        const MessageTemplate(MessageKind.LIBRARY_TAG_MUST_BE_FIRST,
+          "The library declaration should come before other declarations.",
+          howToFix: "Try moving the declaration to the top of the file.",
+          examples: const [
 """
 import 'dart:core';
 library foo;
 main() {}
 """,
-      ]);
+      ]),
 
-  static const MessageKind ONLY_ONE_LIBRARY_TAG = const MessageKind(
-      "There can only be one library declaration.",
-      howToFix: "Try removing all other library declarations.",
-      examples: const [
+      MessageKind.ONLY_ONE_LIBRARY_TAG:
+        const MessageTemplate(MessageKind.ONLY_ONE_LIBRARY_TAG,
+          "There can only be one library declaration.",
+          howToFix: "Try removing all other library declarations.",
+          examples: const [
 """
 library foo;
 library bar;
 main() {}
 """,
 """
 library foo;
 import 'dart:core';
 library bar;
 main() {}
 """,
-      ]);
+      ]),
 
-  static const MessageKind IMPORT_BEFORE_PARTS = const MessageKind(
-      "Import declarations should come before parts.",
-      howToFix: "Try moving this import further up in the file.",
-      examples: const [
-          const <String, String>{
-            'main.dart': """
+      MessageKind.IMPORT_BEFORE_PARTS:
+        const MessageTemplate(MessageKind.IMPORT_BEFORE_PARTS,
+          "Import declarations should come before parts.",
+          howToFix: "Try moving this import further up in the file.",
+          examples: const [
+              const <String, String>{
+                'main.dart': """
 library test.main;
 part 'part.dart';
 import 'dart:core';
 main() {}
 """,
-            'part.dart': """
+                'part.dart': """
 part of test.main;
 """,
-      }]);
+          }]),
 
-  static const MessageKind EXPORT_BEFORE_PARTS = const MessageKind(
-      "Export declarations should come before parts.",
-      howToFix: "Try moving this export further up in the file.",
-      examples: const [
-          const <String, String>{
-            'main.dart': """
+      MessageKind.EXPORT_BEFORE_PARTS:
+        const MessageTemplate(MessageKind.EXPORT_BEFORE_PARTS,
+          "Export declarations should come before parts.",
+          howToFix: "Try moving this export further up in the file.",
+          examples: const [
+              const <String, String>{
+                'main.dart': """
 library test.main;
 part 'part.dart';
 export 'dart:core';
 main() {}
 """,
-            'part.dart': """
+               'part.dart': """
 part of test.main;
 """,
-      }]);
+          }]),
 
   //////////////////////////////////////////////////////////////////////////////
   // Patch errors start.
   //////////////////////////////////////////////////////////////////////////////
 
-  static const MessageKind PATCH_RETURN_TYPE_MISMATCH = const MessageKind(
-      "Patch return type '#{patchReturnType}' does not match "
-      "'#{originReturnType}' on origin method '#{methodName}'.");
+      MessageKind.PATCH_RETURN_TYPE_MISMATCH:
+        const MessageTemplate(MessageKind.PATCH_RETURN_TYPE_MISMATCH,
+          "Patch return type '#{patchReturnType}' does not match "
+          "'#{originReturnType}' on origin method '#{methodName}'."),
 
-  static const MessageKind PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH =
-      const MessageKind(
-          "Required parameter count of patch method "
-          "(#{patchParameterCount}) does not match parameter count on origin "
-          "method '#{methodName}' (#{originParameterCount}).");
+      MessageKind.PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH:
+        const MessageTemplate(MessageKind.PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH,
+              "Required parameter count of patch method "
+              "(#{patchParameterCount}) does not match parameter count on origin "
+              "method '#{methodName}' (#{originParameterCount})."),
 
-  static const MessageKind PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH =
-      const MessageKind(
-          "Optional parameter count of patch method "
-          "(#{patchParameterCount}) does not match parameter count on origin "
-          "method '#{methodName}' (#{originParameterCount}).");
+      MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH:
+        const MessageTemplate(MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH,
+              "Optional parameter count of patch method "
+              "(#{patchParameterCount}) does not match parameter count on origin "
+              "method '#{methodName}' (#{originParameterCount})."),
 
-  static const MessageKind PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH =
-      const MessageKind(
-          "Optional parameters of origin and patch method "
-          "'#{methodName}' must both be either named or positional.");
+      MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH:
+        const MessageTemplate(MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH,
+              "Optional parameters of origin and patch method "
+              "'#{methodName}' must both be either named or positional."),
 
-  static const MessageKind PATCH_PARAMETER_MISMATCH = const MessageKind(
-      "Patch method parameter '#{patchParameter}' does not match "
-      "'#{originParameter}' on origin method '#{methodName}'.");
+      MessageKind.PATCH_PARAMETER_MISMATCH:
+        const MessageTemplate(MessageKind.PATCH_PARAMETER_MISMATCH,
+          "Patch method parameter '#{patchParameter}' does not match "
+          "'#{originParameter}' on origin method '#{methodName}'."),
 
-  static const MessageKind PATCH_PARAMETER_TYPE_MISMATCH = const MessageKind(
-      "Patch method parameter '#{parameterName}' type "
-      "'#{patchParameterType}' does not match '#{originParameterType}' on "
-      "origin method '#{methodName}'.");
+      MessageKind.PATCH_PARAMETER_TYPE_MISMATCH:
+        const MessageTemplate(MessageKind.PATCH_PARAMETER_TYPE_MISMATCH,
+          "Patch method parameter '#{parameterName}' type "
+          "'#{patchParameterType}' does not match '#{originParameterType}' on "
+          "origin method '#{methodName}'."),
 
-  static const MessageKind PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION =
-      const MessageKind("External method without an implementation.");
+      MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION:
+        const MessageTemplate(MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION, "External method without an implementation."),
 
-  static const MessageKind PATCH_POINT_TO_FUNCTION = const MessageKind(
-      "This is the function patch '#{functionName}'.");
+      MessageKind.PATCH_POINT_TO_FUNCTION:
+        const MessageTemplate(MessageKind.PATCH_POINT_TO_FUNCTION,
+          "This is the function patch '#{functionName}'."),
 
-  static const MessageKind PATCH_POINT_TO_CLASS = const MessageKind(
-      "This is the class patch '#{className}'.");
+      MessageKind.PATCH_POINT_TO_CLASS:
+        const MessageTemplate(MessageKind.PATCH_POINT_TO_CLASS,
+          "This is the class patch '#{className}'."),
 
-  static const MessageKind PATCH_POINT_TO_GETTER = const MessageKind(
-      "This is the getter patch '#{getterName}'.");
+      MessageKind.PATCH_POINT_TO_GETTER:
+        const MessageTemplate(MessageKind.PATCH_POINT_TO_GETTER,
+          "This is the getter patch '#{getterName}'."),
 
-  static const MessageKind PATCH_POINT_TO_SETTER = const MessageKind(
-      "This is the setter patch '#{setterName}'.");
+      MessageKind.PATCH_POINT_TO_SETTER:
+        const MessageTemplate(MessageKind.PATCH_POINT_TO_SETTER,
+          "This is the setter patch '#{setterName}'."),
 
-  static const MessageKind PATCH_POINT_TO_CONSTRUCTOR = const MessageKind(
-      "This is the constructor patch '#{constructorName}'.");
+      MessageKind.PATCH_POINT_TO_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
+          "This is the constructor patch '#{constructorName}'."),
 
-  static const MessageKind PATCH_POINT_TO_PARAMETER = const MessageKind(
-      "This is the patch parameter '#{parameterName}'.");
+      MessageKind.PATCH_POINT_TO_PARAMETER:
+        const MessageTemplate(MessageKind.PATCH_POINT_TO_PARAMETER,
+          "This is the patch parameter '#{parameterName}'."),
 
-  static const MessageKind PATCH_NON_EXISTING = const MessageKind(
-      "Origin does not exist for patch '#{name}'.");
+      MessageKind.PATCH_NON_EXISTING:
+        const MessageTemplate(MessageKind.PATCH_NON_EXISTING,
+          "Origin does not exist for patch '#{name}'."),
 
-  // TODO(ahe): Eventually, this error should be removed as it will be handled
-  // by the regular parser.
-  static const MessageKind PATCH_NONPATCHABLE = const MessageKind(
-      "Only classes and functions can be patched.");
+      // TODO(ahe): Eventually, this error should be removed as it will be handled
+      // by the regular parser.
+      MessageKind.PATCH_NONPATCHABLE:
+        const MessageTemplate(MessageKind.PATCH_NONPATCHABLE,
+          "Only classes and functions can be patched."),
 
-  static const MessageKind PATCH_NON_EXTERNAL = const MessageKind(
-      "Only external functions can be patched.");
+      MessageKind.PATCH_NON_EXTERNAL:
+        const MessageTemplate(MessageKind.PATCH_NON_EXTERNAL,
+          "Only external functions can be patched."),
 
-  static const MessageKind PATCH_NON_CLASS = const MessageKind(
-      "Patching non-class with class patch '#{className}'.");
+      MessageKind.PATCH_NON_CLASS:
+        const MessageTemplate(MessageKind.PATCH_NON_CLASS,
+          "Patching non-class with class patch '#{className}'."),
 
-  static const MessageKind PATCH_NON_GETTER = const MessageKind(
-      "Cannot patch non-getter '#{name}' with getter patch.");
+      MessageKind.PATCH_NON_GETTER:
+        const MessageTemplate(MessageKind.PATCH_NON_GETTER,
+          "Cannot patch non-getter '#{name}' with getter patch."),
 
-  static const MessageKind PATCH_NO_GETTER = const MessageKind(
-      "No getter found for getter patch '#{getterName}'.");
+      MessageKind.PATCH_NO_GETTER:
+        const MessageTemplate(MessageKind.PATCH_NO_GETTER,
+          "No getter found for getter patch '#{getterName}'."),
 
-  static const MessageKind PATCH_NON_SETTER = const MessageKind(
-      "Cannot patch non-setter '#{name}' with setter patch.");
+      MessageKind.PATCH_NON_SETTER:
+        const MessageTemplate(MessageKind.PATCH_NON_SETTER,
+          "Cannot patch non-setter '#{name}' with setter patch."),
 
-  static const MessageKind PATCH_NO_SETTER = const MessageKind(
-      "No setter found for setter patch '#{setterName}'.");
+      MessageKind.PATCH_NO_SETTER:
+        const MessageTemplate(MessageKind.PATCH_NO_SETTER,
+          "No setter found for setter patch '#{setterName}'."),
 
-  static const MessageKind PATCH_NON_CONSTRUCTOR = const MessageKind(
-      "Cannot patch non-constructor with constructor patch "
-      "'#{constructorName}'.");
+      MessageKind.PATCH_NON_CONSTRUCTOR:
+        const MessageTemplate(MessageKind.PATCH_NON_CONSTRUCTOR,
+          "Cannot patch non-constructor with constructor patch "
+          "'#{constructorName}'."),
 
-  static const MessageKind PATCH_NON_FUNCTION = const MessageKind(
-      "Cannot patch non-function with function patch "
-      "'#{functionName}'.");
+      MessageKind.PATCH_NON_FUNCTION:
+        const MessageTemplate(MessageKind.PATCH_NON_FUNCTION,
+          "Cannot patch non-function with function patch "
+          "'#{functionName}'."),
 
-  static const MessageKind EXTERNAL_WITH_BODY = const MessageKind(
-      "External function '#{functionName}' cannot have a function body.",
-      options: const ["--output-type=dart"],
-      howToFix: "Try removing the 'external' modifier or the function body.",
-      examples: const ["""
+      MessageKind.EXTERNAL_WITH_BODY:
+        const MessageTemplate(MessageKind.EXTERNAL_WITH_BODY,
+          "External function '#{functionName}' cannot have a function body.",
+          options: const ["--output-type=dart"],
+          howToFix: "Try removing the 'external' modifier or the function body.",
+          examples: const ["""
 external foo() => 0;
 main() => foo();
 """, """
 external foo() {}
 main() => foo();
-"""]);
+"""]),
 
   //////////////////////////////////////////////////////////////////////////////
   // Patch errors end.
   //////////////////////////////////////////////////////////////////////////////
 
-  static const String IMPORT_EXPERIMENTAL_MIRRORS_PADDING = '\n*   ';
-
-  static const MessageKind IMPORT_EXPERIMENTAL_MIRRORS =
-      const MessageKind(r'''
+      MessageKind.IMPORT_EXPERIMENTAL_MIRRORS:
+        const MessageTemplate(MessageKind.IMPORT_EXPERIMENTAL_MIRRORS, r'''
 
 ****************************************************************
 * WARNING: dart:mirrors support in dart2js is experimental,
 *          and not recommended.
 *          This implementation of mirrors is incomplete,
 *          and often greatly increases the size of the generated
 *          JavaScript code.
 *
 * Your app imports dart:mirrors via:''''''
 $IMPORT_EXPERIMENTAL_MIRRORS_PADDING#{importChain}
 *
 * You can disable this message by using the --enable-experimental-mirrors
 * command-line flag.
 *
 * To learn what to do next, please visit:
 *    http://dartlang.org/dart2js-reflection
 ****************************************************************
-''');
+'''),
 
 
-  static const MessageKind MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND =
-      const MessageKind(
-          "dart:mirrors library is not supported when using this backend.");
+      MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND:
+        const MessageTemplate(MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND,
+              "dart:mirrors library is not supported when using this backend."),
 
-  static const MessageKind CALL_NOT_SUPPORTED_ON_NATIVE_CLASS =
-      const MessageKind(
-          "Non-supported 'call' member on a native class, or a "
-          "subclass of a native class.");
+      MessageKind.CALL_NOT_SUPPORTED_ON_NATIVE_CLASS:
+        const MessageTemplate(MessageKind.CALL_NOT_SUPPORTED_ON_NATIVE_CLASS,
+              "Non-supported 'call' member on a native class, or a "
+              "subclass of a native class."),
 
-  static const MessageKind DIRECTLY_THROWING_NSM =
-      const MessageKind(
-          "This 'noSuchMethod' implementation is guaranteed to throw an "
-          "exception. The generated code will be smaller if it is "
-          "rewritten.",
-          howToFix: "Rewrite to "
-                    "'noSuchMethod(Invocation i) => super.noSuchMethod(i);'.");
+      MessageKind.DIRECTLY_THROWING_NSM:
+        const MessageTemplate(MessageKind.DIRECTLY_THROWING_NSM,
+              "This 'noSuchMethod' implementation is guaranteed to throw an "
+              "exception. The generated code will be smaller if it is "
+              "rewritten.",
+              howToFix: "Rewrite to "
+                        "'noSuchMethod(Invocation i) => super.noSuchMethod(i);'."),
 
-  static const MessageKind COMPLEX_THROWING_NSM =
-      const MessageKind(
-          "This 'noSuchMethod' implementation is guaranteed to throw an "
-          "exception. The generated code will be smaller and the compiler "
-          "will be able to perform more optimizations if it is rewritten.",
-          howToFix: "Rewrite to "
-                    "'noSuchMethod(Invocation i) => super.noSuchMethod(i);'.");
+      MessageKind.COMPLEX_THROWING_NSM:
+        const MessageTemplate(MessageKind.COMPLEX_THROWING_NSM,
+              "This 'noSuchMethod' implementation is guaranteed to throw an "
+              "exception. The generated code will be smaller and the compiler "
+              "will be able to perform more optimizations if it is rewritten.",
+              howToFix: "Rewrite to "
+                        "'noSuchMethod(Invocation i) => super.noSuchMethod(i);'."),
 
-  static const MessageKind COMPLEX_RETURNING_NSM =
-      const MessageKind(
-          "Overriding 'noSuchMethod' causes the compiler to generate "
-          "more code and prevents the compiler from doing some optimizations.",
-          howToFix: "Consider removing this 'noSuchMethod' implementation.");
+      MessageKind.COMPLEX_RETURNING_NSM:
+        const MessageTemplate(MessageKind.COMPLEX_RETURNING_NSM,
+              "Overriding 'noSuchMethod' causes the compiler to generate "
+              "more code and prevents the compiler from doing some optimizations.",
+              howToFix: "Consider removing this 'noSuchMethod' implementation."),
+
+
+  }; // End of TEMPLATES.
+
+  static const String IMPORT_EXPERIMENTAL_MIRRORS_PADDING = '\n*   ';
 
   toString() => template;
 
   Message message([Map arguments = const {}, bool terse = false]) {
     return new Message(this, arguments, terse);
   }
 
   bool get hasHowToFix => howToFix != null && howToFix != DONT_KNOW_HOW_TO_FIX;
 }
 
 class Message {
-  final MessageKind kind;
+  final MessageTemplate template;
   final Map arguments;
   final bool terse;
   String message;
 
-  Message(this.kind, this.arguments, this.terse) {
+  Message(this.template, this.arguments, this.terse) {
     assert(() { computeMessage(); return true; });
   }
 
+  MessageKind get kind => template.kind;
+
   String computeMessage() {
     if (message == null) {
-      message = kind.template;
+      message = template.template;
       arguments.forEach((key, value) {
         message = message.replaceAll('#{${key}}', convertToString(value));
       });
       assert(invariant(
           CURRENT_ELEMENT_SPANNABLE,
           kind == MessageKind.GENERIC ||
             !message.contains(new RegExp(r'#\{.+\}')),
           message: 'Missing arguments in error message: "$message"'));
-      if (!terse && kind.hasHowToFix) {
-        String howToFix = kind.howToFix;
+      if (!terse && template.hasHowToFix) {
+        String howToFix = template.howToFix;
         arguments.forEach((key, value) {
           howToFix = howToFix.replaceAll('#{${key}}', convertToString(value));
         });
         message = '$message\n$howToFix';
       }
     }
     return message;
   }
 
   String toString() {
     return computeMessage();
   }
 
   bool operator==(other) {
     if (other is !Message) return false;
-    return (kind == other.kind) && (toString() == other.toString());
+    return (template == other.template) && (toString() == other.toString());
   }
 
   int get hashCode => throw new UnsupportedError('Message.hashCode');
 
   static String convertToString(value) {
     if (value is ErrorToken) {
       // Shouldn't happen.
       return value.assertionMessage;
     } else if (value is Token) {
       value = value.value;
     }
     return '$value';
   }
 }