Project C++ enums to Intl.js rather than hardcoding them and keeping them in sync

jackhorton · jackhorton · commit b9872054d7e9 · 2018-09-06T08:33:11.000-07:00
diff --git a/lib/Runtime/Base/JnDirectFields.h b/lib/Runtime/Base/JnDirectFields.h
@@ -519,10 +519,30 @@ 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)
 
 // 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)
diff --git a/lib/Runtime/Library/InJavascript/Intl.js b/lib/Runtime/Library/InJavascript/Intl.js
@@ -165,41 +165,6 @@
         assert(test, err) { return test ? undefined : platform.raiseAssert(err || new Error("Assert failed")); }
     };
 
-    // Keep these "enums" in sync with lib/Runtime/PlatformAgnostic/Intl.h
-    const CollatorSensitivity = bare({
-        base: 0,
-        accent: 1,
-        case: 2,
-        variant: 3,
-        DEFAULT: 3
-    });
-    const CollatorCaseFirst = bare({
-        upper: 0,
-        lower: 1,
-        false: 2,
-        DEFAULT: 2
-    });
-    const NumberFormatStyle = bare({
-        DEFAULT: 0, // "decimal" is the default
-        DECIMAL: 0, // Intl.NumberFormat(locale, { style: "decimal" }); // aka in our code as "number"
-        PERCENT: 1, // Intl.NumberFormat(locale, { style: "percent" });
-        CURRENCY: 2, // Intl.NumberFormat(locale, { style: "currency", ... });
-    });
-    const NumberFormatCurrencyDisplay = bare({
-        DEFAULT: 0, // "symbol" is the default
-        SYMBOL: 0, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "symbol" }); // e.g. "$" or "US$" depeding on locale
-        CODE: 1, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "code" }); // e.g. "USD"
-        NAME: 2, // Intl.NumberFormat(locale, { style: "currency", currencyDisplay: "name" }); // e.g. "US dollar"
-    });
-
-    const toEnum = function (enumObject, key) {
-        if (!key || typeof key !== "string") {
-            return enumObject.DEFAULT;
-        } else {
-            return enumObject[key];
-        }
-    }
-
     // When this file was originally written, it assumed Windows Globalization semantics.
     // Throughout the transition to ICU, we tried to share as much code as possible between WinGlob and ICU.
     // However, because ICU has different semantics and our ICU-based implementation tries to match a newer
@@ -294,33 +259,6 @@
         }
     };
 
-    /**
-     * Returns an array of acceptable values for a given key in a given locale. It is expected that
-     * locale is one that has already been validated by platform.is*LocaleAvailable and key is limited
-     * to the [[RelevantExtensionKeys]] of Collator, NumberFormat, and DateTimeFormat.
-     *
-     * ECMA402: #sec-internal-slots ([[SortLocaleData]], [[SearchLocaleData]], and [[LocaleData]])
-     *
-     * @param {String} key a unicode extension key like "co", "ca", etc
-     * @param {String} locale the locale for which to get the given key's data
-     * @returns {String[]}
-     */
-    const getKeyLocaleData = function (key, locale) {
-        // NOTE: keep this enum in sync with `enum class LocaleDataKind` in IntlEngineInterfaceExtensionObject.cpp
-        const LocaleDataKind = {
-            co: 0,
-            kf: 1,
-            kn: 2,
-            ca: 3,
-            nu: 4,
-            hc: 5,
-        };
-
-        const keyLocaleData = platform.getLocaleData(LocaleDataKind[key], locale);
-
-        return keyLocaleData;
-    };
-
     /**
      * Determines which locale (or fallback) to use of an array of locales.
      *
@@ -424,7 +362,7 @@
         const result = bare({ dataLocale: foundLocale });
         let supportedExtension = "-u";
         _.forEach(relevantExtensionKeys, function (key) {
-            const keyLocaleData = getKeyLocaleData(key, foundLocale);
+            const keyLocaleData = platform.getLocaleData(platform.LocaleDataKind[key], foundLocale);
             let value = keyLocaleData[0];
             let supportedExtensionAddition = "";
             if (r.extension) {
@@ -956,10 +894,10 @@
             collator.collation = r.co === null ? "default" : r.co;
             collator.numeric = r.kn === "true";
             collator.caseFirst = r.kf;
-            collator.caseFirstEnum = toEnum(CollatorCaseFirst, collator.caseFirst);
+            collator.caseFirstEnum = platform.CollatorCaseFirst[collator.caseFirst];
 
             collator.sensitivity = GetOption(options, "sensitivity", "string", ["base", "accent", "case", "variant"], "variant");
-            collator.sensitivityEnum = toEnum(CollatorSensitivity, collator.sensitivity);
+            collator.sensitivityEnum = platform.CollatorSensitivity[collator.sensitivity];
 
             collator.ignorePunctuation = GetOption(options, "ignorePunctuation", "boolean", undefined, false);
 
@@ -1132,7 +1070,7 @@
 
             const style = GetOption(options, "style", "string", ["decimal", "percent", "currency"], "decimal");
             nf.style = style;
-            nf.formatterToUse = toEnum(NumberFormatStyle, _.toUpperCase(style));
+            nf.formatterToUse = platform.NumberFormatStyle[style];
             const useCurrency = style === "currency";
 
             let currency = GetOption(options, "currency", "string", undefined, undefined);
@@ -1151,8 +1089,8 @@
 
             let currencyDisplay = GetOption(options, "currencyDisplay", "string", ["code", "symbol", "name"], "symbol");
             if (useCurrency) {
-                nf.currencyDisplay = currencyDisplay
-                nf.currencyDisplayToUse = toEnum(NumberFormatCurrencyDisplay, _.toUpperCase(currencyDisplay));
+                nf.currencyDisplay = currencyDisplay;
+                nf.currencyDisplayToUse = platform.NumberFormatCurrencyDisplay[currencyDisplay];
             }
 
             let mnfdDefault, mxfdDefault;
diff --git a/lib/Runtime/Library/IntlEngineInterfaceExtensionObject.cpp b/lib/Runtime/Library/IntlEngineInterfaceExtensionObject.cpp
@@ -48,48 +48,67 @@ 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)
+
+#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)
 
-    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
@@ -549,6 +568,20 @@ namespace Js
 
         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, unicodeKey, value) library->AddMember(enumObj, PropertyIds::##unicodeKey, 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 +1082,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, ...)
