Stop resolving all of js_helper unconditionally.

sdk/lib/_internal/compiler/implementation/enqueue.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.
 
 part of dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 49 matching lines @@
     if (element.isForeign(compiler)) return;
 
     if (!addElementToWorkList(element, elements)) return;
 
     // Enable runtime type support if we discover a getter called runtimeType.
     // We have to enable runtime type before hitting the codegen, so
     // that constructors know whether they need to generate code for
     // runtime type.
     if (element.isGetter() && element.name == Compiler.RUNTIME_TYPE) {
       compiler.enabledRuntimeType = true;
+      compiler.backend.registerRuntimeType();
     } else if (element == compiler.functionApplyMethod) {
       compiler.enabledFunctionApply = true;
     } else if (element == compiler.invokeOnMethod) {
       compiler.enabledInvokeOn = true;
     }
 
     nativeEnqueuer.registerElement(element);
   }
 
   /**
@@ skipping 118 matching lines @@
 
       void processClass(ClassElement cls) {
         if (seenClasses.contains(cls)) return;
 
         seenClasses.add(cls);
         cls.ensureResolved(compiler);
         cls.implementation.forEachMember(processInstantiatedClassMember);
         if (isResolutionQueue) {
           compiler.resolver.checkClass(cls);
         }
-
-        if (compiler.enableTypeAssertions) {
-          // We need to register is checks and helpers for checking
-          // assignments to fields.
-          // TODO(ngeoffray): This should really move to the backend.
-          cls.forEachLocalMember((Element member) {
-            if (!member.isInstanceMember() || !member.isField()) return;
-            DartType type = member.computeType(compiler);
-            registerIsCheck(type);
-            SourceString helper = compiler.backend.getCheckedModeHelper(type);
-            if (helper != null) {
-              Element helperElement = compiler.findHelper(helper);
-              registerStaticUse(helperElement);
-            }
-          });
-        }
       }
       processClass(cls);
       for (Link<DartType> supertypes = cls.allSupertypes;
            !supertypes.isEmpty; supertypes = supertypes.tail) {
         processClass(supertypes.head.element);
       }
     });
   }
 
   void registerNewSelector(SourceString name,
@@ skipping 123 matching lines @@
   void registerFieldGetter(Element element) {
     universe.fieldGetters.add(element);
   }
 
   void registerFieldSetter(Element element) {
     universe.fieldSetters.add(element);
   }
 
   void registerIsCheck(DartType type) {
     universe.isChecks.add(type);
+    compiler.backend.registerIsCheck(type, this);
+  }
+
+  void registerAsCheck(DartType type) {
+    registerIsCheck(type);
+    compiler.backend.registerAsCheck(type);
   }
 
   void forEach(f(WorkItem work));
 
   void logSummary(log(message)) {
     _logSpecificSummary(log);
     nativeEnqueuer.logSummary(log);
   }
 
   /// Log summary specific to the concrete enqueuer.
@@ skipping 158 matching lines @@
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }