Use failedAt in more places

pkg/compiler/lib/src/js_backend/backend.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.
 
 library js_backend.backend;
 
 import '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
@@ skipping 336 matching lines @@
   /// called. When TRACE_METHOD is 'console' this will be logged
   /// directly in the JavaScript console. When TRACE_METHOD is 'post' the
   /// information will be sent to a server via a POST request.
   static const String TRACE_METHOD = const String.fromEnvironment('traceCalls');
   static const bool TRACE_CALLS =
       TRACE_METHOD == 'post' || TRACE_METHOD == 'console';
 
   Namer _namer;
 
   Namer get namer {
-    assert(invariant(NO_LOCATION_SPANNABLE, _namer != null,
-        message: "Namer has not been created yet."));
+    assert(_namer != null,
+        failedAt(NO_LOCATION_SPANNABLE, "Namer has not been created yet."));
     return _namer;
   }
 
   /**
    * Set of classes whose `operator ==` methods handle `null` themselves.
    */
   final Set<ClassEntity> specialOperatorEqClasses = new Set<ClassEntity>();
 
   List<CompilerTask> get tasks {
     List<CompilerTask> result = functionCompiler.tasks;
@@ skipping 161 matching lines @@
 
   CommonElements get commonElements => compiler.commonElements;
 
   Resolution get resolution => compiler.resolution;
 
   Target get target => _target;
 
   /// Resolution support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsResolutionAnalysis get customElementsResolutionAnalysis {
-    assert(invariant(
-        NO_LOCATION_SPANNABLE, _customElementsResolutionAnalysis != null,
-        message: "CustomElementsResolutionAnalysis has not been created yet."));
+    assert(
+        _customElementsResolutionAnalysis != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "CustomElementsResolutionAnalysis has not been created yet."));
     return _customElementsResolutionAnalysis;
   }
 
   /// Codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsCodegenAnalysis get customElementsCodegenAnalysis {
-    assert(invariant(
-        NO_LOCATION_SPANNABLE, _customElementsCodegenAnalysis != null,
-        message: "CustomElementsCodegenAnalysis has not been created yet."));
+    assert(
+        _customElementsCodegenAnalysis != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "CustomElementsCodegenAnalysis has not been created yet."));
     return _customElementsCodegenAnalysis;
   }
 
   NativeBasicData get nativeBasicData {
-    assert(invariant(NO_LOCATION_SPANNABLE, _nativeBasicData != null,
-        message: "NativeBasicData has not been computed yet."));
+    assert(
+        _nativeBasicData != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "NativeBasicData has not been computed yet."));
     return _nativeBasicData;
   }
 
   NativeBasicDataBuilder get nativeBasicDataBuilder => _nativeBasicDataBuilder;
 
   /// Resolution analysis for tracking reflective access to type variables.
   TypeVariableResolutionAnalysis get typeVariableResolutionAnalysis {
-    assert(invariant(
-        NO_LOCATION_SPANNABLE, _typeVariableCodegenAnalysis == null,
-        message: "TypeVariableHandler has already been created."));
+    assert(
+        _typeVariableCodegenAnalysis == null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "TypeVariableHandler has already been created."));
     return _typeVariableResolutionAnalysis;
   }
 
   /// Codegen handler for reflective access to type variables.
   TypeVariableCodegenAnalysis get typeVariableCodegenAnalysis {
-    assert(invariant(
-        NO_LOCATION_SPANNABLE, _typeVariableCodegenAnalysis != null,
-        message: "TypeVariableHandler has not been created yet."));
+    assert(
+        _typeVariableCodegenAnalysis != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "TypeVariableHandler has not been created yet."));
     return _typeVariableCodegenAnalysis;
   }
 
   MirrorsData get mirrorsData => _mirrorsData;
 
   MirrorsDataBuilder get mirrorsDataBuilder => _mirrorsData;
 
   /// Resolution support for computing reflectable elements.
   MirrorsResolutionAnalysis get mirrorsResolutionAnalysis =>
       _mirrorsResolutionAnalysis;
 
   /// Codegen support for computing reflectable elements.
   MirrorsCodegenAnalysis get mirrorsCodegenAnalysis {
-    assert(invariant(NO_LOCATION_SPANNABLE, _mirrorsCodegenAnalysis != null,
-        message: "MirrorsCodegenAnalysis has not been created yet."));
+    assert(
+        _mirrorsCodegenAnalysis != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "MirrorsCodegenAnalysis has not been created yet."));
     return _mirrorsCodegenAnalysis;
   }
 
   /// Codegen support for tree-shaking entries of `LookupMap`.
   LookupMapAnalysis get lookupMapAnalysis {
-    assert(invariant(NO_LOCATION_SPANNABLE, _lookupMapAnalysis != null,
-        message: "LookupMapAnalysis has not been created yet."));
+    assert(
+        _lookupMapAnalysis != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "LookupMapAnalysis has not been created yet."));
     return _lookupMapAnalysis;
   }
 
   OneShotInterceptorData get oneShotInterceptorData {
-    assert(invariant(NO_LOCATION_SPANNABLE, _oneShotInterceptorData != null,
-        message: "OneShotInterceptorData has not been prepared yet."));
+    assert(
+        _oneShotInterceptorData != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "OneShotInterceptorData has not been prepared yet."));
     return _oneShotInterceptorData;
   }
 
   RuntimeTypesNeed get rtiNeed {
-    assert(invariant(NO_LOCATION_SPANNABLE, _rtiNeed != null,
-        message: "RuntimeTypesNeed has not been computed yet."));
+    assert(
+        _rtiNeed != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "RuntimeTypesNeed has not been computed yet."));
     return _rtiNeed;
   }
 
   RuntimeTypesNeedBuilder get rtiNeedBuilder {
-    assert(invariant(NO_LOCATION_SPANNABLE, _rtiNeed == null,
-        message: "RuntimeTypesNeed has already been computed."));
+    assert(
+        _rtiNeed == null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "RuntimeTypesNeed has already been computed."));
     return _rtiNeedBuilder;
   }
 
   RuntimeTypesChecksBuilder get rtiChecksBuilder {
-    assert(invariant(NO_LOCATION_SPANNABLE, !_rti.rtiChecksBuilderClosed,
-        message: "RuntimeTypesChecks has already been computed."));
+    assert(
+        !_rti.rtiChecksBuilderClosed,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "RuntimeTypesChecks has already been computed."));
     return _rti;
   }
 
   RuntimeTypesSubstitutions get rtiSubstitutions => _rti;
 
   RuntimeTypesEncoder get rtiEncoder {
-    assert(invariant(NO_LOCATION_SPANNABLE, _rtiEncoder != null,
-        message: "RuntimeTypesEncoder has not been created."));
+    assert(
+        _rtiEncoder != null,
+        failedAt(NO_LOCATION_SPANNABLE,
+            "RuntimeTypesEncoder has not been created."));
     return _rtiEncoder;
   }
 
   CheckedModeHelpers get checkedModeHelpers => _checkedModeHelpers;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
