Only emit support for aliasing methods if super calls are present.

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 337 matching lines @@
          # = Object.create(null);  // embedded leafTags.
          # = Object.create(null);  // embedded finishedClasses
         })()
       ''', [allClassesAccess,
             interceptorsByTagAccess,
             leafTagsAccess,
             finishedClassesAccess]);
   }
 
   List buildSplitOffAliases() {
+    if (backend.aliasedSuperMembers.isEmpty) return [];
     return [js(r'''
         var splitOffAliases = function(constructor) {
           var hasOwnProperty = Object.prototype.hasOwnProperty;
           var properties = constructor.prototype;
           for (var member in properties) {
             if (hasOwnProperty.call(properties, member)) {
               var s = member.split(':');
               if (s.length > 1) {
                 properties[s[0]] = properties[s[1]] = properties[member];
                 delete properties[member];
@@ skipping 168 matching lines @@
       function finishClass(cls) {
 
         if (finishedClasses[cls]) return;
         finishedClasses[cls] = true;
 
         var superclass = pendingClasses[cls];
         var constructor = allClasses[cls];
 
         // Process aliased members due to super calls. We have to do this early
         // to ensure that we also hit the object class.
-        splitOffAliases(constructor);
+        if (#) splitOffAliases(constructor);
 
         // 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") return;
         finishClass(superclass);
         var superConstructor = allClasses[superclass];
 
         if (!superConstructor)
@@ skipping 45 matching lines @@
                 for (i = 0; i < tags.length; i++) {
                   #[tags[i]] = constructor;  // embedded interceptorsByTag.
                   #[tags[i]] = false;  // embedded leafTags.
                 }
               }
             }
           }
         }
       }
     }''', [finishedClassesAccess,
+           backend.aliasedSuperMembers.isNotEmpty,
            !nativeClasses.isEmpty,
            interceptorsByTagAccess,
            leafTagsAccess,
            true,
            interceptorsByTagAccess,
            leafTagsAccess]);
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
@@ skipping 1387 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }