anchor.diff:    }
   
     bool internalRecordType(Element analyzedElement,
  -                          TypeMask type,
  +                          TypeMask newType,
                             Map<Element, TypeMask> types) {
  -    assert(type != null);
  +    assert(newType != null);
       TypeMask existing = types[analyzedElement];
  -    TypeMask newType = isDynamicType(existing)
  -        ? type // Previous analysis did not find any type.
  -        : computeLUB(existing, type);
       types[analyzedElement] = newType;
       // If the return type is useful, say it has changed.
       return existing != newType
  
positive.code: 
    /**
     * Returns the least upper bound between [firstType] and
     * [secondType]. TODO(ngeoffray): Use TypeMask.union.
     */
    TypeMask computeLUB(TypeMask firstType, TypeMask secondType) {
      bool isNumber(type) {
        return type == numType || type == doubleType || type == intType;
      }
      assert(secondType != null);
      if (firstType == null) {
        return secondType;
      } else if (isGiveUpType(firstType)) {
        return firstType;
      } else if (isDynamicType(secondType)) {
        return secondType;
      } else if (isDynamicType(firstType)) {
        return firstType;
      } else if (firstType != secondType) {
        if (isNumber(firstType) && isNumber(secondType)) {
          // The JavaScript backend knows how to deal with numbers.
          return numType;
        }
        // TODO(ngeoffray): Actually compute the least upper bound.
        return giveUpType;
      } else {
        assert(firstType == secondType);
        return firstType;
      }
    }
  }
  
negative.code:           mappedType = new TypeMask.nonNullExact(
                inferrer.rawTypeOf(type.element));
          }
          returnType = inferrer.computeLUB(returnType, mappedType);
        }
        return returnType;
      } else if (name == const SourceString('JS_OPERATOR_IS_PREFIX')
  