Use failedAt in more places

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

 // Copyright (c) 2017, 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_strategy;
 
 import 'package:front_end/src/fasta/scanner.dart' show Token;
 
 import '../common.dart';
 import '../common_elements.dart';
@@ skipping 216 matching lines @@
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
     if (uri == null && currentElement != null) {
       if (currentElement is! Element) {
         throw 'Can only find tokens from an Element.';
       }
       Element element = currentElement;
       uri = element.compilationUnit.script.resourceUri;
-      assert(invariant(currentElement, () {
+      assert(() {
         bool sameToken(Token token, Token sought) {
           if (token == sought) return true;
           if (token.stringValue == '>>') {
             // `>>` is converted to `>` in the parser when needed.
             return sought.stringValue == '>' &&
                 token.charOffset <= sought.charOffset &&
                 sought.charOffset < token.charEnd;
           }
           return false;
         }
@@ skipping 54 matching lines @@
                 // We might try to report an error while parsing the metadata
                 // itself.
                 return true;
               }
               from = astElement.metadata.first.node.getBeginToken();
             }
             return validateToken(from, to);
           }
         }
         return true;
-      }, message: "Invalid current element: $element [$begin,$end]."));
+      },
+          failedAt(currentElement,
+              "Invalid current element: $element [$begin,$end]."));
     }
     return new SourceSpan.fromTokens(uri, begin, end);
   }
 
   SourceSpan _spanFromNode(Element currentElement, Node node) {
     return _spanFromTokens(
         currentElement, node.getBeginToken(), node.getPrefixEndToken());
   }
 
   SourceSpan _spanFromElement(Element currentElement, Element element) {
@@ skipping 288 matching lines @@
     type.computeUnaliased(_resolution);
     return type.unaliased;
   }
 
   @override
   Iterable<ConstantValue> getMemberMetadata(MemberElement element) {
     List<ConstantValue> values = <ConstantValue>[];
     _compiler.reporter.withCurrentElement(element, () {
       for (MetadataAnnotation metadata in element.implementation.metadata) {
         metadata.ensureResolved(_compiler.resolution);
-        assert(invariant(metadata, metadata.constant != null,
-            message: "Unevaluated metadata constant."));
+        assert(metadata.constant != null,
+            failedAt(metadata, "Unevaluated metadata constant."));
         ConstantValue value =
             _compiler.constants.getConstantValue(metadata.constant);
         values.add(value);
       }
     });
     return values;
   }
 }
 
 /// AST-based logic for processing annotations. These annotations are processed
@@ skipping 190 matching lines @@
 
 /// Builder that creates work item necessary for the resolution of a
 /// [MemberElement].
 class ResolutionWorkItemBuilder extends WorkItemBuilder {
   final Resolution _resolution;
 
   ResolutionWorkItemBuilder(this._resolution);
 
   @override
   WorkItem createWorkItem(MemberElement element) {
-    assert(invariant(element, element.isDeclaration));
+    assert(element.isDeclaration, failedAt(element));
     if (element.isMalformed) return null;
 
-    assert(invariant(element, element is AnalyzableElement,
-        message: 'Element $element is not analyzable.'));
+    assert(element is AnalyzableElement,
+        failedAt(element, 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }