Move main and isolate handling to enqueuer listeners.

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 848 matching lines @@
         // constant emitter will generate a call to the createRuntimeType
         // helper so we register a use of that.
         impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
             helpers.createRuntimeType,
             null));
       }
     }
   }
 
-  // TODO(johnniwinther): Avoid the need for this.
-  WorldImpact computeHelpersImpact() =>
-      _resolutionEnqueuerListener.computeHelpersImpact();
-
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsData.computeMembersNeededForReflection(closedWorld);
     _backendUsage = _backendUsageBuilder.close();
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder,
         closedWorld,
@@ skipping 54 matching lines @@
           }
         }
       }
       reporter.reportErrorMessage(
           node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     }
     // No native behavior for this call.
     return null;
   }
 
-  /// Called to enable support for isolates. Any backend specific [WorldImpact]
-  /// of this is returned.
-  WorldImpact enableIsolateSupport({bool forResolution}) {
-    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
-    // TODO(floitsch): We should also ensure that the class IsolateMessage is
-    // instantiated. Currently, just enabling isolate support works.
-    if (compiler.mainFunction != null) {
-      // The JavaScript backend implements [Isolate.spawn] by looking up
-      // top-level functions by name. So all top-level function tear-off
-      // closures have a private name field.
-      //
-      // The JavaScript backend of [Isolate.spawnUri] uses the same internal
-      // implementation as [Isolate.spawn], and fails if it cannot look main up
-      // by name.
-      impactBuilder.registerStaticUse(
-          new StaticUse.staticTearOff(compiler.mainFunction));
-    }
-    impacts.isolateSupport
-        .registerImpact(impactBuilder, compiler.elementEnvironment);
-    if (forResolution) {
-      backendUsageBuilder.processBackendImpact(impacts.isolateSupport);
-      impacts.isolateSupportForResolution
-          .registerImpact(impactBuilder, compiler.elementEnvironment);
-      backendUsageBuilder
-          .processBackendImpact(impacts.isolateSupportForResolution);
-    }
-    return impactBuilder;
-  }
-
   bool isComplexNoSuchMethod(FunctionElement element) =>
       noSuchMethodRegistry.isComplex(element);
 
   bool methodNeedsRti(FunctionElement function) {
     return rtiNeed.methodNeedsRti(function);
   }
 
   CodegenEnqueuer get codegenEnqueuer => compiler.enqueuer.codegen;
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
@@ skipping 271 matching lines @@
     // chance of making the dispatch record access monomorphic.
     jsAst.PropertyAccess record =
         new jsAst.PropertyAccess(use2, dispatchProperty);
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[use1, record];
     MethodElement helper = helpers.isJsIndexable;
     jsAst.Expression helperExpression = emitter.staticFunctionAccess(helper);
     return new jsAst.Call(helperExpression, arguments);
   }
 
-  void _onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses) {
-    if (compiler.options.useKernel && compiler.mainApp != null) {
-      kernelTask.buildKernelIr();
-    }
-  }
-
   /// Called after the queue is closed. [onQueueEmpty] may be called multiple
   /// times, but [onQueueClosed] is only called once.
   void onQueueClosed() {
     lookupMapAnalysis.onQueueClosed();
     jsInteropAnalysis.onQueueClosed();
   }
 
   // TODO(johnniwinther): Create a CodegenPhase object for the backend to hold
   // data only available during code generation.
   ClosedWorld _closedWorldCache;
@@ skipping 11 matching lines @@
   /// [WorldImpact] of enabled backend features is returned.
   WorldImpact onCodegenStart(ClosedWorld closedWorld) {
     _closedWorld = closedWorld;
     _namer = determineNamer(_closedWorld, compiler.codegenWorldBuilder);
     tracer = new Tracer(_closedWorld, namer, compiler);
     emitter.createEmitter(_namer, _closedWorld);
     _rtiEncoder =
         _namer.rtiEncoder = new _RuntimeTypesEncoder(_namer, emitter, helpers);
 
     lookupMapAnalysis.onCodegenStart();
-    if (backendUsage.isIsolateInUse) {
-      return enableIsolateSupport(forResolution: false);
-    }
     return const WorldImpact();
   }
 
   /// Called when code generation has been completed.
   void onCodegenEnd() {
     sourceInformationStrategy.onComplete();
     tracer.close();
   }
 
   // Does this element belong in the output
@@ skipping 93 matching lines @@
           "@NoSideEffects() should always be combined with @NoInline.");
     }
   }
 
   MethodElement helperForBadMain() => helpers.badMain;
 
   MethodElement helperForMissingMain() => helpers.missingMain;
 
   MethodElement helperForMainArity() => helpers.mainHasTooManyParameters;
 
-  /// Computes the [WorldImpact] of calling [mainMethod] as the entry point.
-  WorldImpact computeMainImpact(MethodElement mainMethod,
-      {bool forResolution}) {
-    WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
-    if (mainMethod.parameters.isNotEmpty) {
-      impacts.mainWithArguments
-          .registerImpact(mainImpact, compiler.elementEnvironment);
-      if (forResolution) {
-        backendUsageBuilder.processBackendImpact(impacts.mainWithArguments);
-      }
-      mainImpact.registerStaticUse(
-          new StaticUse.staticInvoke(mainMethod, CallStructure.TWO_ARGS));
-      // If the main method takes arguments, this compilation could be the
-      // target of Isolate.spawnUri. Strictly speaking, that can happen also if
-      // main takes no arguments, but in this case the spawned isolate can't
-      // communicate with the spawning isolate.
-      mainImpact.addImpact(enableIsolateSupport(forResolution: forResolution));
-    }
-    mainImpact.registerStaticUse(
-        new StaticUse.staticInvoke(mainMethod, CallStructure.NO_ARGS));
-    return mainImpact;
-  }
-
   /// Returns the filename for the output-unit named [name].
   ///
   /// The filename is of the form "<main output file>_<name>.part.js".
   /// If [addExtension] is false, the ".part.js" suffix is left out.
   String deferredPartFileName(String name, {bool addExtension: true}) {
     assert(name != "");
     String outPath = compiler.options.outputUri != null
         ? compiler.options.outputUri.path
         : "out";
     String outName = outPath.substring(outPath.lastIndexOf('/') + 1);
@@ skipping 225 matching lines @@
   }
 
   @override
   FieldEntity get symbolField => helpers.symbolImplementationField;
 
   @override
   InterfaceType get symbolType {
     return _env.getRawType(helpers.symbolImplementationClass);
   }
 }