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 579 matching lines @@
   /// members with these names.
   Map<Name, Setlet<Member>> computeSuperMembers(
       String name, Setlet<Name> names) {
     computeSuperClassMembers(name, names);
     return computeSuperInterfaceMembers(name, names);
   }
 
   Map<Name, Setlet<Member>> computeSuperInterfaceMembers(
       String name, Setlet<Name> names) {
     ResolutionInterfaceType supertype = cls.supertype;
-    assert(invariant(cls, supertype != null,
-        message: "Interface members computed for $cls."));
+    assert(supertype != null,
+        failedAt(cls, "Interface members computed for $cls."));
     ClassElement superclass = supertype.element;
 
     Map<Name, Setlet<Member>> inheritedInterfaceMembers =
         new Map<Name, Setlet<Member>>();
 
     void inheritInterfaceMember(
         ResolutionInterfaceType supertype, MemberSignature member) {
       if (shouldSkipMember(member)) return;
       Setlet<Member> members = inheritedInterfaceMembers.putIfAbsent(
           member.name, () => new Setlet<Member>());
@@ skipping 102 matching lines @@
           DiagnosticMessage warning = reporter.createMessage(
               cls,
               MessageKind.INHERIT_GETTER_AND_METHOD,
               {'class': thisType, 'name': name.text});
           List<DiagnosticMessage> infos = <DiagnosticMessage>[];
           for (Member inherited in inheritedMembers) {
             MessageKind kind;
             if (inherited.isMethod) {
               kind = MessageKind.INHERITED_METHOD;
             } else {
-              assert(invariant(cls, inherited.isGetter,
-                  message: 'Conflicting member is neither a method nor a '
-                      'getter.'));
+              assert(
+                  inherited.isGetter,
+                  failedAt(cls,
+                      'Conflicting member is neither a method nor a getter.'));
               if (inherited.isDeclaredByField) {
                 kind = MessageKind.INHERITED_IMPLICIT_GETTER;
               } else {
                 kind = MessageKind.INHERITED_EXPLICIT_GETTER;
               }
             }
             infos.add(reporter.createMessage(inherited.element, kind,
                 {'class': inherited.declarer, 'name': name.text}));
           }
           reporter.reportWarning(warning, infos);
@@ skipping 171 matching lines @@
   }
 
   void computeAllClassMembers(Resolution resolution) {
     // TODO(johnniwinther): Should we assert that the class has been resolved
     // instead?
     ensureResolved(resolution);
     if (areAllMembersComputed()) return;
     MembersCreator creator = _prepareCreator(resolution);
     creator.computeAllMembers();
     computedMemberNames = null;
-    assert(invariant(this, areAllMembersComputed()));
+    assert(areAllMembersComputed(), failedAt(this));
   }
 
   bool areAllMembersComputed() {
     return computedMemberNames == null && classMembers != null;
   }
 
   bool isMemberComputed(String name) {
     if (computedMemberNames == null) {
       return classMembers != null;
     } else {
       return name == Identifiers.call || computedMemberNames.contains(name);
     }
   }
 
   Member lookupClassMember(Name name) {
-    assert(invariant(this, isMemberComputed(name.text),
-        message: "Member ${name} has not been computed for $this."));
+    assert(isMemberComputed(name.text),
+        failedAt(this, "Member ${name} has not been computed for $this."));
     return classMembers[name];
   }
 
   void forEachClassMember(f(Member member)) {
-    assert(invariant(this, areAllMembersComputed(),
-        message: "Members have not been fully computed for $this."));
+    assert(areAllMembersComputed(),
+        failedAt(this, "Members have not been fully computed for $this."));
     classMembers.forEach((_, member) => f(member));
   }
 
   MemberSignature lookupInterfaceMember(Name name) {
-    assert(invariant(this, isMemberComputed(name.text),
-        message: "Member ${name.text} has not been computed for $this."));
+    assert(isMemberComputed(name.text),
+        failedAt(this, "Member ${name.text} has not been computed for $this."));
     if (interfaceMembersAreClassMembers) {
       Member member = classMembers[name];
       if (member != null && member.isStatic) return null;
       return member;
     }
     return interfaceMembers[name];
   }
 
   void forEachInterfaceMember(f(MemberSignature member)) {
-    assert(invariant(this, areAllMembersComputed(),
-        message: "Members have not been fully computed for $this."));
+    assert(areAllMembersComputed(),
+        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));
     }
   }
 }