[MERGE #5651 @jackhorton] Project C++ enums to Intl.js, implement Intl.Collator's "usage" option

Merge pull request #5651 from jackhorton:intl/projected-enums-and-usage

Also, some assorted fixes and cleanup:
- We now correctly set the initSlotCapacity of the Intl native interface object
- Moved around some of the asserts in GetLocaleData to be more defensive. None hit, just noticed they had gaps.
- Added caching to Number.prototype.toLocaleString, which is now ~O(1) when calling with default arguments (locally on a debug build, time spent calling toLocaleString 100 times went from 140ms to 20ms)

Fixes #5648
Fixes #4007

Author: jackhorton

lib/Runtime/Base/JnDirectFields.h

@@ -519,10 +519,36 @@ ENTRY(tagPublicLibraryCode)
 ENTRY(winglob)
 ENTRY(platform)
 ENTRY(formatToParts)
-ENTRY(FallbackSymbol)
+ENTRY(co)
+ENTRY(kn)
+ENTRY(kf)
+ENTRY(nu)
+ENTRY(ca)
+ENTRY(hc)
+ENTRY(upper)
+ENTRY(lower)
+ENTRY(base)
+ENTRY(accent)
+ENTRY2(case_, _u("case"))
+ENTRY(variant)
+ENTRY(code)
+ENTRY(decimal)
+ENTRY(percent)
+ENTRY(NumberFormatStyle)
+ENTRY(NumberFormatCurrencyDisplay)
+ENTRY(CollatorSensitivity)
+ENTRY(CollatorCaseFirst)
+ENTRY(LocaleDataKind)
+ENTRY(DateToLocaleString)
+ENTRY(DateToLocaleDateString)
+ENTRY(DateToLocaleTimeString)
+ENTRY(NumberToLocaleString)
+ENTRY(StringLocaleCompare)
+ENTRY(BuiltInFunctionID)
 
 // This symbol is not part of the regular Symbol API and is only used in rare circumstances in Intl.js for backwards compatibility
 // with the Intl v1 spec. It is visible to the user only using Object.getOwnPropertySymbols(Intl.NumberFormat.call(new Intl.NumberFormat())).
+ENTRY(FallbackSymbol)
 ENTRY_SYMBOL(_intlFallbackSymbol, _u("Intl.FallbackSymbol"))
 
 ENTRY(NumberFormat)
@@ -561,6 +587,7 @@ ENTRY(numeric)
 ENTRY(sensitivity)
 ENTRY(sensitivityEnum)
 ENTRY(caseFirstEnum)
+ENTRY(usage)
 
 ENTRY(DateTimeFormat)
 ENTRY(__boundFormat)

lib/Runtime/ByteCode/ByteCodeCacheReleaseFileVersion.h

@@ -3,8 +3,7 @@
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 // NOTE: If there is a merge conflict the correct fix is to make a new GUID.
-// This file was generated with tools\update_bytecode_version.ps1
 
-// {BAC3A947-4873-4DAF-AC60-915116FFE744}
+// {DE720CA5-2D6E-4200-B4AB-CCCE40399727}
 const GUID byteCodeCacheReleaseFileVersion =
-{ 0xBAC3A947, 0x4873, 0x4DAF, { 0xAC, 0x60, 0x91, 0x51, 0x16, 0xFF, 0xE7, 0x44 } };
+{ 0xDE720CA5, 0x2D6E, 0x4200, { 0xB4, 0xAB, 0xCC, 0xCE, 0x40, 0x39, 0x97, 0x27 } };

lib/Runtime/Library/InJavascript/Intl.js

@@ -48,48 +48,76 @@ using namespace PlatformAgnostic::ICUHelpers;
 
 #endif // INTL_ICU
 
-// NOTE(jahorto): Keep these enums in sync with those by the same name in Intl.js
-// These enums are used by both WinGlob- and ICU-backed Intl
-enum class NumberFormatStyle
-{
-    Decimal, // Intl.NumberFormat(locale, { style: "decimal" }); // aka in our code as "number"
-    Percent, // Intl.NumberFormat(locale, { style: "percent" });
-    Currency, // Intl.NumberFormat(locale, { style: "currency", ... });
-
-    Max,
-    Default = Decimal,
-};
-
-enum class NumberFormatCurrencyDisplay
-{
-    Symbol, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "symbol" }); // e.g. "$" or "US$" depeding on locale
-    Code, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "code" }); // e.g. "USD"
-    Name, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "name" }); // e.g. "US dollar"
-
-    Max,
-    Default = Symbol,
+// The following macros allow the key-value pairs to be C++ enums as well as JS objects
+// in Intl.js. When adding a new macro, follow the same format as the _VALUES macros below,
+// and add your new _VALUES macro to PROJECTED_ENUMS along with the name of the enum.
+// NOTE: make sure the last VALUE macro has the highest integer value, since the C++ enum's ::Max
+// value is added to the end of the C++ enum definition as an increment of the previous value.
+// The ::Max value is used in a defensive assert, and we want to make sure its always 1 greater
+// than the highest valid value.
+
+#define NUMBERFORMATSTYLE_VALUES(VALUE) \
+VALUE(Default, default_, 0) \
+VALUE(Decimal, decimal, 0) \
+VALUE(Percent, percent, 1) \
+VALUE(Currency, currency, 2)
+
+#define NUMBERFORMATCURRENCYDISPLAY_VALUES(VALUE) \
+VALUE(Default, default_, 0) \
+VALUE(Symbol, symbol, 0) \
+VALUE(Code, code, 1) \
+VALUE(Name, name, 2)
+
+#define COLLATORSENSITIVITY_VALUES(VALUE) \
+VALUE(Default, default_, 3) \
+VALUE(Base, base, 0) \
+VALUE(Accent, accent, 1) \
+VALUE(Case, case_, 2) \
+VALUE(Variant, variant, 3)
+
+#define COLLATORCASEFIRST_VALUES(VALUE) \
+VALUE(Default, default_, 2) \
+VALUE(Upper, upper, 0) \
+VALUE(Lower, lower, 1) \
+VALUE(False, false_, 2)
+
+// LocaleDataKind intentionally has no Default value
+#define LOCALEDATAKIND_VALUES(VALUE) \
+VALUE(Collation, co, 0) \
+VALUE(CaseFirst, kf, 1) \
+VALUE(Numeric, kn, 2) \
+VALUE(Calendar, ca, 3) \
+VALUE(NumberingSystem, nu, 4) \
+VALUE(HourCycle, hc, 5)
+
+//BuiltInFunctionID intentionally has no Default value
+#define BUILTINFUNCTIONID_VALUES(VALUE) \
+VALUE(DateToLocaleString, DateToLocaleString, 0) \
+VALUE(DateToLocaleDateString, DateToLocaleDateString, 1) \
+VALUE(DateToLocaleTimeString, DateToLocaleTimeString, 2) \
+VALUE(NumberToLocaleString, NumberToLocaleString, 3) \
+VALUE(StringLocaleCompare, StringLocaleCompare, 4)
+
+#define ENUM_VALUE(enumName, propId, value) enumName = value,
+#define PROJECTED_ENUM(ClassName, VALUES) \
+enum class ClassName \
+{ \
+    VALUES(ENUM_VALUE) \
+    Max \
 };
 
-enum class CollatorSensitivity
-{
-    Base,
-    Accent,
-    Case,
-    Variant,
+#define PROJECTED_ENUMS(PROJECT) \
+PROJECT(LocaleDataKind, LOCALEDATAKIND_VALUES) \
+PROJECT(CollatorCaseFirst, COLLATORCASEFIRST_VALUES) \
+PROJECT(CollatorSensitivity, COLLATORSENSITIVITY_VALUES) \
+PROJECT(NumberFormatCurrencyDisplay, NUMBERFORMATCURRENCYDISPLAY_VALUES) \
+PROJECT(NumberFormatStyle, NUMBERFORMATSTYLE_VALUES) \
+PROJECT(BuiltInFunctionID, BUILTINFUNCTIONID_VALUES)
 
-    Max,
-    Default = Variant,
-};
+PROJECTED_ENUMS(PROJECTED_ENUM)
 
-enum class CollatorCaseFirst
-{
-    Upper,
-    Lower,
-    False,
-
-    Max,
-    Default = False,
-};
+#undef PROJECTED_ENUM
+#undef ENUM_VALUE
 
 #pragma warning(push)
 #pragma warning(disable:4309) // truncation of constant value
@@ -431,7 +459,7 @@ namespace Js
     template <size_t N>
     static void LangtagToLocaleID(_In_ JavascriptString *langtag, _Out_ char(&localeID)[N])
     {
-        LangtagToLocaleID(langtag->GetSz(), langtag->GetLength(), localeID);
+        LangtagToLocaleID(langtag->GetString(), langtag->GetLength(), localeID);
     }
 
     template <typename Callback>
@@ -533,22 +561,46 @@ namespace Js
 
     bool IntlEngineInterfaceExtensionObject::InitializeIntlNativeInterfaces(DynamicObject* intlNativeInterfaces, DeferredTypeHandlerBase * typeHandler, DeferredInitializeMode mode)
     {
-        typeHandler->Convert(intlNativeInterfaces, mode, 16);
+        int initSlotCapacity = 0;
+
+        // automatically get the initSlotCapacity from everything we are about to add to intlNativeInterfaces
+#define INTL_ENTRY(id, func) initSlotCapacity++;
+#include "IntlExtensionObjectBuiltIns.h"
+#undef INTL_ENTRY
+
+#define PROJECTED_ENUM(ClassName, VALUES) initSlotCapacity++;
+PROJECTED_ENUMS(PROJECTED_ENUM)
+#undef PROJECTED_ENUM
+
+        // add capacity for platform.winglob and platform.FallbackSymbol
+        initSlotCapacity += 2;
+
+        typeHandler->Convert(intlNativeInterfaces, mode, initSlotCapacity);
 
         ScriptContext* scriptContext = intlNativeInterfaces->GetScriptContext();
         JavascriptLibrary* library = scriptContext->GetLibrary();
 
 // gives each entrypoint a property ID on the intlNativeInterfaces library object
-#ifdef INTL_ENTRY
-#undef INTL_ENTRY
-#endif
-#define INTL_ENTRY(id, func) \
-    library->AddFunctionToLibraryObject(intlNativeInterfaces, Js::PropertyIds::##id, &IntlEngineInterfaceExtensionObject::EntryInfo::Intl_##func, 1);
+#define INTL_ENTRY(id, func) library->AddFunctionToLibraryObject(intlNativeInterfaces, Js::PropertyIds::##id, &IntlEngineInterfaceExtensionObject::EntryInfo::Intl_##func, 1);
 #include "IntlExtensionObjectBuiltIns.h"
 #undef INTL_ENTRY
 
         library->AddMember(intlNativeInterfaces, PropertyIds::FallbackSymbol, library->CreateSymbol(BuiltInPropertyRecords::_intlFallbackSymbol));
 
+        DynamicObject * enumObj = nullptr;
+
+// Projects the exact layout of our C++ enums into Intl.js so that we dont have to remember to keep them in sync
+#define ENUM_VALUE(enumName, propId, value) library->AddMember(enumObj, PropertyIds::##propId, JavascriptNumber::ToVar(value, scriptContext));
+#define PROJECTED_ENUM(ClassName, VALUES) \
+    enumObj = library->CreateObject(); \
+    VALUES(ENUM_VALUE) \
+    library->AddMember(intlNativeInterfaces, PropertyIds::##ClassName, enumObj); \
+
+PROJECTED_ENUMS(PROJECTED_ENUM)
+
+#undef PROJECTED_ENUM
+#undef ENUM_VALUE
+
 #if INTL_WINGLOB
         library->AddMember(intlNativeInterfaces, Js::PropertyIds::winglob, library->GetTrue());
 #else
@@ -1049,15 +1101,8 @@ DEFINE_ISXLOCALEAVAILABLE(DTF, udat)
 DEFINE_ISXLOCALEAVAILABLE(PR, uloc)
 
 #ifdef INTL_ICU
-    enum class LocaleDataKind
-    {
-        Collation,
-        CaseFirst,
-        Numeric,
-        Calendar,
-        NumberingSystem,
-        HourCycle
-    };
+
+
 #endif
 
     Var IntlEngineInterfaceExtensionObject::EntryIntl_GetLocaleData(RecyclableObject* function, CallInfo callInfo, ...)
@@ -1087,11 +1132,13 @@ DEFINE_ISXLOCALEAVAILABLE(PR, uloc)
         if (kind == LocaleDataKind::Collation)
         {
             ScopedUEnumeration collations(ucol_getKeywordValuesForLocale("collation", localeID, false, &status));
-            ICU_ASSERT(status, true);
+            int collationsCount = uenum_count(collations, &status);
+
+            // we expect collationsCount to have at least "standard" and "search" in it
+            ICU_ASSERT(status, collationsCount > 2);
 
             // the return array can't include "standard" and "search", but must have its first element be null (count - 2 + 1) [#sec-intl-collator-internal-slots]
-            ret = library->CreateArray(uenum_count(collations, &status) - 1);
-            ICU_ASSERT(status, true);
+            ret = library->CreateArray(collationsCount - 1);
             ret->SetItem(0, library->GetNull(), flag);
 
             int collationLen = 0;
@@ -1111,7 +1158,7 @@ DEFINE_ISXLOCALEAVAILABLE(PR, uloc)
                 const size_t unicodeCollationLen = strlen(unicodeCollation);
 
                 // we only need strlen(unicodeCollation) + 1 char16s because unicodeCollation will always be ASCII (funnily enough)
-                char16 *unicodeCollation16 = RecyclerNewArrayLeaf(scriptContext->GetRecycler(), char16, strlen(unicodeCollation) + 1);
+                char16 *unicodeCollation16 = RecyclerNewArrayLeaf(scriptContext->GetRecycler(), char16, unicodeCollationLen + 1);
                 charcount_t unicodeCollation16Len = 0;
                 HRESULT hr = utf8::NarrowStringToWideNoAlloc(
                     unicodeCollation,
@@ -1836,10 +1883,18 @@ DEFINE_ISXLOCALEAVAILABLE(PR, uloc)
             bool ignorePunctuation = AssertBooleanProperty(state, PropertyIds::ignorePunctuation);
             bool numeric = AssertBooleanProperty(state, PropertyIds::numeric);
             CollatorCaseFirst caseFirst = AssertEnumProperty<CollatorCaseFirst>(state, PropertyIds::caseFirstEnum);
+            JavascriptString *usage = AssertStringProperty(state, PropertyIds::usage);
 
             char localeID[ULOC_FULLNAME_CAPACITY] = { 0 };
             LangtagToLocaleID(langtag, localeID);
 
+            const char16 searchString[] = _u("search");
+            if (usage->BufferEquals(searchString, _countof(searchString) - 1)) // minus the null terminator
+            {
+                uloc_setKeywordValue("collation", "search", localeID, _countof(localeID), &status);
+                ICU_ASSERT(status, true);
+            }
+
             coll = FinalizableUCollator::New(scriptContext->GetRecycler(), ucol_open(localeID, &status));
             ICU_ASSERT(status, true);
 
@@ -3114,45 +3169,34 @@ DEFINE_ISXLOCALEAVAILABLE(PR, uloc)
     */
     Var IntlEngineInterfaceExtensionObject::EntryIntl_RegisterBuiltInFunction(RecyclableObject* function, CallInfo callInfo, ...)
     {
-        // Don't put this in a header or add it to the namespace even in this file. Keep it to the minimum scope needed.
-        enum class IntlBuiltInFunctionID : int32 {
-            Min = 0,
-            DateToLocaleString = Min,
-            DateToLocaleDateString,
-            DateToLocaleTimeString,
-            NumberToLocaleString,
-            StringLocaleCompare,
-            Max
-        };
-
         EngineInterfaceObject_CommonFunctionProlog(function, callInfo);
 
         // This function will only be used during the construction of the Intl object, hence Asserts are in place.
         Assert(args.Info.Count >= 3 && JavascriptFunction::Is(args.Values[1]) && TaggedInt::Is(args.Values[2]));
 
         JavascriptFunction *func = JavascriptFunction::FromVar(args.Values[1]);
         int32 id = TaggedInt::ToInt32(args.Values[2]);
-        Assert(id >= (int32)IntlBuiltInFunctionID::Min && id < (int32)IntlBuiltInFunctionID::Max);
+        Assert(id >= 0 && id < (int32)BuiltInFunctionID::Max);
 
         EngineInterfaceObject* nativeEngineInterfaceObj = scriptContext->GetLibrary()->GetEngineInterfaceObject();
         IntlEngineInterfaceExtensionObject* extensionObject = static_cast<IntlEngineInterfaceExtensionObject*>(nativeEngineInterfaceObj->GetEngineExtension(EngineInterfaceExtensionKind_Intl));
 
-        IntlBuiltInFunctionID functionID = static_cast<IntlBuiltInFunctionID>(id);
+        BuiltInFunctionID functionID = static_cast<BuiltInFunctionID>(id);
         switch (functionID)
         {
-        case IntlBuiltInFunctionID::DateToLocaleString:
+        case BuiltInFunctionID::DateToLocaleString:
             extensionObject->dateToLocaleString = func;
             break;
-        case IntlBuiltInFunctionID::DateToLocaleDateString:
+        case BuiltInFunctionID::DateToLocaleDateString:
             extensionObject->dateToLocaleDateString = func;
             break;
-        case IntlBuiltInFunctionID::DateToLocaleTimeString:
+        case BuiltInFunctionID::DateToLocaleTimeString:
             extensionObject->dateToLocaleTimeString = func;
             break;
-        case IntlBuiltInFunctionID::NumberToLocaleString:
+        case BuiltInFunctionID::NumberToLocaleString:
             extensionObject->numberToLocaleString = func;
             break;
-        case IntlBuiltInFunctionID::StringLocaleCompare:
+        case BuiltInFunctionID::StringLocaleCompare:
             extensionObject->stringLocaleCompare = func;
             break;
         default: