Split MessageKind into a MessageKind key and a MessageTemplate.

pkg/compiler/lib/src/compiler.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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 1144 matching lines @@
   void internalError(Spannable node, reason) {
     String message = tryToString(reason);
     reportDiagnosticInternal(
         node, MessageKind.GENERIC, {'text': message}, api.Diagnostic.CRASH);
     throw 'Internal Error: $message';
   }
 
   void unhandledExceptionOnElement(Element element) {
     if (hasCrashed) return;
     hasCrashed = true;
-    reportDiagnostic(element,
-                     MessageKind.COMPILER_CRASHED.message(),
-                     api.Diagnostic.CRASH);
+    reportDiagnostic(
+        element,
+        MessageTemplate.TEMPLATES[MessageKind.COMPILER_CRASHED].message(),
+        api.Diagnostic.CRASH);
     pleaseReportCrash();
   }
 
   void pleaseReportCrash() {
-    print(MessageKind.PLEASE_REPORT_THE_CRASH.message({'buildId': buildId}));
+    print(
+        MessageTemplate.TEMPLATES[MessageKind.PLEASE_REPORT_THE_CRASH]
+            .message({'buildId': buildId}));
   }
 
   SourceSpan spanFromSpannable(Spannable node) {
     // TODO(johnniwinther): Disallow `node == null` ?
     if (node == null) return null;
     if (node == CURRENT_ELEMENT_SPANNABLE) {
       node = currentElement;
     } else if (node == NO_LOCATION_SPANNABLE) {
       if (currentElement == null) return null;
       node = currentElement;
@@ skipping 35 matching lines @@
     } else if (node is HInstruction) {
       element = _elementFromHInstruction(node);
     } else if (node is MetadataAnnotation) {
       element = node.annotatedElement;
     }
     return element != null ? element : currentElement;
   }
 
   void log(message) {
     reportDiagnostic(null,
-        MessageKind.GENERIC.message({'text': '$message'}),
+        MessageTemplate.TEMPLATES[MessageKind.GENERIC]
+            .message({'text': '$message'}),
         api.Diagnostic.VERBOSE_INFO);
   }
 
   Future<bool> run(Uri uri) {
     totalCompileTime.start();
 
     return new Future.sync(() => runCompiler(uri)).catchError((error) {
       try {
         if (!hasCrashed) {
           hasCrashed = true;
           if (error is SpannableAssertionFailure) {
             reportAssertionFailure(error);
           } else {
-            reportDiagnostic(new SourceSpan(uri, 0, 0),
-                             MessageKind.COMPILER_CRASHED.message(),
-                             api.Diagnostic.CRASH);
+            reportDiagnostic(
+                new SourceSpan(uri, 0, 0),
+                MessageTemplate.TEMPLATES[MessageKind.COMPILER_CRASHED]
+                    .message(),
+                api.Diagnostic.CRASH);
           }
           pleaseReportCrash();
         }
       } catch (doubleFault) {
         // Ignoring exceptions in exception handling.
       }
       throw error;
     }).whenComplete(() {
       tracer.close();
       totalCompileTime.stop();
@@ skipping 117 matching lines @@
           return true;
         });
 
         if (!backend.supportsReflection) {
           reportError(NO_LOCATION_SPANNABLE,
                       MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND);
         } else {
           reportWarning(NO_LOCATION_SPANNABLE,
              MessageKind.IMPORT_EXPERIMENTAL_MIRRORS,
               {'importChain': importChains.join(
-                   MessageKind.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
+                   MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
         }
       }
 
       functionClass.ensureResolved(this);
       functionApplyMethod = functionClass.lookupLocalMember('apply');
 
       proxyConstant =
           constants.getConstantValue(
               resolver.constantCompiler.compileConstant(
                   coreLibrary.find('proxy')));
@@ skipping 215 matching lines @@
     enqueuer.resolution.logSummary(log);
 
     if (!showPackageWarnings && !suppressWarnings) {
       suppressedWarnings.forEach((Uri uri, SuppressionInfo info) {
         MessageKind kind = MessageKind.HIDDEN_WARNINGS_HINTS;
         if (info.warnings == 0) {
           kind = MessageKind.HIDDEN_HINTS;
         } else if (info.hints == 0) {
           kind = MessageKind.HIDDEN_WARNINGS;
         }
+        MessageTemplate template = MessageTemplate.TEMPLATES[kind];
         reportDiagnostic(null,
-            kind.message({'warnings': info.warnings,
-                          'hints': info.hints,
-                          'uri': uri},
-                         terseDiagnostics),
+            template.message(
+                {'warnings': info.warnings,
+                 'hints': info.hints,
+                 'uri': uri},
+                terseDiagnostics),
             api.Diagnostic.HINT);
       });
     }
 
     if (compilationFailed){
       if (!generateCodeWithCompileTimeErrors) return;
       if (!backend.enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
         return;
       }
     }
@@ skipping 257 matching lines @@
         }
         break;
       case api.Diagnostic.INFO:
         if (lastDiagnosticWasFiltered) {
           return;
         }
         break;
       }
     }
     lastDiagnosticWasFiltered = false;
+    MessageTemplate template = MessageTemplate.TEMPLATES[messageKind];
     reportDiagnostic(
-        node, messageKind.message(arguments, terseDiagnostics), kind);
+        node,
+        template.message(arguments, terseDiagnostics),
+        kind);
   }
 
   void reportDiagnostic(Spannable span,
                         Message message,
                         api.Diagnostic kind);
 
   void reportAssertionFailure(SpannableAssertionFailure ex) {
     String message = (ex.message != null) ? tryToString(ex.message)
                                           : tryToString(ex);
     reportDiagnosticInternal(
@@ skipping 587 matching lines @@
   InterfaceType streamType([DartType elementType]) {
     InterfaceType type = streamClass.computeType(compiler);
     if (elementType == null) {
       return streamClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);