anchor.diff:        return isNullable
             ? HType.READABLE_ARRAY.union(HType.NULL, compiler)
             : HType.READABLE_ARRAY;
  -    } else if (mask.isSubtype) {
  -      if (Elements.isNumberOrStringSupertype(element, compiler)) {
  -        return new HBoundedPotentialPrimitiveNumberOrString(mask);
  -      }
  -    }
  +    }
  +
       if (!mask.isExact && (element == compiler.objectClass ||
                             element == compiler.dynamicClass)) {
         return new HBoundedPotentialPrimitiveType(mask, true);
  
positive.code:     }
    }
  }
  
  class HBoundedPotentialPrimitiveNumberOrString
      extends HBoundedPotentialPrimitiveType {
    const HBoundedPotentialPrimitiveNumberOrString(TypeMask mask)
        : super(mask, false);
  
    bool canBePrimitiveNumber(Compiler compiler) => true;
    bool canBePrimitiveString(Compiler compiler) => true;
  
    HType union(HType other, Compiler compiler) {
      if (other.isNumber()) return this;
      if (other.isNumberOrNull()) {
        if (canBeNull()) return this;
        return new HBoundedPotentialPrimitiveNumberOrString(mask.nullable());
      }
  
      if (other.isString()) return this;
      if (other.isStringOrNull()) {
        if (canBeNull()) return this;
        return new HBoundedPotentialPrimitiveNumberOrString(mask.nullable());
      }
  
      if (other.isNull()) {
        if (canBeNull()) return this;
        return new HBoundedPotentialPrimitiveNumberOrString(mask.nullable());
      }
  
      return super.union(other, compiler);
    }
  
    HType intersection(HType other, Compiler compiler) {
      if (other.isNumber()) return other;
      if (other.isNumberOrNull()) {
        if (!canBeNull()) return HType.NUMBER;
        return other;
      }
      if (other.isString()) return other;
      if (other.isStringOrNull()) {
        if (!canBeNull()) return HType.STRING;
        return other;
      }
      return super.intersection(other, compiler);
    }
  }
  
negative.code:   bool canBeNull() => mask.isNullable;
  
    bool canBePrimitive(Compiler compiler) {
      return canBePrimitiveNumber(compiler)
          || canBePrimitiveArray(compiler)
          || canBePrimitiveString(compiler);
    }
  
    bool canBePrimitiveNumber(Compiler compiler) {
      JavaScriptBackend backend = compiler.backend;
      DartType jsNumberType = backend.jsNumberClass.computeType(compiler);
      return mask.contains(jsNumberType, compiler);
    }
  
    bool canBePrimitiveArray(Compiler compiler) {
  