Use failedAt in more places

pkg/compiler/lib/src/native/resolver.dart

 // Copyright (c) 2014, 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.
 
 import 'package:front_end/src/fasta/scanner.dart' show StringToken, Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 import 'package:front_end/src/scanner/token.dart' show BeginToken;
 
 import '../common.dart';
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
@@ skipping 160 matching lines @@
   ///    use the declared @JSName as the expression
   /// 3. If [element] does not have a @JSName annotation, qualify the name of
   ///    the method with the @Native name of the enclosing class.
   void _setNativeNameForStaticMethod(FunctionEntity element) {
     String name = _findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     if (_isIdentifier(name)) {
       List<String> nativeNames =
           nativeBasicData.getNativeTagsOfClass(element.enclosingClass);
       if (nativeNames.length != 1) {
-        throw new SpannableAssertionFailure(
+        failedAt(
             element,
             'Unable to determine a native name for the enclosing class, '
             'options: $nativeNames');
       }
       nativeDataBuilder.setNativeMemberName(element, '${nativeNames[0]}.$name');
     } else {
       nativeDataBuilder.setNativeMemberName(element, name);
     }
   }
 
   bool _isIdentifier(String s) => _identifier.hasMatch(s);
 
   /// Returns the JSName annotation string or `null` if no JSName annotation is
   /// present.
   String _findJsNameFromAnnotation(MemberEntity element) {
     String jsName = null;
     for (ConstantValue value in elementEnvironment.getMemberMetadata(element)) {
       String name = readAnnotationName(
           element, value, commonElements.annotationJSNameClass);
       if (jsName == null) {
         jsName = name;
       } else if (name != null) {
-        throw new SpannableAssertionFailure(
-            element, 'Too many JSName annotations: ${value.toDartText()}');
+        failedAt(element, 'Too many JSName annotations: ${value.toDartText()}');
       }
     }
     return jsName;
   }
 }
 
 class NativeDataResolverImpl extends NativeMemberResolverBase
     implements NativeDataResolver {
   final Compiler _compiler;
 
@@ skipping 224 matching lines @@
       covariant ClassEntity cls, Set<ClassEntity> nativeClasses) {
     nativeClasses.add(cls);
     // Js Interop interfaces do not have tags.
     if (_nativeBasicData.isJsInteropClass(cls)) return;
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in _nativeBasicData.getNativeTagsOfClass(cls)) {
       ClassEntity owner = _tagOwner[tag];
       if (owner != null) {
         if (owner != cls) {
-          throw new SpannableAssertionFailure(
-              cls, "Tag '$tag' already in use by '${owner.name}'");
+          failedAt(cls, "Tag '$tag' already in use by '${owner.name}'");
         }
       } else {
         _tagOwner[tag] = cls;
       }
     }
   }
 
   /// Returns the name of the super class of [cls] or `null` of [cls] has
   /// no explicit superclass.
   String _findExtendsNameOfClass(covariant ClassEntity cls) {
@@ skipping 151 matching lines @@
 /// [annotationClass], otherwise returns `null`.
 String readAnnotationName(
     Spannable spannable, ConstantValue value, ClassEntity annotationClass) {
   if (!value.isConstructedObject) return null;
   ConstructedConstantValue constructedObject = value;
   if (constructedObject.type.element != annotationClass) return null;
 
   Iterable<ConstantValue> fields = constructedObject.fields.values;
   // TODO(sra): Better validation of the constant.
   if (fields.length != 1 || fields.single is! StringConstantValue) {
-    throw new SpannableAssertionFailure(
+    failedAt(
         spannable, 'Annotations needs one string: ${value.toStructuredText()}');
   }
   StringConstantValue specStringConstant = fields.single;
   return specStringConstant.primitiveValue;
 }