Ensure the type inferrer does not infer types for runtime helpers used by the backend.

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;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 315 matching lines @@
   /// List of symbols that the user has requested for reflection.
   final Set<String> symbolsUsed = new Set<String>();
 
   /// List of elements that the user has requested for reflection.
   final Set<Element> targetsUsed = new Set<Element>();
 
   /// List of annotations provided by user that indicate that the annotated
   /// element must be retained.
   final Set<Element> metaTargetsUsed = new Set<Element>();
 
+  /// List of elements that the backend may use.
+  final Set<Element> helpersUsed = new Set<Element>();
+
   JavaScriptBackend(Compiler compiler, bool generateSourceMap, bool disableEval)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         ? new CodeEmitterNoEvalTask(compiler, namer, generateSourceMap)
         : new CodeEmitterTask(compiler, namer, generateSourceMap);
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
         new MinifyNamer(compiler) :
         new Namer(compiler);
   }
 
+  bool canBeUsedForGlobalOptimizations(Element element) {
+    return !helpersUsed.contains(element.declaration);
+  }
+
   bool isInterceptorClass(ClassElement element) {
     if (element == null) return false;
     if (element.isNative()) return true;
     if (interceptedClasses.contains(element)) return true;
     if (classesMixedIntoNativeClasses.contains(element)) return true;
     return false;
   }
 
   String registerOneShotInterceptor(Selector selector) {
     Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
@@ skipping 367 matching lines @@
       world.registerStaticUse(
           compiler.findInterceptor(const SourceString('dispatchPropertyName')));
     }
 
     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);
+      if (e != null) enqueue(world, e, elements);
     }
   }
 
   onResolutionComplete() => rti.computeClassesNeedingRti();
 
   void registerStringInterpolation(TreeElements elements) {
     enqueueInResolution(getStringInterpolationHelper(), elements);
   }
 
   void registerCatchStatement(Enqueuer enqueuer, TreeElements elements) {
@@ skipping 83 matching lines @@
   }
 
   void registerIsCheck(DartType type, Enqueuer world, TreeElements elements) {
     type = type.unalias(compiler);
     world.registerInstantiatedClass(compiler.boolClass, elements);
     bool inCheckedMode = compiler.enableTypeAssertions;
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (inCheckedMode) {
       CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: false);
-      if (helper != null) world.addToWorkList(helper.getElement(compiler));
+      if (helper != null) enqueue(world, helper.getElement(compiler), elements);
       // We also need the native variant of the check (for DOM types).
       helper = getNativeCheckedModeHelper(type, typeCast: false);
-      if (helper != null) world.addToWorkList(helper.getElement(compiler));
+      if (helper != null) enqueue(world, helper.getElement(compiler), elements);
     }
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
     if (!type.isRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
       if (inCheckedMode) {
         enqueueInResolution(getAssertSubtype(), elements);
       }
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getCheckSubtypeOfRuntimeType(), elements);
         if (inCheckedMode) {
           enqueueInResolution(getAssertSubtypeOfRuntimeType(), elements);
         }
       }
       world.registerInstantiatedClass(compiler.listClass, elements);
     }
     if (type is FunctionType) {
       enqueueInResolution(getCheckFunctionSubtype(), elements);
     }
     if (type.element.isNative()) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
-      world.addToWorkList(
-          compiler.findHelper(const SourceString('defineProperty')));
+      enqueue(world,
+              compiler.findHelper(const SourceString('defineProperty')),
+              elements);
     }
    }
 
   void registerAsCheck(DartType type, TreeElements elements) {
     type = type.unalias(compiler);
     CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: true);
     enqueueInResolution(helper.getElement(compiler), elements);
     // We also need the native variant of the check (for DOM types).
     helper = getNativeCheckedModeHelper(type, typeCast: true);
     if (helper != null) {
@@ skipping 80 matching lines @@
     return classElement == compiler.objectClass
         || classElement == jsInterceptorClass
         || classElement == jsNullClass;
   }
 
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) ||
            compiler.enabledRuntimeType;
   }
 
+  // Enqueue [e] in [enqueuer].
+  //
+  // The backend must *always* call this method when enqueuing an
+  // element. Calls done by the backend are not seen by global
+  // optimizations, so they would make these optimizations unsound.
+  // Therefore we need to collect the list of helpers the backend may
+  // use.
   void enqueue(Enqueuer enqueuer, Element e, TreeElements elements) {
+    helpersUsed.add(e.declaration);
     enqueuer.addToWorkList(e);
     elements.registerDependency(e);
   }
 
   void enqueueInResolution(Element e, TreeElements elements) {
     if (e == null) return;
     ResolutionEnqueuer enqueuer = compiler.enqueuer.resolution;
     enqueue(enqueuer, e, elements);
   }
 
@@ skipping 332 matching lines @@
   }
 
   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);
-  }
-
   bool isNullImplementation(ClassElement cls) {
     return cls == jsNullClass;
   }
 
   ClassElement get intImplementation => jsIntClass;
   ClassElement get doubleImplementation => jsDoubleClass;
   ClassElement get numImplementation => jsNumberClass;
   ClassElement get stringImplementation => jsStringClass;
   ClassElement get listImplementation => jsArrayClass;
   ClassElement get constListImplementation => jsArrayClass;
@@ skipping 222 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }