Support runtime check of function types.

sdk/lib/_internal/compiler/implementation/enqueue.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 dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 159 matching lines @@
         }
       }
     });
     return true;
   }
 
   void processInstantiatedClass(ClassElement cls) {
     cls.implementation.forEachMember(processInstantiatedClassMember);
   }
 
-  /**
-   * Documentation wanted -- johnniwinther
-   */
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (isProcessed(member)) return;
     if (!member.isInstanceMember()) return;
 
     String memberName = member.name.slowToString();
 
     if (member.kind == ElementKind.FIELD) {
       // The obvious thing to test here would be "member.isNative()",
       // however, that only works after metadata has been parsed/analyzed,
@@ skipping 32 matching lines @@
         // All field initializers must be resolved as they could
         // have an observable side-effect (and cannot be tree-shaken
         // away).
         addToWorkList(member);
         return;
       }
     } else if (member.kind == ElementKind.FUNCTION) {
       if (member.name == Compiler.NO_SUCH_METHOD) {
         enableNoSuchMethod(member);
       }
+      if (member.name == Compiler.CALL_OPERATOR_NAME &&
+          !cls.typeVariables.isEmpty) {
+        registerGenericCallMethod(member, compiler.globalDependencies);
+      }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(member, compiler)) {
-        // We will emit a closure, so make sure the bound closure class is
+        registerClosurizedMember(member, compiler.globalDependencies);
+        // We will emit a closure, so make sure the closure class is
         // generated.
         registerInstantiatedClass(compiler.boundClosureClass,
                                   // Precise dependency is not important here.
                                   compiler.globalDependencies);
         return addToWorkList(member);
       }
       // Store the member in [instanceFunctionsByName] to catch
       // getters on the function.
       Link<Element> members = instanceFunctionsByName.putIfAbsent(
           memberName, () => const Link<Element>());
@@ skipping 152 matching lines @@
     }
     hasEnqueuedEverything = true;
   }
 
   processLink(Map<String, Link<Element>> map,
               SourceString n,
               bool f(Element e)) {
     String memberName = n.slowToString();
     Link<Element> members = map[memberName];
     if (members != null) {
+      // [f] might add elements to [: map[memberName] :] during the loop below
+      // so we create a new list for [: map[memberName] :] and prepend the
+      // [remaining] members after the loop.
+      map[memberName] = const Link<Element>();
       LinkBuilder<Element> remaining = new LinkBuilder<Element>();
       for (; !members.isEmpty; members = members.tail) {
         if (!f(members.head)) remaining.addLast(members.head);
       }
-      map[memberName] = remaining.toLink();
+      map[memberName] = remaining.toLink(map[memberName]);
     }
   }
 
   processInstanceMembers(SourceString n, bool f(Element e)) {
     processLink(instanceMembersByName, n, f);
   }
 
   processInstanceFunctions(SourceString n, bool f(Element e)) {
     processLink(instanceFunctionsByName, n, f);
   }
 
   void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.appliesUnnamed(member, compiler)) {
+        if (member.isFunction() && selector.isGetter()) {
+          registerClosurizedMember(member, compiler.globalDependencies);
+        }
         if (member.isField() && member.getEnclosingClass().isNative()) {
           if (selector.isGetter() || selector.isCall()) {
             nativeEnqueuer.registerFieldLoad(member);
             // We have to also handle storing to the field because we only get
             // one look at each member and there might be a store we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldStore(member);
           } else {
             assert(selector.isSetter());
@@ skipping 91 matching lines @@
 
   void registerFieldGetter(Element element) {
     universe.fieldGetters.add(element);
   }
 
   void registerFieldSetter(Element element) {
     universe.fieldSetters.add(element);
   }
 
   void registerIsCheck(DartType type, TreeElements elements) {
+    type = universe.registerIsCheck(type, compiler);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(type.kind != TypeKind.TYPE_VARIABLE ||
            !type.element.enclosingElement.isTypedef());
-    universe.isChecks.add(type);
     compiler.backend.registerIsCheck(type, this, elements);
   }
 
   /**
    * If a factory constructor is used with type arguments, we lose track
    * which arguments could be used to create instances of classes that use their
    * type variables as expressions, so we have to remember if we saw such a use.
    */
   void registerFactoryWithTypeArguments(TreeElements elements) {
     universe.usingFactoryWithTypeArguments = true;
   }
 
   void registerAsCheck(DartType type, TreeElements elements) {
     registerIsCheck(type, elements);
     compiler.backend.registerAsCheck(type, elements);
   }
 
+  void registerGenericCallMethod(Element element, TreeElements elements) {
+    compiler.backend.registerGenericCallMethod(element, this, elements);
+    universe.genericCallMethods.add(element);
+  }
+
+  void registerClosurizedMember(Element element, TreeElements elements) {
+    if (element.computeType(compiler).containsTypeVariables) {
+      registerClosurizedGenericMember(element, elements);
+    }
+    universe.closurizedMembers.add(element);
+  }
+
+  void registerClosurizedGenericMember(Element element, TreeElements elements) {
+    compiler.backend.registerGenericClosure(element, this, elements);
+    universe.closurizedGenericMembers.add(element);
+  }
+
   void forEach(f(WorkItem work));
 
   void forEachPostProcessTask(f(PostProcessTask work)) {}
 
   void logSummary(log(message)) {
     _logSpecificSummary(log);
     nativeEnqueuer.logSummary(log);
   }
 
   /// Log summary specific to the concrete enqueuer.
@@ skipping 74 matching lines @@
       }
     }
 
     if (element.isGetter() && element.name == Compiler.RUNTIME_TYPE) {
       // Enable runtime type support if we discover a getter called runtimeType.
       // We have to enable runtime type before hitting the codegen, so
       // that constructors know whether they need to generate code for
       // runtime type.
       compiler.enabledRuntimeType = true;
       // TODO(ahe): Record precise dependency here.
-      compiler.backend.registerRuntimeType(compiler.globalDependencies);
+      compiler.backend.registerRuntimeType(this, compiler.globalDependencies);
     } else if (element == compiler.functionApplyMethod) {
       compiler.enabledFunctionApply = true;
     } else if (element == compiler.invokeOnMethod) {
       compiler.enabledInvokeOn = true;
     }
 
     nativeEnqueuer.registerElement(element);
   }
 
   void enableIsolateSupport(LibraryElement element) {
@@ skipping 90 matching lines @@
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }