Stop resolving all of js_helper unconditionally.

sdk/lib/_internal/compiler/implementation/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.
 
 part of js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 858 matching lines @@
         compiler.jsInvocationMirrorClass.computeType(compiler));
     argumentTypes.registerDynamicInvocation(types, new Selector.noSuchMethod());
   }
 
   void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {
     if (!seenAnyClass) {
       initializeInterceptorElements();
       initializeNoSuchMethod();
       seenAnyClass = true;
     }
+
+    // Register any helper that will be needed by the backend.
+    if (enqueuer.isResolutionQueue) {
+      if (cls == compiler.intClass
+          || cls == compiler.doubleClass
+          || cls == compiler.numClass) {
+        // The backend will try to optimize number operations and use the
+        // `iae` helper directly.
+        enqueuer.registerStaticUse(
+            compiler.findHelper(const SourceString('iae')));
+      } else if (cls == compiler.listClass
+                 || cls == compiler.stringClass) {
+        // The backend will try to optimize array and string access and use the
+        // `ioore` and `iae` helpers directly.
+        enqueuer.registerStaticUse(
+            compiler.findHelper(const SourceString('ioore')));
+        enqueuer.registerStaticUse(
+            compiler.findHelper(const SourceString('iae')));
+      } else if (cls == compiler.functionClass) {
+        enqueuer.registerInstantiatedClass(compiler.closureClass);
+      } else if (cls == compiler.mapClass) {
+        // The backend will use a literal list to initialize the entries
+        // of the map.
+        enqueuer.registerInstantiatedClass(compiler.listClass);
+        enqueuer.registerInstantiatedClass(compiler.mapLiteralClass);
+        enqueueInResolution(getMapMaker());
+      }
+    }
     ClassElement result = null;
     if (cls == compiler.stringClass) {
       addInterceptors(jsStringClass, enqueuer);
     } else if (cls == compiler.listClass) {
       addInterceptors(jsArrayClass, enqueuer);
-      // The backend will try to optimize array access and use the
-      // `ioore` and `iae` helpers directly.
-      if (enqueuer.isResolutionQueue) {
-        enqueuer.registerStaticUse(
-            compiler.findHelper(const SourceString('ioore')));
-        enqueuer.registerStaticUse(
-            compiler.findHelper(const SourceString('iae')));
-      }
     } else if (cls == compiler.intClass) {
       addInterceptors(jsIntClass, enqueuer);
       addInterceptors(jsNumberClass, enqueuer);
     } else if (cls == compiler.doubleClass) {
       addInterceptors(jsDoubleClass, enqueuer);
       addInterceptors(jsNumberClass, enqueuer);
     } else if (cls == compiler.functionClass) {
       addInterceptors(jsFunctionClass, enqueuer);
     } else if (cls == compiler.boolClass) {
       addInterceptors(jsBoolClass, enqueuer);
     } else if (cls == compiler.nullClass) {
       addInterceptors(jsNullClass, enqueuer);
     } else if (cls == compiler.numClass) {
       addInterceptors(jsIntClass, enqueuer);
       addInterceptors(jsDoubleClass, enqueuer);
       addInterceptors(jsNumberClass, enqueuer);
     } else if (cls == compiler.mapClass) {
-      // The backend will use a literal list to initialize the entries
-      // of the map.
-      if (enqueuer.isResolutionQueue) {
-        enqueuer.registerInstantiatedClass(compiler.listClass);
-        enqueuer.registerInstantiatedClass(compiler.mapLiteralClass);
-      }
+    }
+
+    if (compiler.enableTypeAssertions) {
+      // We need to register is checks for assignments to fields.
+      cls.forEachLocalMember((Element member) {
+        if (!member.isInstanceMember() || !member.isField()) return;
+        DartType type = member.computeType(compiler);
+        enqueuer.registerIsCheck(type);
+      });
     }
   }
 
-  Element get cyclicThrowHelper {
-    return compiler.findHelper(const SourceString("throwCyclicInit"));
-  }
-
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
   void enqueueHelpers(ResolutionEnqueuer world) {
-    enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
-
     jsIndexingBehaviorInterface =
         compiler.findHelper(const SourceString('JavaScriptIndexingBehavior'));
     if (jsIndexingBehaviorInterface != null) {
       world.registerIsCheck(jsIndexingBehaviorInterface.computeType(compiler));
     }
 
-    for (var helper in [const SourceString('Closure'),
-                        const SourceString('ConstantMap'),
-                        const SourceString('ConstantProtoMap')]) {
-      var e = compiler.findHelper(helper);
-      if (e != null) world.registerInstantiatedClass(e);
+    if (compiler.enableTypeAssertions) {
+      // Unconditionally register the helper that checks if the
+      // expression in an if/while/for is a boolean.
+      // TODO(ngeoffray): Should we have the resolver register those instead?
+      Element e =
+          compiler.findHelper(const SourceString('boolConversionCheck'));
+      if (e != null) world.addToWorkList(e);
     }
   }
 
+  void registerStringInterpolation() {
+    enqueueInResolution(getStringInterpolationHelper());
+  }
+
+  void registerCatchStatement() {
+    enqueueInResolution(getExceptionUnwrapper());
+  }
+
+  void registerThrow() {
+    enqueueInResolution(getThrowHelper());
+  }
+
+  void registerLazyField() {
+    enqueueInResolution(getCyclicThrowHelper());
+  }
+
+  void registerTypeLiteral() {
+    enqueueInResolution(getCreateRuntimeType());
+  }
+
+  void registerStackTraceInCatch() {
+    enqueueInResolution(getTraceFromException());
+  }
+
+  void registerRuntimeType() {
+    enqueueInResolution(getSetRuntimeTypeInfo());
+    enqueueInResolution(getGetRuntimeTypeInfo());
+    enqueueInResolution(getGetRuntimeTypeArgument());
+  }
+
+  void registerIsCheck(DartType type, Enqueuer world) {
+    if (!type.isRaw) {
+      enqueueInResolution(getSetRuntimeTypeInfo());
+      enqueueInResolution(getGetRuntimeTypeInfo());
+      enqueueInResolution(getGetRuntimeTypeArgument());
+      enqueueInResolution(getCheckArguments());
+    }
+    // [registerIsCheck] is also called for checked mode checks, so we
+    // need to register checked mode helpers.
+    if (compiler.enableTypeAssertions) {
+      SourceString helperName = getCheckedModeHelper(type);
+      Element e = compiler.findHelper(helperName);
+      if (e != null) world.addToWorkList(e);
+      // We also need the native variant of the check (for DOM types).
+      helperName = nativeNames[helperName.stringValue];
+      if (helperName != null) {
+        e = compiler.findHelper(helperName);
+        if (e != null) world.addToWorkList(e);
+      }
+    }
+  }
+
+  void registerAsCheck(DartType type) {
+    SourceString checkedHelperName = getCheckedModeHelper(type);
+    SourceString helperName = castNames[checkedHelperName.stringValue];
+    Element e = compiler.findHelper(helperName);
+    enqueueInResolution(e);
+    // We also need the native variant of the check (for DOM types).
+    checkedHelperName = nativeNames[checkedHelperName.stringValue];
+    if (checkedHelperName != null) {
+      helperName = castNames[checkedHelperName.stringValue];
+      Element e = compiler.findHelper(helperName);
+      enqueueInResolution(e);
+    }
+  }
+
+  void registerThrowNoSuchMethod() {
+    enqueueInResolution(getThrowNoSuchMethod());
+  }
+
+  void registerThrowRuntimeError() {
+    enqueueInResolution(getThrowRuntimeError());
+  }
+
+  void registerAbstractClassInstantiation() {
+    enqueueInResolution(getThrowAbstractClassInstantiationError());
+  }
+
+  void registerFallThroughError() {
+    enqueueInResolution(getFallThroughError());
+  }
+
+  void registerSuperNoSuchMethod() {
+    enqueueInResolution(getCreateInvocationMirror());
+  }
+
+  void enqueueInResolution(Element e) {
+    if (e != null) compiler.enqueuer.resolution.addToWorkList(e);
+  }
+
+  void registerConstantMap() {
+    Element e = compiler.findHelper(const SourceString('ConstantMap'));
+    if (e != null) compiler.enqueuer.resolution.registerInstantiatedClass(e);
+    e = compiler.findHelper(const SourceString('ConstantProtoMap'));
+    if (e != null) compiler.enqueuer.resolution.registerInstantiatedClass(e);
+  }
+
   void codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (element.kind.category == ElementCategory.VARIABLE) {
       Constant initialValue = compiler.constantHandler.compileWorkItem(work);
       if (initialValue != null) {
         return;
       } 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.
-        compiler.enqueuer.codegen.registerStaticUse(cyclicThrowHelper);
+        compiler.enqueuer.codegen.registerStaticUse(getCyclicThrowHelper());
       }
     }
 
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph, false);
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
       jsAst.Expression code = generator.generateBailoutMethod(work, graph);
       generatedBailoutCode[element] = code;
       optimizer.prepareForSpeculativeOptimizations(work, graph);
@@ skipping 222 matching lines @@
             ? const SourceString('listSuperNativeTypeCheck')
             : const SourceString('listSuperTypeCheck');
       } else {
         return nativeCheck
             ? const SourceString('callTypeCheck')
             : const SourceString('propertyTypeCheck');
       }
     }
   }
 
