Use failedAt in more places

pkg/compiler/lib/src/resolution/members.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.resolution.members;
 
 import 'package:front_end/src/fasta/scanner.dart' show isUserDefinableOperator;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
@@ skipping 239 matching lines @@
     }
     var result = action();
     constantState = oldConstantState;
     return result;
   }
 
   /// Visit [node] where the constant state is `ConstantState.CONSTANT` if
   /// not already `ConstantState.CONSTANT_INITIALIZER`.
   ResolutionResult visitInConstantContext(Node node) {
     ResolutionResult result = inConstantContext(() => visit(node));
-    assert(invariant(node, result != null,
-        message: "No resolution result for $node."));
+    assert(result != null, failedAt(node, "No resolution result for $node."));
 
     return result;
   }
 
   ErroneousElement reportAndCreateErroneousElement(
       Node node, String name, MessageKind kind, Map arguments,
       {List<DiagnosticMessage> infos: const <DiagnosticMessage>[],
       bool isError: false}) {
     if (isError) {
       reporter.reportError(
           reporter.createMessage(node, kind, arguments), infos);
     } else {
       reporter.reportWarning(
           reporter.createMessage(node, kind, arguments), infos);
     }
     // TODO(ahe): Use [allowedCategory] to synthesize a more precise subclass
     // of [ErroneousElementX]. For example, [ErroneousFieldElementX],
     // [ErroneousConstructorElementX], etc.
     return new ErroneousElementX(kind, arguments, name, enclosingElement);
   }
 
   /// Report a warning or error on an unresolved access in non-instance context.
   ///
   /// The [ErroneousElement] corresponding to the message is returned.
   ErroneousElement reportCannotResolve(Node node, String name) {
-    assert(invariant(node, !inInstanceContext,
-        message: "ResolverVisitor.reportCannotResolve must not be called in "
+    assert(
+        !inInstanceContext,
+        failedAt(
+            node,
+            "ResolverVisitor.reportCannotResolve must not be called in "
             "instance context."));
 
     // We report an error within initializers because `this` is implicitly
     // accessed when unqualified identifiers are not resolved.  For
     // details, see section 16.14.3 of the spec (2nd edition):
     //   An unqualified invocation `i` of the form `id(a1, ...)`
     //   ...
     //   If `i` does not occur inside a top level or static function, `i`
     //   is equivalent to `this.id(a1 , ...)`.
     bool inInitializer = enclosingElement.isGenerativeConstructor ||
@@ skipping 480 matching lines @@
       return new StaticAccess.superGetter(target);
     } else if (target.isSetter) {
       return new StaticAccess.superSetter(target);
     } else if (target.isField) {
       if (target.isFinal) {
         return new StaticAccess.superFinalField(target);
       } else {
         return new StaticAccess.superField(target);
       }
     } else {
-      assert(invariant(node, target.isFunction,
-          message: "Unexpected super target '$target'."));
+      assert(target.isFunction,
+          failedAt(node, "Unexpected super target '$target'."));
       return new StaticAccess.superMethod(target);
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a compound super access
   /// reading from [getter] and writing to [setter].
   AccessSemantics computeCompoundSuperAccessSemantics(
       Spannable node, Element getter, Element setter,
       {bool isIndex: false}) {
     if (getter.isMalformed) {
       if (setter.isMalformed) {
         return new StaticAccess.unresolvedSuper(getter);
       } else if (setter.isFunction) {
-        assert(invariant(node, setter.name == '[]=',
-            message: "Unexpected super setter '$setter'."));
+        assert(setter.name == '[]=',
+            failedAt(node, "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, setter);
       } else {
-        assert(invariant(node, setter.isSetter,
-            message: "Unexpected super setter '$setter'."));
+        assert(setter.isSetter,
+            failedAt(node, "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, setter);
       }
     } else if (getter.isField) {
       if (setter.isMalformed) {
-        assert(invariant(node, getter.isFinal,
-            message: "Unexpected super setter '$setter' for getter '$getter."));
+        assert(
+            getter.isFinal,
+            failedAt(node,
+                "Unexpected super setter '$setter' for getter '$getter."));
         return new StaticAccess.superFinalField(getter);
       } else if (setter.isField) {
         if (getter == setter) {
           return new StaticAccess.superField(getter);
         } else {
           return new CompoundAccessSemantics(
               CompoundAccessKind.SUPER_FIELD_FIELD, getter, setter);
         }
       } else {
         // Either the field is accessible directly, or a setter shadows the
         // setter access. If there was another instance member it would shadow
         // the field.
-        assert(invariant(node, setter.isSetter,
-            message: "Unexpected super setter '$setter'."));
+        assert(setter.isSetter,
+            failedAt(node, "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_FIELD_SETTER, getter, setter);
       }
     } else if (getter.isGetter) {
       if (setter.isMalformed) {
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, setter);
       } else if (setter.isField) {
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_GETTER_FIELD, getter, setter);
       } else {
-        assert(invariant(node, setter.isSetter,
-            message: "Unexpected super setter '$setter'."));
+        assert(setter.isSetter,
+            failedAt(node, "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_GETTER_SETTER, getter, setter);
       }
     } else {
-      assert(invariant(node, getter.isFunction,
-          message: "Unexpected super getter '$getter'."));
+      assert(getter.isFunction,
+          failedAt(node, "Unexpected super getter '$getter'."));
       if (setter.isMalformed) {
         if (isIndex) {
           return new CompoundAccessSemantics(
               CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, setter);
         } else {
           return new StaticAccess.superMethod(getter);
         }
       } else if (setter.isFunction) {
-        assert(invariant(node, setter.name == '[]=',
-            message: "Unexpected super setter '$setter'."));
-        assert(invariant(node, getter.name == '[]',
-            message: "Unexpected super getter '$getter'."));
+        assert(setter.name == '[]=',
+            failedAt(node, "Unexpected super setter '$setter'."));
+        assert(getter.name == '[]',
+            failedAt(node, "Unexpected super getter '$getter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_GETTER_SETTER, getter, setter);
       } else {
-        assert(invariant(node, setter.isSetter,
-            message: "Unexpected super setter '$setter'."));
+        assert(setter.isSetter,
+            failedAt(node, "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_METHOD_SETTER, getter, setter);
       }
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a local access of [target].
   AccessSemantics computeLocalAccessSemantics(
       Spannable node, LocalElement target) {
     if (target.isRegularParameter) {
       if (target.isFinal || target.isConst) {
         return new StaticAccess.finalParameter(target);
       } else {
         return new StaticAccess.parameter(target);
       }
     } else if (target.isInitializingFormal) {
       return new StaticAccess.finalParameter(target);
     } else if (target.isVariable) {
       if (target.isFinal || target.isConst) {
         return new StaticAccess.finalLocalVariable(target);
       } else {
         return new StaticAccess.localVariable(target);
       }
     } else {
-      assert(invariant(node, target.isFunction,
-          message: "Unexpected local target '$target'."));
+      assert(target.isFunction,
+          failedAt(node, "Unexpected local target '$target'."));
       return new StaticAccess.localFunction(target);
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a static or toplevel access
   /// of [target].
   AccessSemantics computeStaticOrTopLevelAccessSemantics(
       Spannable node, Element target) {
     target = target.declaration;
     if (target.isMalformed) {
       // This handles elements with parser errors.
       return new StaticAccess.unresolved(target);
     }
     if (target.isStatic) {
       if (target.isGetter) {
         return new StaticAccess.staticGetter(target);
       } else if (target.isSetter) {
         return new StaticAccess.staticSetter(target);
       } else if (target.isField) {
         if (target.isFinal || target.isConst) {
           return new StaticAccess.finalStaticField(target);
         } else {
           return new StaticAccess.staticField(target);
         }
       } else {
-        assert(invariant(node, target.isFunction,
-            message: "Unexpected static target '$target'."));
+        assert(target.isFunction,
+            failedAt(node, "Unexpected static target '$target'."));
         return new StaticAccess.staticMethod(target);
       }
     } else {
-      assert(invariant(node, target.isTopLevel,
-          message: "Unexpected statically resolved target '$target'."));
+      assert(target.isTopLevel,
+          failedAt(node, "Unexpected statically resolved target '$target'."));
       if (target.isGetter) {
         return new StaticAccess.topLevelGetter(target);
       } else if (target.isSetter) {
         return new StaticAccess.topLevelSetter(target);
       } else if (target.isField) {
         if (target.isFinal) {
           return new StaticAccess.finalTopLevelField(target);
         } else {
           return new StaticAccess.topLevelField(target);
         }
       } else {
-        assert(invariant(node, target.isFunction,
-            message: "Unexpected top level target '$target'."));
+        assert(target.isFunction,
+            failedAt(node, "Unexpected top level target '$target'."));
         return new StaticAccess.topLevelMethod(target);
       }
     }
   }
 
   /// Compute the [AccessSemantics] for accessing the name of [selector] on the
   /// super class.
   ///
   /// If no matching super member is found and error is reported and
   /// `noSuchMethod` on `super` is registered. Furthermore, if [alternateName]
@@ skipping 276 matching lines @@
     }
     if (semantics != null) {
       registry.registerSendStructure(
           node, new UnaryStructure(semantics, operator));
     }
     return result;
   }
 
   /// Handle a not expression, like `!a`.
   ResolutionResult handleNot(Send node, UnaryOperator operator) {
-    assert(invariant(node, operator.kind == UnaryOperatorKind.NOT));
+    assert(operator.kind == UnaryOperatorKind.NOT, failedAt(node));
 
     Node expression = node.receiver;
     ResolutionResult result = visitExpression(expression);
     registry.registerSendStructure(node, const NotStructure());
 
     if (result.isConstant) {
       ConstantExpression expressionConstant = result.constant;
       if (expressionConstant.getKnownType(commonElements) ==
           commonElements.boolType) {
         // TODO(johnniwinther): Handle potentially invalid constant expressions.
@@ skipping 238 matching lines @@
               node, "Unexpected binary operator '${operator}'.");
           break;
       }
       registry.registerSendStructure(node, sendStructure);
     }
     return result;
   }
 
   /// Handle an invocation of an expression, like `(){}()` or `(foo)()`.
   ResolutionResult handleExpressionInvoke(Send node) {
-    assert(
-        invariant(node, node.isCall, message: "Unexpected expression: $node"));
+    assert(node.isCall, failedAt(node, "Unexpected expression: $node"));
     Node expression = node.selector;
     visitExpression(expression);
     CallStructure callStructure =
         resolveArguments(node.argumentsNode).callStructure;
     Selector selector = callStructure.callSelector;
     // TODO(23998): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
     registry.registerDynamicUse(new DynamicUse(selector, null));
     registry.registerSendStructure(
@@ skipping 149 matching lines @@
     } else if (node.arguments.isEmpty) {
       UnaryOperator operator = UnaryOperator.parse(operatorText);
       if (operator == null) {
         return handleUnresolvedUnary(node, operatorText);
       } else {
         switch (operator.kind) {
           case UnaryOperatorKind.NOT:
             return handleNot(node, operator);
           case UnaryOperatorKind.COMPLEMENT:
           case UnaryOperatorKind.NEGATE:
-            assert(invariant(node, operator.isUserDefinable,
-                message: "Unexpected unary operator '${operator}'."));
+            assert(operator.isUserDefinable,
+                failedAt(node, "Unexpected unary operator '${operator}'."));
             return handleUserDefinableUnary(node, operator);
         }
       }
     } else {
       BinaryOperator operator = BinaryOperator.parse(operatorText);
       if (operator == null) {
         return handleUnresolvedBinary(node, operatorText);
       } else {
         switch (operator.kind) {
           case BinaryOperatorKind.LOGICAL_AND:
@@ skipping 462 matching lines @@
       return new PrefixResult(null, cls);
     } else {
       // `C` or `C()` where 'C' is a class.
       return handleClassTypeLiteralAccess(node, name, cls);
     }
   }
 
   /// Compute a [DeferredPrefixStructure] for [node].
   ResolutionResult handleDeferredAccess(
       Send node, PrefixElement prefix, ResolutionResult result) {
-    assert(invariant(node, prefix.isDeferred,
-        message: "Prefix $prefix is not deferred."));
+    assert(
+        prefix.isDeferred, failedAt(node, "Prefix $prefix is not deferred."));
     SendStructure sendStructure = registry.getSendStructure(node);
-    assert(invariant(node, sendStructure != null,
-        message: "No SendStructure for $node."));
+    assert(
+        sendStructure != null, failedAt(node, "No SendStructure for $node."));
     registry.registerSendStructure(
         node, new DeferredPrefixStructure(prefix, sendStructure));
     if (result.isConstant) {
       ConstantExpression constant =
           new DeferredConstantExpression(result.constant, prefix);
       registry.setConstant(node, constant);
       result = new ConstantResult(node, constant);
     }
     return result;
   }
@@ skipping 126 matching lines @@
       Send node, Name name, AccessSemantics semantics) {
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       selector = new Selector.call(name, callStructure);
       registry.registerDynamicUse(new DynamicUse(selector, null));
       sendStructure = new InvokeStructure(semantics, selector);
     } else {
-      assert(invariant(node, node.isPropertyAccess));
+      assert(node.isPropertyAccess, failedAt(node));
       selector = new Selector.getter(name);
       registry.registerDynamicUse(new DynamicUse(selector, null));
       sendStructure = new GetStructure(semantics);
     }
     registry.registerSendStructure(node, sendStructure);
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     return const NoneResult();
   }
@@ skipping 123 matching lines @@
       Send node, Name name, AccessSemantics semantics) {
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       selector = new Selector.call(name, callStructure);
       registry.registerDynamicUse(new DynamicUse(selector, null));
       sendStructure = new InvokeStructure(semantics, selector);
     } else {
-      assert(invariant(node, node.isPropertyAccess));
+      assert(node.isPropertyAccess, failedAt(node));
       selector = new Selector.getter(name);
       registry.registerDynamicUse(new DynamicUse(selector, null));
       sendStructure = new GetStructure(semantics);
     }
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     registry.useElement(node, semantics.element);
     registry.registerSendStructure(node, sendStructure);
     return const NoneResult();
@@ skipping 144 matching lines @@
       semantics = new StaticAccess.finalParameter(element);
     } else if (element.isVariable) {
       if (element.isFinal || element.isConst) {
         error = reportAndCreateErroneousElement(node.selector, name.text,
             MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
         semantics = new StaticAccess.finalLocalVariable(element);
       } else {
         semantics = new StaticAccess.localVariable(element);
       }
     } else {
-      assert(invariant(node, element.isFunction,
-          message: "Unexpected local $element."));
+      assert(element.isFunction, failedAt(node, "Unexpected local $element."));
       error = reportAndCreateErroneousElement(
           node.selector, name.text, MessageKind.ASSIGNING_METHOD, const {});
       semantics = new StaticAccess.localFunction(element);
     }
     if (isPotentiallyMutableTarget(element)) {
       registry.registerPotentialMutation(element, node);
       if (enclosingElement != element.enclosingElement) {
         registry.registerPotentialMutationInClosure(element, node);
       }
       for (Node scope in promotionScope) {
@@ skipping 230 matching lines @@
         registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a function.
           registry.registerStaticUse(new StaticUse.staticTearOff(method));
         }
         semantics = member.isTopLevel
             ? new StaticAccess.topLevelMethod(method)
             : new StaticAccess.staticMethod(method);
       } else {
         // `a = b`, `a++` or `a += b` where `a` is a field.
-        assert(invariant(node, member.isField,
-            message: "Unexpected element: $member."));
+        assert(member.isField, failedAt(node, "Unexpected element: $member."));
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a field.
           registry.registerStaticUse(new StaticUse.staticGet(member));
         }
         if (member.isFinal || member.isConst) {
           reportAndCreateErroneousElement(node.selector, name.text,
               MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           semantics = member.isTopLevel
               ? new StaticAccess.finalTopLevelField(member)
               : new StaticAccess.finalStaticField(member);
         } else {
           registry.registerStaticUse(new StaticUse.staticSet(member));
           semantics = member.isTopLevel
               ? new StaticAccess.topLevelField(member)
               : new StaticAccess.staticField(member);
         }
       }
     }
     return handleUpdate(node, name, semantics);
   }
 
   /// Handle access to resolved [element].
   ResolutionResult handleResolvedSend(Send node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousSend(node, name, element);
     }
     if (element.isMalformed) {
       // This handles elements with parser errors.
-      assert(invariant(node, element is! ErroneousElement,
-          message: "Unexpected erroneous element $element."));
+      assert(element is! ErroneousElement,
+          failedAt(node, "Unexpected erroneous element $element."));
       return handleErroneousAccess(
           node, name, new StaticAccess.unresolved(element));
     }
     if (element.isInstanceMember) {
       if (inInstanceContext) {
         // TODO(johnniwinther): Maybe use the found [element].
         return handleThisPropertyAccess(node, name);
       } else {
         return handleErroneousAccess(
             node, name, reportStaticInstanceAccess(node, name));
@@ skipping 18 matching lines @@
   }
 
   /// Handle update to resolved [element].
   ResolutionResult handleResolvedSendSet(
       SendSet node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousUpdate(node, name, element);
     }
     if (element.isMalformed) {
       // This handles elements with parser errors..
-      assert(invariant(node, element is! ErroneousElement,
-          message: "Unexpected erroneous element $element."));
+      assert(element is! ErroneousElement,
+          failedAt(node, "Unexpected erroneous element $element."));
       return handleUpdate(node, name, new StaticAccess.unresolved(element));
     }
     if (element.isInstanceMember) {
       if (inInstanceContext) {
         return handleThisPropertyUpdate(node, name, element);
       } else {
         return handleUpdate(node, name, reportStaticInstanceAccess(node, name));
       }
     }
     if (element.isClass) {
@@ skipping 1108 matching lines @@
             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS, {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant = resolver.constantCompiler
         .compileNode(node, registry.mapping, enforceConst: enforceConst);
 
     if (constant == null) {
-      assert(invariant(node, reporter.hasReportedError));
+      assert(reporter.hasReportedError, failedAt(node));
       return;
     }
 
     ConstantValue value = resolution.constants.getConstantValue(constant);
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
   }
 
   void analyzeConstantDeferred(Node node,
@@ skipping 303 matching lines @@
     if (loopVariableSelector != null) {
       registry.setSelector(declaration, loopVariableSelector);
       if (loopVariable == null || loopVariable.isInstanceMember) {
         registry.registerDynamicUse(new DynamicUse(loopVariableSelector, null));
       } else if (loopVariable.isStatic || loopVariable.isTopLevel) {
         MemberElement member = loopVariable.declaration;
         registry.registerStaticUse(new StaticUse.staticSet(member));
       }
     } else {
       // The selector may only be null if we reported an error.
-      assert(invariant(declaration, reporter.hasReportedError));
+      assert(reporter.hasReportedError, failedAt(declaration));
     }
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
       registry.setForInVariable(node, loopVariable);
     }
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
@@ skipping 140 matching lines @@
         cases = cases.tail) {
       SwitchCase switchCase = cases.head;
 
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         // Analyze the constant.
         ConstantExpression constant =
             registry.getConstant(caseMatch.expression);
-        assert(invariant(node, constant != null,
-            message: 'No constant computed for $node'));
+        assert(
+            constant != null, failedAt(node, 'No constant computed for $node'));
 
         ConstantValue value = resolution.constants.getConstantValue(constant);
         ResolutionDartType caseType =
             value.getType(commonElements); //typeOfConstant(value);
 
         if (firstCaseType == null) {
           firstCase = caseMatch;
           firstCaseType = caseType;
 
           // We only report the bad type on the first class element. All others
@@ skipping 243 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }