Use failedAt in more places

pkg/compiler/lib/src/resolution/constructors.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.constructors;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart'
     show
@@ skipping 550 matching lines @@
           reporter.reportWarningMessage(
               diagnosticNode, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
           registry.registerFeature(Feature.ABSTRACT_CLASS_INSTANTIATION);
           return new ConstructorResult(
               ConstructorResultKind.ABSTRACT, prefix, constructor, type);
         } else {
           return new ConstructorResult(
               ConstructorResultKind.GENERATIVE, prefix, constructor, type);
         }
       } else {
-        assert(invariant(diagnosticNode, constructor.isFactoryConstructor,
-            message: "Unexpected constructor $constructor."));
+        assert(constructor.isFactoryConstructor,
+            failedAt(diagnosticNode, "Unexpected constructor $constructor."));
         return new ConstructorResult(
             ConstructorResultKind.FACTORY, prefix, constructor, type);
       }
     }
   }
 
   ConstructorResult visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     ConstructorResult result = visit(selector);
-    assert(invariant(selector, result != null,
-        message: 'No result returned for $selector.'));
+    assert(result != null,
+        failedAt(selector, 'No result returned for $selector.'));
     return finishConstructorReference(result, node.send.selector, node);
   }
 
   /// Finishes resolution of a constructor reference and records the
   /// type of the constructed instance on [expression].
   ConstructorResult finishConstructorReference(
       ConstructorResult result, Node diagnosticNode, Node expression) {
-    assert(invariant(diagnosticNode, result != null,
-        message: 'No result returned for $diagnosticNode.'));
+    assert(result != null,
+        failedAt(diagnosticNode, 'No result returned for $diagnosticNode.'));
 
     if (result.kind != null) {
       resolver.registry.setType(expression, result.type);
       return result;
     }
 
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (result.type != null) {
       // The unnamed constructor may not exist, so [e] may become unresolved.
@@ skipping 32 matching lines @@
       Element element = lookupInScope(reporter, send, resolver.scope, name);
       if (element != null && element.isPrefix) {
         prefix = element;
       }
     }
     return constructorResultForType(node, type, prefix: prefix);
   }
 
   ConstructorResult visitSend(Send node) {
     ConstructorResult receiver = visit(node.receiver);
-    assert(invariant(node.receiver, receiver != null,
-        message: 'No result returned for $node.receiver.'));
+    assert(receiver != null,
+        failedAt(node.receiver, 'No result returned for $node.receiver.'));
     if (receiver.kind != null) {
-      assert(invariant(node, receiver.element.isMalformed,
-          message: "Unexpected prefix result: $receiver."));
+      assert(receiver.element.isMalformed,
+          failedAt(node, "Unexpected prefix result: $receiver."));
       // We have already found an error.
       return receiver;
     }
 
     Identifier name = node.selector.asIdentifier();
     if (name == null) {
       reporter.internalError(node.selector, 'unexpected node');
     }
 
     if (receiver.type != null) {
@@ skipping 226 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }