[turbofan] Utilize the fact that empty string is canonicalized.

src/compiler/types.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <iomanip>
 
 #include "src/compiler/types.h"
 
 #include "src/handles-inl.h"
 #include "src/objects-inl.h"
@@ skipping 446 matching lines @@
 // static
 bool OtherNumberConstantType::IsOtherNumberConstant(Object* value) {
   return value->IsHeapNumber() &&
          IsOtherNumberConstant(HeapNumber::cast(value)->value());
 }
 
 HeapConstantType::HeapConstantType(BitsetType::bitset bitset,
                                    i::Handle<i::HeapObject> object)
     : TypeBase(kHeapConstant), bitset_(bitset), object_(object) {
   DCHECK(!object->IsHeapNumber());
-  DCHECK(!object->IsString());
+  DCHECK_IMPLIES(object->IsString(), object->IsInternalizedString());
 }
 
 // -----------------------------------------------------------------------------
 // Predicates.
 
 bool Type::SimplyEquals(Type* that) {
   DisallowHeapAllocation no_allocation;
   if (this->IsHeapConstant()) {
     return that->IsHeapConstant() &&
            this->AsHeapConstant()->Value().address() ==
@@ skipping 355 matching lines @@
   DCHECK(OtherNumberConstantType::IsOtherNumberConstant(value));
   return OtherNumberConstant(value, zone);
 }
 
 Type* Type::NewConstant(i::Handle<i::Object> value, Zone* zone) {
   if (IsInteger(*value)) {
     double v = value->Number();
     return Range(v, v, zone);
   } else if (value->IsHeapNumber()) {
     return NewConstant(value->Number(), zone);
-  } else if (value->IsString()) {
-    bitset b = BitsetType::Lub(*value);
-    DCHECK(b == BitsetType::kInternalizedString ||
-           b == BitsetType::kOtherString);
-    if (b == BitsetType::kInternalizedString) {
-      return Type::InternalizedString();
-    } else if (b == BitsetType::kOtherString) {
-      return Type::OtherString();
-    } else {
-      UNREACHABLE();
-    }
+  } else if (value->IsString() && !value->IsInternalizedString()) {
+    return Type::OtherString();
   }
   return HeapConstant(i::Handle<i::HeapObject>::cast(value), zone);
 }
 
 Type* Type::Union(Type* type1, Type* type2, Zone* zone) {
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
     return BitsetType::New(type1->AsBitset() | type2->AsBitset());
   }
 
@@ skipping 200 matching lines @@
   return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
 }
 
 BitsetType::bitset BitsetType::UnsignedSmall() {
   return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8