Update dart2js diagnostics to prepare for filtering.

sdk/lib/_internal/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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 676 matching lines @@
            instruction: instruction, element: element);
   }
 
   void internalErrorOnElement(Element element, String message) {
     internalError(message, element: element);
   }
 
   void unhandledExceptionOnElement(Element element) {
     if (hasCrashed) return;
     hasCrashed = true;
-    reportDiagnostic(spanFromElement(element),
-                     MessageKind.COMPILER_CRASHED.error().toString(),
+    reportDiagnostic(element,
+                     MessageKind.COMPILER_CRASHED.error(),
                      api.Diagnostic.CRASH);
     pleaseReportCrash();
   }
 
   void pleaseReportCrash() {
     print(MessageKind.PLEASE_REPORT_THE_CRASH.message({'buildId': 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.
     Spannable spannable = null;
     if (node != null) {
       spannable = node;
     } else if (token != null) {
       spannable = token;
     } else if (instruction != null) {
       spannable = instruction;
     } else if (element != null) {
       spannable = element;
     } else {
       throw 'No error location for error: $reason';
     }
     reportError(spannable, MessageKind.GENERIC, {'text': reason});
     throw new CompilerCancelledException(reason);
   }
 
-  SourceSpan spanFromSpannable(Spannable node, [Uri uri]) {
+  SourceSpan spanFromSpannable(Spannable node) {
     if (node == null) return null;
     if (node == CURRENT_ELEMENT_SPANNABLE) {
       node = currentElement;
     }
     if (node is SourceSpan) {
       return node;
     } else if (node is Node) {
-      return spanFromNode(node, uri);
+      return spanFromNode(node);
     } else if (node is Token) {
-      return spanFromTokens(node, node, uri);
+      return spanFromTokens(node, node);
     } else if (node is HInstruction) {
       return spanFromHInstruction(node);
     } else if (node is Element) {
       return spanFromElement(node);
     } else if (node is MetadataAnnotation) {
       MetadataAnnotation annotation = node;
-      uri = annotation.annotatedElement.getCompilationUnit().script.uri;
+      Uri uri = annotation.annotatedElement.getCompilationUnit().script.uri;
       return spanFromTokens(annotation.beginToken, annotation.endToken, uri);
     } else {
       throw 'No error location.';
     }
   }
 
   void log(message) {
-    reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
+    reportDiagnostic(null,
+        MessageKind.GENERIC.error({'text': '$message'}),
+        api.Diagnostic.VERBOSE_INFO);
   }
 
   Future<bool> run(Uri uri) {
     totalCompileTime.start();
 
     return new Future.sync(() => runCompiler(uri)).catchError((error) {
       if (error is CompilerCancelledException) {
         log('Error: $error');
         return false;
       }
 
       try {
         if (!hasCrashed) {
           hasCrashed = true;
           reportDiagnostic(new SourceSpan(uri, 0, 0),
-                           MessageKind.COMPILER_CRASHED.error().toString(),
+                           MessageKind.COMPILER_CRASHED.error(),
                            api.Diagnostic.CRASH);
           pleaseReportCrash();
         }
       } catch (doubleFault) {
         // Ignoring exceptions in exception handling.
       }
       throw error;
     }).whenComplete(() {
       tracer.close();
       totalCompileTime.stop();
@@ skipping 445 matching lines @@
       }
       if (identical(e.getLibrary(), jsHelperLibrary)) {
         resolved.remove(e);
       }
       if (identical(e.getLibrary(), interceptorsLibrary)) {
         resolved.remove(e);
       }
     }
     log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
-      SourceSpan span = spanFromElement(e);
-      reportDiagnostic(span, 'Warning: $e resolved but not compiled.',
-                       api.Diagnostic.WARNING);
+      reportWarning(e,
+          MessageKind.GENERIC,
+          {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
   TreeElements analyzeElement(Element element) {
     assert(invariant(element,
            element.impliesType() ||
            element.isField() ||
            element.isFunction() ||
            element.isGenerativeConstructor() ||
            element.isGetter() ||
@@ skipping 67 matching lines @@
     withCurrentElement(element,
                        () => resolver.resolve(element));
   }
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
     return withCurrentElement(element,
         () => resolver.computeFunctionType(element, signature));
   }
 
-  reportWarning(Spannable node, var message) {
-    if (message is TypeWarning) {
-      // TODO(ahe): Don't supress these warning when the type checker
-      // is more complete.
-      if (message.message.kind == MessageKind.MISSING_RETURN) return;
-      if (message.message.kind == MessageKind.MAYBE_MISSING_RETURN) return;
-    }
-    SourceSpan span = spanFromSpannable(node);
-    reportDiagnostic(span, '$message', api.Diagnostic.WARNING);
-  }
-
   void reportError(Spannable node,
                    MessageKind errorCode,
                    [Map arguments = const {}]) {
-    reportMessage(spanFromSpannable(node),
-                  errorCode.error(arguments, terseDiagnostics),
-                  api.Diagnostic.ERROR);
+    reportDiagnostic(node,
+                     errorCode.error(arguments, terseDiagnostics),
+                     api.Diagnostic.ERROR);
   }
 
   void reportFatalError(Spannable node, MessageKind errorCode,
                         [Map arguments = const {}]) {
     reportError(node, errorCode, arguments);
     // TODO(ahe): Make this only abort the current method.
     throw new CompilerCancelledException(
         'Error: Cannot continue due to previous error.');
   }
 
-  // TODO(ahe): Rename to reportWarning when that method has been removed.
-  void reportWarningCode(Spannable node, MessageKind errorCode,
-                         [Map arguments = const {}]) {
-    reportMessage(spanFromSpannable(node),
+  void reportWarning(Spannable node, MessageKind errorCode,
+                     [Map arguments = const {}]) {
+    // TODO(ahe): Don't suppress these warning when the type checker
+    // is more complete.
+    if (errorCode == MessageKind.MISSING_RETURN) return;
+    if (errorCode == MessageKind.MAYBE_MISSING_RETURN) return;
+    reportDiagnostic(node,
                   errorCode.error(arguments, terseDiagnostics),
                   api.Diagnostic.WARNING);
   }
 
   void reportInfo(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
-    reportMessage(spanFromSpannable(node),
-                  errorCode.error(arguments, terseDiagnostics),
-                  api.Diagnostic.INFO);
+    reportDiagnostic(node,
+                     errorCode.error(arguments, terseDiagnostics),
+                     api.Diagnostic.INFO);
   }
 
   void reportHint(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
-    reportMessage(spanFromSpannable(node),
-                  errorCode.error(arguments, terseDiagnostics),
-                  api.Diagnostic.HINT);
+    reportDiagnostic(node,
+                     errorCode.error(arguments, terseDiagnostics),
+                     api.Diagnostic.HINT);
   }
 
   /// For debugging only, print a message with a source location.
   void reportHere(Spannable node, String debugMessage) {
     reportInfo(node, MessageKind.GENERIC, {'text': 'HERE: $debugMessage'});
   }
 
   void reportInternalError(Spannable node, String message) {
     reportError(
         node, MessageKind.GENERIC, {'text': 'Internal Error: $message'});
   }
 
-  void reportMessage(SourceSpan span, Diagnostic message, api.Diagnostic kind) {
-    // TODO(ahe): The names Diagnostic and api.Diagnostic are in
-    // conflict. Fix it.
-    reportDiagnostic(span, "$message", kind);
-  }
-
-  void reportDiagnostic(SourceSpan span, String message, api.Diagnostic kind);
+  // TODO(ahe): The names Diagnostic and api.Diagnostic are in conflict. Fix it.
+  void reportDiagnostic(Spannable span,
+                        Diagnostic message,
+                        api.Diagnostic kind);
 
   void reportAssertionFailure(SpannableAssertionFailure ex) {
     String message = (ex.message != null) ? tryToString(ex.message)
                                           : tryToString(ex);
     SourceSpan span = spanFromSpannable(ex.node);
     reportError(ex.node, MessageKind.GENERIC, {'text': message});
   }
 
   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 && currentElement != null) {
       uri = currentElement.getCompilationUnit().script.uri;
     }
     return SourceSpan.withCharacterOffsets(begin, end,
       (beginOffset, endOffset) => new SourceSpan(uri, beginOffset, endOffset));
   }
 
-  SourceSpan spanFromNode(Node node, [Uri uri]) {
-    return spanFromTokens(node.getBeginToken(), node.getEndToken(), uri);
+  SourceSpan spanFromNode(Node node) {
+    return spanFromTokens(node.getBeginToken(), node.getEndToken());
   }
 
   SourceSpan spanFromElement(Element element) {
     if (Elements.isErroneousElement(element)) {
       element = element.enclosingElement;
     }
     if (element.position() == null &&
         !element.isLibrary() &&
         !element.isCompilationUnit()) {
       // Sometimes, the backend fakes up elements that have no
@@ skipping 307 matching lines @@
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }