Move hasRuntimeTypeSupport, hasIsolateSupport, and hasFunctionApplySupport to JavaScriptBackend.

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 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 508 matching lines @@
 
   /// True when we enqueue the loadLibrary code.
   bool isLoadLibraryFunctionResolved = false;
 
   /// `true` if access to [BackendHelpers.invokeOnMethod] is supported.
   bool hasInvokeOnSupport = false;
 
   /// `true` if tear-off are supported for incremental compilation.
   bool hasIncrementalTearOffSupport = false;
 
+  /// `true` of `Object.runtimeType` is supported.
+  bool hasRuntimeTypeSupport = false;
+
+  /// `true` of use of the `dart:isolate` library is supported.
+  bool hasIsolateSupport = false;
+
+  /// `true` of `Function.apply` is supported.
+  bool hasFunctionApplySupport = false;
+
   /// List of constants from metadata.  If metadata must be preserved,
   /// these constants must be registered.
   final List<Dependency> metadataConstants = <Dependency>[];
 
   /// Set of elements for which metadata has been registered as dependencies.
   final Set<Element> _registeredMetadata = new Set<Element>();
 
   /// List of elements that the user has requested for reflection.
   final Set<Element> targetsUsed = new Set<Element>();
 
@@ skipping 916 matching lines @@
     impactTransformer.registerBackendImpact(
         impactBuilder, impacts.isolateSupport);
     if (forResolution) {
       impactTransformer.registerBackendImpact(
           impactBuilder, impacts.isolateSupportForResolution);
     }
     return impactBuilder;
   }
 
   bool classNeedsRti(ClassElement cls) {
-    if (compiler.resolverWorld.hasRuntimeTypeSupport) return true;
+    if (hasRuntimeTypeSupport) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool classNeedsRtiField(ClassElement cls) {
     if (cls.rawType.typeArguments.isEmpty) return false;
-    if (compiler.resolverWorld.hasRuntimeTypeSupport) return true;
+    if (hasRuntimeTypeSupport) return true;
     return rti.classesNeedingRti.contains(cls.declaration);
   }
 
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
     return classElement == coreClasses.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 
   bool methodNeedsRti(FunctionElement function) {
-    return rti.methodsNeedingRti.contains(function) ||
-        compiler.resolverWorld.hasRuntimeTypeSupport;
+    return rti.methodsNeedingRti.contains(function) || hasRuntimeTypeSupport;
   }
 
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   CodegenEnqueuer createCodegenEnqueuer(CompilerTask task, Compiler compiler) {
     return new CodegenEnqueuer(
         task, compiler, const TreeShakingEnqueuerStrategy());
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
@@ skipping 334 matching lines @@
               worldImpact, impacts.loadLibrary);
         }
       }
     } else if (element == helpers.requiresPreambleMarker) {
       requiresPreamble = true;
     } else if (element == helpers.invokeOnMethod && forResolution) {
       hasInvokeOnSupport = true;
     }
     customElementsAnalysis.registerStaticUse(element,
         forResolution: forResolution);
+
+    if (forResolution) {
+      // Enable isolate support if we start using something from the isolate
+      // library, or timers for the async library.  We exclude constant fields,
+      // which are ending here because their initializing expression is
+      // compiled.
+      LibraryElement library = element.library;
+      if (!hasIsolateSupport && !(element.isField && element.isConst)) {
+        Uri uri = library.canonicalUri;
+        if (uri == Uris.dart_isolate) {
+          hasIsolateSupport = true;
+          worldImpact
+              .addImpact(enableIsolateSupport(forResolution: forResolution));
+        } else if (uri == Uris.dart_async) {
+          if (element.name == '_createTimer' ||
+              element.name == '_createPeriodicTimer') {
+            // The [:Timer:] class uses the event queue of the isolate
+            // library, so we make sure that event queue is generated.
+            hasIsolateSupport = true;
+            worldImpact
+                .addImpact(enableIsolateSupport(forResolution: forResolution));
+          }
+        }
+      }
+
+      if (element.isGetter && element.name == Identifiers.runtimeType_) {
+        // 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.
+        hasRuntimeTypeSupport = true;
+        // TODO(ahe): Record precise dependency here.
+        worldImpact.addImpact(registerRuntimeType());
+      } else if (compiler.commonElements.isFunctionApplyMethod(element)) {
+        hasFunctionApplySupport = true;
+      }
+    }
     return worldImpact;
   }
 
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
@@ skipping 534 matching lines @@
     }
 
     entities.forEach(processElementMetadata);
   }
 
   void onQueueClosed() {
     lookupMapAnalysis.onQueueClosed();
     jsInteropAnalysis.onQueueClosed();
   }
 
-  void onCodegenStart() {
+  WorldImpact onCodegenStart() {
     lookupMapAnalysis.onCodegenStart();
+    if (hasIsolateSupport) {
+      return enableIsolateSupport(forResolution: false);
+    }
+    return const WorldImpact();
   }
 
   /// Process backend specific annotations.
   void processAnnotations(Element element) {
     if (element.isMalformed) {
       // Elements that are marked as malformed during parsing or resolution
       // might be registered here. These should just be ignored.
       return;
     }
 
@@ skipping 820 matching lines @@
   ClassElement get mapImplementation => helpers.mapLiteralClass;
   ClassElement get constMapImplementation => helpers.constMapLiteralClass;
   ClassElement get typeImplementation => helpers.typeLiteralClass;
   ClassElement get boolImplementation => helpers.jsBoolClass;
   ClassElement get nullImplementation => helpers.jsNullClass;
   ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
   ClassElement get asyncFutureImplementation => helpers.futureImplementation;
   ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
   ClassElement get functionImplementation => helpers.coreClasses.functionClass;
 }