Fix algorithm to know whether we should emit an is check on a class: all interfaces/implemented cla…

lib/compiler/implementation/js_backend/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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 619 matching lines @@
       buffer.add(memberBuffer);
     }
 
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, defineInstanceMember);
       }
     });
 
-    generateTypeTests(classElement, (Element other) {
+    generateIsTestsOn(classElement, (Element other) {
       String code;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = 'function() { return true; }';
       } else {
         code = 'true';
       }
       CodeBuffer typeTestBuffer = new CodeBuffer();
       typeTestBuffer.add(code);
       defineInstanceMember(namer.operatorIs(other), typeTestBuffer);
     });
@@ skipping 38 matching lines @@
     // syntax.
     buffer.add(' "super": "$superName"');
     if (!checkedSetters.isEmpty()) {
       buffer.add(',\n');
       buffer.add('${Strings.join(checkedSetters, ",\n")}');
     }
     emitInstanceMembers(classElement, buffer, true);
     buffer.add('\n};\n\n');
   }
 
-  void generateTypeTests(ClassElement cls,
-                         void generateTypeTest(ClassElement element)) {
+  /**
+   * Generate "is tests" for [cls]: itself, and the "is tests" for the
+   * classes it implements. We don't need to add the "is tests" of the
+   * super class because they will be inherited at runtime.
+   */
+  void generateIsTestsOn(ClassElement cls,
+                         void emitIsTest(ClassElement element)) {
     if (checkedClasses.contains(cls)) {
-      generateTypeTest(cls);
+      emitIsTest(cls);
     }
-    generateInterfacesIsTests(cls, generateTypeTest, new Set<Element>());
-  }
-
-  void generateInterfacesIsTests(ClassElement cls,
-                                 void generateTypeTest(ClassElement element),
-                                 Set<Element> alreadyGenerated) {
+    Set<Element> generated = new Set<Element>();
     for (DartType interfaceType in cls.interfaces) {
-      Element element = interfaceType.element;
-      if (!alreadyGenerated.contains(element) &&
-          checkedClasses.contains(element)) {
-        alreadyGenerated.add(element);
-        generateTypeTest(element);
-      }
-      generateInterfacesIsTests(element, generateTypeTest, alreadyGenerated);
-
-      // Since [element] is implemented by [cls], we need to also emit
-      // is checks for the superclass and its supertypes.
-      ClassElement superclass = element.superclass;
-      if (!alreadyGenerated.contains(superclass) &&
-          checkedClasses.contains(superclass)) {
-        alreadyGenerated.add(superclass);
-        generateTypeTest(superclass);
-      }
-      generateInterfacesIsTests(superclass, generateTypeTest, alreadyGenerated);
+      generateInterfacesIsTests(interfaceType.element, emitIsTest, generated);
     }
   }
 
+  /**
+   * Generate "is tests" where [cls] is being implemented.
+   */
+  void generateInterfacesIsTests(ClassElement cls,
+                                 void emitIsTest(ClassElement element),
+                                 Set<Element> alreadyGenerated) {
+    void tryEmitTest(ClassElement cls) {
+      if (!alreadyGenerated.contains(cls) && checkedClasses.contains(cls)) {
+        alreadyGenerated.add(cls);
+        emitIsTest(cls);
+      }
+    };
+
+    tryEmitTest(cls);
+
+    for (DartType interfaceType in cls.interfaces) {
+      Element element = interfaceType.element;
+      tryEmitTest(element);
+      generateInterfacesIsTests(element, emitIsTest, alreadyGenerated);
+    }
+
+    // We need to also emit "is checks" for the superclass and its supertypes.
+    ClassElement superclass = cls.superclass;
+    if (superclass != null) {
+      tryEmitTest(superclass);
+      generateInterfacesIsTests(superclass, emitIsTest, alreadyGenerated);
+    }
+  }
+
   void emitClasses(CodeBuffer buffer) {
     // Compute the required type checks to know which classes need a
     // 'is$' method.
     computeRequiredTypeChecks();
     Set<ClassElement> instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses;
     Set<ClassElement> neededClasses =
         new Set<ClassElement>.from(instantiatedClasses);
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
@@ skipping 620 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;