Use failedAt in more places

pkg/compiler/lib/src/parser/partial_elements.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.parser.partial_elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../elements/resolution_types.dart' show ResolutionDynamicType;
 import '../elements/elements.dart'
@@ skipping 67 matching lines @@
     _position = ElementX.findNameToken(
         beginToken,
         modifiers.isFactory || isGenerativeConstructor,
         name,
         enclosingElement.name);
   }
 
   bool get hasNode => cachedNode != null;
 
   FunctionExpression get node {
-    assert(invariant(this, cachedNode != null,
-        message: "Node has not been computed for $this."));
+    assert(cachedNode != null,
+        failedAt(this, "Node has not been computed for $this."));
     return cachedNode;
   }
 
   FunctionExpression parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     parseFunction(Parser p) {
       if (isClassMember && modifiers.isFactory) {
         p.parseFactoryMethod(beginToken);
       } else if (isClassMember) {
         p.parseMember(beginToken);
@@ skipping 234 matching lines @@
       return cachedNode;
     } else {
       assert(metadata is ErrorNode);
       return metadata;
     }
   }
 
   bool get hasNode => cachedNode != null;
 
   Node get node {
-    assert(invariant(this, hasNode));
+    assert(hasNode, failedAt(this));
     return cachedNode;
   }
 }
 
 class PartialClassElement extends ClassElementX with PartialElement {
   ClassNode cachedNode;
 
   PartialClassElement(
       String name, Token beginToken, Token endToken, Element enclosing, int id)
       : super(name, enclosing, id, STATE_NOT_STARTED) {
     this.beginToken = beginToken;
     this.endToken = endToken;
   }
 
   void set supertypeLoadState(int state) {
     assert(state == STATE_NOT_STARTED || state == supertypeLoadState + 1);
     assert(state <= STATE_DONE);
     super.supertypeLoadState = state;
   }
 
   void set resolutionState(int state) {
     assert(state == STATE_NOT_STARTED || state == resolutionState + 1);
     assert(state <= STATE_DONE);
     super.resolutionState = state;
   }
 
   bool get hasNode => cachedNode != null;
 
   ClassNode get node {
-    assert(invariant(this, cachedNode != null,
-        message: "Node has not been computed for $this."));
+    assert(cachedNode != null,
+        failedAt(this, "Node has not been computed for $this."));
     return cachedNode;
   }
 
   ClassNode parseNode(ParsingContext parsing) {
     if (cachedNode != null) return cachedNode;
     DiagnosticReporter reporter = parsing.reporter;
     reporter.withCurrentElement(this, () {
       parsing.measure(() {
         MemberListener listener = new MemberListener(
             parsing.getScannerOptionsFor(this), reporter, this);
         Parser parser = new ClassElementParser(listener);
         try {
           Token token = parser.parseTopLevelDeclaration(beginToken);
           assert(identical(token, endToken.next));
           cachedNode = listener.popNode();
-          assert(invariant(
-              reporter.spanFromToken(beginToken), listener.nodes.isEmpty,
-              message: "Non-empty listener stack: ${listener.nodes}"));
+          assert(
+              listener.nodes.isEmpty,
+              failedAt(reporter.spanFromToken(beginToken),
+                  "Non-empty listener stack: ${listener.nodes}"));
         } on ParserError {
           // TODO(ahe): Often, a ParserError is thrown while parsing the class
           // body. This means that the stack actually contains most of the
           // information synthesized below. Consider rewriting the parser so
           // endClassDeclaration is called before parsing the class body.
           Identifier name = new Identifier(findMyName(beginToken));
           NodeList typeParameters = null;
           Node supertype = null;
           NodeList interfaces = listener.makeNodeList(0, null, null, ",");
           Token extendsKeyword = null;
@@ skipping 50 matching lines @@
       } on ParserError catch (e) {
         partial.hasParseError = true;
         return new ErrorNode(element.position, e.message);
       }
       Node node = listener.popNode();
       assert(listener.nodes.isEmpty);
       return node;
     });
   });
 }