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 313 matching lines @@
 
           var str = "function " + name + "(";
           var body = "";
           if (#hasIsolateSupport) { var fieldNames = ""; }
 
           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 = "parameter_" + field;
+            var parameter = "p_" + field;
             str += parameter;
             body += ("this." + field + " = " + parameter + ";\n");
           }
           str += ") {\n" + body + "}\n";
           str += name + ".builtin$cls=\"" + name + "\";\n";
-          str += "$desc=$collectedClasses." + name + ";\n";
-          str += "if($desc instanceof Array) $desc = \$desc[1];\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("");
 
@@ skipping 61 matching lines @@
                      classFieldsExtractorAssignment,
                      instanceFromClassIdAssignment,
                      initializeEmptyInstanceAssignment]);
     }
 
     return result;
   }
 
   /** Needs defineClass to be defined. */
   jsAst.Expression buildInheritFrom() {
-    jsAst.Expression result = js(r'''
+    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() {}
-          var hasOwnProperty = Object.prototype.hasOwnProperty;
           return function (constructor, superConstructor) {
-            if (superConstructor == null) {
-              // Fix up the the Dart Object class' prototype.
-              var prototype = constructor.prototype;
-              prototype.constructor = constructor;
-              prototype.#isObject = constructor;
-              return prototype;
-            }
             tmp.prototype = superConstructor.prototype;
             var object = new tmp();
+            convertToSlowObject(object);
             var properties = constructor.prototype;
-            for (var member in properties) {
-              if (hasOwnProperty.call(properties, member)) {
-                object[member] = properties[member];
-              }
+            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;
             constructor.prototype = object;
             return object;
           };
         }()
-      ''', { 'operatorIsPrefix' : js.string(namer.operatorIsPrefix),
-             'isObject' : namer.operatorIs(compiler.objectClass) });
+      """, { 'operatorIsPrefix' : js.string(namer.operatorIsPrefix)});
     if (compiler.hasIncrementalSupport) {
       result = js(
           r'#.inheritFrom = #', [namer.accessIncrementalHelper, result]);
     }
     return js(r'var inheritFrom = #', [result]);
   }
 
   jsAst.Statement buildFinishClass(bool hasNativeClasses) {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
@@ skipping 28 matching lines @@
 
         if (#needsMixinSupport) {
           if (superclass && superclass.indexOf("+") > 0) {
             var s = superclass.split("+");
             superclass = s[0];
             var mixinClass = s[1];
             finishClass(mixinClass);
             var mixin = allClasses[mixinClass];
             var mixinPrototype = mixin.prototype;
             var clsPrototype = allClasses[cls].prototype;
-            for (var d in mixinPrototype) {
-              if (hasOwnProperty.call(mixinPrototype, d) &&
-                  !hasOwnProperty.call(clsPrototype, d))
+
+            var properties = Object.keys(mixinPrototype);
+            for (var i = 0; i < properties.length; i++) {
+              var d = properties[i];
+              if (!hasOwnProperty.call(clsPrototype, d))
                 clsPrototype[d] = mixinPrototype[d];
             }
           }
         }
 
         // The superclass is only false (empty string) for the Dart Object
         // 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") {
-          inheritFrom(allClasses[cls], null);
+          // 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;
           return;
         }
         finishClass(superclass);
         var superConstructor = allClasses[superclass];
 
         if (!superConstructor)
           superConstructor = existingIsolateProperties[superclass];
 
         var constructor = allClasses[cls];
         var prototype = inheritFrom(constructor, superConstructor);
 
         if (#hasNativeClasses)
           if (Object.prototype.hasOwnProperty.call(prototype, $specProperty))
             #nativeInfoHandler
       }
     }''', {'finishedClassesAccess': finishedClassesAccess,
            'needsMixinSupport': needsMixinSupport,
            'hasNativeClasses': hasNativeClasses,
-           'nativeInfoHandler': nativeInfoHandler});
+           'nativeInfoHandler': nativeInfoHandler,
+           '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) {
     if (!element.isClass) return false;
@@ skipping 463 matching lines @@
 
         // 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.
         $finishIsolateConstructorName = function (oldIsolate) {
           var isolateProperties = oldIsolate.#isolatePropertiesName;
           function Isolate() {
-            var hasOwnProperty = Object.prototype.hasOwnProperty;
-            for (var staticName in isolateProperties)
-              if (hasOwnProperty.call(isolateProperties, staticName))
-                this[staticName] = isolateProperties[staticName];
+
+            var staticNames = Object.keys(isolateProperties);
+            for (var i = 0; i < staticNames.length; i++) {
+              var staticName = staticNames[i];
+              this[staticName] = isolateProperties[staticName];
+            }
 
             // Reset lazy initializers to null.
             // When forcing the object to fast mode (below) v8 will consider
             // functions as part the object's map. Since we will change them
             // (after the first call to the getter), we would have a map
             // transition.
             var lazies = init.lazies;
-            for (var lazyInit in lazies) {
-               this[lazies[lazyInit]] = null;
+            var lazyInitializers = lazies ? Object.keys(lazies) : [];
+            for (var i = 0; i < lazyInitializers.length; i++) {
+               this[lazies[lazyInitializers[i]]] = null;
             }
 
             // 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.
             function ForceEfficientMap() {}
             ForceEfficientMap.prototype = this;
             new ForceEfficientMap();
 
             // Now, after being a fast map we can set the lazies again.
-            for (var lazyInit in lazies) {
-              var lazyInitName = lazies[lazyInit];
+            for (var i = 0; i < lazyInitializers.length; i++) {
+              var lazyInitName = lazies[lazyInitializers[i]];
               this[lazyInitName] = isolateProperties[lazyInitName];
             }
           }
           Isolate.prototype = oldIsolate.prototype;
           Isolate.prototype.constructor = Isolate;
           Isolate.#isolatePropertiesName = isolateProperties;
           if (#outputContainsConstantList) {
             Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
           }
           if (#hasIncrementalSupport) {
@@ skipping 47 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);
 
       }
     }
   }
 }