Use failedAt in more places (ssa)

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 69 matching lines @@
           work.registry.worldImpact
               .registerConstantUse(new ConstantUse.init(initialValue));
           // We don't need to generate code for static or top-level
           // variables. For instance variables, we may need to generate
           // the checked setter.
           if (field.isStatic || field.isTopLevel) {
             /// No code is created for this field.
             return true;
           }
         } else {
-          assert(invariant(
-              field,
+          assert(
               field.isInstanceMember ||
                   constant.isImplicit ||
                   constant.isPotential,
-              message: "Constant expression without value: "
+              failedAt(
+                  field,
+                  "Constant expression without value: "
                   "${constant.toStructuredText()}."));
         }
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         work.registry.worldImpact.registerStaticUse(new StaticUse.staticInvoke(
             backend.commonElements.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
@@ skipping 212 matching lines @@
   ///
   /// Note: this helper is used selectively. When we know that we are in a
   /// context were we don't expect to see a constructor body element, we
   /// directly fetch the data from the global inference results.
   GlobalTypeInferenceElementResult _resultOf(MemberElement element) =>
       globalInferenceResults.resultOfMember(
           element is ConstructorBodyElementX ? element.constructor : element);
 
   /// Build the graph for [target].
   HGraph build() {
-    assert(invariant(target, target.isImplementation));
+    assert(target.isImplementation, failedAt(target));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
       result = buildFactory(resolvedAst);
     } else if (target.isGenerativeConstructorBody ||
         target.isFactoryConstructor ||
         target.isFunction ||
         target.isGetter ||
@@ skipping 18 matching lines @@
   }
 
   /**
    * Returns a complete argument list for a call of [function].
    */
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
-    assert(invariant(function, function.isImplementation));
+    assert(function.isImplementation, failedAt(function));
     assert(providedArguments != null);
 
     bool isInstanceMember = function.isInstanceMember;
     // For static calls, [providedArguments] is complete, default arguments
     // have been included if necessary, see [makeStaticArgumentList].
     if (!isInstanceMember ||
         currentNode == null || // In erroneous code, currentNode can be null.
         providedArgumentsKnownToBeComplete(currentNode) ||
         function.isGenerativeConstructorBody ||
         selector.isGetter) {
@@ skipping 100 matching lines @@
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         inlineCache.canInline(declaration, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       if (options.disableInlining) return false;
 
-      assert(invariant(
-          currentNode != null ? currentNode : function,
+      assert(
           selector != null ||
               Elements.isStaticOrTopLevel(function) ||
               function.isGenerativeConstructorBody,
-          message: "Missing selector for inlining of $function."));
+          failedAt(currentNode ?? function,
+              "Missing selector for inlining of $function."));
       if (selector != null) {
         if (!selector.applies(function)) return false;
         if (mask != null && !mask.canHit(function, selector, closedWorld)) {
           return false;
         }
       }
 
       if (nativeData.isJsInteropMember(function)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
@@ skipping 173 matching lines @@
   /**
    * Return null so it is simple to remove the optional parameters completely
    * from interop methods to match JavaScript semantics for omitted arguments.
    */
   HInstruction handleConstantForOptionalParameterJsInterop(Element parameter) =>
       null;
 
   HInstruction handleConstantForOptionalParameter(ParameterElement parameter) {
     ConstantValue constantValue =
         constants.getConstantValue(parameter.constant);
-    assert(invariant(parameter, constantValue != null,
-        message: 'No constant computed for $parameter'));
+    assert(constantValue != null,
+        failedAt(parameter, 'No constant computed for $parameter'));
     return graph.addConstant(constantValue, closedWorld);
   }
 
   ClassElement get currentNonClosureClass {
     ClassElement cls = sourceElement.enclosingClass;
     if (cls != null && cls.isClosure) {
       dynamic closureClass = cls;
       // ignore: UNDEFINED_GETTER
       return closureClass.methodElement.enclosingClass;
     } else {
@@ skipping 11 matching lines @@
       <ResolutionDartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
   ResolutionDartType returnType;
 
   ConstantValue getConstantForNode(ast.Node node) {
     ConstantValue constantValue =
         constants.getConstantValueForNode(node, elements);
-    assert(invariant(node, constantValue != null,
-        message: 'No constant computed for $node'));
+    assert(constantValue != null,
+        failedAt(node, 'No constant computed for $node'));
     return constantValue;
   }
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), closedWorld);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(MethodElement functionElement) {
-    assert(invariant(functionElement, functionElement.isImplementation));
+    assert(functionElement.isImplementation, failedAt(functionElement));
     graph.calledInLoop =
         closedWorld.isCalledInLoop(functionElement.declaration);
     ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     if (nativeData.isJsInteropMember(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
       closeAndGotoExit(new HReturn(
           value, sourceInformationBuilder.buildReturn(functionElement.node)));
       return closeFunction();
     }
-    assert(invariant(functionElement, !function.modifiers.isExternal));
+    assert(!function.modifiers.isExternal, failedAt(functionElement));
 
     // If [functionElement] is `operator==` we explicitly add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             node: function,
             visitCondition: () {
               HParameterValue parameter = parameters.values.first;
@@ skipping 48 matching lines @@
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
     HInstruction value =
         typeBuilder.potentiallyCheckOrTrustType(parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(FieldElement variable) {
-    assert(invariant(variable, resolvedAst.element == variable,
-        message: "Unexpected variable $variable for $resolvedAst."));
+    assert(resolvedAst.element == variable,
+        failedAt(variable, "Unexpected variable $variable for $resolvedAst."));
     inLazyInitializerExpression = true;
     ast.VariableDefinitions node = resolvedAst.node;
     ast.Node initializer = resolvedAst.body;
-    assert(invariant(variable, initializer != null,
-        message: "Non-constant variable $variable has no initializer."));
+    assert(
+        initializer != null,
+        failedAt(
+            variable, "Non-constant variable $variable has no initializer."));
     openFunction(variable, node);
     visit(initializer);
     HInstruction value = pop();
     value = typeBuilder.potentiallyCheckOrTrustType(value, variable.type);
     // In the case of multiple declarations (and some definitions) on the same
     // line, the source pointer needs to point to the right initialized
     // variable. So find the specific initialized variable we are referring to.
     ast.Node sourceInfoNode = initializer;
     for (var definition in node.definitions) {
       if (definition is ast.SendSet &&
@@ skipping 202 matching lines @@
       localsHandler.closureData = oldClosureData;
       resolvedAst = oldResolvedAst;
       elementInferenceResults = oldElementInferenceResults;
     });
   }
 
   void buildInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
-    assert(invariant(
-        constructor, resolvedAst.element == constructor.declaration,
-        message: "Expected ResolvedAst for $constructor, found $resolvedAst"));
+    assert(
+        resolvedAst.element == constructor.declaration,
+        failedAt(constructor,
+            "Expected ResolvedAst for $constructor, found $resolvedAst"));
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       buildParsedInitializers(
           constructor, constructorResolvedAsts, fieldValues);
     } else {
       buildSynthesizedConstructorInitializers(
           constructor, constructorResolvedAsts, fieldValues);
     }
   }
 
   void buildSynthesizedConstructorInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
-    assert(invariant(constructor, constructor.isSynthesized,
-        message: "Unexpected unsynthesized constructor: $constructor"));
+    assert(
+        constructor.isSynthesized,
+        failedAt(
+            constructor, "Unexpected unsynthesized constructor: $constructor"));
     List<HInstruction> arguments = <HInstruction>[];
     HInstruction compileArgument(ParameterElement parameter) {
       return localsHandler.readLocal(parameter);
     }
 
     ConstructorElement target = constructor.definingConstructor.implementation;
     bool match = !target.isMalformed &&
         Elements.addForwardingElementArgumentsToList<HInstruction>(
             constructor,
             arguments,
@@ skipping 23 matching lines @@
    * with sub constructors having a lower index than super constructors.
    *
    * Invariant: The [constructor] and elements in [constructors] must all be
    * implementation elements.
    */
   void buildParsedInitializers(
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
     assert(
-        invariant(constructor, resolvedAst.element == constructor.declaration));
-    assert(invariant(constructor, constructor.isImplementation));
-    assert(invariant(constructor, !constructor.isSynthesized,
-        message: "Unexpected synthesized constructor: $constructor"));
+        resolvedAst.element == constructor.declaration, failedAt(constructor));
+    assert(constructor.isImplementation, failedAt(constructor));
+    assert(
+        !constructor.isSynthesized,
+        failedAt(
+            constructor, "Unexpected synthesized constructor: $constructor"));
     ast.FunctionExpression functionNode = resolvedAst.node;
 
     bool foundSuperOrRedirect = false;
     if (functionNode.initializers != null) {
       Link<ast.Node> initializers = functionNode.initializers.nodes;
       for (Link<ast.Node> link = initializers;
           !link.isEmpty;
           link = link.tail) {
         assert(link.head is ast.Send);
         if (link.head is! ast.SendSet) {
@@ skipping 53 matching lines @@
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(
       ClassElement classElement, Map<Element, HInstruction> fieldValues) {
-    assert(invariant(classElement, classElement.isImplementation));
+    assert(classElement.isImplementation, failedAt(classElement));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       if (compiler.elementHasCompileTimeError(member)) return;
       reporter.withCurrentElement(member, () {
         ResolvedAst fieldResolvedAst = member.resolvedAst;
         ast.Expression initializer = fieldResolvedAst.body;
         if (initializer == null) {
           // Unassigned fields of native classes are not initialized to
           // prevent overwriting pre-initialized native properties.
           if (!nativeData.isNativeOrExtendsNative(classElement)) {
@@ skipping 74 matching lines @@
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     List<FieldEntity> fields = <FieldEntity>[];
 
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       HInstruction value = fieldValues[member];
       if (value == null) {
         // Uninitialized native fields are pre-initialized by the native
         // implementation.
-        assert(invariant(
-            member, isNativeUpgradeFactory || reporter.hasReportedError));
+        assert(isNativeUpgradeFactory || reporter.hasReportedError,
+            failedAt(member));
       } else {
         fields.add(member);
         ResolutionDartType type = localsHandler.substInContext(member.type);
         constructorArguments
             .add(typeBuilder.potentiallyCheckOrTrustType(value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
     ResolutionInterfaceType type = classElement.thisType;
     TypeMask ssaType =
@@ skipping 127 matching lines @@
       return null;
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be the implementation element.
    */
   void openFunction(MemberElement element, ast.Node node) {
-    assert(invariant(element, element.isImplementation));
+    assert(element.isImplementation, failedAt(element));
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(element, node,
         isGenerativeConstructorBody: element.isGenerativeConstructorBody);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
@@ skipping 676 matching lines @@
         sourceInformation: sourceInformation);
   }
 
   /// Generate read access of an unresolved static or top level entity.
   void generateStaticUnresolvedGet(ast.Send node, Element element) {
     if (element is ErroneousElement) {
       // An erroneous element indicates an unresolved static getter.
       handleInvalidStaticGet(node, element);
     } else {
       // This happens when [element] has parse errors.
-      assert(invariant(node, element == null || element.isMalformed));
+      assert(element == null || element.isMalformed, failedAt(node));
       // TODO(ahe): Do something like the above, that is, emit a runtime
       // error.
       stack.add(graph.addConstantNull(closedWorld));
     }
   }
 
   /// Read a static or top level [field] of constant value.
   void generateStaticConstGet(ast.Send node, FieldElement field,
       ConstantExpression constant, SourceInformation sourceInformation) {
     ConstantValue value = constants.getConstantValue(constant);
@@ skipping 172 matching lines @@
   }
 
   @override
   void visitTopLevelGetterGet(ast.Send node, FunctionElement getter, _) {
     generateStaticGetterGet(node, getter);
   }
 
   void generateInstanceSetterWithCompiledReceiver(
       ast.Send send, HInstruction receiver, HInstruction value,
       {Selector selector, TypeMask mask, ast.Node location}) {
-    assert(invariant(send == null ? location : send,
+    assert(
         send == null || Elements.isInstanceSend(send, elements),
-        message: "Unexpected instance setter"
+        failedAt(
+            send ?? location,
+            "Unexpected instance setter"
             "${send != null ? " element: ${elements[send]}" : ""}"));
     if (selector == null) {
       assert(send != null);
       selector = elements.getSelector(send);
       mask ??= elementInferenceResults.typeOfSend(send);
     }
     if (location == null) {
       assert(send != null);
       location = send;
     }
@@ skipping 14 matching lines @@
         argumentValues: arguments);
   }
 
   void generateNonInstanceSetter(
       ast.SendSet send, Element element, HInstruction value,
       {ast.Node location}) {
     if (location == null) {
       assert(send != null);
       location = send;
     }
-    assert(invariant(
-        location, send == null || !Elements.isInstanceSend(send, elements),
-        message: "Unexpected non instance setter: $element."));
+    assert(send == null || !Elements.isInstanceSend(send, elements),
+        failedAt(location, "Unexpected non instance setter: $element."));
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter) {
         pushInvokeStatic(location, element, <HInstruction>[value]);
         pop();
       } else {
         FieldElement field = element;
         value = typeBuilder.potentiallyCheckOrTrustType(value, field.type);
         addWithPosition(new HStaticStore(field, value), location);
       }
       stack.add(value);
@@ skipping 170 matching lines @@
   }
 
   /**
    * Returns a list with the evaluated [arguments] in the normalized order.
    *
    * Precondition: `this.applies(element, world)`.
    * Invariant: [element] must be an implementation element.
    */
   List<HInstruction> makeStaticArgumentList(CallStructure callStructure,
       Link<ast.Node> arguments, MethodElement element) {
-    assert(invariant(element, element.isDeclaration));
+    assert(element.isDeclaration, failedAt(element));
 
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
     return Elements.makeArgumentsList<HInstruction>(
         callStructure,
         arguments,
         element.implementation,
@@ skipping 108 matching lines @@
   void handleForeignJs(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     // Don't visit the first argument, which is the type, and the second
     // argument, which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       // We should not get here because the call should be compiled to NSM.
       reporter.internalError(
           node.argumentsNode, 'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
-    assert(invariant(node, nativeBehavior != null,
-        message: "No NativeBehavior for $node"));
+    assert(
+        nativeBehavior != null, failedAt(node, "No NativeBehavior for $node"));
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
       reporter.reportErrorMessage(node, MessageKind.GENERIC, {
         'text': 'Mismatch between number of placeholders'
             ' and number of arguments.'
       });
       // Result expected on stack.
@@ skipping 141 matching lines @@
 
     js.Template template = emitter.builtinTemplateFor(JsBuiltin.values[index]);
 
     List<HInstruction> compiledArguments = <HInstruction>[];
     for (int i = 2; i < arguments.length; i++) {
       visit(arguments[i]);
       compiledArguments.add(pop());
     }
 
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
-    assert(invariant(node, nativeBehavior != null,
-        message: "No NativeBehavior for $node"));
+    assert(
+        nativeBehavior != null, failedAt(node, "No NativeBehavior for $node"));
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
 
     push(new HForeignCode(template, ssaType, compiledArguments,
         nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsEmbeddedGlobal(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
@@ skipping 24 matching lines @@
             'to JS_EMBEDDED_GLOBAL.'
       });
       return;
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue;
     js.Template expr = js.js.expressionTemplateYielding(
         emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
-    assert(invariant(node, nativeBehavior != null,
-        message: "No NativeBehavior for $node"));
+    assert(
+        nativeBehavior != null, failedAt(node, "No NativeBehavior for $node"));
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const [],
         nativeBehavior: nativeBehavior));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
@@ skipping 132 matching lines @@
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(node);
     } else {
       reporter.internalError(node, "Unknown foreign: ${element}");
     }
   }
 
   generateDeferredLoaderGet(ast.Send node, FunctionElement deferredLoader,
       SourceInformation sourceInformation) {
     // Until now we only handle these as getters.
-    invariant(node, deferredLoader.isDeferredLoaderGetter);
+    if (!deferredLoader.isDeferredLoaderGetter) {
+      failedAt(node);
+    }
     FunctionEntity loadFunction = commonElements.loadLibraryWrapper;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId = deferredLoadTask.getImportDeferName(node, prefixElement);
     var inputs = [graph.addConstantString(loadId, closedWorld)];
     push(new HInvokeStatic(loadFunction, inputs, commonMasks.nonNullType,
         targetCanThrow: false)
       ..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(
@@ skipping 54 matching lines @@
     push(buildInvokeSuper(Selectors.noSuchMethod_, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
   void generateSuperInvoke(ast.Send node, MethodElement method,
       SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
     MethodElement implementation = method.implementation;
-    assert(invariant(node, selector.applies(implementation),
-        message: "$selector does not apply to ${implementation}"));
+    assert(selector.applies(implementation),
+        failedAt(node, "$selector does not apply to ${implementation}"));
     List<HInstruction> inputs =
         makeStaticArgumentList(selector.callStructure, node.arguments, method);
     push(buildInvokeSuper(selector, method, inputs, sourceInformation));
   }
 
   /// Access the value from the super [element].
   void handleSuperGet(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
@@ skipping 178 matching lines @@
     // Set the runtime type information on the object.
     MethodElement typeInfoSetterElement = commonElements.setRuntimeTypeInfo;
     pushInvokeStatic(
         null, typeInfoSetterElement, <HInstruction>[newObject, typeInfo],
         typeMask: commonMasks.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // 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();
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
@@ skipping 47 matching lines @@
     ConstructorElement constructorImplementation = constructor.implementation;
     constructor = constructorImplementation.effectiveTarget;
 
     final bool isSymbolConstructor =
         closedWorld.commonElements.isSymbolConstructor(constructorDeclaration);
     final bool isJSArrayTypedConstructor = constructorDeclaration ==
         closedWorld.commonElements.jsArrayTypedConstructor;
 
     if (isSymbolConstructor) {
       constructor = commonElements.symbolValidatedConstructor;
-      assert(invariant(send, constructor != null,
-          message: 'Constructor Symbol.validated is missing'));
+      assert(constructor != null,
+          failedAt(send, 'Constructor Symbol.validated is missing'));
       callStructure =
           commonElements.symbolValidatedConstructorSelector.callStructure;
-      assert(invariant(send, callStructure != null,
-          message: 'Constructor Symbol.validated is missing'));
+      assert(callStructure != null,
+          failedAt(send, 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = constructorDeclaration.isRedirectingFactory;
     if (!constructorDeclaration.isCyclicRedirection) {
       // Insert a check for every deferred redirection on the path to the
       // final target.
       ConstructorElement target = constructorDeclaration;
       while (target.isRedirectingFactory) {
         if (constructorDeclaration.redirectionDeferredPrefix != null) {
           generateIsDeferredLoadedCheckIfNeeded(
@@ skipping 2654 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(errorNode, false,
-          message: 'Continue cannot target a switch.'));
+      assert(false, failedAt(errorNode, '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 732 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }