Support runtime check of function types.

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 90 matching lines @@
    * `x is Set<String>` then the ClassElement `Set` will occur once in
    * [checkedClasses].
    */
   Set<ClassElement> checkedClasses;
 
   /**
    * Raw Typedef symbols occuring in is-checks and type assertions.  If the
    * program contains `x is F<int>` and `x is F<bool>` then the TypedefElement
    * `F` will occur once in [checkedTypedefs].
    */
-  Set<TypedefElement> checkedTypedefs;
+  Set<FunctionType> checkedFunctionTypes;
+
+  Map<ClassElement, Set<FunctionType>> checkedGenericFunctionTypes
+      = new Map<ClassElement, Set<FunctionType>>();
+
+  Set<FunctionType> checkedNonGenericFunctionTypes
+      = new Set<FunctionType>();
+
+  void registerDynamicFunctionTypeCheck(FunctionType functionType) {
+    ClassElement classElement = Types.getClassContext(functionType);
+    if (classElement != null) {
+      checkedGenericFunctionTypes.putIfAbsent(classElement,
+          () => new Set<FunctionType>()).add(functionType);
+    } else {
+      checkedNonGenericFunctionTypes.add(functionType);
+    }
+  }
 
   final bool generateSourceMap;
 
   Iterable<ClassElement> cachedClassesUsingTypeVariableTests;
 
   Iterable<ClassElement> get classesUsingTypeVariableTests {
     if (cachedClassesUsingTypeVariableTests == null) {
       cachedClassesUsingTypeVariableTests = compiler.codegenWorld.isChecks
           .where((DartType t) => t is TypeVariableType)
           .map((TypeVariableType v) => v.element.getEnclosingClass())
@@ skipping 10 matching lines @@
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void addComment(String comment, CodeBuffer buffer) {
     buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
   void computeRequiredTypeChecks() {
-    assert(checkedClasses == null && checkedTypedefs == null);
+    assert(checkedClasses == null && checkedFunctionTypes == null);
 
     compiler.codegenWorld.addImplicitChecks(classesUsingTypeVariableTests);
 
     checkedClasses = new Set<ClassElement>();
-    checkedTypedefs = new Set<TypedefElement>();
+    checkedFunctionTypes = new Set<FunctionType>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
       if (t is InterfaceType) {
         checkedClasses.add(t.element);
-      } else if (t is TypedefType) {
-        checkedTypedefs.add(t.element);
+      } else if (t is FunctionType) {
+        checkedFunctionTypes.add(t);
       }
     });
   }
 
   jsAst.Expression constantReference(Constant value) {
     return constantEmitter.reference(value);
   }
 
   jsAst.Expression constantInitializerExpression(Constant value) {
     return constantEmitter.initializationExpression(value);
@@ skipping 804 matching lines @@
         return;
       }
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = js.fun([], [js.return_(true)]);
       } else {
         code = new jsAst.LiteralBool(true);
       }
       builder.addProperty(namer.operatorIs(other), code);
     }
 
+    void generateIsFunctionTypeTest(FunctionType type) {
+      builder.addProperty(namer.operatorIsFunctionType(type),
+          new jsAst.LiteralBool(true));
+    }
+
+    void generateFunctionTypeSignature(FunctionType type) {
+      RuntimeTypeInformation rti = backend.rti;
+      String encoding = rti.getTypeEncoding(type, alwaysGenerateFunction: true);
+      String operatorSignature = namer.operatorSignature();
+      builder.addProperty(operatorSignature,
+          new jsAst.LiteralExpression(encoding));
+    }
+
     void generateSubstitution(Element other, {bool emitNull: false}) {
       RuntimeTypeInformation rti = backend.rti;
       // TODO(karlklose): support typedefs with variables.
       jsAst.Expression expression;
       bool needsNativeCheck = nativeEmitter.requiresNativeIsCheck(other);
       if (other.kind == ElementKind.CLASS) {
         String substitution = rti.getSupertypeSubstitution(classElement, other,
             alwaysGenerateFunction: true);
         if (substitution != null) {
           expression = new jsAst.LiteralExpression(substitution);
         } else if (emitNull || needsNativeCheck) {
           expression = new jsAst.LiteralNull();
         }
       }
       if (expression != null) {
         if (needsNativeCheck) {
           expression = js.fun([], js.return_(expression));
         }
         builder.addProperty(namer.substitutionName(other), expression);
       }
     }
 
-    generateIsTestsOn(classElement, generateIsTest, generateSubstitution);
+    generateIsTestsOn(classElement, generateIsTest,
+        generateIsFunctionTypeTest, generateFunctionTypeSignature,
+        generateSubstitution);
 
     if (identical(classElement, compiler.objectClass)
         && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethod handlers on the Object prototype now,
       // so that the code in the dynamicFunction helper can find
       // them. Note that this helper is invoked before analyzing the
       // full JS script.
       if (!nativeEmitter.handleNoSuchMethod) {
         emitNoSuchMethodHandlers(builder.addProperty);
       }
@@ skipping 37 matching lines @@
     for (ClassElement cls in typeChecks) {
       String holder = namer.isolateAccess(cls);
       for (ClassElement check in typeChecks[cls]) {
         buffer.write('$holder.${namer.operatorIs(check)}$_=${_}true$N');
         String body = rti.getSupertypeSubstitution(cls, check);
         if (body != null) {
           buffer.write('$holder.${namer.substitutionName(check)}$_=${_}$body$N');
         }
       };
     }
+
+    checkedNonGenericFunctionTypes.forEach((FunctionType type) {
+      String encoding = rti.getTypeEncoding(type);
+      buffer.add('${namer.signatureName(type)}$_=${_}$encoding$N');
+    });
+
+    checkedGenericFunctionTypes.forEach(
+        (ClassElement cls, Set<FunctionType> functionTypes) {
+          for (FunctionType type in functionTypes) {
+            String encoding = rti.getTypeEncoding(type);
+            buffer.add('${namer.signatureName(type)}$_=${_}$encoding$N');
+          }
+        });
   }
 
   void visitNativeMixins(ClassElement classElement,
                          void visit(MixinApplicationElement mixinApplication)) {
     if (!classElement.isNative()) return;
     // Use recursion to make sure to visit the superclasses before the
     // subclasses. Once we start keeping track of the emitted fields
     // and members, we're going to want to visit these in the other
     // order so we get the most specialized definition first.
     void recurse(ClassElement cls) {
@@ skipping 315 matching lines @@
     return arity;
   }
 
   int _compareSelectorNames(Selector selector1, Selector selector2) {
     String name1 = selector1.name.toString();
     String name2 = selector2.name.toString();
     if (name1 != name2) return Comparable.compare(name1, name2);
     return _selectorRank(selector1) - _selectorRank(selector2);
   }
 
-  Iterable<Element> getTypedefChecksOn(DartType type) {
-    bool isSubtype(TypedefElement typedef) {
-      FunctionType typedefType =
-          typedef.computeType(compiler).unalias(compiler);
-      return compiler.types.isSubtype(type, typedefType);
+  /**
+   * Returns a mapping containing all checked function types for which [type]
+   * can be a subtype. A function type is mapped to [:true:] if [type] is
+   * statically known to be a subtype of it.
+   */
+  // TODO(johnniwinther): Change to return a mapping from function types to
+  // a set of variable points and use this to detect statically/dynamically
+  // known subtype relations.
+  Map<FunctionType, bool> getFunctionTypeChecksOn(DartType type) {
+    Map<FunctionType, bool> functionTypeMap =
+        new LinkedHashMap<FunctionType, bool>();
+    for (FunctionType functionType in checkedFunctionTypes) {
+      if (compiler.types.isSubtype(type, functionType)) {
+        functionTypeMap[functionType] = true;
+      } else if (compiler.types.isPotentialSubtype(type, functionType)) {
+        functionTypeMap[functionType] = false;
+      }
     }
-    return checkedTypedefs.where(isSubtype).toList()
-        ..sort(Elements.compareByPosition);
+    // TODO(johnniwinther): Ensure stable ordering of the keys.
+    return functionTypeMap;
   }
 
   /**
    * Generate "is tests" for [cls]: itself, and the "is tests" for the
    * classes it implements and type argument substitution functions for these
    * tests.   We don't need to add the "is tests" of the super class because
    * they will be inherited at runtime, but we may need to generate the
    * substitutions, because they may have changed.
    */
   void generateIsTestsOn(ClassElement cls,
                          void emitIsTest(Element element),
+                         void emitIsFunctionTypeTest(FunctionType type),
+                         void emitFunctionTypeSignature(FunctionType type),
                          void emitSubstitution(Element element, {emitNull})) {
     if (checkedClasses.contains(cls)) {
       emitIsTest(cls);
       emitSubstitution(cls);
     }
 
     RuntimeTypeInformation rti = backend.rti;
     ClassElement superclass = cls.superclass;
 
     bool haveSameTypeVariables(ClassElement a, ClassElement b) {
@@ skipping 31 matching lines @@
         }
       }
       void emitNothing(_, {emitNull}) {};
       emitSubstitution = emitNothing;
     }
 
     Set<Element> generated = new Set<Element>();
     // A class that defines a [:call:] method implicitly implements
     // [Function] and needs checks for all typedefs that are used in is-checks.
     if (checkedClasses.contains(compiler.functionClass) ||
-        !checkedTypedefs.isEmpty) {
+        !checkedFunctionTypes.isEmpty) {
       FunctionElement call = cls.lookupLocalMember(Compiler.CALL_OPERATOR_NAME);
       if (call == null) {
         // If [cls] is a closure, it has a synthetic call operator method.
         call = cls.lookupBackendMember(Compiler.CALL_OPERATOR_NAME);
       }
       if (call != null) {
         generateInterfacesIsTests(compiler.functionClass,
                                   emitIsTest,
                                   emitSubstitution,
                                   generated);
-        getTypedefChecksOn(call.computeType(compiler)).forEach(emitIsTest);
+        FunctionType callType = call.computeType(compiler);
+        Map<FunctionType,bool> functionTypeChecks =
+            getFunctionTypeChecksOn(callType);
+        bool hasDynamicFunctionTypeCheck = false;
+        functionTypeChecks.forEach((FunctionType functionType,
+                                    bool knownSubtype) {
+          emitIsFunctionTypeTest(functionType);
+          if (!knownSubtype) {
+            registerDynamicFunctionTypeCheck(functionType);
+            hasDynamicFunctionTypeCheck = true;
+          }
+        });
+        if (hasDynamicFunctionTypeCheck) {
+          emitFunctionTypeSignature(callType);
+        }
       }
     }
 
     for (DartType interfaceType in cls.interfaces) {
       generateInterfacesIsTests(interfaceType.element, emitIsTest,
                                 emitSubstitution, generated);
     }
 
     // For native classes, we also have to run through their mixin
     // applications and make sure we deal with 'is' tests correctly
@@ skipping 162 matching lines @@
         jsAst.Expression assignment =
             js[isolateProperties][staticName][name].assign(value);
         buffer.write(jsAst.prettyPrint(assignment.toStatement(), compiler));
         buffer.write('$N');
       });
 
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.write('$fieldAccess.$fieldName$_=$_"$staticName"$N');
-      getTypedefChecksOn(element.computeType(compiler)).forEach(
-        (Element typedef) {
-          String operator = namer.operatorIs(typedef);
-          buffer.write('$fieldAccess.$operator$_=${_}true$N');
+      FunctionType elementType = element.computeType(compiler);
+      Map<FunctionType,bool> functionTypeChecks =
+          getFunctionTypeChecksOn(elementType);
+      bool hasDynamicFunctionTypeCheck = false;
+      functionTypeChecks.forEach((FunctionType functionType,
+                                  bool knownSubtype) {
+        String operator = namer.operatorIsFunctionType(functionType);
+        buffer.write('$fieldAccess.$operator$_=${_}true$N');
+        if (!knownSubtype) {
+          TypeVariableType typeVariable = functionType.typeVariableOccurrence;
+          registerDynamicFunctionTypeCheck(functionType);
+          hasDynamicFunctionTypeCheck = true;
         }
-      );
+      });
+      if (hasDynamicFunctionTypeCheck) {
+        RuntimeTypeInformation rti = backend.rti;
+        String encoding = rti.getTypeEncoding(elementType,
+            alwaysGenerateFunction: true);
+        String operatorSignature = namer.operatorSignature();
+        buffer.add('$fieldAccess.$operatorSignature$_=${_}$encoding$N');
+      }
+
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
                                    String superName,
                                    List<String> fieldNames,
                                    ClassBuilder builder) {
     builder.addProperty('',
         js.string("$superName;${fieldNames.join(',')}"));
   }
