Use failedAt in more places

pkg/compiler/lib/src/inferrer/inferrer_engine.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 379 matching lines @@
         trace(elements, new ClosureTracerVisitor(elements, info, this));
       } else if (info is CallSiteTypeInformation) {
         if (info is StaticCallSiteTypeInformation &&
             info.selector != null &&
             info.selector.isCall) {
           // This is a constructor call to a class with a call method. So we
           // need to trace the call method here.
           assert(info.calledElement.isGenerativeConstructor);
           ClassElement cls = info.calledElement.enclosingClass;
           FunctionElement callMethod = cls.lookupMember(Identifiers.call);
-          assert(invariant(cls, callMethod != null));
+          assert(callMethod != null, failedAt(cls));
           Iterable<FunctionElement> elements = [callMethod];
           trace(elements, new ClosureTracerVisitor(elements, info, this));
         } else {
           // We only are interested in functions here, as other targets
           // of this closure call are not a root to trace but an intermediate
           // for some other function.
           Iterable<FunctionElement> elements = new List<FunctionElement>.from(
               info.callees.where((e) => e.isFunction));
           trace(elements, new ClosureTracerVisitor(elements, info, this));
         }
@@ skipping 108 matching lines @@
                 } else {
                   // Although we might find a better type, we have to keep
                   // the old type around to ensure that we get a complete view
                   // of the type graph and do not drop any flow edges.
                   TypeMask refinedType = computeTypeMask(closedWorld, value);
                   assert(TypeMask.assertIsNormalized(refinedType, closedWorld));
                   type = new NarrowTypeInformation(type, refinedType);
                   types.allocatedTypes.add(type);
                 }
               } else {
-                assert(invariant(
-                    fieldElement,
+                assert(
                     fieldElement.isInstanceMember ||
                         constant.isImplicit ||
                         constant.isPotential,
-                    message: "Constant expression without value: "
+                    failedAt(
+                        fieldElement,
+                        "Constant expression without value: "
                         "${constant.toStructuredText()}."));
               }
             }
           }
           recordType(element, type);
         } else if (!element.isInstanceMember) {
           recordType(element, types.nullType);
         }
       } else if (initializer == null) {
         // Only update types of static fields if there is no
@@ skipping 433 matching lines @@
   // to get the same results for [ListTracer] compared to the
   // [SimpleTypesInferrer].
   Iterable<ResolvedAst> sortResolvedAsts() {
     int max = 0;
     Map<int, Setlet<ResolvedAst>> methodSizes = <int, Setlet<ResolvedAst>>{};
     compiler.enqueuer.resolution.processedEntities
         .forEach((MemberElement element) {
       ResolvedAst resolvedAst = element.resolvedAst;
       element = element.implementation;
       if (element.impliesType) return;
-      assert(invariant(
-          element,
+      assert(
           element.isField ||
               element.isFunction ||
               element.isConstructor ||
               element.isGetter ||
               element.isSetter,
-          message: 'Unexpected element kind: ${element.kind}'));
+          failedAt(element, 'Unexpected element kind: ${element.kind}'));
       if (element.isAbstract) return;
       // Put the other operators in buckets by length, later to be added in
       // length order.
       int length = 0;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         TreeElementMapping mapping = resolvedAst.elements;
         length = mapping.getSelectorCount();
       }
       max = length > max ? length : max;
       Setlet<ResolvedAst> set =
@@ skipping 78 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }