Encode super calls via extra properties on prototypes.

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 490 matching lines @@
 
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js.statement('''
     {
-      var finishedClasses = #;  // finishedClassesAccess.
+      var finishedClasses = #finishedClassesAccess;
 
       function finishClass(cls) {
 
         if (finishedClasses[cls]) return;
         finishedClasses[cls] = true;
 
         var superclass = pendingClasses[cls];
-
         // 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 constructor = allClasses[cls];
         var superConstructor = allClasses[superclass];
 
         if (!superConstructor)
           superConstructor = existingIsolateProperties[superclass];
 
+        var constructor = allClasses[cls];
         var prototype = inheritFrom(constructor, superConstructor);
 
-        if (#) {  // !nativeClasses.isEmpty,
+        if (#hasNativeClasses) {
           // The property looks like this:
           //
           // HtmlElement: {
           //     "%": "HTMLDivElement|HTMLAnchorElement;HTMLElement;FancyButton"
           //
           // The first two semicolon-separated parts contain dispatch tags, the
           // third contains the JavaScript names for classes.
           //
           // The tags indicate that JavaScript objects with the dispatch tags
           // (usually constructor names) HTMLDivElement, HTMLAnchorElement and
           // HTMLElement all map to the Dart native class named HtmlElement.
           // The first set is for effective leaf nodes in the hierarchy, the
           // second set is non-leaf nodes.
           //
           // The third part contains the JavaScript names of Dart classes that
           // extend the native class. Here, FancyButton extends HtmlElement, so
           // the runtime needs to know that window.HTMLElement.prototype is the
           // prototype that needs to be extended in creating the custom element.
           //
           // The information is used to build tables referenced by
           // getNativeInterceptor and custom element support.
           if (Object.prototype.hasOwnProperty.call(prototype, $specProperty)) {
             var nativeSpec = prototype[$specProperty].split(";");
             if (nativeSpec[0]) {
               var tags = nativeSpec[0].split("|");
               for (var i = 0; i < tags.length; i++) {
-                #[tags[i]] = constructor;  // embedded interceptorsByTag.
-                #[tags[i]] = true;  // embedded leafTags.
+                #interceptorsByTagAccess[tags[i]] = constructor;
+                #leafTagsAccess[tags[i]] = true;
               }
             }
             if (nativeSpec[1]) {
               tags = nativeSpec[1].split("|");
-              if (#) {  // User subclassing of native classes?
+              if (#allowNativesSubclassing) {
                 if (nativeSpec[2]) {
                   var subclasses = nativeSpec[2].split("|");
                   for (var i = 0; i < subclasses.length; i++) {
                     var subclass = allClasses[subclasses[i]];
                     subclass.\$nativeSuperclassTag = tags[0];
                   }
                 }
                 for (i = 0; i < tags.length; i++) {
-                  #[tags[i]] = constructor;  // embedded interceptorsByTag.
-                  #[tags[i]] = false;  // embedded leafTags.
+                  #interceptorsByTagAccess[tags[i]] = constructor;
+                  #leafTagsAccess[tags[i]] = false;
                 }
               }
             }
           }
         }
       }
-    }''', [finishedClassesAccess,
-           !nativeClasses.isEmpty,
-           interceptorsByTagAccess,
-           leafTagsAccess,
-           true,
-           interceptorsByTagAccess,
-           leafTagsAccess]);
+    }''', {'finishedClassesAccess': finishedClassesAccess,
+           'hasNativeClasses': nativeClasses.isNotEmpty,
+           'interceptorsByTagAccess': interceptorsByTagAccess,
+           'leafTagsAccess': leafTagsAccess,
+           'allowNativesSubclassing': true});
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // 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.
     return js('''
       function (oldIsolate) {
@@ skipping 84 matching lines @@
         }
       }
     ''', [laziesAccess, laziesAccess,
           laziesAccess,
           cyclicThrow]);
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
-    ..add(buildInheritFrom())
-    ..add(js('$finishClassesName = #', finishClassesFunction))
-    ..add(initFinishClasses);
+        ..add(buildInheritFrom())
+        ..add(js('$finishClassesName = #', finishClassesFunction))
+        ..add(initFinishClasses);
   }
 
   List buildLazyInitializerFunctionIfNecessary() {
     if (!needsLazyInitializer) return [];
 
     return [js('# = #', [js(lazyInitializerName), lazyInitializerFunction])];
   }
 
   List buildFinishIsolateConstructor() {
     return [
@@ skipping 1305 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }