fix symbols; fix canonicalization of int64, -0

MikeHolman · MikeHolman · commit f9639b782dd5 · 2018-03-15T15:16:22.000-07:00
diff --git a/lib/Runtime/Language/JavascriptConversion.cpp b/lib/Runtime/Language/JavascriptConversion.cpp
@@ -1522,36 +1522,4 @@ namespace Js
         return NumberUtilities::TryToInt64(length);
     }
 
-    Var JavascriptConversion::TryCanonicalizeAsSimpleVar(Var value)
-    {
-        TypeId typeId = JavascriptOperators::GetTypeId(value);
-        switch (typeId)
-        {
-        case TypeIds_Integer:
-        case TypeIds_Number:
-        {
-            Var taggedInt = TryCanonicalizeAsTaggedInt<true>(value);
-            if (taggedInt)
-            {
-                return taggedInt;
-            }
-
-#if FLOATVAR
-            return value;
-#else
-            return nullptr;
-#endif
-        }
-        case TypeIds_String:
-        case TypeIds_Symbol:
-            // TODO: try to canonicalize Int64/Uint64 to TaggedInt
-        case TypeIds_Int64Number:
-        case TypeIds_UInt64Number:
-            return nullptr;
-
-        default:
-            return value;
-        }
-    }
-
 } // namespace Js
diff --git a/lib/Runtime/Language/JavascriptConversion.h b/lib/Runtime/Language/JavascriptConversion.h
@@ -92,11 +92,17 @@ namespace Js {
         static double LongToDouble(__int64 aValue);
         static double ULongToDouble(unsigned __int64 aValue);
 
-        template <bool allowNegOne>
+        template <bool allowNegOne, bool allowLossyConversion>
         static Var TryCanonicalizeAsTaggedInt(Var value);
+        template <bool allowNegOne, bool allowLossyConversion>
+        static Var TryCanonicalizeAsTaggedInt(Var value, TypeId typeId);
+        template <bool allowLossyConversion>
         static Var TryCanonicalizeAsSimpleVar(Var value);
 
     private:
+        template <typename T, bool allowNegOne>
+        static Var TryCanonicalizeIntHelper(T val);
+
         static BOOL ToInt32Finite(double value, int32* result);
         template<bool zero>
         static bool SameValueCommon(Var aValue, Var bValue);
diff --git a/lib/Runtime/Language/JavascriptConversion.inl b/lib/Runtime/Language/JavascriptConversion.inl
@@ -203,40 +203,109 @@ namespace Js {
        return SameValueCommon<true>(aValue, bValue);
    }
 
-   template <bool allowNegOne>
-   inline Var JavascriptConversion::TryCanonicalizeAsTaggedInt(Var value)
+   template <typename T, bool allowNegOne>
+   inline Var JavascriptConversion::TryCanonicalizeIntHelper(T val)
    {
-       if (TaggedInt::Is(value))
+       if (TaggedInt::IsOverflow(val))
        {
-           return (allowNegOne || value != TaggedInt::ToVarUnchecked(-1))
-               ? value
-               : nullptr;
+           return nullptr;
        }
 
-       if (!JavascriptNumber::Is(value))
+       if (!allowNegOne && val == -1)
        {
            return nullptr;
        }
 
-       double doubleVal = JavascriptNumber::GetValue(value);
-       int32 intVal = 0;
+       return TaggedInt::ToVarUnchecked((int)val);
+   }
 
-       if (!JavascriptNumber::TryGetInt32Value<true>(doubleVal, &intVal))
+   template <bool allowNegOne, bool allowLossyConversion>
+   inline Var JavascriptConversion::TryCanonicalizeAsTaggedInt(Var value, TypeId typeId)
+   {
+       switch (typeId)
        {
-           return nullptr;
+       case TypeIds_Integer:
+           return (allowNegOne || value != TaggedInt::ToVarUnchecked(-1))
+               ? value
+               : nullptr;
+
+       case TypeIds_Number:
+       {
+           double doubleVal = JavascriptNumber::GetValue(value);
+           int32 intVal = 0;
+
+           if (!JavascriptNumber::TryGetInt32Value<allowLossyConversion>(doubleVal, &intVal))
+           {
+               return nullptr;
+           }
+           return TryCanonicalizeIntHelper<int32, allowNegOne>(intVal);
        }
+       case TypeIds_Int64Number:
+       {
+           if (!allowLossyConversion)
+           {
+               return nullptr;
+           }
+           int64 int64Val = JavascriptInt64Number::UnsafeFromVar(value)->GetValue();
+
+           return TryCanonicalizeIntHelper<int64, allowNegOne>(int64Val);
 
-       if (TaggedInt::IsOverflow(intVal))
+       }
+       case TypeIds_UInt64Number:
        {
+           if (!allowLossyConversion)
+           {
+               return nullptr;
+           }
+           uint64 uint64Val = JavascriptUInt64Number::UnsafeFromVar(value)->GetValue();
+
+           return TryCanonicalizeIntHelper<uint64, allowNegOne>(uint64Val);
+       }
+       default:
            return nullptr;
        }
+   }
+
+   template <bool allowNegOne, bool allowLossyConversion>
+   inline Var JavascriptConversion::TryCanonicalizeAsTaggedInt(Var value)
+   {
+       TypeId typeId = JavascriptOperators::GetTypeId(value);
+       return TryCanonicalizeAsTaggedInt<allowNegOne, allowLossyConversion>(value, typeId);
+   }
 
-       if (!allowNegOne && intVal == -1)
+   // Lossy conversion means values are StrictEqual equivalent,
+   // but we cannot reconstruct the original value after canonicalization
+   // (e.g. -0 or an Int64Number object)
+   template <bool allowLossyConversion>
+   inline Var JavascriptConversion::TryCanonicalizeAsSimpleVar(Var value)
+   {
+       TypeId typeId = JavascriptOperators::GetTypeId(value);
+       switch (typeId)
+       {
+       case TypeIds_Integer:
+       case TypeIds_Number:
+       case TypeIds_Int64Number:
+       case TypeIds_UInt64Number:
        {
+           Var taggedInt = TryCanonicalizeAsTaggedInt<true, allowLossyConversion>(value, typeId);
+           if (taggedInt)
+           {
+               return taggedInt;
+           }
+
+#if FLOATVAR
+           return value;
+#else
            return nullptr;
+#endif
        }
+       case TypeIds_String:
+       case TypeIds_Symbol:
+           return nullptr;
 
-       return TaggedInt::ToVarUnchecked(intVal);
+       default:
+           return value;
+       }
    }
 
 } // namespace Js
diff --git a/lib/Runtime/Library/JavascriptMap.cpp b/lib/Runtime/Library/JavascriptMap.cpp
@@ -378,13 +378,13 @@ JavascriptMap::DeleteFromSimpleVarMap(Var value)
 {
     Assert(this->kind == MapKind::SimpleVarMap);
 
-    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);
+    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(value);
     if (!simpleVar)
     {
         return false;
     }
 
-    return this->DeleteFromVarMap<false>(simpleVar);
+    return this->DeleteFromVarMap<false /* isComplex */>(simpleVar);
 }
 
 bool
@@ -427,7 +427,7 @@ JavascriptMap::Get(Var key, Var* value)
             return true;
         }
         // If the key isn't in the map, check if the canonical value is
-        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);
+        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(key);
         // If the simple var is the same as the original key, we know it isn't in the map
         if (!simpleVar || simpleVar == key)
         {
@@ -476,7 +476,7 @@ JavascriptMap::Has(Var key)
             return true;
         }
         // If the key isn't in the map, check if the canonical value is
-        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);
+        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(key);
         // If the simple var is the same as the original key, we know it isn't in the map
         if (!simpleVar || simpleVar == key)
         {
@@ -517,7 +517,7 @@ void
 JavascriptMap::SetOnEmptyMap(Var key, Var value)
 {
     Assert(this->kind == MapKind::EmptyMap);
-    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);
+    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(key);
     if (simpleVar)
     {
         SimpleVarDataMap* newSimpleMap = RecyclerNew(this->GetRecycler(), SimpleVarDataMap, this->GetRecycler());
@@ -548,7 +548,7 @@ JavascriptMap::TrySetOnSimpleVarMap(Var key, Var value)
 {
     Assert(this->kind == MapKind::SimpleVarMap);
 
-    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);
+    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(key);
     if (!simpleVar)
     {
         return false;
diff --git a/lib/Runtime/Library/JavascriptMap.h b/lib/Runtime/Library/JavascriptMap.h
@@ -21,7 +21,7 @@ namespace Js
             // An EmptyMap is a map containing no elements
             EmptyMap,
             // A SimpleVarMap is a map containing only Vars which are comparable by pointer, and don't require
-            // pointer comparison
+            // value comparison
             //
             // Addition of a Var that is not comparable by pointer value causes the set to be promoted to a ComplexVarSet
             SimpleVarMap,
diff --git a/lib/Runtime/Library/JavascriptSet.cpp b/lib/Runtime/Library/JavascriptSet.cpp
@@ -328,7 +328,7 @@ JavascriptSet::AddToEmptySet(Var value)
 {
     Assert(this->kind == SetKind::EmptySet);
     // We cannot store an int with value -1 inside of a bit vector
-    Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);
+    Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne */, false /* allowLossyConversion */>(value);
     if (taggedInt)
     {
         int32 intVal = TaggedInt::ToInt32(taggedInt);
@@ -343,7 +343,7 @@ JavascriptSet::AddToEmptySet(Var value)
         return;
     }
 
-    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);
+    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(value);
     if (simpleVar)
     {
         SimpleVarDataSet* newSimpleSet = RecyclerNew(this->GetRecycler(), SimpleVarDataSet, this->GetRecycler());
@@ -369,7 +369,7 @@ bool
 JavascriptSet::TryAddToIntSet(Var value)
 {
     Assert(this->kind == SetKind::IntSet);
-    Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);
+    Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne */, false /* allowLossyConversion */>(value);
     if (!taggedInt)
     {
         return false;
@@ -387,7 +387,7 @@ bool
 JavascriptSet::TryAddToSimpleVarSet(Var value)
 {
     Assert(this->kind == SetKind::SimpleVarSet);
-    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);
+    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(value);
     if (!simpleVar)
     {
         return false;
@@ -432,7 +432,7 @@ JavascriptSet::Add(Var value)
             return;
         }
 
-        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);
+        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(value);
         if (simpleVar)
         {
             this->PromoteToSimpleVarSet();
@@ -490,7 +490,7 @@ bool
 JavascriptSet::IsInIntSet(Var value)
 {
     Assert(this->kind == SetKind::IntSet);
-    Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);
+    Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne */, true /* allowLossyConversion */>(value);
     if (!taggedInt)
     {
         return false;
@@ -520,7 +520,7 @@ bool
 JavascriptSet::DeleteFromSimpleVarSet(Var value)
 {
     Assert(this->kind == SetKind::SimpleVarSet);
-    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);
+    Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(value);
     if (!simpleVar)
     {
         return false;
@@ -553,7 +553,7 @@ bool JavascriptSet::Delete(Var value)
         return this->DeleteFromSimpleVarSet(value);
 
     case SetKind::ComplexVarSet:
-        return this->DeleteFromVarSet<true>(value);
+        return this->DeleteFromVarSet<true /* isComplex */>(value);
 
     default:
         Assume(UNREACHED);
@@ -571,7 +571,7 @@ bool JavascriptSet::Has(Var value)
 
     case SetKind::IntSet:
     {
-        Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);
+        Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne */, true /* allowLossyConversion */ >(value);
         if (!taggedInt)
         {
             return false;
@@ -588,7 +588,7 @@ bool JavascriptSet::Has(Var value)
             return true;
         }
         // If the value isn't in the set, check if the canonical value is
-        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);
+        Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(value);
         // If the simple value is the same as the original value, we know it isn't in the set
         if (!simpleVar || simpleVar == value)
         {
diff --git a/lib/Runtime/Library/SameValueComparer.h b/lib/Runtime/Library/SameValueComparer.h
@@ -85,10 +85,16 @@ namespace Js
 
             case TypeIds_String:
                 {
-                    JavascriptString* v = JavascriptString::FromVar(i);
+                    JavascriptString* v = JavascriptString::UnsafeFromVar(i);
                     return JsUtil::CharacterBuffer<WCHAR>::StaticGetHashCode(v->GetString(), v->GetLength());
                 }
 
+            case TypeIds_Symbol:
+            {
+                JavascriptSymbol* sym = JavascriptSymbol::UnsafeFromVar(i);
+                return sym->GetValue()->GetHashCode();
+            }
+
             default:
                 return RecyclerPointerComparer<Var>::GetHashCode(i);
             }

Original file line number	Diff line number	Diff line change
`@@ -378,13 +378,13 @@ JavascriptMap::DeleteFromSimpleVarMap(Var value)`
`378`	`378`	`{`
`379`	`379`	`Assert(this->kind == MapKind::SimpleVarMap);`
`380`	`380`
`381`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);`
	`381`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(value);`
`382`	`382`	`if (!simpleVar)`
`383`	`383`	`{`
`384`	`384`	`return false;`
`385`	`385`	`}`
`386`	`386`
`387`		`- return this->DeleteFromVarMap<false>(simpleVar);`
	`387`	`+ return this->DeleteFromVarMap<false /* isComplex */>(simpleVar);`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`bool`
`@@ -427,7 +427,7 @@ JavascriptMap::Get(Var key, Var* value)`
`427`	`427`	`return true;`
`428`	`428`	`}`
`429`	`429`	`// If the key isn't in the map, check if the canonical value is`
`430`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);`
	`430`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(key);`
`431`	`431`	`// If the simple var is the same as the original key, we know it isn't in the map`
`432`	`432`	`if (!simpleVar \|\| simpleVar == key)`
`433`	`433`	`{`
`@@ -476,7 +476,7 @@ JavascriptMap::Has(Var key)`
`476`	`476`	`return true;`
`477`	`477`	`}`
`478`	`478`	`// If the key isn't in the map, check if the canonical value is`
`479`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);`
	`479`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(key);`
`480`	`480`	`// If the simple var is the same as the original key, we know it isn't in the map`
`481`	`481`	`if (!simpleVar \|\| simpleVar == key)`
`482`	`482`	`{`
`@@ -517,7 +517,7 @@ void`
`517`	`517`	`JavascriptMap::SetOnEmptyMap(Var key, Var value)`
`518`	`518`	`{`
`519`	`519`	`Assert(this->kind == MapKind::EmptyMap);`
`520`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);`
	`520`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(key);`
`521`	`521`	`if (simpleVar)`
`522`	`522`	`{`
`523`	`523`	`SimpleVarDataMap* newSimpleMap = RecyclerNew(this->GetRecycler(), SimpleVarDataMap, this->GetRecycler());`
`@@ -548,7 +548,7 @@ JavascriptMap::TrySetOnSimpleVarMap(Var key, Var value)`
`548`	`548`	`{`
`549`	`549`	`Assert(this->kind == MapKind::SimpleVarMap);`
`550`	`550`
`551`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(key);`
	`551`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(key);`
`552`	`552`	`if (!simpleVar)`
`553`	`553`	`{`
`554`	`554`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -328,7 +328,7 @@ JavascriptSet::AddToEmptySet(Var value)`
`328`	`328`	`{`
`329`	`329`	`Assert(this->kind == SetKind::EmptySet);`
`330`	`330`	`// We cannot store an int with value -1 inside of a bit vector`
`331`		`- Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);`
	`331`	`+ Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne /, false / allowLossyConversion */>(value);`
`332`	`332`	`if (taggedInt)`
`333`	`333`	`{`
`334`	`334`	`int32 intVal = TaggedInt::ToInt32(taggedInt);`
`@@ -343,7 +343,7 @@ JavascriptSet::AddToEmptySet(Var value)`
`343`	`343`	`return;`
`344`	`344`	`}`
`345`	`345`
`346`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);`
	`346`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(value);`
`347`	`347`	`if (simpleVar)`
`348`	`348`	`{`
`349`	`349`	`SimpleVarDataSet* newSimpleSet = RecyclerNew(this->GetRecycler(), SimpleVarDataSet, this->GetRecycler());`
`@@ -369,7 +369,7 @@ bool`
`369`	`369`	`JavascriptSet::TryAddToIntSet(Var value)`
`370`	`370`	`{`
`371`	`371`	`Assert(this->kind == SetKind::IntSet);`
`372`		`- Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);`
	`372`	`+ Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne /, false / allowLossyConversion */>(value);`
`373`	`373`	`if (!taggedInt)`
`374`	`374`	`{`
`375`	`375`	`return false;`
`@@ -387,7 +387,7 @@ bool`
`387`	`387`	`JavascriptSet::TryAddToSimpleVarSet(Var value)`
`388`	`388`	`{`
`389`	`389`	`Assert(this->kind == SetKind::SimpleVarSet);`
`390`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);`
	`390`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(value);`
`391`	`391`	`if (!simpleVar)`
`392`	`392`	`{`
`393`	`393`	`return false;`
`@@ -432,7 +432,7 @@ JavascriptSet::Add(Var value)`
`432`	`432`	`return;`
`433`	`433`	`}`
`434`	`434`
`435`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);`
	`435`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<false /* allowLossyConversion */>(value);`
`436`	`436`	`if (simpleVar)`
`437`	`437`	`{`
`438`	`438`	`this->PromoteToSimpleVarSet();`
`@@ -490,7 +490,7 @@ bool`
`490`	`490`	`JavascriptSet::IsInIntSet(Var value)`
`491`	`491`	`{`
`492`	`492`	`Assert(this->kind == SetKind::IntSet);`
`493`		`- Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);`
	`493`	`+ Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne /, true / allowLossyConversion */>(value);`
`494`	`494`	`if (!taggedInt)`
`495`	`495`	`{`
`496`	`496`	`return false;`
`@@ -520,7 +520,7 @@ bool`
`520`	`520`	`JavascriptSet::DeleteFromSimpleVarSet(Var value)`
`521`	`521`	`{`
`522`	`522`	`Assert(this->kind == SetKind::SimpleVarSet);`
`523`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);`
	`523`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(value);`
`524`	`524`	`if (!simpleVar)`
`525`	`525`	`{`
`526`	`526`	`return false;`
`@@ -553,7 +553,7 @@ bool JavascriptSet::Delete(Var value)`
`553`	`553`	`return this->DeleteFromSimpleVarSet(value);`
`554`	`554`
`555`	`555`	`case SetKind::ComplexVarSet:`
`556`		`- return this->DeleteFromVarSet<true>(value);`
	`556`	`+ return this->DeleteFromVarSet<true /* isComplex */>(value);`
`557`	`557`
`558`	`558`	`default:`
`559`	`559`	`Assume(UNREACHED);`
`@@ -571,7 +571,7 @@ bool JavascriptSet::Has(Var value)`
`571`	`571`
`572`	`572`	`case SetKind::IntSet:`
`573`	`573`	`{`
`574`		`- Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false>(value);`
	`574`	`+ Var taggedInt = JavascriptConversion::TryCanonicalizeAsTaggedInt<false /* allowNegOne /, true / allowLossyConversion */ >(value);`
`575`	`575`	`if (!taggedInt)`
`576`	`576`	`{`
`577`	`577`	`return false;`
`@@ -588,7 +588,7 @@ bool JavascriptSet::Has(Var value)`
`588`	`588`	`return true;`
`589`	`589`	`}`
`590`	`590`	`// If the value isn't in the set, check if the canonical value is`
`591`		`- Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar(value);`
	`591`	`+ Var simpleVar = JavascriptConversion::TryCanonicalizeAsSimpleVar<true /* allowLossyConversion */>(value);`
`592`	`592`	`// If the simple value is the same as the original value, we know it isn't in the set`
`593`	`593`	`if (!simpleVar \|\| simpleVar == value)`
`594`	`594`	`{`
Original file line number	Diff line number	Diff line change
`@@ -85,10 +85,16 @@ namespace Js`
`85`	`85`
`86`	`86`	`case TypeIds_String:`
`87`	`87`	`{`
`88`		`- JavascriptString* v = JavascriptString::FromVar(i);`
	`88`	`+ JavascriptString* v = JavascriptString::UnsafeFromVar(i);`
`89`	`89`	`return JsUtil::CharacterBuffer<WCHAR>::StaticGetHashCode(v->GetString(), v->GetLength());`
`90`	`90`	`}`
`91`	`91`
	`92`	`+ case TypeIds_Symbol:`
	`93`	`+ {`
	`94`	`+ JavascriptSymbol* sym = JavascriptSymbol::UnsafeFromVar(i);`
	`95`	`+ return sym->GetValue()->GetHashCode();`
	`96`	`+ }`
	`97`	`+`
`92`	`98`	`default:`
`93`	`99`	`return RecyclerPointerComparer<Var>::GetHashCode(i);`
`94`	`100`	`}`