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;
   bool addedDynamicFunction = false;
   bool addedTypeNameOfFunction = false;
   bool addedDefPropFunction = false;
@@ skipping 157 matching lines @@
   };
   dynamicBind.methods = methods;
   $defPropName(Object.prototype, name, dynamicBind);
   return methods;
 }''';
 }
 
   String buildDynamicMetadataCode() => '''
 if (typeof $dynamicMetadataName == 'undefined') $dynamicMetadataName = [];''';
 
-  // This method will be called for 'is' checks on native types.
-  // It takes the object on which the 'is' check is being done, and the
-  // property name for the type check. The method patches the real
-  // prototype of the object with the value from the Dart object
-  // (see [generateNativeClass]).
-  String buildDynamicIsCheckCode() {
-    ClassElement objectClass =
-        compiler.coreLibrary.find(const SourceString('Object'));
-    return '''
-function(obj, isCheck) {
-  if (obj.constructor === Array) return false;
-  var proto = Object.getPrototypeOf(obj);
-  // Check if the Dart object corresponding to this class has the property.
-  var res =
-      !!${compiler.namer.CURRENT_ISOLATE}.native[$typeNameOfName(obj)][isCheck];
-  res = res || false;
-  $defPropName(proto, isCheck, res);
-  return res;
-}''';
-  }
-
-  String buildNativePropertyCode() => '''
-${compiler.namer.ISOLATE}.prototype.native = {};''';
 
   String buildDynamicSetMetadataCode() => """
 function(inputTable) {
   // TODO: Deal with light isolates.
   var table = [];
   for (var i = 0; i < inputTable.length; i++) {
     var tag = inputTable[i][0];
     var tags = inputTable[i][1];
     var map = {};
     var tagNames = tags.split('|');
     for (var j = 0; j < tagNames.length; j++) {
       map[tagNames[j]] = true;
     }
     table.push({tag: tag, tags: tags, map: map});
   }
   $dynamicMetadataName = table;
 }""";
 
 
   String get dynamicName() => '${compiler.namer.ISOLATE}.\$dynamic';
   String get defPropName() => '${compiler.namer.ISOLATE}.\$defProp';
   String get typeNameOfName() => '${compiler.namer.ISOLATE}.\$typeNameOf';
   String get dynamicMetadataName() =>
       '${compiler.namer.ISOLATE}.\$dynamicMetatada';
-  String get dynamicIsCheckName() =>
-      '${compiler.namer.ISOLATE}.\$dynamicIsCheck';
   String get dynamicSetMetadataName() =>
       '${compiler.namer.ISOLATE}.\$dynamicSetMetatada';
 
   void addDynamicFunctionIfNecessary(StringBuffer buffer) {
     if (addedDynamicFunction) return;
     addedDynamicFunction = true;
     addTypeNameOfFunctionIfNecessary(buffer);
     buffer.add('$dynamicName = ');
     buffer.add(buildDynamicFunctionCode());
     buffer.add('\n');
@@ skipping 11 matching lines @@
   }
 
   void addDefPropFunctionIfNecessary(StringBuffer buffer) {
     if (addedDefPropFunction) return;
     addedDefPropFunction = true;
     buffer.add('$defPropName = ');
     buffer.add(DEF_PROP_FUNCTION);
     buffer.add('\n');
   }
 
-  void addNativePropertyIfNecessary(StringBuffer buffer) {
-    if (addedNativeProperty) return;
-    addedNativeProperty = true;
-    buffer.add(buildNativePropertyCode());
-    buffer.add('\n');
-  }
-
   void generateNativeLiteral(ClassElement classElement, StringBuffer buffer) {
     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);
     buffer.add(';\n');
 
     String attachTo(name) => "$className.$name";
@@ skipping 45 matching lines @@
       return "$dynamicName('$name').$nativeName";
     }
 
     for (Element member in classElement.members) {
       if (member.isInstanceMember()) {
         compiler.emitter.addInstanceMember(
             member, attachTo, buffer, isNative: true);
       }
     }
 
-    addNativePropertyIfNecessary(buffer);
-    // Create an object that contains the is checks properties. The
-    // object will be used when entering [buildDynamicIsCheckCode].
-    buffer.add('${compiler.namer.ISOLATE}.prototype.native.$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

[floitsch, 2012/03/26 20:32:59]

Remove comment.

[ngeoffray, 2012/03/27 10:48:53]

Done.

     // 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 37 matching lines @@
     buffer.add("'$invocationName')) {\n");
     buffer.add('    return this.${member.name.slowToString()}');
     buffer.add('($nativeArguments)');
     buffer.add('\n  }\n');
     buffer.add('  return Object.prototype.$invocationName.call(this');
     buffer.add(stubParameters == '' ? '' : ', $stubParameters');
     buffer.add(');');
   }
 
   void emitDynamicDispatchMetadata(StringBuffer buffer) {
-    // TODO(ngeoffray): emit this conditionally.
-    addTypeNameOfFunctionIfNecessary(buffer);
-    buffer.add('$dynamicIsCheckName = ');
-    buffer.add(buildDynamicIsCheckCode());
-    buffer.add('\n');
-
     if (classesWithDynamicDispatch.isEmpty()) return;
     buffer.add('// ${classesWithDynamicDispatch.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)) {
@@ skipping 98 matching lines @@
         String clsName = toNativeName(cls);
         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;
+      addDefPropFunctionIfNecessary(buffer);
+      String name = compiler.namer.operatorIs(type);
+      buffer.add("$defPropName(Object.prototype, '$name', ");
+      buffer.add('function() { return false; });\n');
+    }
+  }
 }