Add a method on native classes for is checks. Reduces the code for generating is checks.

frog/leg/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.
 
 class NativeEmitter {
 
   Compiler compiler;
   StringBuffer buffer;
 
   // Classes that participate in dynamic dispatch. These are the
@@ skipping 30 matching lines @@
         const SourceString('dynamicSetMetadata'));
     return compiler.namer.isolateAccess(element);
   }
 
   String get typeNameOfName() {
     Element element = compiler.findHelper(
         const SourceString('getTypeNameOf'));
     return compiler.namer.isolateAccess(element);
   }
 
-  String get dynamicIsCheckName() {
+  String get defPropName() {
     Element element = compiler.findHelper(
-        const SourceString('dynamicIsCheck'));
-    return compiler.namer.isolateAccess(element);
-  }
-
-  String get isChecksHelperName() {
-    Element element = compiler.findHelper(
-        const SourceString('isChecksHelper'));
-    if (element === null) return null;
+        const SourceString('defineProperty'));
     return compiler.namer.isolateAccess(element);
   }
 
   void generateNativeLiteral(ClassElement classElement) {
     String quotedNative = classElement.nativeName.slowToString();
     String nativeCode = quotedNative.substring(2, quotedNative.length - 1);
     String className = compiler.namer.getName(classElement);
     buffer.add(className);
     buffer.add(' = ');
     buffer.add(nativeCode);
@@ skipping 47 matching lines @@
       return "$dynamicName('$name').$nativeName";
     }
 
     for (Element member in classElement.members) {
       if (member.isInstanceMember()) {
         compiler.emitter.addInstanceMember(
             member, attachTo, buffer, isNative: true);
       }
     }
 
-    // Create an object that contains the is checks properties.
-    buffer.add('$isChecksHelperName.$nativeName = { ');
-    List<String> tests = <String>[];
-
-    ClassElement objectClass =
-        compiler.coreLibrary.find(const SourceString('Object'));
-    ClassElement element = classElement;
-    // We need to put the super class is checks too, since a check on
-    // the subclass can happen before a check on the super class
-    // (which does the patching on the prototype).
-    do {
-      compiler.emitter.generateTypeTests(element, (Element other) {
-        tests.add("${compiler.namer.operatorIs(other)}:true");
-      });
-      element = element.superclass;
-    } while (element !== objectClass);
-
-    buffer.add('${Strings.join(tests, ",")}');
-    buffer.add('};\n');
+    compiler.emitter.generateTypeTests(classElement, (Element other) {
+      assert(requiresNativeIsCheck(other));
+      buffer.add('${attachTo(compiler.namer.operatorIs(other))} = ');
+      buffer.add('function() { return true; };\n');
+    });
 
     if (hasUsedSelectors) classesWithDynamicDispatch.add(classElement);
   }
 
   List<ClassElement> getDirectSubclasses(ClassElement cls) {
     List<ClassElement> result = subtypes[cls];
     if (result === null) result = const<ClassElement>[];
     return result;
   }
 
@@ skipping 151 matching lines @@
         entries.add("\n    ['$clsName', ${tagDefns[cls]}]");
       }
       buffer.add(Strings.join(entries, ','));
       buffer.add('];\n');
       buffer.add('$dynamicSetMetadataName(table);\n');
 
       buffer.add('})();\n');
     }
   }
 
+  bool isSupertypeOfNativeClass(Element element) {
+    if (element.isTypeVariable()) {
+      compiler.cancel("Is check for type variable", element: work.element);
+      return false;
+    }
+    if (element.computeType(compiler) is FunctionType) return false;
+
+    if (!element.isClass()) {
+      compiler.cancel("Is check does not handle element", element: element);
+      return false;
+    }
+
+    return subtypes[element] !== null;
+  }
+
+  bool requiresNativeIsCheck(Element element) {
+    if (!element.isClass()) return false;
+    ClassElement cls = element;
+    if (cls.isNative()) return true;
+    return isSupertypeOfNativeClass(element);
+  }
+
+  void emitIsChecks(StringBuffer buffer) {
+    for (Element type in compiler.universe.isChecks) {
+      if (!requiresNativeIsCheck(type)) continue;
+      String name = compiler.namer.operatorIs(type);
+      buffer.add("$defPropName(Object.prototype, '$name', ");
+      buffer.add('function() { return false; });\n');
+    }
+  }
+
   void assembleCode(StringBuffer other) {
-    if (isChecksHelperName === null) return;
-    other.add('(function() { $isChecksHelperName = {};\n$buffer\n })();\n');
+    StringBuffer isChecks = new StringBuffer();
+    emitIsChecks(isChecks);
+    other.add('(function() {\n$isChecks$buffer\n})();\n');
   }
 }