Use failedAt in more places

pkg/compiler/lib/src/typechecker.dart

 // Copyright (c) 2012, 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.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 628 matching lines @@
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     analyze(node.function);
   }
 
   ResolutionDartType visitFunctionExpression(FunctionExpression node) {
     ResolutionDartType type;
     ResolutionDartType returnType;
     final FunctionElement element = elements.getFunctionDefinition(node);
-    assert(invariant(node, element != null,
-        message: 'FunctionExpression with no element'));
+    assert(
+        element != null, failedAt(node, 'FunctionExpression with no element'));
     if (Elements.isUnresolved(element)) return const ResolutionDynamicType();
     if (element.isGenerativeConstructor) {
       type = const ResolutionDynamicType();
       returnType = const ResolutionVoidType();
 
       element.functionSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameter = parameter;
           checkAssignable(parameter, parameter.type,
               fieldParameter.fieldElement.computeType(resolution));
@@ skipping 22 matching lines @@
     return type;
   }
 
   ResolutionDartType visitIdentifier(Identifier node) {
     if (node.isThis()) {
       return thisType;
     } else if (node.isSuper()) {
       return superType;
     } else {
       TypedElement element = elements[node];
-      assert(invariant(node, element != null,
-          message: 'Missing element for identifier'));
-      assert(invariant(
-          node, element.isVariable || element.isParameter || element.isField,
-          message: 'Unexpected context element ${element}'));
+      assert(element != null, failedAt(node, 'Missing element for identifier'));
+      assert(element.isVariable || element.isParameter || element.isField,
+          failedAt(node, 'Unexpected context element ${element}'));
       return element.computeType(resolution);
     }
   }
 
   visitIf(If node) {
     Expression condition = node.condition.expression;
     Statement thenPart = node.thenPart;
 
     checkCondition(node.condition);
     analyzeInPromotedContext(condition, thenPart, mustHaveType: false);
@@ skipping 313 matching lines @@
       return const DynamicAccess();
     }
     if (node.receiver != null) {
       Element receiverElement = elements[node.receiver];
       if (receiverElement != null) {
         if (receiverElement.isPrefix) {
           if (node.isConditional) {
             // Skip cases like `prefix?.topLevel`.
             return const DynamicAccess();
           }
-          assert(invariant(node, element != null,
-              message: 'Prefixed node has no element.'));
+          assert(
+              element != null, failedAt(node, 'Prefixed node has no element.'));
           return computeResolvedAccess(node, name, element, memberKind);
         }
       }
       // e.foo() for some expression e.
       ResolutionDartType receiverType = analyze(node.receiver);
       if (receiverType.treatAsDynamic || receiverType.isVoid) {
         return const DynamicAccess();
       }
       return lookupMember(
           node, receiverType, name, memberKind, elements[node.receiver],
@@ skipping 129 matching lines @@
       return const ResolutionDynamicType();
     }
 
     Identifier selector = node.selector.asIdentifier();
     if (Elements.isClosureSend(node, element)) {
       if (element != null) {
         if (element.isError) {
           // foo() where foo is erroneous
           return analyzeInvocation(node, const DynamicAccess());
         } else {
-          assert(invariant(node, element.isLocal,
-              message: "Unexpected element $element in closure send."));
+          assert(element.isLocal,
+              failedAt(node, "Unexpected element $element in closure send."));
           // foo() where foo is a local or a parameter.
           return analyzeInvocation(node, createPromotedAccess(element));
         }
       } else {
         // exp() where exp is some complex expression like (o) or foo().
         ResolutionDartType type = analyze(node.selector);
         return analyzeInvocation(node, new TypeAccess(type));
       }
     } else if (Elements.isMalformed(element) && selector == null) {
       // exp() where exp is an erroneous construct like `new Unresolved()`.
@@ skipping 100 matching lines @@
         return boolType;
       } else if (identical(name, '??')) {
         final Node argument = node.arguments.head;
         final ResolutionDartType argumentType = analyze(argument);
         return types.computeLeastUpperBound(receiverType, argumentType);
       }
       String operatorName = selector.source;
       if (identical(name, '-') && node.arguments.isEmpty) {
         operatorName = 'unary-';
       }
-      assert(invariant(
-          node,
+      assert(
           identical(name, '+') ||
               identical(name, '=') ||
               identical(name, '-') ||
               identical(name, '*') ||
               identical(name, '/') ||
               identical(name, '%') ||
               identical(name, '~/') ||
               identical(name, '|') ||
               identical(name, '&') ||
               identical(name, '^') ||
               identical(name, '~') ||
               identical(name, '<<') ||
               identical(name, '>>') ||
               identical(name, '<') ||
               identical(name, '>') ||
               identical(name, '<=') ||
               identical(name, '>=') ||
               identical(name, '[]'),
-          message: 'Unexpected operator $name'));
+          failedAt(node, 'Unexpected operator $name'));
 
       // TODO(karlklose): handle `void` in expression context by calling
       // [analyzeNonVoid] instead of [analyze].
       ElementAccess access = receiverType.isVoid
           ? const DynamicAccess()
           : lookupMember(
               node, receiverType, operatorName, MemberKind.OPERATOR, null);
       LinkBuilder<ResolutionDartType> argumentTypesBuilder =
           new LinkBuilder<ResolutionDartType>();
       ResolutionDartType resultType =
@@ skipping 38 matching lines @@
     return list.length < 2 ? const ResolutionDynamicType() : list[1];
   }
 
   /**
    * Checks [: target o= value :] for some operator o, and returns the type
    * of the result. This method also handles increment/decrement expressions
    * like [: target++ :].
    */
   ResolutionDartType checkAssignmentOperator(SendSet node, String operatorName,
       Node valueNode, ResolutionDartType value) {
-    assert(invariant(node, !node.isIndex));
+    assert(!node.isIndex, failedAt(node));
     Element setterElement = elements[node];
     Element getterElement = elements[node.selector];
     Identifier selector = node.selector;
     ResolutionDartType getter = computeAccessType(
         node, selector.source, getterElement, MemberKind.GETTER);
     ResolutionDartType setter = computeAccessType(
         node, selector.source, setterElement, MemberKind.SETTER);
     // [operator] is the type of operator+ or operator- on [target].
     ResolutionDartType operator =
         lookupMemberType(node, getter, operatorName, MemberKind.OPERATOR);
@@ skipping 14 matching lines @@
     return const ResolutionDynamicType();
   }
 
   /**
    * Checks [: base[key] o= value :] for some operator o, and returns the type
    * of the result. This method also handles increment/decrement expressions
    * like [: base[key]++ :].
    */
   ResolutionDartType checkIndexAssignmentOperator(SendSet node,
       String operatorName, Node valueNode, ResolutionDartType value) {
-    assert(invariant(node, node.isIndex));
+    assert(node.isIndex, failedAt(node));
     final ResolutionDartType base = analyze(node.receiver);
     final Node keyNode = node.arguments.head;
     final ResolutionDartType key = analyze(keyNode);
 
     // [indexGet] is the type of operator[] on [base].
     ResolutionDartType indexGet =
         lookupMemberType(node, base, '[]', MemberKind.OPERATOR);
     if (indexGet is ResolutionFunctionType) {
       ResolutionFunctionType indexGetType = indexGet;
       ResolutionDartType indexGetKey = firstType(indexGetType.parameterTypes);
@@ skipping 211 matching lines @@
     return constructorType;
   }
 
   ResolutionDartType visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (Elements.isUnresolved(element)) return const ResolutionDynamicType();
 
     checkPrivateAccess(node, element, element.name);
 
     ResolutionDartType newType = elements.getType(node);
-    assert(invariant(node, newType != null,
-        message: "No new type registered in $elements."));
+    assert(newType != null,
+        failedAt(node, "No new type registered in $elements."));
     ResolutionDartType constructorType =
         computeConstructorType(element, newType);
     analyzeArguments(node.send, element, constructorType);
     return newType;
   }
 
   ResolutionDartType visitLiteralList(LiteralList node) {
     ResolutionInterfaceType listType = elements.getType(node);
     ResolutionDartType listElementType = firstType(listType.typeArguments);
     for (Link<Node> link = node.elements.nodes;
@@ skipping 130 matching lines @@
     ResolutionDartType expressionType = analyzeNonVoid(initializer);
     checkAssignable(spannable, expressionType, declaredType);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     ResolutionDartType type = analyzeVariableTypeAnnotation(node);
     for (Link<Node> link = node.definitions.nodes;
         !link.isEmpty;
         link = link.tail) {
       Node definition = link.head;
-      invariant(definition, definition is Identifier || definition is SendSet,
-          message: 'expected identifier or initialization');
+      assert(definition is Identifier || definition is SendSet,
+          failedAt(definition, 'expected identifier or initialization'));
       if (definition is SendSet) {
         SendSet initialization = definition;
         analyzeVariableInitializer(initialization.assignmentOperator, type,
             initialization.arguments.head);
         // TODO(sigmund): explore inferring a type for `var` using the RHS (like
         // DDC does), for example:
         // if (node.type == null && node.modifiers.isVar &&
         //     !initializer.isDynamic) {
         //   var variable = elements[definition];
         //   if (variable != null) {
@@ skipping 243 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }