Defer addStubs to class instantiation time.

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 363 matching lines @@
 
           for (var i = 0; i < fields.length; i++) {
             if(i != 0) str += ", ";
 
             var field = generateAccessor(fields[i], accessors, name);
             if (#hasIsolateSupport) { fieldNames += "'" + field + "',"; }
             var parameter = "p_" + field;
             str += parameter;
             body += ("this." + field + " = " + parameter + ";\n");
           }
+          if (supportsDirectProtoAccess) {
+            body += "this." + #deferredAction + "();";
+          } 
           str += ") {\n" + body + "}\n";
           str += name + ".builtin$cls=\"" + name + "\";\n";
           str += "$desc=$collectedClasses." + name + "[1];\n";
           str += name + ".prototype = $desc;\n";
           if (typeof defineClass.name != "string") {
             str += name + ".name=\"" + name + "\";\n";
           }
           if (#hasIsolateSupport) {
             str += name + "." + #fieldNamesProperty + "=[" + fieldNames
                    + "];\n";
           }
           str += accessors.join("");
 
           return str;
-        }''', { 'hasIsolateSupport': hasIsolateSupport,
+        }''', { 'deferredAction': js.string(namer.deferredAction),

[floitsch, 2015/03/11 13:59:33]

potentially create the string here?
(although maybe not worth it).

that is:
body += #deferredActionCall


'deferredActionCall': js.string("this.${namer.deferredAction}()")

[herhut, 2015/03/13 12:28:52]

I would prefer to leave the fact that it is a call in the js template.

I already don't like that I have to make it a string. We should have a way to
expand a jsAst argument into a string. Maybe ##?

+                'hasIsolateSupport': hasIsolateSupport,
                 'fieldNamesProperty': js.string(fieldNamesProperty)});
 
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction.
     List result = <jsAst.Node>[
         generateAccessorFunction,
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
 
     if (compiler.hasIncrementalSupport) {
@@ skipping 50 matching lines @@
                      instanceFromClassIdAssignment,
                      initializeEmptyInstanceAssignment]);
     }
 
     return result;
   }
 
   /** Needs defineClass to be defined. */
   jsAst.Expression buildInheritFrom() {
     jsAst.Expression result = js(r"""
+    // If the browser supports changing the prototype via __proto__, we make
+    // use of that feature. Otherwise, we copy the properties into a new
+    // constructor.
+     supportsDirectProtoAccess ?
+        function(constructor, superConstructor) {
+          var prototype = constructor.prototype;
+          prototype.__proto__ = superConstructor.prototype;
+          // Use a function for `true` here, as functions are stored in the
+          // hidden class and not as properties in the object.
+          prototype.constructor = constructor;
+          prototype[#operatorIsPrefix + constructor.name] = constructor;
+          return convertToFastObject(prototype);
+        } :
         function() {
           function tmp() {}
           return function (constructor, superConstructor) {
             tmp.prototype = superConstructor.prototype;
             var object = new tmp();
-            object.x = 0; delete object.x; // Make object slow.
+            convertToSlowObject(object);
             var properties = constructor.prototype;
             var members = Object.keys(properties);
             for (var i = 0; i < members.length; i++) {
               var member = members[i];
               object[member] = properties[member];
             }
             // Use a function for `true` here, as functions are stored in the
             // hidden class and not as properties in the object.
             object[#operatorIsPrefix + constructor.name] = constructor;
             object.constructor = constructor;
@@ skipping 64 matching lines @@
         // class.  The minifier together with noSuchMethod can put methods on
         // the Object.prototype object, and they show through here, so we check
         // that we have a string.
         if (!superclass || typeof superclass != "string") {
           // Inlined special case of InheritFrom here for performance reasons.
           // Fix up the the Dart Object class' prototype.
           var constructor = allClasses[cls];
           var prototype = constructor.prototype;
           prototype.constructor = constructor;
           prototype.#isObject = constructor;
+          prototype.#deferredAction = #markerFun;
           return;
         }
         finishClass(superclass);
         var superConstructor = allClasses[superclass];
 
-        if (!superConstructor)
+        if (!superConstructor) {
           superConstructor = existingIsolateProperties[superclass];
+        }
 
         var constructor = allClasses[cls];
         var prototype = inheritFrom(constructor, superConstructor);
 
-        if (#needsNativeSupport)
-          if (Object.prototype.hasOwnProperty.call(prototype, $specProperty))
-            #nativeInfoHandler
+        if (#needsNativeSupport) {
+          if (Object.prototype.hasOwnProperty.call(prototype, $specProperty)) {
+            #nativeInfoHandler;
+            // As native classes can come into existence without a constructor
+            // call, we have to ensure that the class has been fully
+            // initialized. 
+            if (constructor.prototype.#deferredAction) 
+              finishAddStubsHelper(constructor.prototype);
+          }
+        }
+        // Interceptors (or rather their prototypes) are also used without
+        // first instantiating them first.
+        if (prototype.#isInterceptorClass && 
+            constructor.prototype.#deferredAction) {
+          finishAddStubsHelper(constructor.prototype);
+        }
       }
-    }''', {'finishedClassesAccess': finishedClassesAccess,
+    }''', {'deferredAction': namer.deferredAction,
+           'finishedClassesAccess': finishedClassesAccess,
+           'markerFun': markerFun,
            'needsMixinSupport': needsMixinSupport,
            'needsNativeSupport': needsNativeSupport,
            'nativeInfoHandler': nativeInfoHandler,
+           'isInterceptorClass': namer.operatorIs(backend.jsInterceptorClass),
            'isObject' : namer.operatorIs(compiler.objectClass) });
   }
 
   void emitFinishIsolateConstructorInvocation(CodeOutput output) {
     String isolate = namer.isolateName;
     output.add("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
@@ skipping 503 matching lines @@
             'hasIncrementalSupport': compiler.hasIncrementalSupport,
             'lazyInitializerProperty': lazyInitializerProperty,});
 
     output.addBuffer(
         jsAst.prettyPrint(decl, compiler, monitor: compiler.dumpInfoTask));
     if (compiler.enableMinification) {
       output.add('\n');
     }
   }
 
+  String get markerFun => backend.namer.internalGlobal('markerFun');
+
+  void emitMarkerFun(CodeOutput output) {
+    jsAst.Statement markerFunStmt = js.statement('''
+      // This function is used to mark the end of the inheritance chain so that
+      // finishAddStubsHelper knows where to stop searching for deferred work.
+      // We have to put it at the top level so that we only get one instance of
+      // it even if we call parseReflectionData multiple times, e.g., due to 
+      // deferred loading.
+      function #() {}''', markerFun);
+    output.addBuffer(jsAst.prettyPrint(markerFunStmt, compiler));
+    output.add(N);
+  }
+
   void emitConvertToFastObjectFunction(CodeOutput output) {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
         // The following only works on V8 when run with option
         // "--allow-natives-syntax".  We use'new Function' because the
          // miniparser does not understand V8 native syntax.
         if (typeof print === "function") {
           var HasFastProperties =
             new Function("a", "return %HasFastProperties(a)");
@@ skipping 11 matching lines @@
         MyClass.prototype = properties;
         new MyClass();
         #;
         return properties;
       }''', [debugCode]);
 
     output.addBuffer(jsAst.prettyPrint(convertToFastObject, compiler));
     output.add(N);
   }
 
+  void emitConvertToSlowObjectFunction(CodeOutput output) {
+    jsAst.Statement convertToSlowObject = js.statement(r'''
+    function convertToSlowObject(properties) {
+      // Add and remove a property to make the object transition into hashmap
+      // mode.
+      properties.__MAGIC_SLOW_PROPERTY = 1;
+      delete properties.__MAGIC_SLOW_PROPERTY;
+      return properties;
+    }''');
+
+    output.addBuffer(jsAst.prettyPrint(convertToSlowObject, compiler));
+    output.add(N);
+  }
+
+  void emitSupportsDirectProtoAccess(CodeOutput output) {
+    jsAst.Statement supportsDirectProtoAccess = js.statement(r'''
+      var supportsDirectProtoAccess = (function () {
+        var cls = function () {};
+        cls.prototype = {'p': {}};
+        var object = new cls();
+        return object.__proto__ &&
+               object.__proto__.p === cls.prototype.p;
+       })();
+    ''');
+
+    output.addBuffer(jsAst.prettyPrint(supportsDirectProtoAccess, compiler));
+    output.add(N);
+  }
+
   void writeLibraryDescriptors(CodeOutput output, LibraryElement library) {
     var uri = "";
     if (!compiler.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.outputUri != null) {
         uri = relativize(compiler.outputUri, library.canonicalUri, false);
       }
     }
     ClassBuilder descriptor = elementDescriptors[library];
     if (descriptor == null) {
@@ skipping 208 matching lines @@
       /// The semicolon is important in minified mode, without it the
       /// following parenthesis looks like a call to the object literal.
       mainOutput.add(
           'self.${deferredInitializers} = self.${deferredInitializers} || '
           'Object.create(null);$n');
     }
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
     mainOutput.add('(function(${namer.currentIsolate})$_{\n');
+    emitSupportsDirectProtoAccess(mainOutput);
     if (compiler.hasIncrementalSupport) {
       mainOutput.addBuffer(jsAst.prettyPrint(js.statement(
           """
 {
   #helper = #helper || Object.create(null);
   #helper.patch = function(a) { eval(a)};
   #helper.schemaChange = #schemaChange;
   #helper.addMethod = #addMethod;
   #helper.extractStubs = function(array, name, isStatic, originalDescriptor) {
     var descriptor = Object.create(null);
@@ skipping 60 matching lines @@
 
     checkEverythingEmitted(elementDescriptors.keys);
 
     CodeBuffer libraryBuffer = new CodeBuffer();
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
       writeLibraryDescriptors(libraryBuffer, library);
       elementDescriptors.remove(library);
     }
 
     bool needsNativeSupport = program.needsNativeSupport;
-    mainOutput
-        ..addBuffer(
-            jsAst.prettyPrint(
-                getReflectionDataParser(this, backend, needsNativeSupport),
-                compiler))
-        ..add(n);
+    mainOutput.addBuffer(
+        jsAst.prettyPrint(
+            getReflectionDataParser(this, backend, needsNativeSupport),
+            compiler));
 
     // 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');
     if (compiler.useContentSecurityPolicy) {
       jsAst.Statement precompiledFunctionAst =
           buildCspPrecompiledFunctionFor(mainOutputUnit);
@@ skipping 40 matching lines @@
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
     mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
 
     emitFinishIsolateConstructorInvocation(mainOutput);
     mainOutput.add(
         '${namer.currentIsolate}$_=${_}new ${namer.isolateName}()$N');
 
     emitConvertToFastObjectFunction(mainOutput);
+    emitConvertToSlowObjectFunction(mainOutput);
+    emitMarkerFun(mainOutput);
+
     for (String globalObject in Namer.reservedGlobalObjectNames) {
       mainOutput.add('$globalObject = convertToFastObject($globalObject)$N');
     }
     if (DEBUG_FAST_OBJECTS) {
       mainOutput.add(r'''
           // The following only works on V8 when run with option
           // "--allow-natives-syntax".  We use'new Function' because the
           // miniparser does not understand V8 native syntax.
           if (typeof print === "function") {
             var HasFastProperties =
@@ skipping 505 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }