Update dart2js to use diagnostic kinds.

dart/lib/compiler/implementation/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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 214 matching lines @@
   void unimplemented(String methodName,
                      [Node node, Token token, HInstruction instruction,
                       Element element]) {
     internalError("$methodName not implemented",
                   node, token, instruction, element);
   }
 
   void internalError(String message,
                      [Node node, Token token, HInstruction instruction,
                       Element element]) {
-    cancel("${red('internal error:')} $message",
-           node, token, instruction, element);
+    cancel('Internal error: $message', node, token, instruction, element);
   }
 
   void internalErrorOnElement(Element element, String message) {
     internalError(message, element: element);
   }
 
   void unhandledExceptionOnElement(Element element) {
     reportDiagnostic(spanFromElement(element),
                      MessageKind.COMPILER_CRASHED.error().toString(),
-                     false);
+                     api.Diagnostic.CRASH);
     // TODO(ahe): Obtain the build ID.
     var buildId = 'build number could not be determined';
     print(MessageKind.PLEASE_REPORT_THE_CRASH.message([buildId]));
   }
 
   void cancel([String reason, Node node, Token token,
                HInstruction instruction, Element element]) {
     assembledCode = null; // Compilation failed. Make sure that we
                           // don't return a bogus result.
     SourceSpan span = const SourceSpan(null, null, null);
     if (node !== null) {
       span = spanFromNode(node);
     } else if (token !== null) {
       span = spanFromTokens(token, token);
     } else if (instruction !== null) {
       span = spanFromElement(currentElement);
     } else if (element !== null) {
       span = spanFromElement(element);
     } else {
       throw 'No error location for error: $reason';
     }
-    reportDiagnostic(span, red(reason), true);
+    reportDiagnostic(span, reason, api.Diagnostic.ERROR);
     throw new CompilerCancelledException(reason);
   }
 
   void reportFatalError(String reason, Element element,
                         [Node node, Token token, HInstruction instruction]) {
     withCurrentElement(element, () {
       cancel(reason, node, token, instruction, element);
     });
   }
 
   void log(message) {
-    reportDiagnostic(null, message, false);
+    reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
   bool run(Uri uri) {
     try {
       runCompiler(uri);
     } catch (CompilerCancelledException exception) {
       log(exception.toString());
       log('compilation failed');
       return false;
     }
@@ skipping 221 matching lines @@
         resolved.remove(e);
       }
       if (e.getLibrary() === interceptorsLibrary) {
         resolved.remove(e);
       }
     }
     log('Excess resolution work: ${resolved.length}.');
     if (!REPORT_EXCESS_RESOLUTION) return;
     for (Element e in resolved) {
       SourceSpan span = spanFromElement(e);
-      reportDiagnostic(span, 'Warning: $e resolved but not compiled.', false);
+      reportDiagnostic(span, 'Warning: $e resolved but not compiled.',
+                       api.Diagnostic.WARNING);
     }
   }
 
   TreeElements analyzeElement(Element element) {
     TreeElements elements = enqueuer.resolution.getCachedElements(element);
     if (elements !== null) return elements;
     final int allowed = ElementCategory.VARIABLE | ElementCategory.FUNCTION
                         | ElementCategory.FACTORY;
     ElementKind kind = element.kind;
     if (!element.isAccessor() &&
@@ skipping 95 matching lines @@
       // TODO(ahe): Don't supress these warning when the type checker
       // is more complete.
       if (message.message.kind === MessageKind.NOT_ASSIGNABLE) return;
       if (message.message.kind === MessageKind.MISSING_RETURN) return;
       if (message.message.kind === MessageKind.MAYBE_MISSING_RETURN) return;
       if (message.message.kind === MessageKind.ADDITIONAL_ARGUMENT) return;
       if (message.message.kind === MessageKind.METHOD_NOT_FOUND) return;
     }
     SourceSpan span = spanFromNode(node);
 
-    reportDiagnostic(span, "${magenta('warning:')} $message", false);
+    reportDiagnostic(span, 'Warning: $message', api.Diagnostic.WARNING );
   }
 
   reportError(Node node, var message) {
     SourceSpan span = spanFromNode(node);
-    reportDiagnostic(span, "${red('error:')} $message", true);
+    reportDiagnostic(span, 'Error: $message', api.Diagnostic.ERROR);
     throw new CompilerCancelledException(message.toString());
   }
 
-  abstract void reportDiagnostic(SourceSpan span, String message, bool fatal);
+  abstract void reportDiagnostic(SourceSpan span, String message,
+                                 api.Diagnostic kind);
 
   SourceSpan spanFromTokens(Token begin, Token end, [Uri uri]) {
     if (begin === null || end === null) {
       // TODO(ahe): We can almost always do better. Often it is only
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
     if (uri === null) {
       uri = currentElement.getCompilationUnit().script.uri;
@@ skipping 105 matching lines @@
     // invariant that endOffset > beginOffset, but for EOF the
     // charoffset of the next token may be [beginOffset]. This can
     // also happen for synthetized tokens that are produced during
     // error handling.
     final endOffset =
       Math.max((end.next !== null) ? end.next.charOffset : 0, beginOffset + 1);
     assert(endOffset > beginOffset);
     return f(beginOffset, endOffset);
   }
 }