Defer addStubs to class instantiation time.

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

Index: pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart
diff --git a/pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart b/pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart
index d97440f5e98ef3855c7ff0295751fa50722725b7..6fef4b6d39900119810ee1e1a321f295cd91da0f 100644
--- a/pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart
+++ b/pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart
@@ -335,6 +335,8 @@ class OldEmitter implements Emitter {
             str += parameter;
             body += ("this." + field + " = " + parameter + ";\n");
           }
+          if (supportsDirectProtoAccess)

[floitsch, 2015/03/06 14:54:09]

Sigurd put in an optimization that removes blocks if they only contain one
statement.
-> add the curly braces.

[herhut, 2015/03/09 14:28:34]

WHOOHOO!

Done.

+            body += "this." + #deferredAction + "();"; 
           str += ") {\n" + body + "}\n";
           str += name + ".builtin$cls=\"" + name + "\";\n";
           str += "$desc=$collectedClasses." + name + "[1];\n";
@@ -349,7 +351,8 @@ class OldEmitter implements Emitter {
           str += accessors.join("");
 
           return str;
-        }''', { 'hasIsolateSupport': hasIsolateSupport,
+        }''', { 'deferredAction': js.string(namer.deferredAction),
+                'hasIsolateSupport': hasIsolateSupport,
                 'fieldNamesProperty': js.string(fieldNamesProperty)});
 
     // Declare a function called "generateAccessor".  This is used in
@@ -423,13 +426,7 @@ class OldEmitter implements Emitter {
     // If the browser supports changing the prototype via __proto__, we make
     // use of that feature. Otherwise, we copy the properties into a new
     // constructor.
-    (function () {
-      var cls = function () {};
-      cls.prototype = {'p': {}};
-      var object = new cls();
-      return object.__proto__ &&
-             object.__proto__.p === cls.prototype.p;
-     })() ?
+     supportsDirectProtoAccess ?
         function(constructor, superConstructor) {
           var prototype = constructor.prototype;
           prototype.__proto__ = superConstructor.prototype;
@@ -529,6 +526,7 @@ class OldEmitter implements Emitter {
           var prototype = constructor.prototype;
           prototype.constructor = constructor;
           prototype.#isObject = constructor;
+          prototype.#deferredAction = markerFun;

[floitsch, 2015/03/06 14:54:09]

given that this function comes from a different file, use a shared constant to
link them.

[floitsch, 2015/03/06 14:54:09]

Explain what the marker-fun is for (either here or at the marker-fun
declaration. maybe both).

[herhut, 2015/03/09 14:28:34]

zarah@ is working on putting the two chunks of JS into one file, so she would
undo it soon, anyway. I'll leave it as it is.

[herhut, 2015/03/09 14:28:34]

Done.

           return;
         }
         finishClass(superclass);
@@ -541,13 +539,28 @@ class OldEmitter implements Emitter {
         var prototype = inheritFrom(constructor, superConstructor);
 
         if (#hasNativeClasses)
-          if (Object.prototype.hasOwnProperty.call(prototype, $specProperty))
-            #nativeInfoHandler
+          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) 

[floitsch, 2015/03/06 14:54:09]

ditto (add curly braces).

[herhut, 2015/03/09 14:28:34]

Done.

+              finishAddStubsHelper(constructor.prototype);
+          }
+        // Interceptors (or rather their prototypes) are also used without
+        // first instantiating them first.

[floitsch, 2015/03/06 14:54:09]

This looks like we are only eagerly running the deferredAction if the direct
superclass is the interceptor class.
Are we sure that there are not sub-subclasses? I'm particularly worried about
typed-arrays.

[floitsch, 2015/03/09 16:35:06]

any thoughts on this one?

+        if (superclass === #interceptorClassName && 
+            constructor.prototype.#deferredAction) {
+          finishAddStubsHelper(constructor.prototype);
+        }
       }
-    }''', {'finishedClassesAccess': finishedClassesAccess,
+    }''', {'deferredAction': namer.deferredAction,
+           'finishedClassesAccess': finishedClassesAccess,
            'needsMixinSupport': needsMixinSupport,
            'hasNativeClasses': hasNativeClasses,
            'nativeInfoHandler': nativeInfoHandler,
+           'interceptorClassName':
+             js.string(namer.getNameOfClass(backend.jsInterceptorClass)),
            'isObject' : namer.operatorIs(compiler.objectClass) });
   }
 
@@ -1141,6 +1154,21 @@ class OldEmitter implements Emitter {
     output.add(N);
   }
 
+  void emitSupportsDirectProtoAccess(CodeOutput output) {
+    jsAst.Statement supportsDirectProtoAccess = js.statement(r'''

[floitsch, 2015/03/06 14:54:09]

Since this is used in a completely different part of the code, use a common
constant to link the places.

Maybe we should have a class: ClassConstructionNames constructionNames;
and then use it with constructionNames.supportsDirectProtoAccess.

This way we wouldn't have all these "final XyzName = '...'" and group them into
nice classes.
Ideally we should then run them through the namer to make sure that they are
safe (and don't shadow anything important).

[herhut, 2015/03/09 14:28:35]

I would actually prefer to emit this as part of the combined
reflectionDataParser with finishClasses, as this should not be visible to other
parts of the code. It currently is here as we have this artificial split between
finishClasses and parsing reflection data. 

I will work with zarah@ to make this happen in a follow up CL.

+      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) {
@@ -1370,6 +1398,7 @@ class OldEmitter implements Emitter {
     // 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(
           """