@@ skipping 74 matching lines @@
       ClassEntity interceptorClass) {
     if (interceptorClass == null) return;
     ClassEntity objectClass = commonElements.objectClass;
     compiler.elementEnvironment.forEachClassMember(objectClass,
         (_, MemberEntity member) {
       if (member.isConstructor) return;
       MemberEntity interceptorMember = compiler.elementEnvironment
           .lookupClassMember(interceptorClass, member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
-      assert(invariant(interceptorMember,
+      assert(
           interceptorMember.enclosingClass == interceptorClass,
-          message:
+          failedAt(
+              interceptorMember,
               "Member ${member.name} not overridden in ${interceptorClass}. "
               "Found $interceptorMember from "
               "${interceptorMember.enclosingClass}."));
     });
   }
 
   /// Called before processing of the resolution queue is started.
   void onResolutionStart(ResolutionEnqueuer enqueuer) {
     // TODO(johnniwinther): Avoid the compiler.elementEnvironment.getThisType
     // calls. Currently needed to ensure resolution of the classes for various
@@ skipping 205 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 (Elements.isStaticOrTopLevel(element)) {
             return _codegenImpactTransformer
                 .transformCodegenImpact(work.registry.worldImpact);
           }
         } else {
-          assert(invariant(
-              variableElement,
+          assert(
               variableElement.isInstanceMember ||
                   constant.isImplicit ||
                   constant.isPotential,
-              message: "Constant expression without value: "
+              failedAt(
+                  variableElement,
+                  "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(
             commonElements.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
@@ skipping 25 matching lines @@
         ? commonElements.jsInterceptorClass
         : commonElements.objectClass;
   }
 
   /**
    * Unit test hook that returns code of an element as a String.
    *
    * Invariant: [element] must be a declaration element.
    */
   String getGeneratedCode(Element element) {
-    assert(invariant(element, element.isDeclaration));
+    assert(element.isDeclaration, failedAt(element));
     return jsAst.prettyPrint(generatedCode[element], compiler.options);
   }
 
   /// Generates the output and returns the total size of the generated code.
   int assembleProgram(ClosedWorld closedWorld) {
     int programSize = emitter.assembleProgram(namer, closedWorld);
     noSuchMethodRegistry.emitDiagnostic(reporter);
     int totalMethodCount = generatedCode.length;
     if (totalMethodCount != mirrorsCodegenAnalysis.preMirrorsMethodCount) {
       int mirrorCount =
@@ skipping 418 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }