Use failedAt in more places

pkg/compiler/lib/src/resolution/send_resolver.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.semantics_visitor.resolver;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 33 matching lines @@
             node, element, node.parameters, node.initializers, node.body, arg);
       case ConstructorKind.REDIRECTING_GENERATIVE:
         return visitor.visitRedirectingGenerativeConstructorDeclaration(
             node, element, node.parameters, node.initializers, arg);
       case ConstructorKind.FACTORY:
         return visitor.visitFactoryConstructorDeclaration(
             node, element, node.parameters, node.body, arg);
       default:
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Unhandled constructor declaration kind: ${kind}");
+    throw failedAt(node, "Unhandled constructor declaration kind: ${kind}");
   }
 }
 
 class RedirectingFactoryConstructorDeclStructure<R, A>
     extends DeclStructure<R, A> {
   ResolutionInterfaceType redirectionTargetType;
   ConstructorElement redirectionTarget;
 
   RedirectingFactoryConstructorDeclStructure(ConstructorElement constructor,
       this.redirectionTargetType, this.redirectionTarget)
@@ skipping 215 matching lines @@
     }
     return list;
   }
 
   ParameterStructure computeParameterStructure(
       VariableDefinitions definitions, int index,
       {bool isRequired: true, bool isNamed: false}) {
     Node node = definitions.definitions.nodes.single;
     ParameterElement element = elements[node];
     if (element == null) {
-      throw new SpannableAssertionFailure(
-          node, "No parameter structure for $node.");
+      throw failedAt(node, "No parameter structure for $node.");
     }
     if (isRequired) {
       return new RequiredParameterStructure(definitions, node, element, index);
     } else {
       // TODO(johnniwinther): Should we differentiate between implicit (null)
       // and explicit values? What about optional parameters on redirecting
       // factories?
       if (isNamed) {
         return new NamedParameterStructure(
             definitions, node, element, element.constant);
@@ skipping 26 matching lines @@
       return internalError(node, "Unexpected variable $element.");
     }
     if (element.isConst) {
       ConstantExpression constant = elements.getConstant(element.initializer);
       return new ConstantVariableStructure(kind, node, element, constant);
     } else {
       return new NonConstantVariableStructure(kind, node, element);
     }
   }
 }