Use failedAt in more places

[email protected]

BUG=

Review-Url: https://codereview.chromium.org/2905463003 .

Author: rakudrama

pkg/compiler/lib/src/resolution/class_hierarchy.dart

@@ -179,7 +179,7 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
     if (element.interfaces == null) {
       element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     } else {
-      assert(invariant(element, element.hasIncompleteHierarchy));
+      assert(element.hasIncompleteHierarchy, failedAt(element));
     }
     calculateAllSupertypes(element);
 
@@ -359,9 +359,9 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
-      assert(invariant(node, reporter.hasReportedError));
+      assert(reporter.hasReportedError, failedAt(node));
       supertype = mixinApplication.supertype;
-      assert(invariant(node, supertype.isObject));
+      assert(supertype.isObject, failedAt(node));
     } else {
       mixinApplication.supertype = supertype;
     }
@@ -385,7 +385,7 @@ class ClassResolverVisitor extends TypeDefinitionVisitor {
       mixinApplication.interfaces = interfaces;
     } else {
       assert(
-          invariant(mixinApplication, mixinApplication.hasIncompleteHierarchy));
+          mixinApplication.hasIncompleteHierarchy, failedAt(mixinApplication));
     }
 
     ClassElement superclass = supertype.element;

pkg/compiler/lib/src/resolution/class_members.dart

@@ -597,8 +597,8 @@ class InterfaceMembersCreator extends MembersCreator {
   Map<Name, Setlet<Member>> computeSuperInterfaceMembers(
       String name, Setlet<Name> names) {
     ResolutionInterfaceType supertype = cls.supertype;
-    assert(invariant(cls, supertype != null,
-        message: "Interface members computed for $cls."));
+    assert(supertype != null,
+        failedAt(cls, "Interface members computed for $cls."));
     ClassElement superclass = supertype.element;
 
     Map<Name, Setlet<Member>> inheritedInterfaceMembers =
@@ -721,9 +721,10 @@ class InterfaceMembersCreator extends MembersCreator {
             if (inherited.isMethod) {
               kind = MessageKind.INHERITED_METHOD;
             } else {
-              assert(invariant(cls, inherited.isGetter,
-                  message: 'Conflicting member is neither a method nor a '
-                      'getter.'));
+              assert(
+                  inherited.isGetter,
+                  failedAt(cls,
+                      'Conflicting member is neither a method nor a getter.'));
               if (inherited.isDeclaredByField) {
                 kind = MessageKind.INHERITED_IMPLICIT_GETTER;
               } else {
@@ -915,7 +916,7 @@ abstract class ClassMemberMixin implements ClassElement {
     MembersCreator creator = _prepareCreator(resolution);
     creator.computeAllMembers();
     computedMemberNames = null;
-    assert(invariant(this, areAllMembersComputed()));
+    assert(areAllMembersComputed(), failedAt(this));
   }
 
   bool areAllMembersComputed() {
@@ -931,20 +932,20 @@ abstract class ClassMemberMixin implements ClassElement {
   }
 
   Member lookupClassMember(Name name) {
-    assert(invariant(this, isMemberComputed(name.text),
-        message: "Member ${name} has not been computed for $this."));
+    assert(isMemberComputed(name.text),
+        failedAt(this, "Member ${name} has not been computed for $this."));
     return classMembers[name];
   }
 
   void forEachClassMember(f(Member member)) {
-    assert(invariant(this, areAllMembersComputed(),
-        message: "Members have not been fully computed for $this."));
+    assert(areAllMembersComputed(),
+        failedAt(this, "Members have not been fully computed for $this."));
     classMembers.forEach((_, member) => f(member));
   }
 
   MemberSignature lookupInterfaceMember(Name name) {
-    assert(invariant(this, isMemberComputed(name.text),
-        message: "Member ${name.text} has not been computed for $this."));
+    assert(isMemberComputed(name.text),
+        failedAt(this, "Member ${name.text} has not been computed for $this."));
     if (interfaceMembersAreClassMembers) {
       Member member = classMembers[name];
       if (member != null && member.isStatic) return null;
@@ -954,8 +955,8 @@ abstract class ClassMemberMixin implements ClassElement {
   }
 
   void forEachInterfaceMember(f(MemberSignature member)) {
-    assert(invariant(this, areAllMembersComputed(),
-        message: "Members have not been fully computed for $this."));
+    assert(areAllMembersComputed(),
+        failedAt(this, "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);

pkg/compiler/lib/src/resolution/constructors.dart

@@ -568,8 +568,8 @@ class ConstructorResolver extends CommonResolverVisitor<ConstructorResult> {
               ConstructorResultKind.GENERATIVE, prefix, constructor, type);
         }
       } else {
-        assert(invariant(diagnosticNode, constructor.isFactoryConstructor,
-            message: "Unexpected constructor $constructor."));
+        assert(constructor.isFactoryConstructor,
+            failedAt(diagnosticNode, "Unexpected constructor $constructor."));
         return new ConstructorResult(
             ConstructorResultKind.FACTORY, prefix, constructor, type);
       }
@@ -579,17 +579,17 @@ class ConstructorResolver extends CommonResolverVisitor<ConstructorResult> {
   ConstructorResult visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     ConstructorResult result = visit(selector);
-    assert(invariant(selector, result != null,
-        message: 'No result returned for $selector.'));
+    assert(result != null,
+        failedAt(selector, 'No result returned for $selector.'));
     return finishConstructorReference(result, node.send.selector, node);
   }
 
   /// Finishes resolution of a constructor reference and records the
   /// type of the constructed instance on [expression].
   ConstructorResult finishConstructorReference(
       ConstructorResult result, Node diagnosticNode, Node expression) {
-    assert(invariant(diagnosticNode, result != null,
-        message: 'No result returned for $diagnosticNode.'));
+    assert(result != null,
+        failedAt(diagnosticNode, 'No result returned for $diagnosticNode.'));
 
     if (result.kind != null) {
       resolver.registry.setType(expression, result.type);
@@ -642,11 +642,11 @@ class ConstructorResolver extends CommonResolverVisitor<ConstructorResult> {
 
   ConstructorResult visitSend(Send node) {
     ConstructorResult receiver = visit(node.receiver);
-    assert(invariant(node.receiver, receiver != null,
-        message: 'No result returned for $node.receiver.'));
+    assert(receiver != null,
+        failedAt(node.receiver, 'No result returned for $node.receiver.'));
     if (receiver.kind != null) {
-      assert(invariant(node, receiver.element.isMalformed,
-          message: "Unexpected prefix result: $receiver."));
+      assert(receiver.element.isMalformed,
+          failedAt(node, "Unexpected prefix result: $receiver."));
       // We have already found an error.
       return receiver;
     }

pkg/compiler/lib/src/resolution/member_impl.dart

@@ -143,17 +143,18 @@ class InheritedMember implements DeclaredMember {
   }
 
   DeclaredMember inheritFrom(ResolutionInterfaceType newInstance) {
-    assert(invariant(declaration.element, () {
+    assert(() {
       // Assert that if [instance] contains type variables, then these are
       // defined in the declaration of [newInstance] and will therefore be
       // substituted into the context of [newInstance] in the created member.
       ClassElement contextClass = Types.getClassContext(instance);
       return contextClass == null || contextClass == newInstance.element;
-    }, message: () {
-      return "Context mismatch: Context class "
-          "${Types.getClassContext(instance)} from $instance does match "
-          "the new instance $newInstance.";
-    }));
+    },
+        failedAt(
+            declaration.element,
+            "Context mismatch: Context class "
+            "${Types.getClassContext(instance)} from $instance does match "
+            "the new instance $newInstance."));
     return _newInheritedMember(newInstance);
   }