Use failedAt in more places

pkg/compiler/lib/src/universe/resolution_world_builder.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.
 
 part of world_builder;
 
 abstract class ResolutionWorldBuilder implements WorldBuilder, OpenWorld {
   /// Set of all local functions in the program. Used by the mirror tracking
   /// system to find all live closure instances.
   Iterable<Local> get localFunctions;
@@ skipping 375 matching lines @@
       this._backendUsageBuilder,
       this._rtiNeedBuilder,
       this._nativeResolutionEnqueuer,
       this.selectorConstraintsStrategy);
 
   Iterable<ClassEntity> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   ClosedWorld get closedWorldForTesting {
     if (!_closed) {
-      throw new SpannableAssertionFailure(
+      failedAt(
           NO_LOCATION_SPANNABLE, "The world builder has not yet been closed.");
     }
     return _closedWorldCache;
   }
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassEntity> get directlyInstantiatedClasses {
@@ skipping 234 matching lines @@
       case StaticUseKind.DIRECT_USE:
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
       case StaticUseKind.REDIRECTION:
         useSet.addAll(usage.normalUse());
         break;
       case StaticUseKind.DIRECT_INVOKE:
         failedAt(element, 'Direct static use is not supported for resolution.');
         break;
       case StaticUseKind.INLINING:
-        throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
+        failedAt(CURRENT_ELEMENT_SPANNABLE,
             "Static use ${staticUse.kind} is not supported during resolution.");
     }
     if (useSet.isNotEmpty) {
       memberUsed(usage.entity, useSet);
     }
   }
 
   /// Called to create a [_ClassUsage] for [cls].
   ///
   /// Subclasses override this to ensure needed invariants on [cls].
@@ skipping 233 matching lines @@
 
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
     /// properties of the [ClassHierarchyNode] for [cls].
 
     void addSubtypes(ClassEntity cls, InstantiationInfo info) {
       if (!info.hasInstantiation) {
         return;
       }
       assert(checkClass(cls));
       if (!validateClass(cls)) {
-        throw new SpannableAssertionFailure(
-            cls, 'Class "${cls.name}" is not resolved.');
+        failedAt(cls, 'Class "${cls.name}" is not resolved.');
       }
 
       _updateClassHierarchyNodeForClass(cls,
           directlyInstantiated: info.isDirectlyInstantiated,
           abstractlyInstantiated: info.isAbstractlyInstantiated);
 
       // Walk through the superclasses, and record the types
       // implemented by that type on the superclasses.
       ClassEntity superclass = getSuperClass(cls);
       while (superclass != null) {
@@ skipping 91 matching lines @@
         typesImplementedBySubclasses: typesImplementedBySubclasses,
         classHierarchyNodes: _classHierarchyNodes,
         classSets: _classSets);
   }
 
   @override
   void registerClass(ClassEntity cls) {
     throw new UnimplementedError('KernelResolutionWorldBuilder.registerClass');
   }
 }