Use failedAt in more places

pkg/compiler/lib/src/js_backend/native_data.dart

 // Copyright (c) 2016, 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 js_backend.native_data;
 
 import '../common.dart';
 import '../common_elements.dart' show ElementEnvironment;
 import '../elements/entities.dart';
 import '../native/behavior.dart' show NativeBehavior;
@@ skipping 155 matching lines @@
   /// Sets the native tag info for [cls].
   ///
   /// The tag info string contains comma-separated 'words' which are either
   /// dispatch tags (having JavaScript identifier syntax) and directives that
   /// begin with `!`.
   void setNativeClassTagInfo(ClassEntity cls, String tagText) {
     // TODO(johnniwinther): Assert that this is only called once. The memory
     // compiler copies pre-processed elements into a new compiler through
     // [Compiler.onLibraryScanned] and thereby causes multiple calls to this
     // method.
-    assert(invariant(
-        cls,
+    assert(
         nativeClassTagInfo[cls] == null ||
             nativeClassTagInfo[cls].text == tagText,
-        message: "Native tag info set inconsistently on $cls: "
+        failedAt(
+            cls,
+            "Native tag info set inconsistently on $cls: "
             "Existing tag info '${nativeClassTagInfo[cls]}', "
             "new tag info '$tagText'."));
     nativeClassTagInfo[cls] = new NativeClassTag(tagText);
   }
 
   @override
   void markAsJsInteropLibrary(LibraryEntity element) {
     jsInteropLibraries.add(element);
   }
 
@@ skipping 97 matching lines @@
   Map<MemberEntity, String> jsInteropMemberNames = <MemberEntity, String>{};
 
   NativeDataBuilderImpl(this._nativeBasicData);
 
   /// Sets the native [name] for the member [element]. This name is used for
   /// [element] in the generated JavaScript.
   void setNativeMemberName(MemberEntity element, String name) {
     // TODO(johnniwinther): Avoid setting this more than once. The enqueuer
     // might enqueue [element] several times (before processing it) and computes
     // name on each call to `internalAddToWorkList`.
-    assert(invariant(element,
+    assert(
         nativeMemberName[element] == null || nativeMemberName[element] == name,
-        message: "Native member name set inconsistently on $element: "
+        failedAt(
+            element,
+            "Native member name set inconsistently on $element: "
             "Existing name '${nativeMemberName[element]}', "
             "new name '$name'."));
     nativeMemberName[element] = name;
   }
 
   /// Registers the [behavior] for calling the native [method].
   void setNativeMethodBehavior(FunctionEntity method, NativeBehavior behavior) {
     nativeMethodBehavior[method] = behavior;
   }
 
   /// Registers the [behavior] for reading from the native [field].
   void setNativeFieldLoadBehavior(FieldEntity field, NativeBehavior behavior) {
     nativeFieldLoadBehavior[field] = behavior;
   }
 
   /// Registers the [behavior] for writing to the native [field].
   void setNativeFieldStoreBehavior(FieldEntity field, NativeBehavior behavior) {
     nativeFieldStoreBehavior[field] = behavior;
   }
 
   /// Sets the explicit js interop [name] for the library [element].
   void setJsInteropLibraryName(LibraryEntity element, String name) {
-    assert(invariant(element, _nativeBasicData.isJsInteropLibrary(element),
-        message:
+    assert(
+        _nativeBasicData.isJsInteropLibrary(element),
+        failedAt(element,
             'Library $element is not js interop but given a js interop name.'));
     jsInteropLibraryNames[element] = name;
   }
 
   @override
   void markJsInteropClassAsAnonymous(ClassEntity element) {
     anonymousJsInteropClasses.add(element);
   }
 
   /// Sets the explicit js interop [name] for the class [element].
   void setJsInteropClassName(ClassEntity element, String name) {
-    assert(invariant(element, _nativeBasicData.isJsInteropClass(element),
-        message:
+    assert(
+        _nativeBasicData.isJsInteropClass(element),
+        failedAt(element,
             'Class $element is not js interop but given a js interop name.'));
     jsInteropClassNames[element] = name;
   }
 
   @override
   void markAsJsInteropMember(MemberEntity element) {
     jsInteropMemberNames[element] = null;
   }
 
   /// Sets the explicit js interop [name] for the member [element].
   void setJsInteropMemberName(MemberEntity element, String name) {
-    assert(invariant(element, jsInteropMemberNames.containsKey(element),
-        message:
+    assert(
+        jsInteropMemberNames.containsKey(element),
+        failedAt(element,
             'Member $element is not js interop but given a js interop name.'));
     jsInteropMemberNames[element] = name;
   }
 
   @override
   NativeData close() => new NativeDataImpl(
       _nativeBasicData,
       nativeMemberName,
       nativeMethodBehavior,
       nativeFieldLoadBehavior,
@@ skipping 150 matching lines @@
   }
 
   String _jsClassNameHelper(ClassEntity element) {
     String jsInteropName = getJsInteropClassName(element);
     if (jsInteropName != null && jsInteropName.isNotEmpty) return jsInteropName;
     return computeUnescapedJSInteropName(element.name);
   }
 
   String _jsMemberNameHelper(MemberEntity element) {
     String jsInteropName = jsInteropMemberNames[element];
-    assert(invariant(element,
+    assert(
         !(jsInteropMemberNames.containsKey(element) && jsInteropName == null),
-        message:
+        failedAt(
+            element,
             'Member $element is js interop but js interop name has not yet '
             'been computed.'));
     if (jsInteropName != null && jsInteropName.isNotEmpty) {
       return jsInteropName;
     }
     return computeUnescapedJSInteropName(element.name);
   }
 
   /// Returns a JavaScript path specifying the context in which
   /// [element.fixedBackendName] should be evaluated. Only applicable for
@@ skipping 21 matching lines @@
   }
 
   /// Returns `true` if [element] is a native member of a native class.
   bool isNativeMember(MemberEntity element) {
     if (isJsInteropMember(element)) return true;
     return nativeMemberName.containsKey(element);
   }
 
   /// Returns the [NativeBehavior] for calling the native [method].
   NativeBehavior getNativeMethodBehavior(FunctionEntity method) {
-    assert(invariant(method, nativeMethodBehavior.containsKey(method),
-        message: "No native method behavior has been computed for $method."));
+    assert(
+        nativeMethodBehavior.containsKey(method),
+        failedAt(method,
+            "No native method behavior has been computed for $method."));
     return nativeMethodBehavior[method];
   }
 
   /// Returns the [NativeBehavior] for reading from the native [field].
   NativeBehavior getNativeFieldLoadBehavior(FieldEntity field) {
-    assert(invariant(field, nativeFieldLoadBehavior.containsKey(field),
-        message: "No native field load behavior has been "
+    assert(
+        nativeFieldLoadBehavior.containsKey(field),
+        failedAt(
+            field,
+            "No native field load behavior has been "
             "computed for $field."));
     return nativeFieldLoadBehavior[field];
   }
 
   /// Returns the [NativeBehavior] for writing to the native [field].
   NativeBehavior getNativeFieldStoreBehavior(FieldEntity field) {
-    assert(invariant(field, nativeFieldStoreBehavior.containsKey(field),
-        message: "No native field store behavior has been "
-            "computed for $field."));
+    assert(
+        nativeFieldStoreBehavior.containsKey(field),
+        failedAt(field,
+            "No native field store behavior has been computed for $field."));
     return nativeFieldStoreBehavior[field];
   }
 
   /// Apply JS$ escaping scheme to convert possible escaped Dart names into
   /// JS names.
   String computeUnescapedJSInteropName(String name) {
     return name.startsWith(_jsInteropEscapePrefix)
         ? name.substring(_jsInteropEscapePrefix.length)
         : name;
   }
@@ skipping 27 matching lines @@
   int get hashCode => Hashing.listHash(names, isNonLeaf.hashCode);
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! NativeClassTag) return false;
     return equalElements(names, other.names) && isNonLeaf == other.isNonLeaf;
   }
 
   String toString() => text;
 }