Use failedAt in more places

pkg/compiler/lib/src/serialization/system.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_system;
 
 import 'dart:async';
 
 import '../common.dart';
 import '../common/resolution.dart';
@@ skipping 70 matching lines @@
   bool hasResolutionImpact(Element element) => true;
 
   @override
   ResolutionImpact getResolutionImpact(Element element) {
     return const ResolutionImpact();
   }
 
   @override
   WorldImpact computeWorldImpact(Element element) {
     ResolutionImpact resolutionImpact = getResolutionImpact(element);
-    assert(invariant(element, resolutionImpact != null,
-        message: 'No impact found for $element (${element.library})'));
+    assert(resolutionImpact != null,
+        failedAt(element, 'No impact found for $element (${element.library})'));
     if (element is ExecutableElement) {
       getResolvedAst(element);
     }
     if (element.isField && !element.isConst) {
       FieldElement field = element;
       if (field.isTopLevel || field.isStatic) {
         if (field.constant == null) {
           // TODO(johnniwinther): Find a cleaner way to do this. Maybe
           // `Feature.LAZY_FIELD` of the resolution impact should be used
           // instead.
@@ skipping 50 matching lines @@
   }
 
   @override
   ResolutionImpact getResolutionImpact(Element element) {
     if (element.isConstructor &&
         element.enclosingClass.isUnnamedMixinApplication) {
       ConstructorElement constructor = element;
       ClassElement superclass = constructor.enclosingClass.superclass;
       ConstructorElement superclassConstructor =
           superclass.lookupConstructor(constructor.name);
-      assert(invariant(element, superclassConstructor != null,
-          message: "Superclass constructor '${constructor.name}' called from "
+      assert(
+          superclassConstructor != null,
+          failedAt(
+              element,
+              "Superclass constructor '${constructor.name}' called from "
               "${element} not found in ${superclass}."));
       // TODO(johnniwinther): Compute callStructure. Currently not used.
       CallStructure callStructure;
       return _resolutionImpactDeserializer.registerResolutionImpact(constructor,
           () {
         List<TypeUse> typeUses = <TypeUse>[];
         void addCheckedModeCheck(ResolutionDartType type) {
           if (!type.isDynamic) {
             typeUses.add(new TypeUse.checkedModeCheck(type));
           }
@@ skipping 76 matching lines @@
 const String RESOLVED_AST_TAG = 'resolvedAst';
 
 class ResolvedAstSerializerPlugin extends SerializerPlugin {
   final Resolution resolution;
   final SerializerPlugin nativeDataSerializer;
 
   ResolvedAstSerializerPlugin(this.resolution, this.nativeDataSerializer);
 
   @override
   void onElement(Element element, ObjectEncoder createEncoder(String tag)) {
-    assert(invariant(element, element.isDeclaration,
-        message: "Element $element must be the declaration"));
+    assert(element.isDeclaration,
+        failedAt(element, "Element $element must be the declaration"));
     if (element.isError) return;
     if (element is MemberElement) {
-      assert(invariant(element, resolution.hasResolvedAst(element),
-          message: "Element $element must have a resolved ast"));
+      assert(resolution.hasResolvedAst(element),
+          failedAt(element, "Element $element must have a resolved ast"));
       ResolvedAst resolvedAst = resolution.getResolvedAst(element);
       ObjectEncoder objectEncoder = createEncoder(RESOLVED_AST_TAG);
       new ResolvedAstSerializer(
               objectEncoder, resolvedAst, nativeDataSerializer)
           .serialize();
     }
   }
 }
 
 class ResolvedAstDeserializerPlugin extends DeserializerPlugin {
@@ skipping 15 matching lines @@
   ResolvedAst getResolvedAst(ExecutableElement element) {
     if (element.hasResolvedAst) {
       return element.resolvedAst;
     }
 
     ObjectDecoder decoder = _decoderMap[element.memberContext];
     if (decoder != null) {
       ResolvedAstDeserializer.deserialize(element.memberContext, decoder,
           parsingContext, findToken, nativeDataDeserializer);
       _decoderMap.remove(element);
-      assert(invariant(element, element.hasResolvedAst,
-          message: "ResolvedAst not computed for $element."));
+      assert(element.hasResolvedAst,
+          failedAt(element, "ResolvedAst not computed for $element."));
       return element.resolvedAst;
     }
     return null;
   }
 
   Token findToken(Uri uri, int offset) {
     Token beginToken = beginTokenMap.putIfAbsent(uri, () {
       Script script = scripts[uri];
       if (script == null) {
         parsingContext.reporter.internalError(NO_LOCATION_SPANNABLE,
             'No source file found for $uri in:\n ${scripts.keys.join('\n ')}');
       }
       if (script.isSynthesized) return null;
       return parsingContext.scanner.scanFile(script.file);
     });
     if (beginToken == null) return null;
     return ResolvedAstDeserializer.findTokenInStream(beginToken, offset);
   }
 
   @override
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {
     ObjectDecoder decoder = getDecoder(RESOLVED_AST_TAG);
     if (decoder != null) {
       _decoderMap[element] = decoder;
     }
   }
 }