Use failedAt in more places (ssa)

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 457 matching lines @@
       arguments.positional[positionalIndex++].accept(this);
       builtArguments.add(pop());
     });
     if (!signature.optionalParametersAreNamed) {
       signature.forEachOptionalParameter((ParameterElement element) {
         if (positionalIndex < arguments.positional.length) {
           arguments.positional[positionalIndex++].accept(this);
           builtArguments.add(pop());
         } else {
           var constantValue = constants.getConstantValue(element.constant);
-          assert(invariant(element, constantValue != null,
-              message: 'No constant computed for $element'));
+          assert(constantValue != null,
+              failedAt(element, 'No constant computed for $element'));
           builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     } else {
       signature.orderedOptionalParameters.forEach((ParameterElement element) {
         var correspondingNamed = arguments.named.firstWhere(
             (named) => named.name == element.name,
             orElse: () => null);
         if (correspondingNamed != null) {
           correspondingNamed.value.accept(this);
           builtArguments.add(pop());
         } else {
           var constantValue = constants.getConstantValue(element.constant);
-          assert(invariant(element, constantValue != null,
-              message: 'No constant computed for $element'));
+          assert(constantValue != null,
+              failedAt(element, 'No constant computed for $element'));
           builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     }
 
     return builtArguments;
   }
 
   /// Creates localsHandler bindings for type parameters of a Supertype.
   void _bindSupertypeTypeParameters(ir.Supertype supertype) {
@@ skipping 589 matching lines @@
       HInstruction typeInfo, HInstruction newObject) {
     // Set the runtime type information on the object.
     FunctionEntity typeInfoSetterFn = _commonElements.setRuntimeTypeInfo;
     // TODO(efortuna): Insert source information in this static invocation.
     _pushStaticInvocation(typeInfoSetterFn, <HInstruction>[newObject, typeInfo],
         commonMasks.dynamicType);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
-    assert(invariant(CURRENT_ELEMENT_SPANNABLE,
+    assert(
         stack.last is HInvokeStatic || stack.last == newObject,
-        message: "Unexpected `stack.last`: Found ${stack.last}, "
+        failedAt(
+            CURRENT_ELEMENT_SPANNABLE,
+            "Unexpected `stack.last`: Found ${stack.last}, "
             "expected ${newObject} or an HInvokeStatic. "
             "State: typeInfo=$typeInfo, stack=$stack."));
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   @override
   void visitWhileStatement(ir.WhileStatement whileStatement) {
     assert(isReachable);
     HInstruction buildCondition() {
@@ skipping 610 matching lines @@
     // to create the phis in [joinBlock].
     // If we never jump to the join block, [caseHandlers] will stay empty, and
     // the join block is never added to the graph.
     HBasicBlock joinBlock = new HBasicBlock();
     List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseHandlers.add(locals);
     });
     jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
-      assert(invariant(
-          _elementMap.getSpannable(targetElement, switchStatement), false,
-          message: 'Continue cannot target a switch.'));
+      assert(
+          false,
+          failedAt(_elementMap.getSpannable(targetElement, switchStatement),
+              'Continue cannot target a switch.'));
     });
     if (!isAborted()) {
       current.close(new HGoto());
       lastOpenedBlock.addSuccessor(joinBlock);
       caseHandlers.add(localsHandler);
     }
     if (!hasDefault) {
       // Always create a default case, to avoid a critical edge in the
       // graph.
       HBasicBlock defaultCase = addNewBlock();
@@ skipping 807 matching lines @@
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
     String globalName = _foreignConstantStringArgument(
         invocation, 1, 'JS_EMBEDDED_GLOBAL', 'second ');
     js.Template expr = js.js.expressionTemplateYielding(
         emitter.generateEmbeddedGlobalAccess(globalName));
 
     native.NativeBehavior nativeBehavior =
         _elementMap.getNativeBehaviorForJsEmbeddedGlobalCall(invocation);
-    assert(invariant(_elementMap.getSpannable(targetElement, invocation),
+    assert(
         nativeBehavior != null,
-        message: "No NativeBehavior for $invocation"));
+        failedAt(_elementMap.getSpannable(targetElement, invocation),
+            "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
         _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const <HInstruction>[],
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsBuiltin(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       // Result expected on stack.
@@ skipping 22 matching lines @@
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     for (ir.Expression argument in arguments.skip(2)) {
       argument.accept(this);
       inputs.add(pop());
     }
 
     native.NativeBehavior nativeBehavior =
         _elementMap.getNativeBehaviorForJsBuiltinCall(invocation);
-    assert(invariant(_elementMap.getSpannable(targetElement, invocation),
+    assert(
         nativeBehavior != null,
-        message: "No NativeBehavior for $invocation"));
+        failedAt(_elementMap.getSpannable(targetElement, invocation),
+            "No NativeBehavior for $invocation"));
 
     TypeMask ssaType =
         _typeInferenceMap.typeFromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(template, ssaType, inputs,
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsGetFlag(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       stack.add(
@@ skipping 45 matching lines @@
 
   void handleForeignJs(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     native.NativeBehavior nativeBehavior =
         _elementMap.getNativeBehaviorForJsCall(invocation);
-    assert(invariant(_elementMap.getSpannable(targetElement, invocation),
+    assert(
         nativeBehavior != null,
-        message: "No NativeBehavior for $invocation"));
+        failedAt(_elementMap.getSpannable(targetElement, invocation),
+            "No NativeBehavior for $invocation"));
 
     List<HInstruction> inputs = <HInstruction>[];
     for (ir.Expression argument in invocation.arguments.positional.skip(2)) {
       argument.accept(this);
       inputs.add(pop());
     }
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
       reporter.reportErrorMessage(
           _elementMap.getSpannable(targetElement, invocation),
@@ skipping 720 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }