Use failedAt in more places

pkg/compiler/lib/src/resolution/class_members.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.
 
 library dart2js.resolution.compute_members;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Names;
 import '../common/resolution.dart' show Resolution;
 import '../elements/resolution_types.dart';
@@ skipping 16 matching lines @@
   final Resolution resolution;
 
   final Iterable<String> computedMemberNames;
   final Map<Name, Member> classMembers;
 
   Map<dynamic /* Member | Element */, Set<MessageKind>> reportedMessages =
       new Map<dynamic, Set<MessageKind>>();
 
   MembersCreator(
       this.resolution, this.cls, this.computedMemberNames, this.classMembers) {
-    assert(invariant(cls, cls.isDeclaration,
-        message: "Members may only be computed on declarations."));
+    assert(cls.isDeclaration,
+        failedAt(cls, "Members may only be computed on declarations."));
   }
 
   DiagnosticReporter get reporter => resolution.reporter;
 
   void reportMessage(var marker, MessageKind kind, report()) {
     Set<MessageKind> messages =
         reportedMessages.putIfAbsent(marker, () => new Set<MessageKind>());
     if (messages.add(kind)) {
       report();
     }
@@ skipping 157 matching lines @@
           ResolutionFunctionType functionType = element.computeType(resolution);
           ResolutionDartType type;
           if (!functionType.parameterTypes.isEmpty) {
             type = functionType.parameterTypes.first;
           } else {
             type = const ResolutionDynamicType();
           }
           name = name.setter;
           addDeclaredMember(name, type, functionType);
         } else {
-          assert(invariant(element, element.isFunction));
+          assert(element.isFunction, failedAt(element));
           ResolutionFunctionType type = element.computeType(resolution);
           addDeclaredMember(name, type, type);
         }
       }
 
       cls.forEachLocalMember(createMember);
       if (cls.isPatched) {
         cls.implementation.forEachLocalMember((Element element) {
           if (element.isDeclaration) {
             createMember(element);
@@ skipping 132 matching lines @@
           superclass = superclass.superclass;
         }
       }
     } else {
       assert(declared.name == superMember.name);
 
       if (declared.isStatic) {
         for (Member inherited in superMember.declarations) {
           if (cls == inherited.declarer.element) {
             // An error should already have been reported.
-            assert(invariant(
-                declared.element, resolution.reporter.hasReportedError));
+            assert(resolution.reporter.hasReportedError,
+                failedAt(declared.element));
             continue;
           }
 
           reportMessage(inherited.element, MessageKind.NO_STATIC_OVERRIDE, () {
             reportErrorWithContext(
                 declared.element,
                 MessageKind.NO_STATIC_OVERRIDE,
                 inherited.element,
                 MessageKind.NO_STATIC_OVERRIDE_CONT);
           });
         }
       }
 
       ResolutionDartType declaredType = declared.functionType;
       for (Member inherited in superMember.declarations) {
         if (inherited.element == declared.element) {
           // TODO(ahe): For some reason, "call" elements are repeated in
           // superMember.declarations. Investigate why.
         } else if (cls == inherited.declarer.element) {
           // An error should already have been reported.
           assert(
-              invariant(declared.element, resolution.reporter.hasReportedError,
-                  message: "Member $inherited inherited from its "
-                      "declaring class: ${cls}."));
+              resolution.reporter.hasReportedError,
+              failedAt(
+                  declared.element,
+                  "Member $inherited inherited from its "
+                  "declaring class: ${cls}."));
           continue;
         }
 
         void reportError(MessageKind errorKind, MessageKind infoKind) {
           reportMessage(inherited.element, MessageKind.INVALID_OVERRIDE_METHOD,
               () {
             reporter.reportError(
                 reporter.createMessage(declared.element, errorKind, {
                   'name': declared.name.text,
                   'class': cls.thisType,
@@ skipping 554 matching lines @@
         failedAt(this, "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }