Clean up error handling.

dart/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 379 matching lines @@
    * [element].  Can be nested.
    */
   withCurrentElement(Element element, f()) {
     Element old = currentElement;
     _currentElement = element;
     try {
       return f();
     } on SpannableAssertionFailure catch (ex) {
       if (!hasCrashed) {
         SourceSpan span = spanFromSpannable(ex.node);
-        reportDiagnostic(span, ex.message, api.Diagnostic.ERROR);
+        reportError(ex.node, MessageKind.GENERIC, {'text': ex.message});
         pleaseReportCrash();
       }
       hasCrashed = true;
       rethrow;
     } on CompilerCancelledException catch (ex) {
       rethrow;
     } on StackOverflowError catch (ex) {
       // We cannot report anything useful in this case, because we
       // do not have enough stack space.
       rethrow;
@@ skipping 164 matching lines @@
                      {Node node, Token token, HInstruction instruction,
                       Element element}) {
     internalError("$methodName not implemented",
                   node: node, token: token,
                   instruction: instruction, element: element);
   }
 
   void internalError(String message,
                      {Node node, Token token, HInstruction instruction,
                       Element element}) {
-    cancel('Internal error: $message',
+    cancel('Internal Error: $message',
            node: node, token: token,
            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(),
                      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.
-    SourceSpan span = null;
+    Spannable spannable = null;
     if (node != null) {
-      span = spanFromNode(node);
+      spannable = node;
     } else if (token != null) {
-      span = spanFromTokens(token, token);
+      spannable = token;
     } else if (instruction != null) {
-      span = spanFromHInstruction(instruction);
+      spannable = instruction;
     } else if (element != null) {
-      span = spanFromElement(element);
+      spannable = element;
     } else {
       throw 'No error location for error: $reason';
     }
-    reportDiagnostic(span, reason, api.Diagnostic.ERROR);
+    reportError(spannable, MessageKind.GENERIC, {'text': reason});
     throw new CompilerCancelledException(reason);
   }
 
   SourceSpan spanFromSpannable(Spannable node, [Uri uri]) {
+    if (node == null) return null;
     if (node == CURRENT_ELEMENT_SPANNABLE) {
       node = currentElement;
     }
     if (node is Node) {
       return spanFromNode(node, uri);
     } else if (node is Token) {
       return spanFromTokens(node, node, uri);
     } else if (node is HInstruction) {
       return spanFromHInstruction(node);
     } else if (node is Element) {
       return spanFromElement(node);
     } else if (node is MetadataAnnotation) {
       MetadataAnnotation annotation = node;
       return spanFromTokens(annotation.beginToken, annotation.endToken);
     } else {
       throw 'No error location.';
     }
   }
 
-  void reportFatalError(String reason, Element element,
-                        {Node node, Token token, HInstruction instruction}) {
-    withCurrentElement(element, () {
-      cancel(reason, node: node, token: token, instruction: instruction,
-             element: element);
-    });
-  }
-
   void log(message) {
     reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
   bool run(Uri uri) {
     totalCompileTime.start();
     try {
       runCompiler(uri);
     } on CompilerCancelledException catch (exception) {
       log('Error: $exception');
@@ skipping 26 matching lines @@
    */
   void onLibraryScanned(LibraryElement library, Uri uri) {
     if (dynamicClass != null) {
       // When loading the built-in libraries, dynamicClass is null. We
       // take advantage of this as core imports js_helper and sees [dynamic]
       // this way.
       withCurrentElement(dynamicClass, () {
         library.addToScope(dynamicClass, this);
       });
     }
-    if (uri == new Uri(scheme: 'dart', path: 'dart:mirrors')) {
+    if (uri == new Uri(scheme: 'dart', path: 'mirrors')) {
       mirrorSystemClass =
           findRequiredElement(library, const SourceString('MirrorSystem'));
     } else if (uri == new Uri(scheme: 'dart', path: '_collection-dev')) {
       symbolImplementationClass =
           findRequiredElement(library, const SourceString('Symbol'));
     } else if (uri == new Uri(scheme: 'dart', path: 'async')) {
       deferredLibraryClass =
           findRequiredElement(library, const SourceString('DeferredLibrary'));
     }
     backend.onLibraryScanned(library, uri);
@@ skipping 156 matching lines @@
         log('compiling $uri ($buildId)');
       }
       mainApp = libraryLoader.loadLibrary(uri, null, uri);
     }
     Element main = null;
     if (mainApp != null) {
       main = mainApp.find(MAIN);
       if (main == null) {
         if (!analyzeOnly) {
           // Allow analyze only of libraries with no main.
-          reportFatalError('Could not find $MAIN', mainApp);
+          reportFatalError(
+              mainApp,
+              MessageKind.GENERIC,
+              {'text': 'Error: Could not find "${MAIN.slowToString()}".'});
         } else if (!analyzeAll) {
           reportFatalError(
-              "Could not find $MAIN. "
-              "No source will be analyzed. "
-              "Use '--analyze-all' to analyze all code in the library.",
-              mainApp);
+              mainApp,
+              MessageKind.GENERIC,
+              {'text': 'Error: Could not find "${MAIN.slowToString()}". '
+                  'No source will be analyzed. '
+                  'Use "--analyze-all" to analyze all code in the library.'});
         }
       } else {
         if (!main.isFunction()) {
-          reportFatalError('main is not a function', main);
+          reportFatalError(
+              main,
+              MessageKind.GENERIC,
+              {'text': 'Error: "${MAIN.slowToString()}" is not a function.'});
         }
         FunctionElement mainMethod = main;
         FunctionSignature parameters = mainMethod.computeSignature(this);
         parameters.forEachParameter((Element parameter) {
-          reportFatalError('main cannot have parameters', parameter);
+          reportError(
+              parameter,
+              MessageKind.GENERIC,
+              {'text':
+                  'Error: "${MAIN.slowToString()}" cannot have parameters.'});
         });
       }
 
       // In order to see if a library is deferred, we must compute the
       // compile-time constants that are metadata.  This means adding
       // something to the resolution queue.  So we cannot wait with
       // this until after the resolution queue is processed.
       // TODO(ahe): Clean this up, for example, by not enqueueing
       // classes only used for metadata.
       deferredLoadTask.findDeferredLibraries(mainApp);
@@ skipping 225 matching lines @@
     if (message is TypeWarning) {
       // TODO(ahe): Don't supress these warning when the type checker
       // is more complete.
       if (identical(message.message.kind, MessageKind.MISSING_RETURN)) return;
       if (identical(message.message.kind, MessageKind.MAYBE_MISSING_RETURN)) {
         return;
       }
     }
     SourceSpan span = spanFromNode(node);
 
-    reportDiagnostic(span, 'Warning: $message', api.Diagnostic.WARNING);
+    reportDiagnostic(span, '$message', api.Diagnostic.WARNING);
   }
 
-  // TODO(ahe): Remove this method.
-  reportError(Node node, var message) {
-    SourceSpan span = spanFromNode(node);
-    reportDiagnostic(span, 'Error: $message', api.Diagnostic.ERROR);
-    throw new CompilerCancelledException(message.toString());
-  }
-
-  // TODO(ahe): Rename to reportError when that method has been removed.
-  void reportErrorCode(Spannable node, MessageKind errorCode,
-                       [Map arguments = const {}]) {
+  void reportError(Spannable node,
+                   MessageKind errorCode,
+                   [Map arguments = const {}]) {
     reportMessage(spanFromSpannable(node),
                   errorCode.error(arguments),
                   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),
                   errorCode.error(arguments),
                   api.Diagnostic.WARNING);
   }
 
   void reportInfo(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
     reportMessage(spanFromSpannable(node),
                   errorCode.error(arguments),
                   api.Diagnostic.INFO);
   }
 
   void reportHint(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
     reportMessage(spanFromSpannable(node),
                   errorCode.error(arguments),
                   api.Diagnostic.HINT);
   }
 
   void reportInternalError(Spannable node, String message) {
-    reportMessage(spanFromSpannable(node),
-                  MessageKind.GENERIC.error({'text': message}),
-                  api.Diagnostic.ERROR);
+    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);
   }
 
   /// Returns true if a diagnostic was emitted.
   bool onDeprecatedFeature(Spannable span, String feature) {
@@ skipping 260 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');
   }
 }