anchor.diff:            const MessageTemplate(
                 MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT,
                 "Argument for 'JS_INTERCEPTOR_CONSTANT' must be a type constant."),
  -
  -      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."),
  -
  -      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() {}; }"]),
  -
  -      MessageKind.UNUSED_METHOD: const MessageTemplate(
  -          MessageKind.UNUSED_METHOD, "The method '#{name}' is never called.",
  -          howToFix: "Consider deleting it.",
  -          examples: const ["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() {}"]),
  -
  -      MessageKind.UNUSED_TYPEDEF: const MessageTemplate(
  -          MessageKind.UNUSED_TYPEDEF, "The typedef '#{name}' is never used.",
  -          howToFix: "Consider deleting it.",
  -          examples: const ["typedef DeadCode(); main() {}"]),
  -
  -      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();
  -"""
  -          ]),
   
         MessageKind.ABSTRACT_GETTER: const MessageTemplate(
             MessageKind.ABSTRACT_GETTER,
  
positive.code:           "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.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 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.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();"""
            ]),
  
        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.UNDEFINED_STATIC_SETTER_BUT_GETTER: const MessageTemplate(
            MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER,
            "Cannot resolve setter."),
  
        MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER: const MessageTemplate(
            MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
            "Cannot assign a value to final field '#{name}' "
            "in superclass '#{superclassName}'."),
  
        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;
  """
              }
            ]),
  
        MessageKind.IMPORT_PART_OF_HERE: const MessageTemplate(
            MessageKind.IMPORT_PART_OF_HERE, "The library is imported here."),
  
        MessageKind.MAIN_HAS_PART_OF: const MessageTemplate(
            MessageKind.MAIN_HAS_PART_OF,
            "The main application file must not have a 'part-of' directive.",
            howToFix: "Try removing the 'part-of' directive or starting "
                "compilation from another file.",
            examples: const [
              const {
                'main.dart': """
  part of library;
  
  main() {}
  """
              }
            ]),
  
        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;
  """
              }
            ]),
  
        MessageKind.LIBRARY_URI_MISMATCH: const MessageTemplate(
            MessageKind.LIBRARY_URI_MISMATCH,
            "Expected URI of library '#{libraryUri}'.",
            howToFix: "Try changing the directive to 'part of "
                "\"#{libraryUri}\";'.",
            examples: const [
              const {
                'main.dart': """
  library lib.foo;
  
  part 'part.dart';
  
  main() {}
  """,
                'part.dart': """
  part of 'not-main.dart';
  """
              }
            ]),
  
        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;
  """
              }
            ]),
  
        MessageKind.THIS_IS_THE_PART_OF_TAG: const MessageTemplate(
            MessageKind.THIS_IS_THE_PART_OF_TAG,
            "This is the part of directive."),
  
        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."),
  
        MessageKind.DUPLICATED_PART_OF: const MessageTemplate(
            MessageKind.DUPLICATED_PART_OF, "Duplicated part-of directive."),
  
        MessageKind.DUPLICATED_LIBRARY_NAME: const MessageTemplate(
            MessageKind.DUPLICATED_LIBRARY_NAME,
            "Duplicated library name '#{libraryName}'."),
  
        MessageKind.DUPLICATED_RESOURCE: const MessageTemplate(
            MessageKind.DUPLICATED_RESOURCE,
            "The resource '#{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.
        MessageKind.INVALID_SOURCE_FILE_LOCATION:
            const MessageTemplate(MessageKind.INVALID_SOURCE_FILE_LOCATION, '''
  Invalid offset (#{offset}) in source map.
  File: #{fileName}
  Length: #{length}'''),
  
        MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC: const MessageTemplate(
            MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC,
            "Top-level variable cannot be declared static."),
  
        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);
  """
            ]),
  
        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.
  }"""
            ]),
  
        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;"
            ]),
  
        MessageKind.CONST_LOOP_VARIABLE: const MessageTemplate(
            MessageKind.CONST_LOOP_VARIABLE,
            "A loop variable cannot be constant.",
            howToFix: "Try remove the 'const' modifier or "
                "replacing it with a 'final' modifier.",
            examples: const [
              """
  void main() {
    for (const c in []) {}
  }"""
            ]),
  
        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;
  """
            ]),
  
        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}."),
  
        MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS: const MessageTemplate(
            MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
            "'assert' takes no named arguments, but given #{argumentCount}."),
  
        MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY: const MessageTemplate(
            MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY,
            "Factory redirection only allowed in factories."),
  
        MessageKind.MISSING_FACTORY_KEYWORD: const MessageTemplate(
            MessageKind.MISSING_FACTORY_KEYWORD,
            "Did you forget a factory keyword here?"),
  
        MessageKind.NO_SUCH_METHOD_IN_NATIVE: const MessageTemplate(
            MessageKind.NO_SUCH_METHOD_IN_NATIVE,
            "'NoSuchMethod' is not supported for classes that extend native "
            "classes."),
  
        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."),
  
        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 '@MirrorsUsed(...)' as described at "
                "https://goo.gl/Akrrog."),
  
        MessageKind.NON_CONST_BLOAT: const MessageTemplate(
            MessageKind.NON_CONST_BLOAT,
            "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."),
  
        MessageKind.STRING_EXPECTED: const MessageTemplate(
            MessageKind.STRING_EXPECTED,
            "Expected a 'String', but got an instance of '#{type}'."),
  
        MessageKind.PRIVATE_IDENTIFIER: const MessageTemplate(
            MessageKind.PRIVATE_IDENTIFIER,
            "'#{value}' is not a valid Symbol name because it starts with "
            "'_'."),
  
        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();"""]),
  
        MessageKind.UNSUPPORTED_LITERAL_SYMBOL: const MessageTemplate(
            MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
            "Symbol literal '##{value}' is currently unsupported by dart2js."),
  
        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."),
  
        MessageKind.AMBIGUOUS_REEXPORT: const MessageTemplate(
            MessageKind.AMBIGUOUS_REEXPORT,
            "'#{name}' is (re)exported by multiple libraries."),
  
        MessageKind.AMBIGUOUS_LOCATION: const MessageTemplate(
            MessageKind.AMBIGUOUS_LOCATION, "'#{name}' is defined here."),
  
        MessageKind.IMPORTED_HERE: const MessageTemplate(
            MessageKind.IMPORTED_HERE, "'#{name}' is imported here."),
  
        MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE: const MessageTemplate(
            MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
            "The class '#{class}' overrides 'operator==', "
            "but not 'get hashCode'."),
  
        MessageKind.INTERNAL_LIBRARY_FROM: const MessageTemplate(
            MessageKind.INTERNAL_LIBRARY_FROM,
            "Internal library '#{resolvedUri}' is not accessible from "
            "'#{importingUri}'."),
  
        MessageKind.INTERNAL_LIBRARY: const MessageTemplate(
            MessageKind.INTERNAL_LIBRARY,
            "Internal library '#{resolvedUri}' is not accessible."),
  
        MessageKind.JS_INTEROP_CLASS_CANNOT_EXTEND_DART_CLASS:
            const MessageTemplate(
  
negative.code:           " require a preamble file located in:\n"
            "  <sdk>/lib/_internal/js_runtime/lib/preambles."),
  
        MessageKind.INVALID_CONSTANT_CONDITIONAL_TYPE: const MessageTemplate(
            MessageKind.INVALID_CONSTANT_CONDITIONAL_TYPE,
            "`#{constant}` of type '#{type}' is not a valid constant condition. "
  