deps: update ChakraCore to chakra-core/ChakraCore@4d96e78734

obastemur · chakrabot · commit 4cae9e440dcf · 2018-01-24T03:08:29.000-08:00
[1.8>1.9] [MERGE #4580 @obastemur] Update PropertyRecord interface to preserve the record life time Merge pull request #4580 from obastemur:props_swb Reviewed-By: chakrabot <chakrabot@users.noreply.github.com>
diff --git a/deps/chakrashim/core/lib/Runtime/Base/ScriptContext.cpp b/deps/chakrashim/core/lib/Runtime/Base/ScriptContext.cpp
@@ -877,7 +877,7 @@ namespace Js
 
     void ScriptContext::GetOrAddPropertyRecord(_In_ Js::JavascriptString * propertyString, _Out_ PropertyRecord const** propertyRecord)
     {
-        *propertyRecord = propertyString->GetPropertyRecord();
+        propertyString->GetPropertyRecord(propertyRecord);
     }
 
     void ScriptContext::GetOrAddPropertyRecord(JsUtil::CharacterBuffer<WCHAR> const& propertyName, PropertyRecord const ** propertyRecord)
diff --git a/deps/chakrashim/core/lib/Runtime/Base/ThreadContext.cpp b/deps/chakrashim/core/lib/Runtime/Base/ThreadContext.cpp
@@ -888,10 +888,9 @@ ThreadContext::GetPropertyNameImpl(Js::PropertyId propertyId)
 void
 ThreadContext::FindPropertyRecord(Js::JavascriptString *pstName, Js::PropertyRecord const ** propertyRecord)
 {
-    const Js::PropertyRecord * propRecord = pstName->GetPropertyRecord(true);
-    if (propRecord != nullptr)
+    pstName->GetPropertyRecord(propertyRecord, true);
+    if (*propertyRecord != nullptr)
     {
-        *propertyRecord = propRecord;
         return;
     }
 
diff --git a/deps/chakrashim/core/lib/Runtime/Language/JavascriptConversion.cpp b/deps/chakrashim/core/lib/Runtime/Language/JavascriptConversion.cpp
@@ -293,7 +293,7 @@ namespace Js
         {
             // For all other types, convert the key into a string and use that as the property name
             JavascriptString * propName = JavascriptConversion::ToString(key, scriptContext);
-            *propertyRecord = propName->GetPropertyRecord();
+            propName->GetPropertyRecord(propertyRecord);
         }
 
         if (propString)
diff --git a/deps/chakrashim/core/lib/Runtime/Language/JavascriptOperators.cpp b/deps/chakrashim/core/lib/Runtime/Language/JavascriptOperators.cpp
@@ -1914,7 +1914,7 @@ namespace Js
             {
                 if (value && !WithScopeObject::Is(object) && info->GetPropertyString())
                 {
-                    PropertyId propertyId = info->GetPropertyString()->GetPropertyRecord()->GetPropertyId();
+                    PropertyId propertyId = info->GetPropertyString()->GetPropertyId();
                     CacheOperators::CachePropertyRead(instance, object, false, propertyId, false, info, requestContext);
                 }
                 return JavascriptConversion::PropertyQueryFlagsToBoolean(result);
@@ -1928,7 +1928,7 @@ namespace Js
         if (!PHASE_OFF1(MissingPropertyCachePhase) && info->GetPropertyString() && DynamicObject::Is(instance) && ((DynamicObject*)instance)->GetDynamicType()->GetTypeHandler()->IsPathTypeHandler())
         {
             PropertyValueInfo::Set(info, requestContext->GetLibrary()->GetMissingPropertyHolder(), 0);
-            CacheOperators::CachePropertyRead(instance, requestContext->GetLibrary()->GetMissingPropertyHolder(), false, info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), true, info, requestContext);
+            CacheOperators::CachePropertyRead(instance, requestContext->GetLibrary()->GetMissingPropertyHolder(), false, info->GetPropertyString()->GetPropertyId(), true, info, requestContext);
         }
 
         *value = requestContext->GetMissingPropertyResult();
@@ -2302,7 +2302,7 @@ namespace Js
                     {
                         if (!WithScopeObject::Is(receiver) && info->GetPropertyString())
                         {
-                            CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, object->GetType(), info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), info, requestContext);
+                            CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, object->GetType(), info->GetPropertyString()->GetPropertyId(), info, requestContext);
                         }
                         receiver = (RecyclableObject::FromVar(receiver))->GetThisObjectOrUnWrap();
                         RecyclableObject* func = RecyclableObject::FromVar(setterValueOrProxy);
@@ -2358,12 +2358,12 @@ namespace Js
             {
                 if (!JavascriptProxy::Is(receiver) && info->GetPropertyString() && info->GetFlags() != InlineCacheSetterFlag && !object->CanHaveInterceptors())
                 {
-                    CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, typeWithoutProperty, info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), info, requestContext);
+                    CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, typeWithoutProperty, info->GetPropertyString()->GetPropertyId(), info, requestContext);
 
                     if (info->GetInstance() == receiverObject)
                     {
                         PropertyValueInfo::SetCacheInfo(info, info->GetPropertyString(), info->GetPropertyString()->GetLdElemInlineCache(), info->AllowResizingPolymorphicInlineCache());
-                        CacheOperators::CachePropertyRead(object, receiverObject, false, info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), false, info, requestContext);
+                        CacheOperators::CachePropertyRead(object, receiverObject, false, info->GetPropertyString()->GetPropertyId(), false, info, requestContext);
                     }
                 }
                 return TRUE;
@@ -3778,7 +3778,8 @@ namespace Js
                     LiteralStringWithPropertyStringPtr * strWithPtr = (LiteralStringWithPropertyStringPtr *)temp;
                     if (!strWithPtr->HasPropertyRecord())
                     {
-                        strWithPtr->GetPropertyRecord(); // lookup-cache propertyRecord
+                        PropertyRecord const * propertyRecord;
+                        strWithPtr->GetPropertyRecord(&propertyRecord); // lookup-cache propertyRecord
                     }
                     else
                     {
@@ -3798,7 +3799,8 @@ namespace Js
                             JavascriptString::FromVar(index)->GetSz());
                     }
 
-                    PropertyRecord const * propertyRecord = propertyString->GetPropertyRecord();
+                    PropertyRecord const * propertyRecord;
+                    propertyString->GetPropertyRecord(&propertyRecord);
                     Var value;
 
                     if (propertyRecord->IsNumeric())
@@ -4430,13 +4432,13 @@ namespace Js
             LiteralStringWithPropertyStringPtr * strWithPtr = LiteralStringWithPropertyStringPtr::TryFromVar(index);
             if (strWithPtr != nullptr)
             {
-                propertyString = strWithPtr->GetPropertyString(); // do not force create the PropertyString,
-                                                                  // if it wasn't there, it won't be efficient for now.
-                propertyRecord = strWithPtr->GetPropertyRecord(true /* dontLookupFromDictionary */);
+                propertyString = strWithPtr->GetPropertyString();   // do not force create the PropertyString,
+                                                                    // if it wasn't there, it won't be efficient for now.
+                strWithPtr->GetPropertyRecord(&propertyRecord, true /* dontLookupFromDictionary */);
                 if (propertyRecord == nullptr)
                 {
-                    propertyRecord = strWithPtr->GetPropertyRecord(); // lookup-cache propertyRecord
-                                                                      // later this call, there will be a lookup anyways!
+                    strWithPtr->GetPropertyRecord(&propertyRecord); // lookup-cache propertyRecord
+                                                                    // later this call, there will be a lookup anyways!
                 }
                 else if (propertyString == nullptr)
                 {
@@ -4448,7 +4450,7 @@ namespace Js
         }
         else
         {
-            propertyRecord = propertyString->GetPropertyRecord();
+            propertyString->GetPropertyRecord(&propertyRecord);
         }
 
         if (propertyRecord != nullptr)
@@ -10529,7 +10531,9 @@ namespace Js
 
     BOOL JavascriptOperators::CheckPrototypesForAccessorOrNonWritableProperty(RecyclableObject* instance, JavascriptString* propertyNameString, Var* setterValue, DescriptorFlags* flags, PropertyValueInfo* info, ScriptContext* scriptContext)
     {
-        PropertyId propertyId = propertyNameString->GetPropertyRecord()->GetPropertyId();
+        Js::PropertyRecord const * localPropertyRecord;
+        propertyNameString->GetPropertyRecord(&localPropertyRecord);
+        PropertyId propertyId = localPropertyRecord->GetPropertyId();
         return CheckPrototypesForAccessorOrNonWritableProperty(instance, propertyId, setterValue, flags, info, scriptContext);
     }
 
diff --git a/deps/chakrashim/core/lib/Runtime/Library/ConcatString.cpp b/deps/chakrashim/core/lib/Runtime/Library/ConcatString.cpp
@@ -151,7 +151,9 @@ namespace Js
         this->propertyString = propStr;
         if (propStr != nullptr)
         {
-            this->propertyRecord = propStr->GetPropertyRecord();
+            Js::PropertyRecord const * localPropertyRecord;
+            propStr->GetPropertyRecord(&localPropertyRecord);
+            this->propertyRecord = localPropertyRecord;
         }
     }
 
@@ -167,20 +169,29 @@ namespace Js
         return RecyclableObject::Is(var) && LiteralStringWithPropertyStringPtr::Is(RecyclableObject::UnsafeFromVar(var));
     }
 
-    Js::PropertyRecord const * LiteralStringWithPropertyStringPtr::GetPropertyRecord(bool dontLookupFromDictionary)
+    void LiteralStringWithPropertyStringPtr::GetPropertyRecord(_Out_ PropertyRecord const** propRecord, bool dontLookupFromDictionary)
     {
+        *propRecord = nullptr;
         ScriptContext * scriptContext = this->GetScriptContext();
 
-        if (this->propertyRecord == nullptr && !dontLookupFromDictionary)
+        if (this->propertyRecord == nullptr)
         {
-            Js::PropertyRecord const * localPropertyRecord;
-            scriptContext->GetOrAddPropertyRecord(this->GetSz(),
-                static_cast<int>(this->GetLength()),
-                &localPropertyRecord);
-            this->propertyRecord = localPropertyRecord;
+            if (!dontLookupFromDictionary)
+            {
+                // cache PropertyRecord
+                Js::PropertyRecord const * localPropertyRecord;
+                scriptContext->GetOrAddPropertyRecord(this->GetSz(),
+                    static_cast<int>(this->GetLength()),
+                    &localPropertyRecord);
+                this->propertyRecord = localPropertyRecord;
+            }
+            else
+            {
+                return;
+            }
         }
 
-        return this->propertyRecord;
+        *propRecord = this->propertyRecord;
     }
 
     /////////////////////// ConcatStringBase //////////////////////////
diff --git a/deps/chakrashim/core/lib/Runtime/Library/ConcatString.h b/deps/chakrashim/core/lib/Runtime/Library/ConcatString.h
@@ -13,7 +13,8 @@ namespace Js
         Field(const Js::PropertyRecord*) propertyRecord;
 
     public:
-        virtual Js::PropertyRecord const * GetPropertyRecord(bool dontLookupFromDictionary = false) override;
+        virtual void GetPropertyRecord(_Out_ PropertyRecord const** propRecord, bool dontLookupFromDictionary = false) override;
+
         bool HasPropertyRecord() const { return propertyRecord != nullptr; }
 
         PropertyString * GetPropertyString() const;
