Revert "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]);
   }
 
-  emitMain(CodeOutput output, jsAst.Statement invokeMain) {
+  /// 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) {
     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);
+
     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) {
-    MainFragment mainFragment = program.fragments.first;
+    Fragment 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, mainFragment.invokeMain);
+    emitMain(mainOutput);
     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);
 
       }
     }
   }
 }