Make use of __proto__ when available.

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 402 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.
+    (function () {
+      var cls = function () {};
+      cls.prototype = {'p': {}};
+      var object = new cls();
+      return object.__proto__ &&
+             object.__proto__.p === cls.prototype.p;
+     })() ?
+        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 662 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 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 344 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);
+
     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 514 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }