Use failedAt in more places

pkg/compiler/lib/src/serialization/resolved_ast_serialization.dart

 // Copyright (c) 2016, 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.serialization.resolved_ast;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
@@ skipping 103 matching lines @@
         kind = AstKind.ENUM_INDEX_FIELD;
       } else if (element.name == '_name') {
         kind = AstKind.ENUM_NAME_FIELD;
       } else if (element.name == 'values') {
         kind = AstKind.ENUM_VALUES_FIELD;
       } else if (element.name == 'toString') {
         kind = AstKind.ENUM_TO_STRING;
       } else if (element.isConstructor) {
         kind = AstKind.ENUM_CONSTRUCTOR;
       } else {
-        assert(invariant(element, element.isConst,
-            message: "Unexpected enum member: $element"));
+        assert(element.isConst,
+            failedAt(element, "Unexpected enum member: $element"));
         kind = AstKind.ENUM_CONSTANT;
       }
     } else {
       // [element] has a body that we'll need to re-parse. We store where to
       // start parsing from.
       objectEncoder.setInt(Key.OFFSET, root.getBeginToken().charOffset);
       if (element.isFactoryConstructor) {
         kind = AstKind.FACTORY;
       } else if (element.isField) {
         kind = AstKind.FIELD;
       } else {
         kind = AstKind.FUNCTION;
         FunctionExpression functionExpression = root.asFunctionExpression();
         if (functionExpression.getOrSet != null) {
           // Getters/setters need the get/set token to be parsed.
           objectEncoder.setInt(
               Key.GET_OR_SET, functionExpression.getOrSet.charOffset);
         }
       }
     }
     objectEncoder.setEnum(Key.SUB_KIND, kind);
     root.accept(indexComputer);
     objectEncoder.setBool(Key.CONTAINS_TRY, elements.containsTryStatement);
     if (resolvedAst.body != null) {
       int index = nodeIndices[resolvedAst.body];
-      assert(invariant(element, index != null,
-          message: "No index for body of $element: "
+      assert(
+          index != null,
+          failedAt(
+              element,
+              "No index for body of $element: "
               "${resolvedAst.body} ($nodeIndices)."));
       objectEncoder.setInt(Key.BODY, index);
     }
     root.accept(this);
     if (jumpTargetMap.isNotEmpty) {
       ListEncoder list = objectEncoder.createList(Key.JUMP_TARGETS);
       for (JumpTarget jumpTarget in jumpTargetMap.keys) {
         serializeJumpTarget(jumpTarget, list.createObject());
       }
     }
@@ skipping 51 matching lines @@
   /// Computes the [ListEncoder] for serializing data for nodes.
   ListEncoder get nodeDataEncoder {
     if (_nodeDataEncoder == null) {
       _nodeDataEncoder = objectEncoder.createList(Key.DATA);
     }
     return _nodeDataEncoder;
   }
 
   /// Computes the [ObjectEncoder] for serializing data for [node].
   ObjectEncoder getNodeDataEncoder(Node node) {
-    assert(invariant(element, node != null, message: "Node must be non-null."));
+    assert(node != null, failedAt(element, "Node must be non-null."));
     int id = nodeIndices[node];
-    assert(invariant(element, id != null, message: "Node without id: $node"));
+    assert(id != null, failedAt(element, "Node without id: $node"));
     return nodeData.putIfAbsent(id, () {
       ObjectEncoder objectEncoder = nodeDataEncoder.createObject();
       objectEncoder.setInt(Key.ID, id);
       return objectEncoder;
     });
   }
 
   @override
   visitNode(Node node) {
     Element nodeElement = elements[node];
@@ skipping 308 matching lines @@
     Node root = computeNode(kind);
     TreeElementMapping elements = new TreeElementMapping(element);
     AstIndexComputer indexComputer = new AstIndexComputer();
     List<Node> nodeList = indexComputer.nodeList;
     root.accept(indexComputer);
     elements.containsTryStatement = objectDecoder.getBool(Key.CONTAINS_TRY);
 
     Node body;
     int bodyNodeIndex = objectDecoder.getInt(Key.BODY, isOptional: true);
     if (bodyNodeIndex != null) {
-      assert(invariant(element, bodyNodeIndex < nodeList.length,
-          message: "Body node index ${bodyNodeIndex} out of range. "
+      assert(
+          bodyNodeIndex < nodeList.length,
+          failedAt(
+              element,
+              "Body node index ${bodyNodeIndex} out of range. "
               "Node count: ${nodeList.length}"));
       body = nodeList[bodyNodeIndex];
     }
 
     List<JumpTarget> jumpTargets = <JumpTarget>[];
     Map<JumpTarget, List<int>> jumpTargetLabels = <JumpTarget, List<int>>{};
     List<LabelDefinition> labelDefinitions = <LabelDefinition>[];
 
     ListDecoder jumpTargetsDecoder =
         objectDecoder.getList(Key.JUMP_TARGETS, isOptional: true);
@@ skipping 132 matching lines @@
         }
       }
     }
     element.resolvedAst =
         new ParsedResolvedAst(element, root, body, elements, uri);
   }
 }
 
 const Key PARAMETER_NODE = const Key('parameter.node');
 const Key PARAMETER_INITIALIZER = const Key('parameter.initializer');