+  Map<String, SourceString> nativeNames = const <String, SourceString> {

[ahe, 2013/02/18 12:38:04]

Document this.

+    'stringSuperTypeCheck':
+        const SourceString('stringSuperNativeTypeCheck'),
+    'numberOrStringSuperTypeCheck':
+        const SourceString('numberOrStringSuperNativeTypeCheck'),
+    'listSuperTypeCheck':
+        const SourceString('listSuperNativeTypeCheck'),
+    'propertyTypeCheck':
+        const SourceString('callTypeCheck')
+  };
+
+  Map<String, SourceString> castNames = const <String, SourceString> {

[ahe, 2013/02/18 12:38:04]

Ditto.

+    "stringTypeCheck":
+        const SourceString("stringTypeCast"),
+    "doubleTypeCheck":
+        const SourceString("doubleTypeCast"),
+    "numTypeCheck":
+        const SourceString("numTypeCast"),
+    "boolTypeCheck":
+        const SourceString("boolTypeCast"),
+    "functionTypeCheck":
+        const SourceString("functionTypeCast"),
+    "intTypeCheck":
+        const SourceString("intTypeCast"),
+    "numberOrStringSuperNativeTypeCheck":
+        const SourceString("numberOrStringSuperNativeTypeCast"),
+    "numberOrStringSuperTypeCheck":
+        const SourceString("numberOrStringSuperTypeCast"),
+    "stringSuperNativeTypeCheck":
+        const SourceString("stringSuperNativeTypeCast"),
+    "stringSuperTypeCheck":
+        const SourceString("stringSuperTypeCast"),
+    "listTypeCheck":
+        const SourceString("listTypeCast"),
+    "listSuperNativeTypeCheck":
+        const SourceString("listSuperNativeTypeCast"),
+    "listSuperTypeCheck":
+        const SourceString("listSuperTypeCast"),
+    "callTypeCheck":
+        const SourceString("callTypeCast"),
+    "propertyTypeCheck":
+        const SourceString("propertyTypeCast"),
+    // TODO(johnniwinther): Add a malformedTypeCast which produces a TypeError
+    // with another message.
+    "malformedTypeCheck":
+        const SourceString("malformedTypeCheck")
+  };
+
   void dumpInferredTypes() {
     print("Inferred argument types:");
     print("------------------------");
     argumentTypes.dump();
     print("");
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
@@ skipping 13 matching lines @@
   Element getThrowMalformedSubtypeError() {
     return compiler.findHelper(
         const SourceString('throwMalformedSubtypeError'));
   }
 
   Element getThrowAbstractClassInstantiationError() {
     return compiler.findHelper(
         const SourceString('throwAbstractClassInstantiationError'));
   }
 
+  Element getStringInterpolationHelper() {
+    return compiler.findHelper(const SourceString('S'));
+  }
+
+  Element getThrowHelper() {
+    return compiler.findHelper(const SourceString(r'$throw'));
+  }
+
   Element getClosureConverter() {
     return compiler.findHelper(const SourceString('convertDartClosureToJS'));
   }
 
   Element getTraceFromException() {
     return compiler.findHelper(const SourceString('getTraceFromException'));
   }
 
   Element getMapMaker() {
     return compiler.findHelper(const SourceString('makeLiteralMap'));
   }
 
   Element getSetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('setRuntimeTypeInfo'));
   }
 
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
   }
 
   Element getGetRuntimeTypeArgument() {
     return compiler.findHelper(const SourceString('getRuntimeTypeArgument'));
   }
 
+  Element getCheckArguments() {
+    return compiler.findHelper(const SourceString('checkArguments'));
+  }
+
+  Element getThrowNoSuchMethod() {
+    return compiler.findHelper(const SourceString('throwNoSuchMethod'));
+  }
+
+  Element getCreateRuntimeType() {
+    return compiler.findHelper(const SourceString('createRuntimeType'));
+  }
+
+  Element getFallThroughError() {
+    return compiler.findHelper(const SourceString("getFallThroughError"));
+  }
+
+  Element getCreateInvocationMirror() {
+    return compiler.findHelper(Compiler.CREATE_INVOCATION_MIRROR);
+  }
+
+  Element getCyclicThrowHelper() {
+    return compiler.findHelper(const SourceString("throwCyclicInit"));
+  }
+   
   /**
    * Remove [element] from the set of generated code, and put it back
    * into the worklist.
    *
    * Invariant: [element] must be a declaration element.
    */
   void eagerRecompile(Element element) {
     assert(invariant(element, element.isDeclaration));
     generatedCode.remove(element);
     generatedBailoutCode.remove(element);
     compiler.enqueuer.codegen.addToWorkList(element);
   }
 }