Generate tear-off closures dynamically.

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 495 matching lines @@
       return f();
     } on SpannableAssertionFailure catch (ex, s) {
       if (!hasCrashed) {
         String message = (ex.message != null) ? tryToString(ex.message)
                                               : tryToString(ex);
         SourceSpan span = spanFromSpannable(ex.node);
         reportError(ex.node, MessageKind.GENERIC, {'text': message});
         pleaseReportCrash(s, 'The compiler crashed: $message.');
       }
       hasCrashed = true;
-      throw new CompilerCancelledException('The compiler crashed.');
+      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;
     } catch (ex, s) {
       if (hasCrashed) rethrow;
       String message = 'The compiler crashed: ${tryToString(ex)}.';
       try {
         unhandledExceptionOnElement(element, s, message);
       } catch (doubleFault) {
         // Ignoring exceptions in exception handling.
       }
-      throw new CompilerCancelledException(message);
+      rethrow;
     } finally {
       _currentElement = old;
     }
   }
 
   List<CompilerTask> tasks;
   ScannerTask scanner;
   DietParserTask dietParser;
   ParserTask parser;
   PatchParserTask patchParser;
@@ skipping 166 matching lines @@
     if (hasCrashed) return;
     hasCrashed = true;
     reportDiagnostic(spanFromElement(element),
                      MessageKind.COMPILER_CRASHED.error().toString(),
                      api.Diagnostic.CRASH);
     pleaseReportCrash(stackTrace, message);
   }
 
   void pleaseReportCrash(StackTrace stackTrace, String message) {
     print(MessageKind.PLEASE_REPORT_THE_CRASH.message({'buildId': buildId}));
-    if (message != null) {
-      print(message);
-    }
-    if (stackTrace != null) {
-      print(stackTrace);
-    }
   }
 
   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) {
@@ skipping 34 matching lines @@
   }
 
   void log(message) {
     reportDiagnostic(null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
   Future<bool> run(Uri uri) {
     totalCompileTime.start();
 
     return new Future.sync(() => runCompiler(uri)).catchError((error, trace) {
-      if (error is CompilerCancelledException) {
+      if (!hasCrashed && error is CompilerCancelledException) {
         log('Error: $error');
         return false;
       }
 
       try {
         if (!hasCrashed) {
           hasCrashed = true;
           reportDiagnostic(new SourceSpan(uri, 0, 0),
                            MessageKind.COMPILER_CRASHED.error().toString(),
                            api.Diagnostic.CRASH);
@@ skipping 867 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');
   }
 }