dart2js: fast startup cache superclass in inheritance

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.dart

 // Copyright (c) 2015, 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.startup_emitter.model_emitter;
 
 /// The name of the property that stores the tear-off getter on a static
 /// function.
 ///
 /// This property is only used when isolates are used.
@@ skipping 825 matching lines @@
     }
 
     return properties;
   }
 
   /// Emits the inheritance block of the fragment.
   ///
   /// In this section prototype chains are updated and mixin functions are
   /// copied.
   js.Statement emitInheritance(Fragment fragment) {
-    List<js.Expression> inheritCalls = <js.Expression>[];
-    List<js.Expression> mixinCalls = <js.Expression>[];
+    List<js.Statement> inheritCalls = <js.Statement>[];
+    List<js.Statement> mixinCalls = <js.Statement>[];
 
     Set<Class> classesInFragment = new Set<Class>();
     for (Library library in fragment.libraries) {
       classesInFragment.addAll(library.classes);
     }
 
-    Set<Class> emittedClasses = new Set<Class>();
+    Map<Class, List<Class>> subclasses = <Class, List<Class>>{};
+    Set<Class> seen = new Set<Class>();
 
-    void emitInheritanceForClass(cls) {
-      if (cls == null || emittedClasses.contains(cls)) return;
+    void collect(cls) {
+      if (cls == null || seen.contains(cls)) return;
 
       Class superclass = cls.superclass;
       if (classesInFragment.contains(superclass)) {
-        emitInheritanceForClass(superclass);
+        collect(superclass);
       }
 
-      js.Expression superclassReference = (superclass == null)
-          ? new js.LiteralNull()
-          : classReference(superclass);
+      subclasses.putIfAbsent(superclass, () => <Class>[]).add(cls);
 
-      inheritCalls.add(
-          js.js('inherit(#, #)', [classReference(cls), superclassReference]));
-
-      emittedClasses.add(cls);
+      seen.add(cls);
     }
 
     for (Library library in fragment.libraries) {
       for (Class cls in library.classes) {
-        emitInheritanceForClass(cls);
+        collect(cls);
 
         if (cls.isMixinApplication) {
           MixinApplication mixin = cls;
-          mixinCalls.add(js.js('mixin(#, #)',
+          mixinCalls.add(js.js.statement('mixin(#, #)',
               [classReference(cls), classReference(mixin.mixinClass)]));
         }
       }
     }
 
+    js.Expression temp = null;
+    for (Class superclass in subclasses.keys) {
+      List<Class> list = subclasses[superclass];
+      js.Expression superclassReference = (superclass == null)
+          ? new js.LiteralNull()
+          : classReference(superclass);
+      if (list.length == 1) {
+        inheritCalls.add(js.js.statement('inherit(#, #)',
+            [classReference(list.single), superclassReference]));
+      } else {
+        // Hold common superclass in temporary for sequence of calls.
+        if (temp == null) {
+          String tempName = '_';
+          temp = new js.VariableUse(tempName);
+          var declaration = new js.VariableDeclaration(tempName);
+          inheritCalls.add(
+              js.js.statement('var # = #', [declaration, superclassReference]));
+        } else {
+          inheritCalls
+              .add(js.js.statement('# = #', [temp, superclassReference]));
+        }
+        for (Class cls in list) {
+          inheritCalls.add(
+              js.js.statement('inherit(#, #)', [classReference(cls), temp]));
+        }
+      }
+    }
+
     return wrapPhase(
-        'inheritance',
-        js.js.statement('{#; #;}', [
-          inheritCalls.map((e) => new js.ExpressionStatement(e)),
-          mixinCalls.map((e) => new js.ExpressionStatement(e))
-        ]));
+        'inheritance', js.js.statement('{#; #;}', [inheritCalls, mixinCalls]));
   }
 
   /// Emits the setup of method aliases.
   ///
   /// This step consists of simply copying JavaScript functions to their
   /// aliased names so they point to the same function.
   js.Statement emitInstanceMethodAliases(Fragment fragment) {
     List<js.Statement> assignments = <js.Statement>[];
 
     for (Library library in fragment.libraries) {
@@ skipping 511 matching lines @@
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(
         js.js.statement("setOrUpdateLeafTags(#);", js.objectLiteral(leafTags)));
     statements.addAll(subclassAssignments);
 
     return wrapPhase('nativeSupport', new js.Block(statements));
   }
 }