Split MessageKind into a MessageKind key and a MessageTemplate.

tests/compiler/dart2js/resolver_test.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
@@ skipping 290 matching lines @@
       () => testLocals([["foo", true], ["bar", true]]),
 
       () => testLocals([["foo", false], ["bar", false], ["foobar", true]]),
       () => testLocals([["foo", false], ["bar", true], ["foobar", true]]),
       () => testLocals([["foo", true], ["bar", true], ["foobar", true]]),
 
       () => testLocals([["foo", false], ["foo", false]])
           .then((MockCompiler compiler) {
       Expect.equals(1, compiler.errors.length);
       Expect.equals(
-          new Message(MessageKind.DUPLICATE_DEFINITION, {'name': 'foo'}, false),
+          new Message(
+              MessageTemplate.TEMPLATES[MessageKind.DUPLICATE_DEFINITION],
+              {'name': 'foo'}, false),
           compiler.errors[0].message);
     })], (f) => f());
 }
 
 
 Future testLocalsTwo() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Node tree = parseStatement("if (true) { var a = 1; var b = 2; }");
     ResolutionResult result = visitor.visit(tree);
@@ skipping 162 matching lines @@
     // Test that we get a warning when Foo is not defined.
     Map mapping = compiler.resolveStatement(statement).map;
 
     Expect.equals(1, mapping.length); // Only [bar] has an element.
     Expect.equals(1, compiler.warnings.length);
 
     Node warningNode = compiler.warnings[0].node;
 
     Expect.equals(
         new Message(
-            MessageKind.CANNOT_RESOLVE_TYPE,  {'typeName': 'Foo'}, false),
+            MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
+            {'typeName': 'Foo'}, false),
         compiler.warnings[0].message);
     VariableDefinitions definition = compiler.parsedTree;
     Expect.equals(warningNode, definition.type);
     compiler.clearMessages();
 
     // Test that there is no warning after defining Foo.
     compiler.parseScript("class Foo {}");
     mapping = compiler.resolveStatement(statement).map;
     Expect.equals(1, mapping.length);
     Expect.equals(0, compiler.warnings.length);
 
     // Test that 'var' does not create a warning.
     mapping = compiler.resolveStatement("var foo;").map;
     Expect.equals(1, mapping.length);
     Expect.equals(0, compiler.warnings.length);
   });
 }
 
 Future testSuperclass() {
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo extends Bar {}");
       compiler.resolveStatement("Foo bar;");
       Expect.equals(1, compiler.errors.length);
-      var cannotResolveBar = new Message(MessageKind.CANNOT_EXTEND_MALFORMED,
+      var cannotResolveBar = new Message(
+          MessageTemplate.TEMPLATES[MessageKind.CANNOT_EXTEND_MALFORMED],
           {'className': 'Foo', 'malformedType': 'Bar'}, false);
       Expect.equals(cannotResolveBar, compiler.errors[0].message);
       compiler.clearMessages();
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo extends Bar {}");
       compiler.parseScript("class Bar {}");
       Map mapping = compiler.resolveStatement("Foo bar;").map;
       Expect.equals(1, mapping.length);
 
       ClassElement fooElement = compiler.mainApp.find('Foo');
       ClassElement barElement = compiler.mainApp.find('Bar');
       Expect.equals(barElement.computeType(compiler),
                     fooElement.supertype);
       Expect.isTrue(fooElement.interfaces.isEmpty);
       Expect.isTrue(barElement.interfaces.isEmpty);
     }),
   ]);
 }
 
 Future testVarSuperclass() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("class Foo extends var {}");
     compiler.resolveStatement("Foo bar;");
     Expect.equals(1, compiler.errors.length);
     Expect.equals(
         new Message(
-            MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': 'var'}, false),
+            MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
+            {'typeName': 'var'}, false),
         compiler.errors[0].message);
     compiler.clearMessages();
   });
 }
 
 Future testOneInterface() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript("class Foo implements Bar {}");
     compiler.resolveStatement("Foo bar;");
     Expect.equals(1, compiler.errors.length);
     Expect.equals(
         new Message(
-            MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': 'bar'}, false),
+            MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
+            {'typeName': 'bar'}, false),
         compiler.errors[0].message);
     compiler.clearMessages();
 
     // Add the abstract class to the world and make sure everything is setup
     // correctly.
     compiler.parseScript("abstract class Bar {}");
 
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, null,
             new ResolutionRegistry.internal(compiler,
@@ skipping 810 matching lines @@
     }
     main() => A.m();
   ''', functionName: 'm');
   check('''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''', className: 'A');
 }