Use failedAt in more places

pkg/compiler/lib/src/resolution/send_structure.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.resolution.send_structure;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../elements/elements.dart';
 import '../elements/operators.dart';
@@ skipping 273 matching lines @@
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperInvoke(
             node, semantics.element, node.argumentsNode, selector, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidInvoke(
             node, semantics.element, node.argumentsNode, selector, arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid invoke: ${semantics}");
+    throw failedAt(node, "Invalid invoke: ${semantics}");
   }
 
   String toString() => 'invoke($selector, $semantics)';
 }
 
 /// The structure for a [Send] that is an incompatible invocation, i.e. an
 /// invocation of a known target where the call structure does not match.
 class IncompatibleInvokeStructure<R, A> implements SendStructure<R, A> {
   /// The target of the invocation.
   final AccessSemantics semantics;
@@ skipping 22 matching lines @@
       case AccessKind.TOPLEVEL_METHOD:
         return visitor.visitTopLevelFunctionIncompatibleInvoke(
             node, semantics.element, node.argumentsNode, callStructure, arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionIncompatibleInvoke(
             node, semantics.element, node.argumentsNode, callStructure, arg);
       default:
         // TODO(johnniwinther): Support more variants of this invoke structure.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid incompatible invoke: ${semantics}");
+    throw failedAt(node, "Invalid incompatible invoke: ${semantics}");
   }
 
   String toString() => 'incompatible-invoke($selector, $semantics)';
 }
 
 /// The structure for a [Send] that is a read access.
 class GetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the read access.
   final AccessSemantics semantics;
 
@@ skipping 69 matching lines @@
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedGet(node, semantics.element, arg);
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperGet(node, semantics.element, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidGet(node, semantics.element, arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid getter: ${semantics}");
+    throw failedAt(node, "Invalid getter: ${semantics}");
   }
 
   String toString() => 'get($semantics)';
 }
 
 /// The structure for a [Send] that is an assignment.
 class SetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the assignment.
   final AccessSemantics semantics;
 
@@ skipping 100 matching lines @@
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedSet(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidSet(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.COMPOUND:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
+    throw failedAt(node, "Invalid setter: ${semantics}");
   }
 
   String toString() => 'set($semantics)';
 }
 
 /// The structure for a [Send] that is a negation, i.e. of the form `!e`.
 class NotStructure<R, A> implements SendStructure<R, A> {
   const NotStructure();
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
@@ skipping 29 matching lines @@
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperUnary(
             node, operator, semantics.element, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidUnary(
             node, operator, semantics.element, arg);
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid setter: ${semantics}");
+    throw failedAt(node, "Invalid setter: ${semantics}");
   }
 
   String toString() => 'unary($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a undefined unary
 /// operator.
 class InvalidUnaryStructure<R, A> implements SendStructure<R, A> {
   const InvalidUnaryStructure();
 
@@ skipping 31 matching lines @@
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperIndex(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidIndex(
             node, semantics.element, node.arguments.single, arg);
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid index: ${semantics}");
+    throw failedAt(node, "Invalid index: ${semantics}");
   }
 }
 
 /// The structure for a [Send] that is an equals test, i.e. of the form
 /// `a == b`.
 class EqualsStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
   EqualsStructure(this.semantics);
 
   @override
   SendStructureKind get kind => SendStructureKind.EQUALS;
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.EXPRESSION:
         return visitor.visitEquals(
             node, node.receiver, node.arguments.single, arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperEquals(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidEquals(
             node, semantics.element, node.arguments.single, arg);
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid equals: ${semantics}");
+    throw failedAt(node, "Invalid equals: ${semantics}");
   }
 
   String toString() => '==($semantics)';
 }
 
 /// The structure for a [Send] that is a not-equals test, i.e. of the form
 /// `a != b`.
 class NotEqualsStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
@@ skipping 11 matching lines @@
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperNotEquals(
             node, semantics.element, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidNotEquals(
             node, semantics.element, node.arguments.single, arg);
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid not equals: ${semantics}");
+    throw failedAt(node, "Invalid not equals: ${semantics}");
   }
 
   String toString() => '!=($semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a user-definable binary
 /// operator.
 class BinaryStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
@@ skipping 17 matching lines @@
       case AccessKind.UNRESOLVED_SUPER:
         return visitor.visitUnresolvedSuperBinary(
             node, semantics.element, operator, node.arguments.single, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidBinary(
             node, semantics.element, operator, node.arguments.single, arg);
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(node, "Invalid binary: ${semantics}");
+    throw failedAt(node, "Invalid binary: ${semantics}");
   }
 
   String toString() => 'binary($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is an invocation of a undefined binary
 /// operator.
 class InvalidBinaryStructure<R, A> implements SendStructure<R, A> {
   const InvalidBinaryStructure();
 
@@ skipping 31 matching lines @@
       case AccessKind.UNRESOLVED:
         return visitor.visitUnresolvedSuperIndexSet(node, semantics.element,
             node.arguments.first, node.arguments.tail.head, arg);
       case AccessKind.INVALID:
         return visitor.errorInvalidIndexSet(node, semantics.element,
             node.arguments.first, node.arguments.tail.head, arg);
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid index set: ${semantics}");
+    throw failedAt(node, "Invalid index set: ${semantics}");
   }
 
   String toString() => '[]=($semantics)';
 }
 
 /// The structure for a [Send] that is an prefix operation on an index
 /// expression, i.e. of the form `--a[b]`.
 class IndexPrefixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
@@ skipping 41 matching lines @@
                 arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid index prefix: ${semantics}");
+    throw failedAt(node, "Invalid index prefix: ${semantics}");
   }
 }
 
 /// The structure for a [Send] that is an postfix operation on an index
 /// expression, i.e. of the form `a[b]++`.
 class IndexPostfixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
   /// The `++` or `--` operator used in the operation.
@@ skipping 44 matching lines @@
                 arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid index postfix: ${semantics}");
+    throw failedAt(node, "Invalid index postfix: ${semantics}");
   }
 }
 
 /// The structure for a [Send] that is a compound assignment. For instance
 /// `a += b`.
 class CompoundStructure<R, A> implements SendStructure<R, A> {
   /// The target of the compound assignment, i.e. the left-hand side.
   final AccessSemantics semantics;
 
   /// The assignment operator used in the compound assignment.
@@ skipping 229 matching lines @@
             return visitor.visitUnresolvedSuperSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
         }
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid compound assigment: ${semantics}");
+    throw failedAt(node, "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'compound($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is an if-null assignment. For instance
 /// `a ??= b`.
 class SetIfNullStructure<R, A> implements SendStructure<R, A> {
   /// The target of the if-null assignment, i.e. the left-hand side.
   final AccessSemantics semantics;
@@ skipping 208 matching lines @@
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
             return visitor.visitUnresolvedSuperSetterSetIfNull(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 arg);
         }
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid if-null assigment: ${semantics}");
+    throw failedAt(node, "Invalid if-null assigment: ${semantics}");
   }
 
   String toString() => 'ifNull($semantics)';
 }
 
 /// The structure for a [Send] that is a compound assignment on the index
 /// operator. For instance `a[b] += c`.
 class CompoundIndexSetStructure<R, A> implements SendStructure<R, A> {
   /// The target of the index operations.
   final AccessSemantics semantics;
@@ skipping 54 matching lines @@
                 arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid compound index set: ${semantics}");
+    throw failedAt(node, "Invalid compound index set: ${semantics}");
   }
 
   String toString() => 'compound []=($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is a if-null assignment on the index
 /// operator. For instance `a[b] ??= c`.
 class IndexSetIfNullStructure<R, A> implements SendStructure<R, A> {
   /// The target of the index operations.
   final AccessSemantics semantics;
@@ skipping 47 matching lines @@
                 arg);
           default:
             // This is not a valid case.
             break;
         }
         break;
       default:
         // This is not a valid case.
         break;
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid index set if-null: ${semantics}");
+    throw failedAt(node, "Invalid index set if-null: ${semantics}");
   }
 
   String toString() => 'index set if-null []??=($semantics)';
 }
 
 /// The structure for a [Send] that is a prefix operations. For instance
 /// `++a`.
 class PrefixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the prefix operation.
   final AccessSemantics semantics;
@@ skipping 217 matching lines @@
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
             return visitor.visitUnresolvedSuperSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid compound assigment: ${semantics}");
+    throw failedAt(node, "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'prefix($operator,$semantics)';
 }
 
 /// The structure for a [Send] that is a postfix operations. For instance
 /// `a++`.
 class PostfixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the postfix operation.
   final AccessSemantics semantics;
@@ skipping 210 matching lines @@
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
             return visitor.visitUnresolvedSuperSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid compound assigment: ${semantics}");
+    throw failedAt(node, "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'postfix($operator,$semantics)';
 }
 
 /// The structure for a [Send] whose prefix is a prefix for a deferred library.
 /// For instance `deferred.a` where `deferred` is a deferred prefix.
 class DeferredPrefixStructure<R, A> implements SendStructure<R, A> {
   /// The deferred prefix element.
   final PrefixElement prefix;
@@ skipping 130 matching lines @@
             arg);
       case ConstructorAccessKind.INCOMPATIBLE:
         return visitor.visitConstructorIncompatibleInvoke(
             node,
             semantics.element,
             semantics.type,
             node.send.argumentsNode,
             callStructure,
             arg);
     }
-    throw new SpannableAssertionFailure(
+    throw failedAt(
         node, "Unhandled constructor invocation kind: ${semantics.kind}");
   }
 
   String toString() => 'new($semantics,$selector)';
 }
 
 enum ConstantInvokeKind {
   CONSTRUCTED,
   BOOL_FROM_ENVIRONMENT,
   INT_FROM_ENVIRONMENT,
@@ skipping 66 matching lines @@
         case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
           kind = ConstantInvokeKind.BOOL_FROM_ENVIRONMENT;
           break;
         case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
           kind = ConstantInvokeKind.INT_FROM_ENVIRONMENT;
           break;
         case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
           kind = ConstantInvokeKind.STRING_FROM_ENVIRONMENT;
           break;
         default:
-          throw new SpannableAssertionFailure(
+          throw failedAt(
               node, "Unexpected constant kind $kind: ${constant.toDartText()}");
       }
       return new ConstInvokeStructure(kind, constant);
     }
   }
 
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
     Element element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
     ResolutionDartType type = elements.getType(node);
@@ skipping 13 matching lines @@
         case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
           return visitor.visitBoolFromEnvironmentConstructorInvoke(
               node, constant, arg);
         case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
           return visitor.visitIntFromEnvironmentConstructorInvoke(
               node, constant, arg);
         case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
           return visitor.visitStringFromEnvironmentConstructorInvoke(
               node, constant, arg);
         default:
-          throw new SpannableAssertionFailure(
+          throw failedAt(
               node, "Unexpected constant kind $kind: ${constant.toDartText()}");
       }
     }
   }
 }
 
 /// The structure of a parameter declaration.
 abstract class ParameterStructure<R, A> {
   final VariableDefinitions definitions;
   final Node node;
@@ skipping 123 matching lines @@
         return visitor.visitTopLevelConstantDeclaration(
             definitions, node, variable, constant, arg);
       case VariableKind.STATIC_FIELD:
         return visitor.visitStaticConstantDeclaration(
             definitions, node, variable, constant, arg);
       case VariableKind.LOCAL_VARIABLE:
         return visitor.visitLocalConstantDeclaration(
             definitions, node, variable, constant, arg);
       default:
     }
-    throw new SpannableAssertionFailure(
-        node, "Invalid constant variable: $variable");
+    throw failedAt(node, "Invalid constant variable: $variable");
   }
 }
 
 class InitializersStructure<R, A> {
   final List<InitializerStructure<R, A>> initializers;
 
   InitializersStructure(this.initializers);
 }
 
 abstract class InitializerStructure<R, A> {
@@ skipping 56 matching lines @@
   ThisConstructorInvokeStructure(
       this.node, this.constructor, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }