Emit CSP code in separate file.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.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.
 
 part of js_backend;
 
 /// Enables debugging of fast/slow objects using V8-specific primitives.
 const DEBUG_FAST_OBJECTS = false;
 
 /**
@@ skipping 72 matching lines @@
 typedef void FunctionTypeTestEmitter(FunctionType functionType);
 typedef void SubstitutionEmitter(Element element, {bool emitNull});
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
-  bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer mainBuffer;
   final CodeBuffer deferredLibraries = new CodeBuffer();
   final CodeBuffer deferredConstants = new CodeBuffer();
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
@@ skipping 57 matching lines @@
    */
   Set<FunctionType> checkedFunctionTypes;
 
   Map<ClassElement, Set<FunctionType>> checkedGenericFunctionTypes =
       new Map<ClassElement, Set<FunctionType>>();
 
   Set<FunctionType> checkedNonGenericFunctionTypes =
       new Set<FunctionType>();
 
   /**
+   * List of expressions and statements that will be included in the
+   * precompiled function.
+   *
+   * To save space, dart2js normally generates constructors and accessors
+   * dynamically. This doesn't work in CSP mode, and may impact startup time
+   * negatively. So dart2js will emit these functions to a separate file that
+   * can be optionally included to support CSP mode or for faster startup.
+   */
+  List<jsAst.Node> precompiledFunction = <jsAst.Node>[];
+
+  List<jsAst.Expression> precompiledConstructorNames = <jsAst.Expression>[];
+
+  /**
    * For classes and libraries, record code for static/top-level members.
    * Later, this code is emitted when the class or library is emitted.
    * See [bufferForElement].
    */
   // TODO(ahe): Generate statics with their class, and store only libraries in
   // this map.
   final Map<Element, List<CodeBuffer>> elementBuffers =
       new Map<Element, List<CodeBuffer>>();
 
   void registerDynamicFunctionTypeCheck(FunctionType functionType) {
@@ skipping 75 matching lines @@
   String get generateAccessorHolder
       => '$isolatePropertiesName.\$generateAccessor';
   String get finishClassesProperty
       => r'$finishClasses';
   String get finishClassesName
       => '${namer.isolateName}.$finishClassesProperty';
   String get finishIsolateConstructorName
       => '${namer.isolateName}.\$finishIsolateConstructor';
   String get isolatePropertiesName
       => '${namer.isolateName}.${namer.isolatePropertiesName}';
-  String get supportsProtoName
-      => 'supportsProto';
   String get lazyInitializerName
       => '${namer.isolateName}.\$lazy';
 
   // Compact field specifications.  The format of the field specification is
   // <accessorName>:<fieldName><suffix> where the suffix and accessor name
   // prefix are optional.  The suffix directs the generation of getter and
   // setter methods.  Each of the getter and setter has two bits to determine
   // the calling convention.  Setter listed below, getter is similar.
   //
   //     00: no setter
@@ skipping 142 matching lines @@
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction (it's a local declaration in init()).
     return [
         generateAccessorFunction,
         js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
   }
 
   /** Needs defineClass to be defined. */
-  List buildProtoSupportCheck() {
-    // On Firefox and Webkit browsers we can manipulate the __proto__
-    // directly. Opera claims to have __proto__ support, but it is buggy.
-    // So we have to do more checks.
-    // Opera bug was filed as DSK-370158, and fixed as CORE-47615
-    // (http://my.opera.com/desktopteam/blog/2012/07/20/more-12-01-fixes).
-    // If the browser does not support __proto__ we need to instantiate an
-    // object with the correct (internal) prototype set up correctly, and then
-    // copy the members.
-    // TODO(8541): Remove this work around.
-
+  List buildInheritFrom() {
     return [
-      js('var $supportsProtoName = false'),
-      // js('var tmp = defineClass("c", "c", ["f<"], {}).prototype'),
-      //
-      // js.if_(js('tmp.__proto__'), [
-      //   js('tmp.__proto__ = {}'),
-      //   js.if_(js(r'typeof tmp.get$f != "undefined"'),
-      //          js('$supportsProtoName = true'))
-      // ])
-    ];
+      js('var inheritFrom = #',
+          js.fun([], [
+              new jsAst.FunctionDeclaration(
+                  new jsAst.VariableDeclaration('tmp'), js.fun([], [])),
+              js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
+              js.return_(js.fun(['constructor', 'superConstructor'], [
+                  js('tmp.prototype = superConstructor.prototype'),
+                  js('var object = new tmp()'),
+                  js('var properties = constructor.prototype'),
+                  js.forIn('member', 'properties',
+                    js.if_('hasOwnProperty.call(properties, member)',
+                           js('object[member] = properties[member]'))),
+                  js('object.constructor = constructor'),
+                  js('constructor.prototype = object'),
+                  js.return_('object')
+              ]))])())];
   }
 
   static const MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING = 4;
 
   // If we need fewer than this many noSuchMethod handlers we can save space by
   // just emitting them in JS, rather than emitting the JS needed to generate
   // them at run time.
   static const VERY_FEW_NO_SUCH_METHOD_HANDLERS = 10;
 
   /**
@@ skipping 234 matching lines @@
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
 
     String reflectableField = namer.reflectableField;
     List<jsAst.Node> statements = [
       js('var pendingClasses = {}'),
       js.if_('!init.allClasses', js('init.allClasses = {}')),
       js('var allClasses = init.allClasses'),
 
-      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
-      js('var combinedConstructorFunction = '
-         '"function \$reflectable(fn){fn.$reflectableField=1;return fn};\\n"'
-         '+ "var \$desc;\\n"'),
-      js('var constructorsList = []'),
-
       optional(
           DEBUG_FAST_OBJECTS,
           js('print("Number of classes: "'
              r' + Object.getOwnPropertyNames($$).length)')),
 
+      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
+
+      js.if_('typeof dart_precompiled == "function"',
+          [js('var constructors = dart_precompiled(collectedClasses)')],
+
+          [js('var combinedConstructorFunction = "function \$reflectable(fn){'
+              'fn.$reflectableField=1;return fn};\\n"+ "var \$desc;\\n"'),
+           js('var constructorsList = []')]),
       js.forIn('cls', 'collectedClasses', [
         js.if_('hasOwnProperty.call(collectedClasses, cls)', [
           js('var desc = collectedClasses[cls]'),
           js.if_('desc instanceof Array', js('desc = desc[1]')),
 
           /* The 'fields' are either a constructor function or a
            * string encoding fields, constructor and superclass.  Get
            * the superclass and the fields in the format
            *   '[name/]Super;field1,field2'
            * from the null-string property on the descriptor.
            * The 'name/' is optional and contains the name that should be used
            * when printing the runtime type string.  It is used, for example, to
            * print the runtime type JSInt as 'int'.
            */
           js('var classData = desc[""], supr, name = cls, fields = classData'),
           optional(
               backend.hasRetainedMetadata,
               js.if_('typeof classData == "object" && '
                      'classData instanceof Array',
                      [js('classData = fields = classData[0]')])),
 
           js.if_('typeof classData == "string"', [
             js('var split = classData.split("/")'),
             js.if_('split.length == 2', [
               js('name = split[0]'),
               js('fields = split[1]')
             ])
           ]),
 
-          js.if_('typeof fields == "string"', [
-            js('var s = fields.split(";")'),
-            js('fields = s[1] == "" ? [] : s[1].split(",")'),
-            js('supr = s[0]'),
-          ], /* else */ [
-            js('supr = desc.super'),
-            js.if_(r'!!desc.$name', js(r'name = desc.$name'))
-          ]),
+          js('var s = fields.split(";")'),
+          js('fields = s[1] == "" ? [] : s[1].split(",")'),
+          js('supr = s[0]'),
 
           optional(needsMixinSupport, js.if_('supr && supr.indexOf("+") > 0', [
             js('s = supr.split("+")'),
             js('supr = s[0]'),
             js('var mixin = collectedClasses[s[1]]'),
             js.if_('mixin instanceof Array', js('mixin = mixin[1]')),
             js.forIn('d', 'mixin', [
               js.if_('hasOwnProperty.call(mixin, d)'
                      '&& !hasOwnProperty.call(desc, d)',
                 js('desc[d] = mixin[d]'))
             ]),
           ])),
 
-          js('combinedConstructorFunction += defineClass(name, cls, fields)'),
-          js('constructorsList.push(cls)'),
+          js.if_('typeof dart_precompiled != "function"',
+              [js('combinedConstructorFunction +='
+                  ' defineClass(name, cls, fields)'),
+                 js('constructorsList.push(cls)')]),
           js.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
-      js('combinedConstructorFunction +='
-         ' "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]"'),
-      js('var constructors ='
-         ' new Function("\$collectedClasses", combinedConstructorFunction)'
-         '(collectedClasses)'),
-      js('combinedConstructorFunction = null'),
+      js.if_('typeof dart_precompiled != "function"',
+          [js('combinedConstructorFunction +='
+              ' "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]"'),
+           js('var constructors ='
+              ' new Function("\$collectedClasses", combinedConstructorFunction)'
+              '(collectedClasses)'),
+           js('combinedConstructorFunction = null')]),
       js.for_('var i = 0', 'i < constructors.length', 'i++', [
         js('var constructor = constructors[i]'),
         js('var cls = constructor.name'),
         js('var desc = collectedClasses[cls]'),
         js('var globalObject = isolateProperties'),
         js.if_('desc instanceof Array', [
             js('globalObject = desc[0] || isolateProperties'),
             js('desc = desc[1]')
         ]),
         optional(backend.isTreeShakingDisabled,
@@ skipping 47 matching lines @@
       // we have a string.
       js.if_('!superclass || typeof superclass != "string"', js.return_()),
       js('finishClass(superclass)'),
       js('var constructor = allClasses[cls]'),
       js('var superConstructor = allClasses[superclass]'),
 
       js.if_(js('!superConstructor'),
              js('superConstructor ='
                     'existingIsolateProperties[superclass]')),
 
-      js('var prototype = constructor.prototype'),
-
-      // if ($supportsProtoName) {
-      js.if_(supportsProtoName, [
-        js('prototype.__proto__ = superConstructor.prototype'),
-        js('prototype.constructor = constructor'),
-
-      ], /* else */ [
-        // function tmp() {};
-        new jsAst.FunctionDeclaration(
-            new jsAst.VariableDeclaration('tmp'),
-            js.fun([], [])),
-
-        js('tmp.prototype = superConstructor.prototype'),
-        js('var newPrototype = new tmp()'),
-
-        js('constructor.prototype = newPrototype'),
-        js('newPrototype.constructor = constructor'),
-
-        // for (var member in prototype) {
-        js.forIn('member', 'prototype', [
-          /* Short version of: if (member == '') */
-          // if (!member) continue;
-          js.if_('!member', new jsAst.Continue(null)),
-
-          // if (hasOwnProperty.call(prototype, member)) {
-          js.if_('hasOwnProperty.call(prototype, member)', [
-            js('newPrototype[member] = prototype[member]')
-          ])
-        ])
-
-      ])
+      js('prototype = inheritFrom(constructor, superConstructor)'),
     ]);
 
     return new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('finishClass'),
         fun);
   }
 
-  jsAst.Fun get finishIsolateConstructorFunction {
+  jsAst.Fun get finishIsolateConstructorFunction_NO_CSP {
     String isolate = namer.isolateName;
     // We replace the old Isolate function with a new one that initializes
     // all its field with the initial (and often final) value of all globals.
     // This has two advantages:
     //   1. the properties are in the object itself (thus avoiding to go through
     //      the prototype when looking up globals.
     //   2. a new isolate goes through a (usually well optimized) constructor
     //      function of the form: "function() { this.x = ...; this.y = ...; }".
     //
     // Example: If [isolateProperties] is an object containing: x = 3 and
@@ skipping 43 matching lines @@
       // TODO(ahe): Only copy makeConstantList when it is used.
       js('newIsolate.makeConstantList = oldIsolate.makeConstantList'),
     ]..addAll(copyFinishClasses)
      ..addAll([
 
       // return newIsolate;
       js.return_('newIsolate')
     ]));
   }
 
+  jsAst.Fun get finishIsolateConstructorFunction {
+    // We replace the old Isolate function with a new one that initializes
+    // all its fields with the initial (and often final) value of all globals.
+    //
+    // We also copy over old values like the prototype, and the
+    // isolateProperties themselves.
+    return js.fun('oldIsolate', [
+      js('var isolateProperties = oldIsolate.${namer.isolatePropertiesName}'),
+      new jsAst.FunctionDeclaration(
+        new jsAst.VariableDeclaration('Isolate'),
+          js.fun([], [
+            js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
+            js.forIn('staticName', 'isolateProperties',
+              js.if_('hasOwnProperty.call(isolateProperties, staticName)',
+                js('this[staticName] = isolateProperties[staticName]'))),
+            // Use the newly created object as prototype. In Chrome,
+            // this creates a hidden class for the object and makes
+            // sure it is fast to access.
+            new jsAst.FunctionDeclaration(

[kasperl, 2013/09/20 13:04:47]

Could you use the convertToFast helper?

+              new jsAst.VariableDeclaration('ForceEfficientMap'),
+              js.fun([], [])),
+            js('ForceEfficientMap.prototype = this'),
+            js('new ForceEfficientMap()')])),
+      js('Isolate.prototype = oldIsolate.prototype'),
+      js('Isolate.prototype.constructor = Isolate'),
+      js('Isolate.${namer.isolatePropertiesName} = isolateProperties'),
+      optional(needsDefineClass,
+               js('Isolate.$finishClassesProperty ='
+                  ' oldIsolate.$finishClassesProperty')),
+      js.return_('Isolate')]);
+  }
+
+
   jsAst.Fun get lazyInitializerFunction {
     // function(prototype, staticName, fieldName, getterName, lazyValue) {
     var parameters = <String>['prototype', 'staticName', 'fieldName',
                               'getterName', 'lazyValue'];
-    return js.fun(parameters, [
-      js('var getter = new Function("{ return this." + fieldName + ";}")'),
-    ]..addAll(addLazyInitializerLogic())
-    );
+    return js.fun(parameters, addLazyInitializerLogic());
   }
 
   List addLazyInitializerLogic() {
     String isolate = namer.CURRENT_ISOLATE;
     String cyclicThrow = namer.isolateAccess(backend.getCyclicThrowHelper());
     var lazies = [];
     if (backend.rememberLazies) {
       lazies = [
           js.if_('!init.lazies', js('init.lazies = {}')),
           js('init.lazies[fieldName] = getterName')];
@@ skipping 32 matching lines @@
           ], /* else */ [
             js.if_('result === sentinelInProgress',
               js('$cyclicThrow(staticName)')
             )
           ]),
 
           // return result;
           js.return_('result')
 
         ], finallyPart: [
-          js('$isolate[getterName] = getter')
+          js('$isolate[getterName] = #',
+             js.fun([], [js.return_('this[fieldName]')]))

[kasperl, 2013/09/20 13:04:47]

It might be worth investigating how much this costs performance wise. Add a
TODO?

         ])
       ]))
     ]);
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
-    ..addAll(buildProtoSupportCheck())
+    ..addAll(buildInheritFrom())
     ..addAll([
       js('$finishClassesName = #', finishClassesFunction)
     ]);
   }
 
   List buildLazyInitializerFunctionIfNecessary() {
     if (!needsLazyInitializer) return [];
 
     return [js('$lazyInitializerName = #', lazyInitializerFunction)];
   }
