Extract invoke-main stub generator.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 903 matching lines @@
                           backend.rti.getFunctionThatReturnsNullName]),
             compiler, monitor: compiler.dumpInfoTask));
     output.add(N);
   }
 
   jsAst.Expression generateFunctionThatReturnsNull() {
     return js("#.#", [backend.namer.currentIsolate,
                       backend.rti.getFunctionThatReturnsNullName]);
   }
 
-  /// Returns the code equivalent to:
-  ///   `function(args) { $.startRootIsolate(X.main$closure(), args); }`
-  jsAst.Expression buildIsolateSetupClosure(Element appMain,
-                                            Element isolateMain) {
-    jsAst.Expression mainAccess = isolateStaticClosureAccess(appMain);
-    // Since we pass the closurized version of the main method to
-    // the isolate method, we must make sure that it exists.
-    return js('function(a){ #(#, a); }',
-        [backend.emitter.staticFunctionAccess(isolateMain), mainAccess]);
-  }
-
-  emitMain(CodeOutput output) {
+  emitMain(CodeOutput output, jsAst.Statement invokeMain) {
     if (compiler.isMockCompilation) return;
-    Element main = compiler.mainFunction;
-    jsAst.Expression mainCallClosure = null;
-    if (compiler.hasIsolateSupport) {
-      Element isolateMain =
-        backend.isolateHelperLibrary.find(JavaScriptBackend.START_ROOT_ISOLATE);
-      mainCallClosure = buildIsolateSetupClosure(main, isolateMain);
-    } else if (compiler.hasIncrementalSupport) {
-      mainCallClosure = js(
-          'function() { return #(); }',
-          backend.emitter.staticFunctionAccess(main));
-    } else {
-      mainCallClosure = backend.emitter.staticFunctionAccess(main);
-    }
 
     if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
       jsAst.Statement nativeBoilerPlate =
           NativeGenerator.generateIsolateAffinityTagInitialization(
               backend,
               generateEmbeddedGlobalAccess,
               js("convertToFastObject", []));
       output.addBuffer(jsAst.prettyPrint(
           nativeBoilerPlate, compiler, monitor: compiler.dumpInfoTask));
     }
 
-    jsAst.Expression currentScriptAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.CURRENT_SCRIPT);
-
+    output.add(';');
     addComment('BEGIN invoke [main].', output);
-    // This code finds the currently executing script by listening to the
-    // onload event of all script tags and getting the first script which
-    // finishes. Since onload is called immediately after execution this should
-    // not substantially change execution order.
-    jsAst.Statement invokeMain = js.statement('''
-(function (callback) {
-  if (typeof document === "undefined") {
-    callback(null);
-    return;
-  }
-  if (document.currentScript) {
-    callback(document.currentScript);
-    return;
-  }
-
-  var scripts = document.scripts;
-  function onLoad(event) {
-    for (var i = 0; i < scripts.length; ++i) {
-      scripts[i].removeEventListener("load", onLoad, false);
-    }
-    callback(event.target);
-  }
-  for (var i = 0; i < scripts.length; ++i) {
-    scripts[i].addEventListener("load", onLoad, false);
-  }
-})(function(currentScript) {
-  #currentScript = currentScript;
-
-  if (typeof dartMainRunner === "function") {
-    dartMainRunner(#mainCallClosure, []);
-  } else {
-    #mainCallClosure([]);
-  }
-})''', {'currentScript': currentScriptAccess,
-        'mainCallClosure': mainCallClosure});
-
-    output.add(';');
     output.addBuffer(jsAst.prettyPrint(invokeMain,
                      compiler, monitor: compiler.dumpInfoTask));
     output.add(N);
     addComment('END invoke [main].', output);
   }
 
   void emitInitFunction(CodeOutput output) {
     String isolate = namer.currentIsolate;
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
@@ skipping 346 matching lines @@
     ClassBuilder libraryBuilder = getElementDescriptor(libraryElement);
     for (Class cls in library.classes) {
       emitClass(cls, libraryBuilder);
     }
 
     classEmitter.emitFields(library, libraryBuilder, emitStatics: true);
   }
 
   void emitMainOutputUnit(Program program,
                           Map<OutputUnit, String> deferredLoadHashes) {
-    Fragment mainFragment = program.fragments.first;
+    MainFragment mainFragment = program.fragments.first;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
 
     LineColumnCollector lineColumnCollector;
     List<CodeOutputListener> codeOutputListeners;
     if (generateSourceMap) {
       lineColumnCollector = new LineColumnCollector();
       codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
     }
 
     CodeOutput mainOutput =
@@ skipping 193 matching lines @@
                  + String(Object.getOwnPropertyNames($object).length)
                  + ", fast properties " + HasFastProperties($object));
 }
 ''');
       }
     }
 
     jsAst.FunctionDeclaration precompiledFunctionAst =
         buildCspPrecompiledFunctionFor(mainOutputUnit);
     emitInitFunction(mainOutput);
-    emitMain(mainOutput);
+    emitMain(mainOutput, mainFragment.invokeMain);
     mainOutput.add('})()\n');
 
     if (compiler.useContentSecurityPolicy) {
       mainOutput.addBuffer(
           jsAst.prettyPrint(
               precompiledFunctionAst,
               compiler,
               monitor: compiler.dumpInfoTask,
               allowVariableMinification: false));
     }
@@ skipping 467 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }