Throw an exception when invariant fails and report nice diagnostic.

dart/lib/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 124 matching lines @@
   Element assertMethod;
   Element identicalFunction;
   Element functionApplyMethod;
 
   Element get currentElement => _currentElement;
   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);
+      }
+      hasCrashed = true;
+      throw;
     } on CompilerCancelledException catch (ex) {
       throw;
     } on StackOverflowError catch (ex) {
       // We cannot report anything useful in this case, because we
       // do not have enough stack space.
       throw;
     } catch (ex) {
       try {
         unhandledExceptionOnElement(element);
       } catch (doubleFault) {
@@ skipping 117 matching lines @@
   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;
     if (node != null) {
       span = spanFromNode(node);
     } else if (token != null) {
       span = spanFromTokens(token, token);
     } else if (instruction != null) {
-      span = spanFromElement(currentElement);
+      span = spanFromHInstruction(instruction);
     } else if (element != null) {
       span = spanFromElement(element);
     } else {
       throw 'No error location for error: $reason';
     }
     reportDiagnostic(span, reason, api.Diagnostic.ERROR);
     throw new CompilerCancelledException(reason);
   }
 
+  SourceSpan spanFromSpannable(Spannable node) {
+    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) {
+      return spanFromElement(node);
+    } else {
+      throw 'No error location for error: $reason';
+    }
+  }
+
   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);
@@ skipping 450 matching lines @@
     if (element == null) {
       element = currentElement;
     }
     Token position = element.position();
     Uri uri = element.getCompilationUnit().script.uri;
     return (position == null)
         ? new SourceSpan(uri, 0, 0)
         : spanFromTokens(position, position, uri);
   }
 
+  SourceSpan spanFromHInstruction(HInstruction instruction) {
+    Element element = instruction.sourceElement;
+    if (element == null) element = currentElement;
+    var position = instruction.sourcePosition;
+    if (position == null) return spanFromElement(element);
+    Token token = position.token;
+    if (token == null) return spanFromElement(element);
+    Uri uri = element.getCompilationUnit().script.uri;
+    return spanFromTokens(token, token, uri);
+  }
+
   Script readScript(Uri uri, [Node node]) {
     unimplemented('Compiler.readScript');
   }
 
   String get legDirectory {
     unimplemented('Compiler.legDirectory');
   }
 
   // TODO(karlklose): split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
@@ skipping 85 matching lines @@
  *
  * [spannable] must be non-null and will be used to provide positional
  * information in the generated error message.
  */
 bool invariant(Spannable spannable, var condition, {String message: null}) {
   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
   if (condition is Function){
     condition = condition();
   }
-  if (!condition && message != null) {
-    print('assertion failed: $message');
+  if (spannable == null || !condition) {
+    throw new SpannableAssertionFailure(spannable, message);
   }
-  return spannable != null && condition;
+  return true;
 }