Use failedAt in more places

pkg/compiler/lib/src/resolution/class_hierarchy.dart

 // Copyright (c) 2015, 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.class_hierarchy;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../common_elements.dart' show CommonElements;
 import '../elements/resolution_types.dart';
@@ skipping 161 matching lines @@
         } else {
           superElement.ensureResolved(resolution);
         }
         element.supertype = superElement.computeType(resolution);
       }
     }
 
     if (element.interfaces == null) {
       element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     } else {
-      assert(invariant(element, element.hasIncompleteHierarchy));
+      assert(element.hasIncompleteHierarchy, failedAt(element));
     }
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember = element.superclass.localLookup('');
       if (superMember == null) {
         MessageKind kind = MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR;
         Map arguments = {'className': element.superclass.name};
         // TODO(ahe): Why is this a compile-time error? Or if it is an error,
         // why do we bother to registerThrowNoSuchMethod below?
@@ skipping 159 matching lines @@
     constructor.computeType(resolution);
     return constructor;
   }
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
       ResolutionDartType supertype, ResolutionDartType mixinType) {
     Node node = mixinApplication.parseNode(resolution.parsingContext);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
-      assert(invariant(node, reporter.hasReportedError));
+      assert(reporter.hasReportedError, failedAt(node));
       supertype = mixinApplication.supertype;
-      assert(invariant(node, supertype.isObject));
+      assert(supertype.isObject, failedAt(node));
     } else {
       mixinApplication.supertype = supertype;
     }
 
     // Named mixin application may have an 'implements' clause.
     NamedMixinApplication namedMixinApplication =
         node.asNamedMixinApplication();
     Link<ResolutionDartType> interfaces = (namedMixinApplication != null)
         ? resolveInterfaces(
             namedMixinApplication.interfaces, namedMixinApplication.superclass)
         : const Link<ResolutionDartType>();
 
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in so always prepend
     // that to the interface list.
     if (mixinApplication.interfaces == null) {
       if (mixinType.isInterfaceType) {
         // Avoid malformed types in the interfaces.
         interfaces = interfaces.prepend(mixinType);
       }
       mixinApplication.interfaces = interfaces;
     } else {
       assert(
-          invariant(mixinApplication, mixinApplication.hasIncompleteHierarchy));
+          mixinApplication.hasIncompleteHierarchy, failedAt(mixinApplication));
     }
 
     ClassElement superclass = supertype.element;
     if (mixinType.kind != ResolutionTypeKind.INTERFACE) {
       mixinApplication.hasIncompleteHierarchy = true;
       mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
       return;
     }
 
     assert(mixinApplication.mixinType == null);
@@ skipping 247 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       reporter.reportErrorMessage(node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }