Fix missing classes in native emitters superclass info.

sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.dart

 // Copyright (c) 2012, 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 js_backend;
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 267 matching lines @@
     if (classesWithDynamicDispatch.isEmpty) return;
     int length = classesWithDynamicDispatch.length;
     nativeBuffer.add('// $length dynamic classes.\n');
 
     // Build a pre-order traversal over all the classes and their subclasses.
     Set<ClassElement> seen = new Set<ClassElement>();
     List<ClassElement> classes = <ClassElement>[];
     void visit(ClassElement cls) {
       if (seen.contains(cls)) return;
       seen.add(cls);
-      for (final ClassElement subclass in getDirectSubclasses(cls)) {
-        visit(subclass);
-      }
+      getDirectSubclasses(cls).forEach(visit);
       classes.add(cls);
     }
-    for (final ClassElement classElement in classesWithDynamicDispatch) {
-      visit(classElement);
-    }
+    classesWithDynamicDispatch.forEach(visit);
 
-    Collection<ClassElement> dispatchClasses = classes.filter(
+    Collection<ClassElement> preorderDispatchClasses = classes.filter(
         (cls) => !getDirectSubclasses(cls).isEmpty &&
                   classesWithDynamicDispatch.contains(cls));
 
     nativeBuffer.add('// ${classes.length} classes\n');
     Collection<ClassElement> classesThatHaveSubclasses = classes.filter(
         (ClassElement t) => !getDirectSubclasses(t).isEmpty);
     nativeBuffer.add('// ${classesThatHaveSubclasses.length} !leaf\n');
 
     // Generate code that builds the map from cls tags used in dynamic dispatch
     // to the set of cls tags of classes that extend (TODO: or implement) those
     // classes.  The set is represented as a string of tags joined with '|'.
     // This is easily split into an array of tags, or converted into a regexp.
     //
     // To reduce the size of the sets, subsets are CSE-ed out into variables.
     // The sets could be much smaller if we could make assumptions about the
     // cls tags of other classes (which are constructor names or part of the
     // result of Object.protocls.toString).  For example, if objects that are
     // Dart objects could be easily excluded, then we might be able to simplify
     // the test, replacing dozens of HTMLxxxElement classes with the regexp
     // /HTML.*Element/.
 
     // Temporary variables for common substrings.
     List<String> varNames = <String>[];
-    // var -> expression
-    Map<dynamic, js.Expression> varDefns = new Map<dynamic, js.Expression>();
-    // tag -> expression (a string or a variable)
+    // Values of temporary variables.
+    Map<String, js.Expression> varDefns = new Map<String, js.Expression>();
+
+    // Expression to compute tags string for a class.  The expression will
+    // initially be a string or expression building a string, but may be
+    // replaced with a variable reference to the common substring.
     Map<ClassElement, js.Expression> tagDefns =
         new Map<ClassElement, js.Expression>();
 
     js.Expression makeExpression(ClassElement classElement) {
       // Expression fragments for this set of cls keys.
       List<js.Expression> expressions = <js.Expression>[];
       // TODO: Remove if cls is abstract.
       List<String> subtags = [toNativeName(classElement)];
       void walk(ClassElement cls) {
         for (final ClassElement subclass in getDirectSubclasses(cls)) {
           ClassElement tag = subclass;
-          var existing = tagDefns[tag];
+          js.Expression existing = tagDefns[tag];
           if (existing == null) {
+            // [subclass] is still within the subtree between dispatch classes.
             subtags.add(toNativeName(tag));
             walk(subclass);
           } else {
-            if (varDefns.containsKey(existing)) {
-              expressions.add(existing);
+            // [subclass] is one of the preorderDispatchClasses, so CSE this
+            // reference with the previous reference.
+            if (existing is js.VariableUse &&
+                varDefns.containsKey(existing.name)) {
+              // We end up here if the subclasses have a DAG structure.  We
+              // don't have DAGs yet, but if the dispatch is used for mixins
+              // that will be a possibility.
+              // Re-use the previously created temporary variable.
+              expressions.add(new js.VariableUse(existing.name));
             } else {
               String varName = 'v${varNames.length}_${tag.name.slowToString()}';
               varNames.add(varName);
               varDefns[varName] = existing;
               tagDefns[tag] = new js.VariableUse(varName);
               expressions.add(new js.VariableUse(varName));
             }
           }
         }
       }
       walk(classElement);
+
       if (!subtags.isEmpty) {
         expressions.add(
             new js.LiteralString("'${Strings.join(subtags, '|')}'"));
       }
       js.Expression expression;
       if (expressions.length == 1) {
         expression = expressions[0];
       } else {
         js.Expression array = new js.ArrayInitializer.from(expressions);
         expression = new js.Call(
             new js.PropertyAccess.field(array, 'join'),
             [new js.LiteralString("'|'")]);
       }
       return expression;
     }
 
-    for (final ClassElement classElement in dispatchClasses) {
+    for (final ClassElement classElement in preorderDispatchClasses) {
       tagDefns[classElement] = makeExpression(classElement);
     }
 
     // Write out a thunk that builds the metadata.
     if (!tagDefns.isEmpty) {
       List<js.Statement> statements = <js.Statement>[];
 
       List<js.VariableInitialization> initializations =
           <js.VariableInitialization>[];
       for (final String varName in varNames) {
         initializations.add(
             new js.VariableInitialization(
                 new js.VariableDeclaration(varName),
                 varDefns[varName]));
       }
       if (!initializations.isEmpty) {
         statements.add(
             new js.ExpressionStatement(
                 new js.VariableDeclarationList(initializations)));
       }
 
       // [table] is a list of lists, each inner list of the form:
       //   [dynamic-dispatch-tag, tags-of-classes-implementing-dispatch-tag]
       // E.g.
       //   [['Node', 'Text|HTMLElement|HTMLDivElement|...'], ...]
       js.Expression table =
           new js.ArrayInitializer.from(
-              dispatchClasses.map((cls) =>
+              preorderDispatchClasses.map((cls) =>
                   new js.ArrayInitializer.from([
                       new js.LiteralString("'${toNativeName(cls)}'"),
                       tagDefns[cls]])));
 
       //  $.dynamicSetMetadata(table);
       statements.add(
           new js.ExpressionStatement(
               new js.Call(
                   new js.VariableUse(dynamicSetMetadataName),
                   [table])));
@@ skipping 90 matching lines @@
         if (!first) targetBuffer.add(",\n");
         targetBuffer.add(" $name: $function");
         first = false;
       });
       targetBuffer.add("\n});\n\n");
     }
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }