anchor.diff:      internalError(message, element: element);
     }
   
  -  void unhandledExceptionOnElement(Element element) {
  +  void unhandledExceptionOnElement(Element element, StackTrace stackTrace) {
       if (hasCrashed) return;
       hasCrashed = true;
       reportDiagnostic(spanFromElement(element),
                        MessageKind.COMPILER_CRASHED.error().toString(),
                        api.Diagnostic.CRASH);
  -    pleaseReportCrash();
  -  }
  -
  -  void pleaseReportCrash() {
  +    pleaseReportCrash(stackTrace);
  +  }
  +
  +  void pleaseReportCrash(StackTrace stackTrace) {
       print(MessageKind.PLEASE_REPORT_THE_CRASH.message({'buildId': buildId}));
  +    if (stackTrace != null) {
  +      print(stackTrace);
  +    }
     }
   
     void cancel(String reason, {Node node, Token token,
  
positive.code:     _currentElement = element;
      try {
        return f();
      } on SpannableAssertionFailure catch (ex) {
        if (!hasCrashed) {
          SourceSpan span = spanFromSpannable(ex.node);
          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;
      } catch (ex) {
        try {
          unhandledExceptionOnElement(element);
        } catch (doubleFault) {
          // Ignoring exceptions in exception handling.
        }
        rethrow;
      } finally {
        _currentElement = old;
      }
  
negative.code:           reportDiagnostic(new SourceSpan(uri, 0, 0),
                             MessageKind.COMPILER_CRASHED.error().toString(),
                             api.Diagnostic.CRASH);
            pleaseReportCrash(getAttachedStackTrace(error));
          }
        } catch (doubleFault) {
          // Ignoring exceptions in exception handling.
  