Remove cancel and make crash exit with code 253.

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 677 matching lines @@
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
 
   bool get analyzeAll => analyzeAllFlag || compileAll;
 
   bool get compileAll => false;
 
   bool get disableTypeInference => disableTypeInferenceFlag;
 
   int getNextFreeClassId() => nextFreeClassId++;
 
-  void unimplemented(String methodName,
-                     {Node node, Token token, HInstruction instruction,
-                      Element element}) {
-    internalError("$methodName not implemented",
-                  node: node, token: token,
-                  instruction: instruction, element: element);
+  void unimplemented(Spannable spannable, String methodName) {
+    internalError(spannable, "$methodName not implemented.");
   }
 
-  void internalError(String message,
-                     {Node node, Token token, HInstruction instruction,
-                      Element element}) {
-    cancel(message,
-           node: node, token: token,
-           instruction: instruction, element: element);
-  }
-
-  void internalErrorOnElement(Element element, String message) {
-    internalError(message, element: element);
+  void internalError(Spannable node, reason) {
+    assembledCode = null; // Compilation failed. Make sure that we
+                          // don't return a bogus result.
+    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);
     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';
-    }
-    reportInternalError(spannable, MessageKind.GENERIC, {'text': reason});
-    throw new CompilerCancelledException(reason);
-  }
-
   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;
     }
     if (node is SourceSpan) {
       return node;
     } else if (node is Node) {
       return spanFromNode(node);
     } else if (node is Token) {
       return spanFromTokens(node, node);
     } else if (node is HInstruction) {
       return spanFromHInstruction(node);
     } else if (node is Element) {
@@ skipping 96 matching lines @@
     } else if (foreignLibrary == null
                && (uri == new Uri(scheme: 'dart', path: '_foreign_helper'))) {
       foreignLibrary = library;
     }
     return backend.onLibraryLoaded(library, uri);
   }
 
   Element findRequiredElement(LibraryElement library, String name) {
     var element = library.find(name);
     if (element == null) {
-      internalErrorOnElement(
-          library,
-          'The library "${library.canonicalUri}" does not contain required '
-          'element: $name');
+      internalError(library,
+          "The library '${library.canonicalUri}' does not contain required "
+          "element: '$name'.");
       }
     return element;
   }
 
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
       mirrorSystemGetNameFunction =
         cls.lookupLocalMember('getName');
     } else if (symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
@@ skipping 29 matching lines @@
     intClass = lookupCoreClass('int');
     doubleClass = lookupCoreClass('double');
     stringClass = lookupCoreClass('String');
     functionClass = lookupCoreClass('Function');
     listClass = lookupCoreClass('List');
     typeClass = lookupCoreClass('Type');
     mapClass = lookupCoreClass('Map');
     nullClass = lookupCoreClass('Null');
     stackTraceClass = lookupCoreClass('StackTrace');
     if (!missingCoreClasses.isEmpty) {
-      internalErrorOnElement(coreLibrary,
+      internalError(coreLibrary,
           'dart:core library does not contain required classes: '
           '$missingCoreClasses');
     }
 
     // The Symbol class may not exist during unit testing.
     // TODO(ahe): It is possible that we have to require the presence
     // of Symbol as we change how we implement noSuchMethod.
     symbolClass = lookupCoreClass('Symbol');
 
     final List missingHelperClasses = [];
     ClassElement lookupHelperClass(String name) {
       ClassElement result = jsHelperLibrary.find(name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
       return result;
     }
     jsInvocationMirrorClass = lookupHelperClass('JSInvocationMirror');
     boundClosureClass = lookupHelperClass('BoundClosure');
     closureClass = lookupHelperClass('Closure');
     dynamicClass = lookupHelperClass('Dynamic_');
     if (!missingHelperClasses.isEmpty) {
-      internalErrorOnElement(jsHelperLibrary,
+      internalError(jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
 
     if (types == null) {
       types = new Types(this, dynamicClass);
     }
     backend.initializeHelperClasses();
 
     dynamicClass.ensureResolved(this);
@@ skipping 289 matching lines @@
 
   /**
    * Perform various checks of the queues. This includes checking that
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues() {
     for (Enqueuer world in [enqueuer.resolution, enqueuer.codegen]) {
       world.forEach((WorkItem work) {
-        internalErrorOnElement(work.element, "Work list is not empty.");
+        internalError(work.element, "Work list is not empty.");
       });
     }
     if (!REPORT_EXCESS_RESOLUTION) return;
     var resolved = new Set.from(enqueuer.resolution.resolvedElements.keys);
     for (Element e in enqueuer.codegen.generatedCode.keys) {
       resolved.remove(e);
     }
     for (Element e in new Set.from(resolved)) {
       if (e.isClass() ||
           e.isField() ||
@@ skipping 141 matching lines @@
   void reportHint(Spannable node, MessageKind messageKind,
                   [Map arguments = const {}]) {
     reportDiagnosticInternal(node, messageKind, arguments, 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, MessageKind messageKind,
-                           [Map arguments = const {}]) {
-    reportDiagnosticInternal(
-        node, messageKind, arguments, api.Diagnostic.CRASH);
-  }
-
   void reportDiagnosticInternal(Spannable node,
                                 MessageKind messageKind,
                                 Map arguments,
                                 api.Diagnostic kind) {
     if (!showPackageWarnings) {
       switch (kind) {
       case api.Diagnostic.WARNING:
       case api.Diagnostic.HINT:
         Element element = elementFromSpannable(node);
         if (!inUserCode(element)) {
@@ skipping 22 matching lines @@
   }
 
   void reportDiagnostic(Spannable span,
                         Message message,
                         api.Diagnostic kind);
 
   void reportAssertionFailure(SpannableAssertionFailure ex) {
     String message = (ex.message != null) ? tryToString(ex.message)
                                           : tryToString(ex);
     SourceSpan span = spanFromSpannable(ex.node);
-    reportInternalError(ex.node, MessageKind.GENERIC, {'text': message});
+    reportDiagnosticInternal(
+        ex.node, MessageKind.GENERIC, {'text': message}, api.Diagnostic.CRASH);
   }
 
   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) {
@@ skipping 51 matching lines @@
    * [importingLibrary] is used to grant access to internal libraries from
    * platform libraries and patch libraries.
    *
    * If the [resolvedUri] is not accessible from [importingLibrary], this method
    * is responsible for reporting errors.
    *
    * See [LibraryLoader] for terminology on URIs.
    */
   Uri translateResolvedUri(LibraryElement importingLibrary,
                            Uri resolvedUri, Node node) {
-    unimplemented('Compiler.translateResolvedUri');
+    unimplemented(importingLibrary, 'Compiler.translateResolvedUri');
     return null;
   }
 
   /**
    * Reads the script specified by the [readableUri].
    *
    * See [LibraryLoader] for terminology on URIs.
    */
-  Future<Script> readScript(Uri readableUri, [Element element, Node node]) {
-    unimplemented('Compiler.readScript');
+  Future<Script> readScript(Spannable node, Uri readableUri) {
+    unimplemented(node, 'Compiler.readScript');
     return null;
   }
 
-  String get legDirectory {
-    unimplemented('Compiler.legDirectory');
-    return null;
-  }
-
   // TODO(karlklose): split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
   Element findHelper(String name)
       => jsHelperLibrary.findLocal(name);
   Element findInterceptor(String name)
       => interceptorsLibrary.findLocal(name);
 
   Element lookupElementIn(ScopeContainerElement container, String name) {
     Element element = container.localLookup(name);
     if (element == null) {
@@ skipping 262 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }