Use failedAt in more places

pkg/compiler/lib/src/serialization/serialization_util.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.util;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
 import '../diagnostics/messages.dart';
@@ skipping 470 matching lines @@
 }
 
 /// Serialize a reference from [context] to an [element] which might be a member
 /// of an unnamed mixin application. If it is, [element] is by serialized
 /// indirectly by name in the [nameKey] of [encoder], otherwise [element] is
 /// serialized directly in [elementKey] in [encoder].
 void serializeElementReference(Element context, Key elementKey, Key nameKey,
     ObjectEncoder encoder, Element element) {
   if (element.isGenerativeConstructor &&
       element.enclosingClass.isUnnamedMixinApplication) {
-    assert(invariant(element, element.isConstructor,
-        message: "Unexpected reference of forwarding constructor "
+    assert(
+        element.isConstructor,
+        failedAt(
+            element,
+            "Unexpected reference of forwarding constructor "
             "${element} from $context."));
     encoder.setString(nameKey, element.name);
   } else {
     encoder.setElement(elementKey, element);
   }
 }
 
 /// Deserialize a reference from [context] to an [Element] which might be a
 /// member of an unnamed mixin application. If it is, the [Element] is by
 /// deserialized indirectly by name from [nameKey] in [decoder], otherwise
 /// the [Element] is deserialized directly from [elementKey] in [encoder].
 Element deserializeElementReference(
     Element context, Key elementKey, Key nameKey, ObjectDecoder decoder,
     {bool isOptional: false}) {
   Element element = decoder.getElement(elementKey, isOptional: true);
   if (element == null) {
     String elementName = decoder.getString(nameKey, isOptional: isOptional);
     if (elementName == null) {
       return null;
     }
     ClassElement cls;
     if (context is ClassElement) {
-      assert(invariant(NO_LOCATION_SPANNABLE, context.isNamedMixinApplication,
-          message: "Unexpected reference of forwarding constructor "
+      assert(
+          context.isNamedMixinApplication,
+          failedAt(
+              NO_LOCATION_SPANNABLE,
+              "Unexpected reference of forwarding constructor "
               "'${elementName}' from $context."));
       cls = context;
     } else {
-      assert(invariant(NO_LOCATION_SPANNABLE, context.isConstructor,
-          message: "Unexpected reference of forwarding constructor "
+      assert(
+          context.isConstructor,
+          failedAt(
+              NO_LOCATION_SPANNABLE,
+              "Unexpected reference of forwarding constructor "
               "'${elementName}' from $context."));
       cls = context.enclosingClass;
     }
     ClassElement superclass = cls.superclass;
     element = superclass.lookupConstructor(elementName);
-    assert(invariant(NO_LOCATION_SPANNABLE, element != null,
-        message: "Unresolved reference of forwarding constructor "
+    assert(
+        element != null,
+        failedAt(
+            NO_LOCATION_SPANNABLE,
+            "Unresolved reference of forwarding constructor "
             "'${elementName}' from $context."));
   }
   return element;
 }
 
 void serializeMessageArguments(
     ObjectEncoder encoder, Key key, Map<String, dynamic> messageArguments) {
   if (messageArguments.isNotEmpty) {
     MapEncoder mapEncoder = encoder.createMap(Key.ARGUMENTS);
     messageArguments.forEach((String key, var value) {
@@ skipping 44 matching lines @@
   ObjectDecoder sourceSpanDecoder =
       object.getObject(Key.SOURCE_SPAN, isOptional: true);
   if (sourceSpanDecoder != null) {
     sourceSpan = deserializeSourceSpan(sourceSpanDecoder);
   }
   MessageKind messageKind = object.getEnum(Key.KIND, MessageKind.values);
   Map<String, dynamic> messageArguments =
       deserializeMessageArguments(object, Key.ARGUMENTS);
   return new WrappedMessage(sourceSpan, messageKind, messageArguments);
 }