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

frog/leg/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 147 matching lines @@
     buffer.add('$parametersString) {\n');
 
     if (isNative) {
       nativeEmitter.emitParameterStub(
           member, invocationName, parametersString, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else {
       String arguments = Strings.join(argumentsBuffer, ",");
       buffer.add('  return this.${namer.getName(member)}($arguments)');
   }
-    buffer.add('\n}\n');
+    buffer.add('\n};\n');
   }
 
   void addParameterStubs(FunctionElement member,
                          String attachTo(String invocationName),
                          StringBuffer buffer,
                          [bool isNative = false]) {
     Set<Selector> selectors = compiler.universe.invokedNames[member.name];
     if (selectors == null) return;
     FunctionParameters parameters = member.computeParameters(compiler);
     for (Selector selector in selectors) {
@@ skipping 132 matching lines @@
       if (member.isInstanceMember()) {
         addInstanceMember(member, attachTo, buffer);
       }
     }
     for (Element member in classElement.backendMembers) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, attachTo, buffer);
       }
     }
     generateTypeTests(classElement, (Element other) {
-      buffer.add('${attachTo(namer.operatorIs(other))} = true;\n');
+      buffer.add('${attachTo(namer.operatorIs(other))} = ');
+      if (nativeEmitter.requiresNativeIsCheck(other)) {
+        buffer.add('function() { return true; }');
+      } else {
+        buffer.add('true');
+      }
+      buffer.add(';\n');
     });
 
     if (classElement === compiler.objectClass && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethods on the Object prototype now, so that
       // the code in the dynamicMethod can find them. Note that the
       // code in dynamicMethod is invoked before analyzing the full JS
       // script.
       emitNoSuchMethodCalls(buffer);
     }
   }
 
   void generateTypeTests(ClassElement cls,
                          void generateTypeTest(ClassElement element)) {
     if (compiler.universe.isChecks.contains(cls)) {
       generateTypeTest(cls);
     }
-    generateInterfacesIsTests(cls, generateTypeTest);
+    generateInterfacesIsTests(cls, generateTypeTest, new Set<Element>());
   }
 
   void generateInterfacesIsTests(ClassElement cls,
-                                 void generateTypeTest(ClassElement element)) {
+                                 void generateTypeTest(ClassElement element),
+                                 Set<Element> alreadyGenerated) {
     for (Type interfaceType in cls.interfaces) {
       Element element = interfaceType.element;
-      if (compiler.universe.isChecks.contains(element)) {
+      if (!alreadyGenerated.contains(element) &&
+          compiler.universe.isChecks.contains(element)) {
+        alreadyGenerated.add(element);
         generateTypeTest(element);
       }
-      generateInterfacesIsTests(element, generateTypeTest);
+      generateInterfacesIsTests(element, generateTypeTest, alreadyGenerated);
     }
   }
 
   void emitClasses(StringBuffer buffer) {
     for (ClassElement element in compiler.universe.instantiatedClasses) {
       ensureGenerated(element, buffer);
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
@@ skipping 347 matching lines @@
       nativeEmitter.emitDynamicDispatchMetadata();
       mainBuffer.add(
           'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }