Implement is-checks with typedefs for callable objects.

sdk/lib/_internal/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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 41 matching lines @@
    */
   final Map<int, String> boundClosureCache;
 
   /**
    * A cache of closures that are used to closurize instance methods
    * of interceptors. These closures are dynamically bound to the
    * interceptor instance, and the actual receiver of the method.
    */
   final Map<int, String> interceptorClosureCache;
   Set<ClassElement> checkedClasses;
+  Set<TypedefElement> checkedTypedefs;
 
   final bool generateSourceMap;
 
   CodeEmitterTask(Compiler compiler, Namer namer, this.generateSourceMap)
       : boundClosureBuffer = new CodeBuffer(),
         mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
         interceptorClosureCache = new Map<int, String>(),
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void computeRequiredTypeChecks() {
     assert(checkedClasses == null);
     checkedClasses = new Set<ClassElement>();
+    checkedTypedefs = new Set<TypedefElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
-      if (t is InterfaceType) checkedClasses.add(t.element);
+      if (t is InterfaceType) {
+        checkedClasses.add(t.element);
+      } else if (t is TypedefType) {
+        checkedTypedefs.add(t.element);
+      }
     });
   }
 
   js.Expression constantReference(Constant value) {
     return constantEmitter.reference(value);
   }
 
   js.Expression constantInitializerExpression(Constant value) {
     return constantEmitter.initializationExpression(value);
   }
@@ skipping 624 matching lines @@
 
     classElement.implementation.forEachMember(
         (ClassElement enclosing, Element member) {
           assert(invariant(classElement, member.isDeclaration));
           if (member.isInstanceMember()) {
             addInstanceMember(member, defineInstanceMember);
           }
         },
         includeBackendMembers: true);
 
-    generateIsTestsOn(classElement, (ClassElement other) {
+    generateIsTestsOn(classElement, (Element other) {
       String code;
-      if (other.isObject(compiler)) return;
+      if (compiler.objectClass == other) return;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = 'function() { return true; }';
       } else {
         code = 'true';
       }
       CodeBuffer typeTestBuffer = new CodeBuffer();
       typeTestBuffer.add(code);
       defineInstanceMember(namer.operatorIs(other), typeTestBuffer);
     });
 
@@ skipping 278 matching lines @@
       defineInstanceMember(name, code);
     }
   }
 
   /**
    * 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)) {
+                         void emitIsTest(Element element)) {
     if (checkedClasses.contains(cls)) {
       emitIsTest(cls);
     }
+
     Set<Element> generated = new Set<Element>();
     // A class that defines a [:call:] method implicitly implements
-    // [Function].
-    if (checkedClasses.contains(compiler.functionClass)
-        && cls.lookupLocalMember(Compiler.CALL_OPERATOR_NAME) != null) {
-      generateInterfacesIsTests(compiler.functionClass, emitIsTest, generated);
+    // [Function] and needs checks for all typedefs that are used in is-checks.
+    if (checkedClasses.contains(compiler.functionClass) ||
+        !checkedTypedefs.isEmpty) {
+      FunctionElement call = cls.lookupLocalMember(Compiler.CALL_OPERATOR_NAME);
+      if (call != null) {
+        generateInterfacesIsTests(compiler.functionClass,
+                                  emitIsTest,
+                                  generated);
+        FunctionType callType = call.computeType(compiler);
+        for (TypedefElement typedef in checkedTypedefs) {
+          FunctionType typedefType =
+              typedef.computeType(compiler).unalias(compiler);
+          if (compiler.types.isSubtype(callType, typedefType)) {
+            emitIsTest(typedef);
+          }
+        }
+      }
     }
     for (DartType interfaceType in cls.interfaces) {
       generateInterfacesIsTests(interfaceType.element, emitIsTest, generated);
     }
   }
 
   /**
    * Generate "is tests" where [cls] is being implemented.
    */
   void generateInterfacesIsTests(ClassElement cls,
@@ skipping 915 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].
 """;