Fix bug 4648: invalidate type parameter optimization on a method if a call with a selector that has…

lib/compiler/implementation/js_backend/backend.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 InvocationInfo {
   int parameterCount = -1;
   List<HType> providedTypes;
   List<Element> compiledFunctions;
 
   InvocationInfo(HInvoke node, HTypeMap types)
@@ skipping 20 matching lines @@
   InvocationInfo.unknownTypes();
 
   void update(HInvoke node, HTypeMap types, var recompile) {
     // If we don't know anything useful about the types adding more
     // information will not help.
     if (!hasTypeInformation) return;
 
     // Update the type information with the provided types.
     bool typesChanged = false;
     bool allUnknown = true;
-    for (int i = 0; i < providedTypes.length; i++) {
-      HType newType = providedTypes[i].union(types[node.inputs[i + 1]]);
-      if (newType != providedTypes[i]) {
-        typesChanged = true;
-        providedTypes[i] = newType;
+
+    if (providedTypes.length != node.inputs.length - 1) {
+      // If the signatures don't match, remove all optimizations on
+      // that selector.
+      typesChanged = true;

[Søren Gjesse, 2012/08/23 10:37:09]

Maybe add

allUnknown = true

here for clarity.

[ngeoffray, 2012/08/23 12:30:19]

Done.

+    } else {
+      for (int i = 0; i < providedTypes.length; i++) {
+        HType newType = providedTypes[i].union(types[node.inputs[i + 1]]);
+        if (newType != providedTypes[i]) {
+          typesChanged = true;
+          providedTypes[i] = newType;
+        }
+        if (providedTypes[i] != HType.UNKNOWN) allUnknown = false;
       }
-      if (providedTypes[i] != HType.UNKNOWN) allUnknown = false;
     }
     // If the provided types change we need to recompile all functions which
     // have been compiled under the now invalidated assumptions.
     if (typesChanged && compiledFunctions.length != 0) {
       if (recompile != null) {
         compiledFunctions.forEach(recompile);
       }
       compiledFunctions.clear();
     }
     // If all information is lost no need to keep it around.
@@ skipping 223 matching lines @@
   /**
    *  Register a dynamic invocation and collect the provided types for the
    *  named selector.
    */
   void registerDynamicInvocation(HInvokeDynamicMethod node,
                                  Selector selector,
                                  HTypeMap types) {
     Map<Selector, InvocationInfo> invocationInfos =
         invocationInfo.putIfAbsent(selector.name,
                                    () => new Map<Selector, InvocationInfo>());
-    InvocationInfo info = invocationInfos[selector];
-    if (info != null) {
-      void recompile(Element element) {
-        if (compiler.phase == Compiler.PHASE_COMPILING) {
-          invalidateAfterCodegen.add(element);
+    if (!invocationInfos.isEmpty()) {
+      invocationInfos.forEach((Selector _, InvocationInfo info) {
+        // TODO(ngeoffray): Check that the signature of [info] applies to
+        // [element]. We cannot do that right now because the
+        // strategy is all or nothing. We should actually retain the
+        // methods that don't apply to [selector].
+        void recompile(Element element) {
+          if (compiler.phase == Compiler.PHASE_COMPILING) {
+            invalidateAfterCodegen.add(element);
+          }
         }
-      }
 
-      info.update(node, types, recompile);
+        info.update(node, types, recompile);
+      });
     } else {
       invocationInfos[selector] = new InvocationInfo(node, types);
     }
   }
 
   /**
    *  Register a static invocation and collect the provided types for the
    *  named selector.
    */
   void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
@@ skipping 101 matching lines @@
   HType optimisticReturnTypesWithRecompilationOnTypeChange(
       FunctionElement caller, FunctionElement callee) {
     returnInfo.putIfAbsent(callee, () => new ReturnInfo.unknownType());
     ReturnInfo info = returnInfo[callee];
     if (info.returnType != HType.UNKNOWN && caller != null) {
       info.addCompiledFunction(caller);
     }
     return info.returnType;
   }
 }