Inline special case of inheritFrom to call site.

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 406 matching lines @@
 
     return result;
   }
 
   /** Needs defineClass to be defined. */
   jsAst.Expression buildInheritFrom() {
     jsAst.Expression result = js(r"""
         function() {
           function tmp() {}
           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();
             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;
             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 43 matching lines @@
                 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 1456 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }