Move the dart_precompiled function inside scoping function.

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 700 matching lines @@
     throw compiler.internalError(element,
         'Do not know how to reflect on this $element.');
   }
 
   String namedParametersAsReflectionNames(Selector selector) {
     if (selector.getOrderedNamedArguments().isEmpty) return '';
     String names = selector.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
-  jsAst.FunctionDeclaration buildCspPrecompiledFunctionFor(
+  jsAst.Statement buildCspPrecompiledFunctionFor(
       OutputUnit outputUnit) {
     // TODO(ahe): Compute a hash code.
+    // TODO(sigurdm): Avoid this precompiled function. Generated
+    // constructor-functions and getter/setter functions can be stored in the
+    // library-description table. Setting properties on these can be moved to
+    // finishClasses.
     return js.statement('''
-      function dart_precompiled(\$collectedClasses) {
+      # = function (\$collectedClasses) {
         var \$desc;
         #;
         return #;
-      }''',
-        [cspPrecompiledFunctionFor(outputUnit),
+      };''',
+        [generateEmbeddedGlobalAccess(embeddedNames.PRECOMPILED),
+         cspPrecompiledFunctionFor(outputUnit),
          new jsAst.ArrayInitializer(
              cspPrecompiledConstructorNamesFor(outputUnit))]);
   }
 
   void emitClass(Class cls, ClassBuilder enclosingBuilder) {
     ClassElement classElement = cls.element;
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
@@ skipping 694 matching lines @@
             jsAst.prettyPrint(
                 getReflectionDataParser(this, backend, hasNativeClasses),
                 compiler))
         ..add(n);
 
     // The argument to reflectionDataParser is assigned to a temporary 'dart'
     // so that 'dart.' will appear as the prefix to dart methods in stack
     // traces and profile entries.
     mainOutput..add('var dart = [$n')
               ..addBuffer(libraryBuffer)
-              ..add(']$N')
-              ..add('$parseReflectionDataName(dart)$N');
+              ..add(']$N');
+    if (compiler.useContentSecurityPolicy) {
+      jsAst.Statement precompiledFunctionAst =
+          buildCspPrecompiledFunctionFor(mainOutputUnit);
+      mainOutput.addBuffer(
+          jsAst.prettyPrint(
+              precompiledFunctionAst,
+              compiler,
+              monitor: compiler.dumpInfoTask,
+              allowVariableMinification: false));
+    }
+
+    mainOutput.add('$parseReflectionDataName(dart)$N');
 
     interceptorEmitter.emitGetInterceptorMethods(mainOutput);
     interceptorEmitter.emitOneShotInterceptors(mainOutput);
 
     if (task.outputContainsConstantList) {
       emitMakeConstantList(mainOutput);
     }
 
     // Constants in checked mode call into RTI code to set type information
     // which may need getInterceptor (and one-shot interceptor) methods, so
@@ skipping 64 matching lines @@
       mainOutput.add('''
         if (typeof print === "function") {
            print("Size of $object: "
                  + String(Object.getOwnPropertyNames($object).length)
                  + ", fast properties " + HasFastProperties($object));
 }
 ''');
       }
     }
 
-    jsAst.FunctionDeclaration precompiledFunctionAst =
-        buildCspPrecompiledFunctionFor(mainOutputUnit);
     emitInitFunction(mainOutput);
     emitMain(mainOutput, mainFragment.invokeMain);
+
     mainOutput.add('})()\n');
 
-    if (compiler.useContentSecurityPolicy) {
-      mainOutput.addBuffer(
-          jsAst.prettyPrint(
-              precompiledFunctionAst,
-              compiler,
-              monitor: compiler.dumpInfoTask,
-              allowVariableMinification: false));
-    }
 
     if (generateSourceMap) {
       mainOutput.add(
           generateSourceMapTag(compiler.sourceMapUri, compiler.outputUri));
     }
 
     mainOutput.close();
 
     if (generateSourceMap) {
       outputSourceMap(mainOutput, lineColumnCollector, '',
@@ skipping 335 matching lines @@
         // Isolate.prototype object.  We know this will turn it into a
         // slow object in V8, so instead we should do something similar
         // to Isolate.$finishIsolateConstructor.
         output
             ..add('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
             // The argument to reflectionDataParser is assigned to a temporary
             // 'dart' so that 'dart.' will appear as the prefix to dart methods
             // in stack traces and profile entries.
             ..add('var dart = [$n ')
             ..addBuffer(libraryDescriptorBuffer)
-            ..add(']$N')
-            ..add('$parseReflectionDataName(dart)$N');
+            ..add(']$N');
+
+        if (compiler.useContentSecurityPolicy) {
+          jsAst.Statement precompiledFunctionAst =
+              buildCspPrecompiledFunctionFor(outputUnit);
+
+          output.addBuffer(
+              jsAst.prettyPrint(
+                  precompiledFunctionAst, compiler,
+                  monitor: compiler.dumpInfoTask,
+                  allowVariableMinification: false));
+        }
+        output.add('$parseReflectionDataName(dart)$N');
       }
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
       // After we have done the setup it must point to the current Isolate.
       // Otherwise all methods/functions accessing isolate variables will
       // access the wrong object.
       output.add("${namer.currentIsolate}$_=${_}arguments[1]$N");
 
       emitCompileTimeConstants(
           output, fragment.constants, isMainFragment: false);
       emitStaticNonFinalFieldInitializations(output, outputUnit);
+
       output.add('}$N');
-
-      if (compiler.useContentSecurityPolicy) {
-        jsAst.FunctionDeclaration precompiledFunctionAst =
-            buildCspPrecompiledFunctionFor(outputUnit);
-
-        output.addBuffer(
-            jsAst.prettyPrint(
-                precompiledFunctionAst, compiler,
-                monitor: compiler.dumpInfoTask,
-                allowVariableMinification: false));
-      }
-
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
       String hash = hasher.getHash();
 
       output.add('${deferredInitializers}["$hash"]$_=$_'
                        '${deferredInitializers}.current$N');
 
       if (generateSourceMap) {
 
@@ skipping 71 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }