Fix for dartbug.com/6036: the intersection of two different types is not always conflicting.

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.
 
 part of js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
   List<Element> compiledFunctions;
 
   ReturnInfo(HType this.returnType)
       : compiledFunctions = new List<Element>();
 
   ReturnInfo.unknownType()
       : this.returnType = null,
         compiledFunctions = new List<Element>();
 
-  void update(HType type, Recompile recompile) {
-    HType newType = returnType != null ? returnType.union(type) : type;
+  void update(HType type, Recompile recompile, Compiler compiler) {
+    HType newType =
+        returnType != null ? returnType.union(type, compiler) : type;
     if (newType != returnType) {
       if (returnType == null && identical(newType, HType.UNKNOWN)) {
         // If the first actual piece of information is not providing any type
         // information there is no need to recompile callers.
         compiledFunctions.clear();
       }
       returnType = newType;
       if (recompile != null) {
         compiledFunctions.forEach(recompile);
       }
@@ skipping 81 matching lines @@
     return result;
   }
 
   static const HTypeList ALL_UNKNOWN = const HTypeList.withAllUnknown();
 
   bool get allUnknown => types == null;
   bool get hasNamedArguments => namedArguments != null;
   int get length => types.length;
   HType operator[](int index) => types[index];
 
-  HTypeList union(HTypeList other) {
+  HTypeList union(HTypeList other, Compiler compiler) {
     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]);
+      HType newType = this[i].union(other[i], compiler);
       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 unionWithInvoke(HInvoke node, HTypeMap types) {
+  HTypeList unionWithInvoke(HInvoke node, HTypeMap types, Compiler compiler) {
     // 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;
     for (int i = 0; i < length; i++) {
-      HType newType = this[i].union(types[node.inputs[i + 1]]);
+      HType newType = this[i].union(types[node.inputs[i + 1]], compiler);
       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;
     }
@@ skipping 127 matching lines @@
   void registerFieldType(Map<Element, HType> typeMap,
                          Element field,
                          HType type) {
     assert(field.isField());
     HType before = optimisticFieldType(field);
 
     HType oldType = typeMap[field];
     HType newType;
 
     if (oldType != null) {
-      newType = oldType.union(type);
+      newType = oldType.union(type, compiler);
     } else {
       newType = type;
     }
     typeMap[field] = newType;
     if (oldType != newType) {
       scheduleRecompilation(field);
     }
   }
 
   void registerConstructor(Element element) {
@@ skipping 75 matching lines @@
     if (initializerType == null && constructorType == null) {
       // If there are no constructor type information return UNKNOWN. This
       // ensures that the function will be recompiled if useful constructor
       // type information becomes available.
       return HType.UNKNOWN;
     }
     // A type set through the constructor overrides the type from the
     // initializer list.
     HType result = constructorType != null ? constructorType : initializerType;
     HType type = fieldTypeMap[field];
-    if (type != null) result = result.union(type);
+    if (type != null) result = result.union(type, compiler);
     return result;
   }
 
   void registerOptimizedFunction(FunctionElement element,
                                  Element field,
                                  HType type) {
     assert(field.isField());
     if (Elements.isStaticOrTopLevel(element)) {
       optimizedStaticFunctions.putIfAbsent(
           field, () => new Set<Element>());
@@ skipping 56 matching lines @@
   Compiler get compiler => backend.compiler;
 
   void registerStaticInvocation(HInvokeStatic node, HTypeMap types) {
     Element element = node.element;
     assert(invariant(node, element.isDeclaration));
     HTypeList oldTypes = staticTypeMap[element];
     if (oldTypes == null) {
       staticTypeMap[element] = new HTypeList.fromStaticInvocation(node, types);
     } else {
       if (oldTypes.allUnknown) return;
-      HTypeList newTypes = oldTypes.unionWithInvoke(node, types);
+      HTypeList newTypes =
+          oldTypes.unionWithInvoke(node, types, backend.compiler);
       if (identical(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 21 matching lines @@
          resolverWorld.hasInvokedGetter(element, compiler))) {
       return;
     }
 
     HTypeList providedTypes =
         new HTypeList.fromDynamicInvocation(node, selector, types);
     if (!selectorTypeMap.containsKey(selector)) {
       selectorTypeMap[selector] = providedTypes;
     } else {
       HTypeList oldTypes = selectorTypeMap[selector];
-      HTypeList newTypes = oldTypes.unionWithInvoke(node, types);
+      HTypeList newTypes =
+           oldTypes.unionWithInvoke(node, types, backend.compiler);
       if (identical(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 46 matching lines @@
     HTypeList found = null;
     selectorTypeMap.visitMatching(element,
         (Selector selector, HTypeList types) {
       if (selector.argumentCount != signature.parameterCount ||
           selector.namedArgumentCount > 0) {
         types = types.unionWithOptionalParameters(selector,
                                                   signature,
                                                   defaultValueTypes);
       }
       assert(types.allUnknown || types.length == signature.parameterCount);
-      found = (found == null) ? types : found.union(types);
+      found = (found == null) ? types : found.union(types, compiler);
       return !found.allUnknown;
     });
     return found != null ? found : HTypeList.ALL_UNKNOWN;
   }
 
   void registerOptimizedFunction(Element element,
                                  HTypeList parameterTypes,
                                  OptionalParameterTypes defaultValueTypes) {
     if (Elements.isStaticOrTopLevelFunction(element)) {
       if (parameterTypes.allUnknown) {
@@ skipping 231 matching lines @@
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void registerReturnType(FunctionElement element, HType returnType) {
     assert(invariant(element, element.isDeclaration));
     ReturnInfo info = returnInfo[element];
     if (info != null) {
-      info.update(returnType, scheduleForRecompilation);
+      info.update(returnType, scheduleForRecompilation, compiler);
     } else {
       returnInfo[element] = new ReturnInfo(returnType);
     }
   }
 
   /**
    * Retrieve the return type of the function [callee]. The type is optimistic
    * in the sense that is is based on the compilation of [callee]. If [callee]
    * is recompiled the return type might change to someting broader. For that
    * reason [caller] is registered for recompilation if this happens. If the
@@ skipping 92 matching lines @@
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
     print("------------------------");
     fieldTypes.dump();
     print("");
   }
 }