@@ skipping 675 matching lines @@
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
       builder.addProperty('+$reflectionName', reflectable);
     }
   }
 
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
-    String receiver = backend.isInterceptorClass(member.getEnclosingClass())
-        ? 'receiver' : 'this';
-    List<String> args = backend.isInterceptedMethod(member)
-        ? ['receiver']
-        : [];
-    builder.addProperty(getterName,
-        js.fun(args, js.return_(js('$receiver.$fieldName'))));
-    generateReflectionDataForFieldGetterOrSetter(
-        member, getterName, builder, isGetter: true);
+    ClassElement cls = member.getEnclosingClass();
+    String className = namer.getNameOfClass(cls);
+    String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
+    List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
+    precompiledFunction.add(
+        js('$className.prototype.$getterName = #',
+           js.fun(args, js.return_(js('$receiver.$fieldName')))));
+    if (backend.isNeededForReflection(member)) {
+      precompiledFunction.add(
+          js('$className.prototype.$getterName.${namer.reflectableField} = 1'));
+    }
   }
 
   void generateSetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String setterName = namer.setterNameFromAccessorName(accessorName);
-    String receiver = backend.isInterceptorClass(member.getEnclosingClass())
-        ? 'receiver' : 'this';
-    List<String> args = backend.isInterceptedMethod(member)
-        ? ['receiver', 'v']
-        : ['v'];
-    builder.addProperty(setterName,
-        js.fun(args, js('$receiver.$fieldName = v')));
-    generateReflectionDataForFieldGetterOrSetter(
-        member, setterName, builder, isGetter: false);
+    ClassElement cls = member.getEnclosingClass();
+    String className = namer.getNameOfClass(cls);
+    String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
+    List<String> args =
+        backend.isInterceptedMethod(member) ? ['receiver', 'v'] : ['v'];
+    precompiledFunction.add(
+        js('$className.prototype.$setterName = #',
+           js.fun(args, js.return_(js('$receiver.$fieldName = v')))));
+    if (backend.isNeededForReflection(member)) {
+      precompiledFunction.add(
+          js('$className.prototype.$setterName.${namer.reflectableField} = 1'));
+    }
   }
 
   bool canGenerateCheckedSetter(VariableElement field) {
     // We never generate accessors for top-level/static fields.
     if (!field.isInstanceMember()) return false;
     DartType type = field.computeType(compiler).unalias(compiler);
     if (type.element.isTypeVariable() ||
         (type is FunctionType && type.containsTypeVariables) ||
         type.treatAsDynamic ||
         type.element == compiler.objectClass) {
@@ skipping 29 matching lines @@
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver', 'v']
         : ['v'];
     builder.addProperty(setterName,
         js.fun(args,
             js('$receiver.$fieldName = #', js(helperName)(arguments))));
     generateReflectionDataForFieldGetterOrSetter(
         member, setterName, builder, isGetter: false);
   }
 
-  void emitClassConstructor(ClassElement classElement, ClassBuilder builder) {
-    /* Do nothing. */
+  void emitClassConstructor(ClassElement classElement,
+                            ClassBuilder builder,
+                            String runtimeName) {
+    List<String> fields = <String>[];
+    if (!classElement.isNative()) {
+      visitFields(classElement, false,
+                  (Element member,
+                   String name,
+                   String accessorName,
+                   bool needsGetter,
+                   bool needsSetter,
+                   bool needsCheckedSetter) {
+        fields.add(name);
+      });
+    }
+    String constructorName = namer.getNameOfClass(classElement);
+    precompiledFunction.add(new jsAst.FunctionDeclaration(
+        new jsAst.VariableDeclaration(constructorName),
+        js.fun(fields, fields.map(
+            (name) => js('this.$name = $name')).toList())));
+    if (runtimeName == null) {
+      runtimeName = constructorName;
+    }
+    precompiledFunction.addAll([
+        js('$constructorName.builtin\$cls = "$runtimeName"'),
+        js.if_('!"name" in $constructorName',
+              js('$constructorName.name = "$constructorName"')),
+        js('\$desc=\$collectedClasses.$constructorName'),
+        js.if_('\$desc instanceof Array', js('\$desc = \$desc[1]')),
+        js('$constructorName.prototype = \$desc'),
+    ]);
+
+    precompiledConstructorNames.add(js(constructorName));
+  }
+
+  jsAst.FunctionDeclaration buildPrecompiledFunction() {
+    // TODO(ahe): Compute a hash code.

[kasperl, 2013/09/20 13:04:47]

Maybe elaborate on the TODO so others would understand what is left to
implement?

+    String name = 'dart_precompiled';

[kasperl, 2013/09/20 13:04:47]

Factor out this constant?

+
+    precompiledFunction.add(
+        js.return_(
+            new jsAst.ArrayInitializer.from(precompiledConstructorNames)));
+    precompiledFunction.insert(0, js(r'var $desc'));
+    return new jsAst.FunctionDeclaration(
+        new jsAst.VariableDeclaration(name),
+        js.fun([r'$collectedClasses'], precompiledFunction));
   }
 
   void emitSuper(String superName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
   void emitRuntimeName(String runtimeName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
@@ skipping 163 matching lines @@
                  String name,
                  String accessorName,
                  bool needsGetter,
                  bool needsSetter,
                  bool needsCheckedSetter) {
       compiler.withCurrentElement(member, () {
         if (needsCheckedSetter) {
           assert(!needsSetter);
           generateCheckedSetter(member, name, accessorName, builder);
         }
-        if (!getterAndSetterCanBeImplementedByFieldSpec) {
-          if (needsGetter) {
-            generateGetter(member, name, accessorName, builder);
-          }
-          if (needsSetter) {
-            generateSetter(member, name, accessorName, builder);
-          }
+        if (needsGetter) {
+          generateGetter(member, name, accessorName, builder);
+        }
+        if (needsSetter) {
+          generateSetter(member, name, accessorName, builder);
         }
       });
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
@@ skipping 14 matching lines @@
     String runtimeName =
         namer.getPrimitiveInterceptorRuntimeName(classElement);
 
     if (classElement.isMixinApplication) {
       String mixinName = namer.getNameOfClass(computeMixinClass(classElement));
       superName = '$superName+$mixinName';
       needsMixinSupport = true;
     }
 
     ClassBuilder builder = new ClassBuilder();
-    emitClassConstructor(classElement, builder);
+    emitClassConstructor(classElement, builder, runtimeName);
     emitSuper(superName, builder);
     emitRuntimeName(runtimeName, builder);
     emitFields(classElement, builder, superName, onlyForRti: onlyForRti);
     emitClassGettersSetters(classElement, builder);
     if (!classElement.isMixinApplication) {
       emitInstanceMembers(classElement, builder);
     }
     emitIsTests(classElement, builder);
 
     emitClassBuilderWithReflectionData(
@@ skipping 47 matching lines @@
     String reflectionName = getReflectionName(classElement, className);
     if (reflectionName != null) {
       List<int> interfaces = <int>[];
       for (DartType interface in classElement.interfaces) {
         interfaces.add(reifyType(interface));
       }
       buffer.write(',$n$n"+$reflectionName": $interfaces');
     }
   }
 
-  bool get getterAndSetterCanBeImplementedByFieldSpec => true;
-
   /// If this is true then we can generate the noSuchMethod handlers at startup
   /// time, instead of them being emitted as part of the Object class.
   bool get generateTrivialNsmHandlers => true;
 
   int _selectorRank(Selector selector) {
     int arity = selector.argumentCount * 3;
     if (selector.isGetter()) return arity + 2;
     if (selector.isSetter()) return arity + 1;
     return arity;
   }
@@ skipping 396 matching lines @@
           emitFunctionTypeSignature, emitIsFunctionTypeTest);
     }
   }
 
   void emitClosureClassHeader(String mangledName,
                               String superName,
                               List<String> fieldNames,
                               ClassBuilder builder) {
     builder.addProperty('',
         js.string("$superName;${fieldNames.join(',')}"));
+
+    List<String> fields = fieldNames;
+    String constructorName = mangledName;
+    precompiledFunction.add(new jsAst.FunctionDeclaration(
+        new jsAst.VariableDeclaration(constructorName),
+        js.fun(fields, fields.map(
+            (name) => js('this.$name = $name')).toList())));
+    precompiledFunction.addAll([
+        js('$constructorName.builtin\$cls = "$constructorName"'),
+        js('\$desc=\$collectedClasses.$constructorName'),
+        js.if_('\$desc instanceof Array', js('\$desc = \$desc[1]')),
+        js('$constructorName.prototype = \$desc'),
+    ]);
+
+    precompiledConstructorNames.add(js(constructorName));
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineStubFunction defineStub) {
     assert(invariant(member, member.isDeclaration));
@@ skipping 1244 matching lines @@
           buffer.write(metadata);
         }
       } else {
         throw 'Unexpected value in metadata: ${Error.safeToString(metadata)}';
       }
       buffer.write(',$n');
     }
     buffer.write('];$n');
   }
 
-  void emitConvertToFastObjectFunction() {
+  void emitConvertToFastObjectFunction_NO_CSP() {
     mainBuffer.add(r'''
 function convertToFastObject(properties) {

[kasperl, 2013/09/20 13:04:47]

Could this go through js ASTs?

   function makeConstructor() {
     var str = "{\n";
     var hasOwnProperty = Object.prototype.hasOwnProperty;
     for (var property in properties) {
       if (hasOwnProperty.call(properties, property)) {
         str += "this." + property + "= properties." + property + ";\n";
       }
     }
     str += "}\n";
     return new Function("properties", str);
   };
   var constructor = makeConstructor();
   return makeConstructor.prototype = new constructor(properties);
 }
 ''');
   }
 
+  void emitConvertToFastObjectFunction() {
+    // Create an instance that uses 'properties' as prototype. This should make
+    // 'properties' a fast object.
+    mainBuffer.add(r'''function convertToFastObject(properties) {

[kasperl, 2013/09/20 13:04:47]

Could this go through js ASTs?

+  function MyClass() {};
+  MyClass.prototype = properties;
+  new MyClass();
+''');
+    if (DEBUG_FAST_OBJECTS) {
+      ClassElement primitives =
+          compiler.findHelper(const SourceString('Primitives'));
+      FunctionElement printHelper =
+          compiler.lookupElementIn(
+              primitives, const SourceString('printString'));
+      String printHelperName = namer.isolateAccess(printHelper);
+      mainBuffer.add('''
+// The following only works on V8 when run with option "--allow-natives-syntax".
+if (typeof $printHelperName === "function") {
+  $printHelperName("Size of global object: "
+                   + String(Object.getOwnPropertyNames(properties).length)
+                   + ", fast properties " + %HasFastProperties(properties));
+}
+''');
+    }
+mainBuffer.add(r'''
+  return properties;
+}
+''');
+  }
+
+
   String assembleProgram() {
     measure(() {
       // Compute the required type checks to know which classes need a
       // 'is$' method.
       computeRequiredTypeChecks();
 
       computeNeededClasses();
 
       mainBuffer.add(buildGeneratedBy());
       addComment(HOOKS_API_USAGE, mainBuffer);
@@ skipping 231 matching lines @@
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('${namer.CURRENT_ISOLATE}$_=${_}null$N');
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add(
           '${namer.CURRENT_ISOLATE}$_=${_}new ${namer.isolateName}()$N');
 
       emitConvertToFastObjectFunction();
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         mainBuffer.add('$globalObject = convertToFastObject($globalObject)$N');

[kasperl, 2013/09/20 13:04:47]

Could this go through js AST?

       }
       if (DEBUG_FAST_OBJECTS) {
         ClassElement primitives =
             compiler.findHelper(const SourceString('Primitives'));
         FunctionElement printHelper =
             compiler.lookupElementIn(
                 primitives, const SourceString('printString'));
         String printHelperName = namer.isolateAccess(printHelper);
 
         mainBuffer.add('''
@@ skipping 25 matching lines @@
 if (typeof $printHelperName === "function") {
   $printHelperName("Size of $object: "
                    + String(Object.getOwnPropertyNames($object).length)
                    + ", fast properties " + %HasFastProperties($object));
 }
 ''');
         }
       }
 
       emitMain(mainBuffer);
+      jsAst.FunctionDeclaration precompiledFunctionAst =
+          buildPrecompiledFunction();
       emitInitFunction(mainBuffer);
       if (!areAnyElementsDeferred) {
         mainBuffer.add('})()$n');
       }
       compiler.assembledCode = mainBuffer.getText();
       outputSourceMap(mainBuffer, compiler.assembledCode, '');
 
+      mainBuffer.write(
+          jsAst.prettyPrint(precompiledFunctionAst, compiler).getText());
+
+      compiler.outputProvider('precompiled', 'js')
+          ..add(mainBuffer.getText())
+          ..close();
+
       emitDeferredCode();
 
     });
     return compiler.assembledCode;
   }
 
   CodeBuffer bufferForElement(Element element, CodeBuffer eagerBuffer) {
     Element owner = element.getLibrary();
     if (!element.isTopLevel() && !element.isNative()) {
       // For static (not top level) elements, record their code in a buffer
@@ skipping 233 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;