Use failedAt in more places

pkg/compiler/lib/src/resolution/resolution.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;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 64 matching lines @@
   CommonElements get commonElements => resolution.commonElements;
   ParsingContext get parsingContext => resolution.parsingContext;
   CompilerOptions get options => resolution.options;
   ResolutionEnqueuer get enqueuer => resolution.enqueuer;
   OpenWorld get world => enqueuer.worldBuilder;
 
   ResolutionImpact resolve(Element element) {
     return measure(() {
       if (Elements.isMalformed(element)) {
         // TODO(johnniwinther): Add a predicate for this.
-        assert(invariant(element, element is! ErroneousElement,
-            message: "Element $element expected to have parse errors."));
+        assert(
+            element is! ErroneousElement,
+            failedAt(
+                element, "Element $element expected to have parse errors."));
         _ensureTreeElements(element);
         return const ResolutionImpact();
       }
 
       WorldImpact processMetadata([WorldImpact result]) {
         for (MetadataAnnotation metadata in element.implementation.metadata) {
           metadata.ensureResolved(resolution);
         }
         return result;
       }
@@ skipping 16 matching lines @@
         TypedefElement typdef = element;
         return processMetadata(resolveTypedef(typdef));
       }
 
       reporter.internalError(element, "resolve($element) not implemented.");
     });
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver, Node node,
       FunctionElement constructor, FunctionElement redirection) {
-    assert(invariant(node, constructor.isImplementation,
-        message: 'Redirecting constructors must be resolved on implementation '
+    assert(
+        constructor.isImplementation,
+        failedAt(
+            node,
+            'Redirecting constructors must be resolved on implementation '
             'elements.'));
     Setlet<FunctionElement> seen = new Setlet<FunctionElement>();
     seen.add(constructor);
     while (redirection != null) {
       // Ensure that we follow redirections through implementation elements.
       redirection = redirection.implementation;
       if (redirection.isError) {
         break;
       }
       if (seen.contains(redirection)) {
@@ skipping 151 matching lines @@
       }
 
       resolution.target.resolveNativeMember(element, registry.impactBuilder);
 
       return registry.impactBuilder;
     });
   }
 
   /// Returns `true` if [element] has been processed by the resolution enqueuer.
   bool _hasBeenProcessed(MemberElement element) {
-    assert(invariant(element, element == element.analyzableElement.declaration,
-        message: "Unexpected element $element"));
+    assert(element == element.analyzableElement.declaration,
+        failedAt(element, "Unexpected element $element"));
     return enqueuer.processedEntities.contains(element);
   }
 
   WorldImpact resolveMethodElement(FunctionElementX element) {
-    assert(invariant(element, element.isDeclaration));
+    assert(element.isDeclaration, failedAt(element));
     return reporter.withCurrentElement(element, () {
       if (_hasBeenProcessed(element)) {
         // TODO(karlklose): Remove the check for [isConstructor]. [elememts]
         // should never be non-null, not even for constructors.
-        assert(invariant(element, element.isConstructor,
-            message: 'Non-constructor element $element '
-                'has already been analyzed.'));
+        assert(
+            element.isConstructor,
+            failedAt(element,
+                'Non-constructor element $element has already been analyzed.'));
         return const ResolutionImpact();
       }
       if (element.isSynthesized) {
         if (element.isGenerativeConstructor) {
           ResolutionRegistry registry =
               new ResolutionRegistry(this.target, _ensureTreeElements(element));
           ConstructorElement constructor = element.asFunctionElement();
           ConstructorElement target = constructor.definingConstructor;
           // Ensure the signature of the synthesized element is
           // resolved. This is the only place where the resolver is
@@ skipping 54 matching lines @@
       }
       ResolverVisitor visitor = visitorFor(element);
       ResolutionRegistry registry = visitor.registry;
       // TODO(johnniwinther): Maybe remove this when placeholderCollector
       // migrates to the backend ast.
       registry.defineElement(element.definition, element);
       // TODO(johnniwinther): Share the resolved type between all variables
       // declared in the same declaration.
       if (tree.type != null) {
         ResolutionDartType type = visitor.resolveTypeAnnotation(tree.type);
-        assert(invariant(
-            element,
+        assert(
             element.variables.type == null ||
                 // Crude check but we have no equivalence relation that
                 // equates malformed types, like matching creations of type
                 // `Foo<Unresolved>`.
                 element.variables.type.toString() == type.toString(),
-            message: "Unexpected type computed for $element. "
+            failedAt(
+                element,
+                "Unexpected type computed for $element. "
                 "Was ${element.variables.type}, computed $type."));
         element.variables.type = type;
       } else if (element.variables.type == null) {
         // Only assign the dynamic type if the element has no known type. This
         // happens for enum fields where the type is known but is not in the
         // synthesized AST.
         element.variables.type = const ResolutionDynamicType();
       } else {
         registry.registerCheckedModeCheck(element.variables.type);
       }
@@ skipping 51 matching lines @@
       reporter.reportErrorMessage(annotation, MessageKind.VOID_NOT_ALLOWED);
     }
     return type;
   }
 
   ResolutionDartType _resolveReturnType(
       Element element, TypeAnnotation annotation) {
     if (annotation == null) return const ResolutionDynamicType();
     ResolutionDartType result =
         visitorFor(element).resolveTypeAnnotation(annotation);
-    assert(invariant(annotation, result != null,
-        message: "No type computed for $annotation."));
+    assert(result != null,
+        failedAt(annotation, "No type computed for $annotation."));
     if (result == null) {
       // TODO(karklose): warning.
       return const ResolutionDynamicType();
     }
     return result;
   }
 
   void resolveRedirectionChain(ConstructorElement constructor, Spannable node) {
     ConstructorElement target = constructor;
     ResolutionDartType targetType;
     List<ConstructorElement> seen = new List<ConstructorElement>();
     bool isMalformed = false;
     // Follow the chain of redirections and check for cycles.
     while (target.isRedirectingFactory) {
       if (target.hasEffectiveTarget) {
         // We found a constructor that already has been processed.
         // TODO(johnniwinther): Should `effectiveTargetType` be part of the
         // interface?
         targetType =
             target.computeEffectiveTargetType(target.enclosingClass.thisType);
-        assert(invariant(target, targetType != null,
-            message: 'Redirection target type has not been computed for '
-                '$target'));
+        assert(
+            targetType != null,
+            failedAt(target,
+                'Redirection target type has not been computed for $target'));
         target = target.effectiveTarget;
         break;
       }
 
       Element nextTarget = target.immediateRedirectionTarget;
 
       if (seen.contains(nextTarget)) {
         reporter.reportErrorMessage(
             node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
         targetType = target.enclosingClass.thisType;
@@ skipping 17 matching lines @@
     }
 
     // [target] is now the actual target of the redirections.  Run through
     // the constructors again and set their [redirectionTarget], so that we
     // do not have to run the loop for these constructors again. Furthermore,
     // compute [redirectionTargetType] for each factory by computing the
     // substitution of the target type with respect to the factory type.
     while (!seen.isEmpty) {
       ConstructorElementX factory = seen.removeLast();
       ResolvedAst resolvedAst = factory.resolvedAst;
-      assert(invariant(node, resolvedAst != null,
-          message: 'No ResolvedAst for $factory.'));
+      assert(
+          resolvedAst != null, failedAt(node, 'No ResolvedAst for $factory.'));
       RedirectingFactoryBody redirectionNode = resolvedAst.body;
       ResolutionDartType factoryType =
           resolvedAst.elements.getType(redirectionNode);
       if (!factoryType.isDynamic) {
         targetType = targetType.substByContext(factoryType);
       }
       factory.setEffectiveTarget(target, targetType, isMalformed: isMalformed);
     }
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(BaseClassElementX cls, Spannable from) {
     measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         reporter.reportErrorMessage(
             from, MessageKind.CYCLIC_CLASS_HIERARCHY, {'className': cls.name});
         cls.supertypeLoadState = STATE_DONE;
         cls.hasIncompleteHierarchy = true;
         ClassElement objectClass = commonElements.objectClass;
         cls.allSupertypesAndSelf = objectClass.allSupertypesAndSelf
             .extendClass(cls.computeType(resolution));
         cls.supertype = cls.allSupertypes.head;
-        assert(invariant(from, cls.supertype != null,
-            message: 'Missing supertype on cyclic class $cls.'));
+        assert(cls.supertype != null,
+            failedAt(from, 'Missing supertype on cyclic class $cls.'));
         cls.interfaces = const Link<ResolutionDartType>();
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       reporter.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls
             .parseNode(parsingContext)
             .accept(new ClassSupertypeResolver(resolution, cls));
         if (cls.supertypeLoadState != STATE_DONE) {
@@ skipping 229 matching lines @@
     // Show the user the problematic uses of 'super' in the mixin.
     List<DiagnosticMessage> infos = <DiagnosticMessage>[];
     for (SourceSpan use in superUses) {
       infos.add(
           reporter.createMessage(use, MessageKind.ILLEGAL_MIXIN_SUPER_USE));
     }
     reporter.reportError(error, infos);
   }
 
   void checkClassMembers(ClassElement cls) {
-    assert(invariant(cls, cls.isDeclaration));
+    assert(cls.isDeclaration, failedAt(cls));
     if (cls.isObject) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     List<Element> constConstructors = <Element>[];
     List<Element> nonFinalInstanceFields = <Element>[];
     cls.forEachMember((holder, dynamic member) {
       reporter.withCurrentElement(member, () {
         // Perform various checks as side effect of "computing" the type.
         member.computeType(resolution);
 
@@ skipping 255 matching lines @@
               annotation.resolutionState = STATE_STARTED;
 
               Node node = annotation.parseNode(parsingContext);
               Element annotatedElement = annotation.annotatedElement;
               AnalyzableElement context = annotatedElement.analyzableElement;
               ClassElement classElement = annotatedElement.enclosingClass;
               if (classElement != null) {
                 // The annotation is resolved in the scope of [classElement].
                 classElement.ensureResolved(resolution);
               }
-              assert(invariant(node, context != null,
-                  message: "No context found for metadata annotation "
+              assert(
+                  context != null,
+                  failedAt(
+                      node,
+                      "No context found for metadata annotation "
                       "on $annotatedElement."));
               ResolverVisitor visitor =
                   visitorFor(context, useEnclosingScope: true);
               ResolutionRegistry registry = visitor.registry;
               node.accept(visitor);
               // TODO(johnniwinther): Avoid passing the [TreeElements] to
               // [compileMetadata].
               ConstantExpression constant = constantCompiler.compileMetadata(
                   annotation, node, registry.mapping);
               switch (constant.kind) {
@@ skipping 47 matching lines @@
   }
   return element._treeElements;
 }
 
 abstract class AnalyzableElementX implements AnalyzableElement {
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
 
   TreeElements get treeElements {
-    assert(invariant(this, _treeElements != null,
-        message: "TreeElements have not been computed for $this."));
+    assert(_treeElements != null,
+        failedAt(this, "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }