Use failedAt in more places (ssa)

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 139 matching lines @@
     _resolvedAst = _resolvedAstStack.removeLast();
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
   DiagnosticReporter get reporter => _compiler.reporter;
 
   // TODO(johnniwinther): Use the more precise functions below.
   Element getElement(ir.Node node) {
     Element result = _nodeToElement[node];
-    assert(invariant(CURRENT_ELEMENT_SPANNABLE, result != null,
-        message: "No element found for $node."));
+    assert(result != null,
+        failedAt(CURRENT_ELEMENT_SPANNABLE, "No element found for $node."));
     return result;
   }
 
   ConstructorElement getConstructor(ir.Member node) =>
       getElement(node).declaration;
 
   @override
   ConstructorEntity getSuperConstructor(
       ir.Constructor constructor, ir.Member target) {
     assert(target != null);
@@ skipping 14 matching lines @@
   FieldElement getField(ir.Field node) => getElement(node).declaration;
 
   ClassElement getClass(ir.Class node) => getElement(node).declaration;
 
   LibraryElement getLibrary(ir.Library node) => getElement(node).declaration;
 
   LocalFunctionElement getLocalFunction(ir.TreeNode node) => getElement(node);
 
   ast.Node getNode(ir.Node node) {
     ast.Node result = _nodeToAst[node];
-    assert(invariant(CURRENT_ELEMENT_SPANNABLE, result != null,
-        message: "No node found for $node"));
+    assert(result != null,
+        failedAt(CURRENT_ELEMENT_SPANNABLE, "No node found for $node"));
     return result;
   }
 
   ast.Node getNodeOrNull(ir.Node node) {
     return _nodeToAst[node];
   }
 
   void assertNodeIsSynthetic(ir.Node node) {
-    assert(invariant(
-        CURRENT_ELEMENT_SPANNABLE, kernel.syntheticNodes.contains(node),
-        message: "No synthetic marker found for $node"));
+    assert(
+        kernel.syntheticNodes.contains(node),
+        failedAt(
+            CURRENT_ELEMENT_SPANNABLE, "No synthetic marker found for $node"));
   }
 
   @override
   Local getLocal(ir.VariableDeclaration variable) {
     // If this is a synthetic local, return the synthetic local
     if (variable.name == null) {
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null, null));
     }
     return getElement(variable) as LocalElement;
@@ skipping 412 matching lines @@
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
     return TypeMaskFactory.inferredTypeForSelector(
         selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(
       native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
     return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
   }
 }