@@ skipping 40 matching lines @@
       extraArg = 'receiver';
     } else {
       cache = boundClosureCache;
     }
     List<String> fieldNames = compiler.enableMinification
         ? inInterceptor ? const ['a', 'b', 'c']
                         : const ['a', 'b']
         : inInterceptor ? const ['self', 'target', 'receiver']
                         : const ['self', 'target'];
 
-    Iterable<Element> typedefChecks =
-        getTypedefChecksOn(member.computeType(compiler));
-    bool hasTypedefChecks = !typedefChecks.isEmpty;
+    DartType memberType = member.computeType(compiler);
+    Map<FunctionType, bool> functionTypeChecks =
+        getFunctionTypeChecksOn(memberType);
+    bool hasFunctionTypeChecks = !functionTypeChecks.isEmpty;
 
-    bool canBeShared = !hasOptionalParameters && !hasTypedefChecks;
+    bool canBeShared = !hasOptionalParameters && !hasFunctionTypeChecks;
 
+    ClassElement classElement = member.getEnclosingClass();
     String closureClass = canBeShared ? cache[parameterCount] : null;
     if (closureClass == null) {
       // Either the class was not cached yet, or there are optional parameters.
       // Create a new closure class.
       String name;
       if (canBeShared) {
         if (inInterceptor) {
           name = 'BoundClosure\$i${parameterCount}';
         } else {
           name = 'BoundClosure\$${parameterCount}';
@@ skipping 36 matching lines @@
         arguments.add(js[name]);
       }
 
       jsAst.Expression fun = js.fun(
           parameters,
           js.return_(
               js['this'][fieldNames[0]][js['this'][fieldNames[1]]](arguments)));
       boundClosureBuilder.addProperty(invocationName, fun);
 
       addParameterStubs(callElement, boundClosureBuilder.addProperty);
-      typedefChecks.forEach((Element typedef) {
-        String operator = namer.operatorIs(typedef);
+      bool hasDynamicFunctionTypeCheck = false;
+      functionTypeChecks.forEach((FunctionType functionType,
+                                  bool knownSubtype) {
+        String operator = namer.operatorIsFunctionType(functionType);
         boundClosureBuilder.addProperty(operator, new jsAst.LiteralBool(true));
+        if (!knownSubtype) {
+          registerDynamicFunctionTypeCheck(functionType);
+          hasDynamicFunctionTypeCheck = true;
+        }
       });
+      if (hasDynamicFunctionTypeCheck) {
+        RuntimeTypeInformation rti = backend.rti;
+        String encoding = rti.getTypeEncoding(memberType,
+            alwaysGenerateFunction: true);
+        String operatorSignature = namer.operatorSignature();
+        boundClosureBuilder.addProperty(operatorSignature,
+            new jsAst.LiteralExpression(encoding));
+      }
 
       boundClosures.add(
           js[classesCollector][mangledName].assign(
               boundClosureBuilder.toObjectInitializer()));
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (canBeShared) {
         cache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
     String getterName = namer.getterName(member);
     String targetName = namer.instanceMethodName(member);
 
     List<String> parameters = <String>[];
     List<jsAst.Expression> arguments = <jsAst.Expression>[];
     arguments.add(js['this']);
     arguments.add(js.string(targetName));
     if (inInterceptor) {
       parameters.add(extraArg);
       arguments.add(js[extraArg]);
     }
 
+    jsAst.Expression newClosure = js[closureClass].newWith(arguments);
     jsAst.Expression getterFunction = js.fun(
         parameters,
-        js.return_(js[closureClass].newWith(arguments)));
+        forwardRuntimeTypeInfo(newClosure, memberType, classElement));
 
     defineStub(getterName, getterFunction);
   }
 
   /**
+   * Wraps the [newExpression] of a closure with code for setting the runtime
+   * type information if needed.
+   */
+  forwardRuntimeTypeInfo(jsAst.Expression newExpression,
+                         DartType memberType,
+                         ClassElement thisClass) {
+    if (compiler.world.needsRti(thisClass) &&
+        memberType.containsTypeVariables) {
+      String forwardRuntimeTypeInfo =
+          namer.isolateAccess(backend.getForwardRuntimeTypeInfo());
+      String substitution = namer.substitutionName(thisClass);
+      return js.return_(new jsAst.Call(js[forwardRuntimeTypeInfo],
+          [newExpression, js['this.$substitution'], js['this']]));
+    } else {
+      return js.return_(newExpression);
+    }
+  }
+
+  /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineStubFunction defineStub) {
     assert(invariant(member, member.isDeclaration));
     LibraryElement memberLibrary = member.getLibrary();
     // If the method is intercepted, the stub gets the
@@ skipping 14 matching lines @@
             ? member.fixedBackendName()
             : namer.instanceFieldName(member);
         return js['this'][fieldName];
       }
     }
 
     // Two selectors may match but differ only in type.  To avoid generating
     // identical stubs for each we track untyped selectors which already have
     // stubs.
     Set<Selector> generatedSelectors = new Set<Selector>();
-
+    DartType memberType = member.computeType(compiler);
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         selector = selector.asUntyped;
         if (generatedSelectors.contains(selector)) continue;
         generatedSelectors.add(selector);
 
         String invocationName = namer.invocationName(selector);
         Selector callSelector = new Selector.callClosureFrom(selector);
         String closureCallName = namer.invocationName(callSelector);
 
@@ skipping 919 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // 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].
 """;