diff --git a/deps/chakrashim/core/lib/Runtime/Library/ForInObjectEnumerator.cpp b/deps/chakrashim/core/lib/Runtime/Library/ForInObjectEnumerator.cpp
@@ -184,10 +184,10 @@ namespace Js
                 // Property Id does not exist.
                 if (propertyId == Constants::NoProperty)
                 {
-                    propRecord = currentIndex->GetPropertyRecord(true);
+                    currentIndex->GetPropertyRecord(&propRecord, true);
                     if (propRecord == nullptr)
                     {
-                        propRecord = currentIndex->GetPropertyRecord(false); // will create
+                        currentIndex->GetPropertyRecord(&propRecord, false); // will create
                         // We keep the track of what is enumerated using a bit vector of propertyID.
                         // so the propertyId can't be collected until the end of the for in enumerator
                         // Keep a list of the property string.
diff --git a/deps/chakrashim/core/lib/Runtime/Library/JSONStringifier.cpp b/deps/chakrashim/core/lib/Runtime/Library/JSONStringifier.cpp
@@ -235,7 +235,7 @@ JSONStringifier::ReadValue(_In_ JavascriptString* key, _In_opt_ const PropertyRe
 
     if (propertyRecord == nullptr)
     {
-        propertyRecord = key->GetPropertyRecord();
+        key->GetPropertyRecord(&propertyRecord);
     }
     JavascriptOperators::GetProperty(holder, propertyRecord->GetPropertyId(), &value, this->scriptContext, &info);
     return value;
diff --git a/deps/chakrashim/core/lib/Runtime/Library/JavascriptObject.cpp b/deps/chakrashim/core/lib/Runtime/Library/JavascriptObject.cpp
@@ -1733,7 +1733,7 @@ namespace Js
             }
             else
             {
-                propertyRecord = ((PropertyString*)propertyName)->GetPropertyRecord();
+                propertyName->GetPropertyRecord(&propertyRecord);
             }
 
             if (descCount == descSize)
diff --git a/deps/chakrashim/core/lib/Runtime/Library/JavascriptString.cpp b/deps/chakrashim/core/lib/Runtime/Library/JavascriptString.cpp
@@ -224,17 +224,15 @@ namespace Js
         return JavascriptOperators::GetTypeId(aValue) == TypeIds_String;
     }
 
-    Js::PropertyRecord const * JavascriptString::GetPropertyRecord(bool dontLookupFromDictionary)
+    void JavascriptString::GetPropertyRecord(_Out_ Js::PropertyRecord const ** propertyRecord, bool dontLookupFromDictionary)
     {
+        *propertyRecord = nullptr;
         if (dontLookupFromDictionary)
         {
-            return nullptr;
+            return;
         }
 
-        Js::PropertyRecord const * propertyRecord;
-        GetScriptContext()->GetOrAddPropertyRecord(GetString(), GetLength(), &propertyRecord);
-
-        return propertyRecord;
+        GetScriptContext()->GetOrAddPropertyRecord(GetString(), GetLength(), propertyRecord);
     }
 
     JavascriptString* JavascriptString::FromVar(Var aValue)
diff --git a/deps/chakrashim/core/lib/Runtime/Library/JavascriptString.h b/deps/chakrashim/core/lib/Runtime/Library/JavascriptString.h
@@ -50,7 +50,7 @@ namespace Js
         BOOL GetItemAt(charcount_t idxChar, Var* value);
         char16 GetItem(charcount_t index);
 
-        virtual Js::PropertyRecord const * GetPropertyRecord(bool dontLookupFromDictionary = false);
+        virtual void GetPropertyRecord(_Out_ PropertyRecord const** propertyRecord, bool dontLookupFromDictionary = false);
 
         _Ret_range_(m_charLength, m_charLength) charcount_t GetLength() const;
         virtual size_t GetAllocatedByteCount() const;
@@ -354,8 +354,8 @@ namespace Js
     {
         inline static bool Equals(JavascriptString * str1, JavascriptString * str2)
         {
-            // We want to pin the strings str1 and str2 because flattening of any of these strings could cause a GC and result in the other string getting collected if it was optimized 
-            // away by the compiler. We would normally have called the EnterPinnedScope/LeavePinnedScope methods here but it adds extra call instructions to the assembly code. As Equals 
+            // We want to pin the strings str1 and str2 because flattening of any of these strings could cause a GC and result in the other string getting collected if it was optimized
+            // away by the compiler. We would normally have called the EnterPinnedScope/LeavePinnedScope methods here but it adds extra call instructions to the assembly code. As Equals
             // methods could get called a lot of times this can show up as regressions in benchmarks.
             volatile Js::JavascriptString** keepAliveString1 = (volatile Js::JavascriptString**)& str1;
             volatile Js::JavascriptString** keepAliveString2 = (volatile Js::JavascriptString**)& str2;
diff --git a/deps/chakrashim/core/lib/Runtime/Library/LazyJSONString.cpp b/deps/chakrashim/core/lib/Runtime/Library/LazyJSONString.cpp
@@ -57,8 +57,10 @@ LazyJSONString::ReconstructObject(_In_ JSONObject* valueList) const
         PropertyValueInfo info;
         if (!propertyString || !propertyString->TrySetPropertyFromCache(obj, propertyValue, this->GetScriptContext(), PropertyOperation_None, &info))
         {
-            const PropertyRecord* propertyRecord = propertyName->GetPropertyRecord();
-            JavascriptOperators::SetProperty(obj, obj, propertyRecord->GetPropertyId(), propertyValue, &info, this->GetScriptContext());
+            Js::PropertyRecord const * localPropertyRecord;
+            propertyName->GetPropertyRecord(&localPropertyRecord);
+            JavascriptOperators::SetProperty(obj, obj, localPropertyRecord->GetPropertyId(),
+                propertyValue, &info, this->GetScriptContext());
         }
     }
     NEXT_SLISTCOUNTED_ENTRY;
diff --git a/deps/chakrashim/core/lib/Runtime/Library/PropertyString.h b/deps/chakrashim/core/lib/Runtime/Library/PropertyString.h
@@ -18,9 +18,14 @@ class PropertyString : public JavascriptString
 
     PropertyString(StaticType* type, const Js::PropertyRecord* propertyRecord);
 public:
-    virtual Js::PropertyRecord const * GetPropertyRecord(bool dontLookupFromDictionary = false) override
+    virtual void GetPropertyRecord(_Out_ PropertyRecord const** propertyRecord, bool dontLookupFromDictionary = false) override
     {
-        return this->propertyRecord;
+        *propertyRecord = this->propertyRecord;
+    }
+
+    Js::PropertyId GetPropertyId()
+    {
+        return this->propertyRecord->GetPropertyId();
     }
 
     PolymorphicInlineCache * GetLdElemInlineCache() const;
diff --git a/deps/chakrashim/core/lib/Runtime/Types/DynamicObjectPropertyEnumerator.cpp b/deps/chakrashim/core/lib/Runtime/Types/DynamicObjectPropertyEnumerator.cpp
@@ -180,7 +180,7 @@ namespace Js
         {
             PropertyString * propertyString = cachedData->strings[enumeratedCount];
             propertyStringName = propertyString;
-            propertyId = propertyString->GetPropertyRecord()->GetPropertyId();
+            propertyId = propertyString->GetPropertyId();
 
 #if DBG
             PropertyId tempPropertyId;
diff --git a/deps/chakrashim/core/lib/Runtime/Types/SimpleDictionaryTypeHandler.cpp b/deps/chakrashim/core/lib/Runtime/Types/SimpleDictionaryTypeHandler.cpp
@@ -91,7 +91,7 @@ namespace Js
         PropertyString * propertyString = PropertyString::TryFromVar(key);
         if (propertyString != nullptr)
         {
-            propertyRecord = propertyString->GetPropertyRecord();
+            propertyString->GetPropertyRecord(&propertyRecord);
         }
         else
         {
@@ -104,7 +104,8 @@ namespace Js
     bool TPropertyKey_IsInternalPropertyId(JavascriptString* key)
     {
         // WARNING: This will return false for PropertyStrings that are actually InternalPropertyIds
-        Assert(!PropertyString::Is(key) || !IsInternalPropertyId(((PropertyString*)key)->GetPropertyRecord()->GetPropertyId()));
+        Assert(!PropertyString::Is(key) || !IsInternalPropertyId(((PropertyString*)key)->GetPropertyId()));
+
         return false;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -877,7 +877,7 @@ namespace Js`
`877`	`877`
`878`	`878`	`void ScriptContext::GetOrAddPropertyRecord(_In_ Js::JavascriptString * propertyString, _Out_ PropertyRecord const** propertyRecord)`
`879`	`879`	`{`
`880`		`- *propertyRecord = propertyString->GetPropertyRecord();`
	`880`	`+ propertyString->GetPropertyRecord(propertyRecord);`
`881`	`881`	`}`
`882`	`882`
`883`	`883`	`void ScriptContext::GetOrAddPropertyRecord(JsUtil::CharacterBuffer<WCHAR> const& propertyName, PropertyRecord const ** propertyRecord)`
Original file line number	Diff line number	Diff line change
`@@ -888,10 +888,9 @@ ThreadContext::GetPropertyNameImpl(Js::PropertyId propertyId)`
`888`	`888`	`void`
`889`	`889`	`ThreadContext::FindPropertyRecord(Js::JavascriptString pstName, Js::PropertyRecord const * propertyRecord)`
`890`	`890`	`{`
`891`		`- const Js::PropertyRecord * propRecord = pstName->GetPropertyRecord(true);`
`892`		`- if (propRecord != nullptr)`
	`891`	`+ pstName->GetPropertyRecord(propertyRecord, true);`
	`892`	`+ if (*propertyRecord != nullptr)`
`893`	`893`	`{`
`894`		`- *propertyRecord = propRecord;`
`895`	`894`	`return;`
`896`	`895`	`}`
`897`	`896`
Original file line number	Diff line number	Diff line change
`@@ -293,7 +293,7 @@ namespace Js`
`293`	`293`	`{`
`294`	`294`	`// For all other types, convert the key into a string and use that as the property name`
`295`	`295`	`JavascriptString * propName = JavascriptConversion::ToString(key, scriptContext);`
`296`		`- *propertyRecord = propName->GetPropertyRecord();`
	`296`	`+ propName->GetPropertyRecord(propertyRecord);`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`if (propString)`
Original file line number	Diff line number	Diff line change
`@@ -1914,7 +1914,7 @@ namespace Js`
`1914`	`1914`	`{`
`1915`	`1915`	`if (value && !WithScopeObject::Is(object) && info->GetPropertyString())`
`1916`	`1916`	`{`
`1917`		`- PropertyId propertyId = info->GetPropertyString()->GetPropertyRecord()->GetPropertyId();`
	`1917`	`+ PropertyId propertyId = info->GetPropertyString()->GetPropertyId();`
`1918`	`1918`	`CacheOperators::CachePropertyRead(instance, object, false, propertyId, false, info, requestContext);`
`1919`	`1919`	`}`
`1920`	`1920`	`return JavascriptConversion::PropertyQueryFlagsToBoolean(result);`
`@@ -1928,7 +1928,7 @@ namespace Js`
`1928`	`1928`	`if (!PHASE_OFF1(MissingPropertyCachePhase) && info->GetPropertyString() && DynamicObject::Is(instance) && ((DynamicObject*)instance)->GetDynamicType()->GetTypeHandler()->IsPathTypeHandler())`
`1929`	`1929`	`{`
`1930`	`1930`	`PropertyValueInfo::Set(info, requestContext->GetLibrary()->GetMissingPropertyHolder(), 0);`
`1931`		`- CacheOperators::CachePropertyRead(instance, requestContext->GetLibrary()->GetMissingPropertyHolder(), false, info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), true, info, requestContext);`
	`1931`	`+ CacheOperators::CachePropertyRead(instance, requestContext->GetLibrary()->GetMissingPropertyHolder(), false, info->GetPropertyString()->GetPropertyId(), true, info, requestContext);`
`1932`	`1932`	`}`
`1933`	`1933`
`1934`	`1934`	`*value = requestContext->GetMissingPropertyResult();`
`@@ -2302,7 +2302,7 @@ namespace Js`
`2302`	`2302`	`{`
`2303`	`2303`	`if (!WithScopeObject::Is(receiver) && info->GetPropertyString())`
`2304`	`2304`	`{`
`2305`		`- CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, object->GetType(), info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), info, requestContext);`
	`2305`	`+ CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, object->GetType(), info->GetPropertyString()->GetPropertyId(), info, requestContext);`
`2306`	`2306`	`}`
`2307`	`2307`	`receiver = (RecyclableObject::FromVar(receiver))->GetThisObjectOrUnWrap();`
`2308`	`2308`	`RecyclableObject* func = RecyclableObject::FromVar(setterValueOrProxy);`
`@@ -2358,12 +2358,12 @@ namespace Js`
`2358`	`2358`	`{`
`2359`	`2359`	`if (!JavascriptProxy::Is(receiver) && info->GetPropertyString() && info->GetFlags() != InlineCacheSetterFlag && !object->CanHaveInterceptors())`
`2360`	`2360`	`{`
`2361`		`- CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, typeWithoutProperty, info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), info, requestContext);`
	`2361`	`+ CacheOperators::CachePropertyWrite(RecyclableObject::FromVar(receiver), false, typeWithoutProperty, info->GetPropertyString()->GetPropertyId(), info, requestContext);`
`2362`	`2362`
`2363`	`2363`	`if (info->GetInstance() == receiverObject)`
`2364`	`2364`	`{`
`2365`	`2365`	`PropertyValueInfo::SetCacheInfo(info, info->GetPropertyString(), info->GetPropertyString()->GetLdElemInlineCache(), info->AllowResizingPolymorphicInlineCache());`
`2366`		`- CacheOperators::CachePropertyRead(object, receiverObject, false, info->GetPropertyString()->GetPropertyRecord()->GetPropertyId(), false, info, requestContext);`
	`2366`	`+ CacheOperators::CachePropertyRead(object, receiverObject, false, info->GetPropertyString()->GetPropertyId(), false, info, requestContext);`
`2367`	`2367`	`}`
`2368`	`2368`	`}`
`2369`	`2369`	`return TRUE;`
`@@ -3778,7 +3778,8 @@ namespace Js`
`3778`	`3778`	`LiteralStringWithPropertyStringPtr * strWithPtr = (LiteralStringWithPropertyStringPtr *)temp;`
`3779`	`3779`	`if (!strWithPtr->HasPropertyRecord())`
`3780`	`3780`	`{`
`3781`		`- strWithPtr->GetPropertyRecord(); // lookup-cache propertyRecord`
	`3781`	`+ PropertyRecord const * propertyRecord;`
	`3782`	`+ strWithPtr->GetPropertyRecord(&propertyRecord); // lookup-cache propertyRecord`
`3782`	`3783`	`}`
`3783`	`3784`	`else`
`3784`	`3785`	`{`
`@@ -3798,7 +3799,8 @@ namespace Js`
`3798`	`3799`	`JavascriptString::FromVar(index)->GetSz());`
`3799`	`3800`	`}`
`3800`	`3801`
`3801`		`- PropertyRecord const * propertyRecord = propertyString->GetPropertyRecord();`
	`3802`	`+ PropertyRecord const * propertyRecord;`
	`3803`	`+ propertyString->GetPropertyRecord(&propertyRecord);`
`3802`	`3804`	`Var value;`
`3803`	`3805`
`3804`	`3806`	`if (propertyRecord->IsNumeric())`
`@@ -4430,13 +4432,13 @@ namespace Js`
`4430`	`4432`	`LiteralStringWithPropertyStringPtr * strWithPtr = LiteralStringWithPropertyStringPtr::TryFromVar(index);`
`4431`	`4433`	`if (strWithPtr != nullptr)`
`4432`	`4434`	`{`
`4433`		`- propertyString = strWithPtr->GetPropertyString(); // do not force create the PropertyString,`
`4434`		`- // if it wasn't there, it won't be efficient for now.`
`4435`		`- propertyRecord = strWithPtr->GetPropertyRecord(true /* dontLookupFromDictionary */);`
	`4435`	`+ propertyString = strWithPtr->GetPropertyString(); // do not force create the PropertyString,`
	`4436`	`+ // if it wasn't there, it won't be efficient for now.`
	`4437`	`+ strWithPtr->GetPropertyRecord(&propertyRecord, true /* dontLookupFromDictionary */);`
`4436`	`4438`	`if (propertyRecord == nullptr)`
`4437`	`4439`	`{`
`4438`		`- propertyRecord = strWithPtr->GetPropertyRecord(); // lookup-cache propertyRecord`
`4439`		`- // later this call, there will be a lookup anyways!`
	`4440`	`+ strWithPtr->GetPropertyRecord(&propertyRecord); // lookup-cache propertyRecord`
	`4441`	`+ // later this call, there will be a lookup anyways!`
`4440`	`4442`	`}`
`4441`	`4443`	`else if (propertyString == nullptr)`
`4442`	`4444`	`{`
`@@ -4448,7 +4450,7 @@ namespace Js`
`4448`	`4450`	`}`
`4449`	`4451`	`else`
`4450`	`4452`	`{`
`4451`		`- propertyRecord = propertyString->GetPropertyRecord();`
	`4453`	`+ propertyString->GetPropertyRecord(&propertyRecord);`
`4452`	`4454`	`}`
`4453`	`4455`
`4454`	`4456`	`if (propertyRecord != nullptr)`
`@@ -10529,7 +10531,9 @@ namespace Js`
`10529`	`10531`
`10530`	`10532`	`BOOL JavascriptOperators::CheckPrototypesForAccessorOrNonWritableProperty(RecyclableObject* instance, JavascriptString* propertyNameString, Var* setterValue, DescriptorFlags* flags, PropertyValueInfo* info, ScriptContext* scriptContext)`
`10531`	`10533`	`{`
`10532`		`- PropertyId propertyId = propertyNameString->GetPropertyRecord()->GetPropertyId();`
	`10534`	`+ Js::PropertyRecord const * localPropertyRecord;`
	`10535`	`+ propertyNameString->GetPropertyRecord(&localPropertyRecord);`
	`10536`	`+ PropertyId propertyId = localPropertyRecord->GetPropertyId();`
`10533`	`10537`	`return CheckPrototypesForAccessorOrNonWritableProperty(instance, propertyId, setterValue, flags, info, scriptContext);`
`10534`	`10538`	`}`
`10535`	`10539`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,9 @@ namespace Js`
`151`	`151`	`this->propertyString = propStr;`
`152`	`152`	`if (propStr != nullptr)`
`153`	`153`	`{`
`154`		`- this->propertyRecord = propStr->GetPropertyRecord();`
	`154`	`+ Js::PropertyRecord const * localPropertyRecord;`
	`155`	`+ propStr->GetPropertyRecord(&localPropertyRecord);`
	`156`	`+ this->propertyRecord = localPropertyRecord;`
`155`	`157`	`}`
`156`	`158`	`}`
`157`	`159`
`@@ -167,20 +169,29 @@ namespace Js`
`167`	`169`	`return RecyclableObject::Is(var) && LiteralStringWithPropertyStringPtr::Is(RecyclableObject::UnsafeFromVar(var));`
`168`	`170`	`}`
`169`	`171`
`170`		`- Js::PropertyRecord const * LiteralStringWithPropertyStringPtr::GetPropertyRecord(bool dontLookupFromDictionary)`
	`172`	`+ void LiteralStringWithPropertyStringPtr::GetPropertyRecord(_Out_ PropertyRecord const** propRecord, bool dontLookupFromDictionary)`
`171`	`173`	`{`
	`174`	`+ *propRecord = nullptr;`
`172`	`175`	`ScriptContext * scriptContext = this->GetScriptContext();`
`173`	`176`
`174`		`- if (this->propertyRecord == nullptr && !dontLookupFromDictionary)`
	`177`	`+ if (this->propertyRecord == nullptr)`
`175`	`178`	`{`
`176`		`- Js::PropertyRecord const * localPropertyRecord;`
`177`		`- scriptContext->GetOrAddPropertyRecord(this->GetSz(),`
`178`		`- static_cast<int>(this->GetLength()),`
`179`		`- &localPropertyRecord);`
`180`		`- this->propertyRecord = localPropertyRecord;`
	`179`	`+ if (!dontLookupFromDictionary)`
	`180`	`+ {`
	`181`	`+ // cache PropertyRecord`
	`182`	`+ Js::PropertyRecord const * localPropertyRecord;`
	`183`	`+ scriptContext->GetOrAddPropertyRecord(this->GetSz(),`
	`184`	`+ static_cast<int>(this->GetLength()),`
	`185`	`+ &localPropertyRecord);`
	`186`	`+ this->propertyRecord = localPropertyRecord;`
	`187`	`+ }`
	`188`	`+ else`
	`189`	`+ {`
	`190`	`+ return;`
	`191`	`+ }`
`181`	`192`	`}`
`182`	`193`
`183`		`- return this->propertyRecord;`
	`194`	`+ *propRecord = this->propertyRecord;`
`184`	`195`	`}`
`185`	`196`
`186`	`197`	`/////////////////////// ConcatStringBase //////////////////////////`
Original file line number	Diff line number	Diff line change
`@@ -184,10 +184,10 @@ namespace Js`
`184`	`184`	`// Property Id does not exist.`
`185`	`185`	`if (propertyId == Constants::NoProperty)`
`186`	`186`	`{`
`187`		`- propRecord = currentIndex->GetPropertyRecord(true);`
	`187`	`+ currentIndex->GetPropertyRecord(&propRecord, true);`
`188`	`188`	`if (propRecord == nullptr)`
`189`	`189`	`{`
`190`		`- propRecord = currentIndex->GetPropertyRecord(false); // will create`
	`190`	`+ currentIndex->GetPropertyRecord(&propRecord, false); // will create`
`191`	`191`	`// We keep the track of what is enumerated using a bit vector of propertyID.`
`192`	`192`	`// so the propertyId can't be collected until the end of the for in enumerator`
`193`	`193`	`// Keep a list of the property string.`
Original file line number	Diff line number	Diff line change
`@@ -235,7 +235,7 @@ JSONStringifier::ReadValue(_In_ JavascriptString* key, _In_opt_ const PropertyRe`
`235`	`235`
`236`	`236`	`if (propertyRecord == nullptr)`
`237`	`237`	`{`
`238`		`- propertyRecord = key->GetPropertyRecord();`
	`238`	`+ key->GetPropertyRecord(&propertyRecord);`
`239`	`239`	`}`
`240`	`240`	`JavascriptOperators::GetProperty(holder, propertyRecord->GetPropertyId(), &value, this->scriptContext, &info);`
`241`	`241`	`return value;`
Original file line number	Diff line number	Diff line change
`@@ -1733,7 +1733,7 @@ namespace Js`
`1733`	`1733`	`}`
`1734`	`1734`	`else`
`1735`	`1735`	`{`
`1736`		`- propertyRecord = ((PropertyString*)propertyName)->GetPropertyRecord();`
	`1736`	`+ propertyName->GetPropertyRecord(&propertyRecord);`
`1737`	`1737`	`}`
`1738`	`1738`
`1739`	`1739`	`if (descCount == descSize)`
Original file line number	Diff line number	Diff line change
`@@ -224,17 +224,15 @@ namespace Js`
`224`	`224`	`return JavascriptOperators::GetTypeId(aValue) == TypeIds_String;`
`225`	`225`	`}`
`226`	`226`
`227`		`- Js::PropertyRecord const * JavascriptString::GetPropertyRecord(bool dontLookupFromDictionary)`
	`227`	`+ void JavascriptString::GetPropertyRecord(_Out_ Js::PropertyRecord const ** propertyRecord, bool dontLookupFromDictionary)`
`228`	`228`	`{`
	`229`	`+ *propertyRecord = nullptr;`
`229`	`230`	`if (dontLookupFromDictionary)`
`230`	`231`	`{`
`231`		`- return nullptr;`
	`232`	`+ return;`
`232`	`233`	`}`
`233`	`234`
`234`		`- Js::PropertyRecord const * propertyRecord;`
`235`		`- GetScriptContext()->GetOrAddPropertyRecord(GetString(), GetLength(), &propertyRecord);`
`236`		`-`
`237`		`- return propertyRecord;`
	`235`	`+ GetScriptContext()->GetOrAddPropertyRecord(GetString(), GetLength(), propertyRecord);`
`238`	`236`	`}`
`239`	`237`
`240`	`238`	`JavascriptString* JavascriptString::FromVar(Var aValue)`