Create the union of parameter types if several selectors match the same function

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.
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
   List<Element> compiledFunctions;
 
@@ skipping 46 matching lines @@
     }
     return result;
   }
 
   static const HTypeList ALL_UNKNOWN = const HTypeList.allUnknown();
 
   bool get allUnknown => types === null;
   int get length => types.length;
   HType operator[](int index) => types[index];
 
+  HTypeList union(HTypeList other) {
+    if (allUnknown) return this;
+    if (other.allUnknown) return other;
+    if (length != other.length) return HTypeList.ALL_UNKNOWN;
+    bool onlyUnknown = true;
+    HTypeList result = this;
+    for (int i = 0; i < length; i++) {
+      HType newType = this[i].union(other[i]);
+      if (result == this && newType != this[i]) {
+        // Create a new argument types object with the matching types copied.
+        result = new HTypeList(length);
+        result.types.setRange(0, i, this.types);
+      }
+      if (result != this) {
+        result.types[i] = newType;
+      }
+      if (result[i] != HType.UNKNOWN) onlyUnknown = false;
+    }
+    return onlyUnknown ? HTypeList.ALL_UNKNOWN : result;
+  }
+
   /**
    * Create the union of this [HTypeList] object with the types used by
    * the [node]. If the union results in exactly the same types the receiver
    * is returned. Otherwise a different [HTypeList] object is returned
    * with the type union information.
    */
-  HTypeList union(HInvoke node, HTypeMap types) {
+  HTypeList unionWithInvoke(HInvoke node, HTypeMap types) {
     // Union an all unknown list with something stays all unknown.
     if (allUnknown) return this;
 
     bool allUnknown = true;
     if (length != node.inputs.length - 1) {
       return HTypeList.ALL_UNKNOWN;
     }
 
     bool onlyUnknown = true;
     HTypeList result = this;
@@ skipping 40 matching lines @@
     return new HTypeList.fromInvocation(node, types);
   }
 
   void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
     Element element = node.element;
     HTypeList oldTypes = staticTypeMap[element];
     if (oldTypes == null) {
       staticTypeMap[element] = computeProvidedTypes(node, types);
     } else {
       if (oldTypes.allUnknown) return;
-      HTypeList newTypes = oldTypes.union(node, types);
+      HTypeList newTypes = oldTypes.unionWithInvoke(node, types);
       if (newTypes === oldTypes) return;
       staticTypeMap[element] = newTypes;
       if (optimizedStaticFunctions.contains(element)) {
         backend.scheduleForRecompilation(element);
       }
     }
   }
 
   void registerNonCallStaticUse(HStatic node) {
     // When a static is used for anything else than a call target we cannot
@@ skipping 23 matching lines @@
 
     // TODO(kasperl): For now, we're only dealing with non-named arguments.
     // We should generalize this.
     HTypeList providedTypes = selector.namedArguments.isEmpty()
         ? computeProvidedTypes(node, types)
         : HTypeList.ALL_UNKNOWN;
     if (!selectorTypeMap.containsKey(selector)) {
       selectorTypeMap[selector] = providedTypes;
     } else {
       HTypeList oldTypes = selectorTypeMap[selector];
-      HTypeList newTypes = oldTypes.union(node, types);
+      HTypeList newTypes = oldTypes.unionWithInvoke(node, types);
       if (newTypes === oldTypes) return;
       selectorTypeMap[selector] = newTypes;
     }
 
     // If we're not compiling, we don't have to do anything.
     if (compiler.phase != Compiler.PHASE_COMPILING) return;
 
     // Run through all optimized functions and figure out if they need
     // to be recompiled because of this new invocation.
     optimizedFunctions.filterBySelector(selector).forEach((Element element) {
@@ skipping 35 matching lines @@
       }
     }
 
     // TODO(kasperl): What kind of non-members do we get here?
     if (!element.isMember()) return HTypeList.ALL_UNKNOWN;
 
     FunctionSignature signature = element.computeSignature(compiler);
     HTypeList found = null;
     selectorTypeMap.visitMatching(element,
         (Selector selector, HTypeList types) {
-      if (selector.argumentCount != signature.parameterCount ||
-          types === null) {
+      if (selector.argumentCount != signature.parameterCount) {
         found = HTypeList.ALL_UNKNOWN;
         return false;
       } else if (found === null) {
         found = types;
         return true;
       } else {
-        found = HTypeList.ALL_UNKNOWN;
-        return false;
+        found = found.union(types);
+        return !found.allUnknown;
       }
     });
     return found !== null ? found : HTypeList.ALL_UNKNOWN;
   }
 
   void registerOptimization(Element element, HTypeList parameterTypes) {
     if (Elements.isStaticOrTopLevelFunction(element)) {
       if (parameterTypes.allUnknown) {
         optimizedStaticFunctions.remove(element);
       } else {
@@ skipping 264 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;
   }
 }