[Intl] Intl.NumberFormat Unified API Proposal

Design Doc: https://goo.gl/ZAtL1f

Bug: v8:8515
Change-Id: I543ab704fd3f8b41e396879ebbc581977ec0ff10
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1612325Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Commit-Queue: Frank Tang <ftang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61709}

src/flag-definitions.h

@@ -213,10 +213,11 @@ DEFINE_IMPLICATION(harmony_import_meta, harmony_dynamic_import)
   V(harmony_weak_refs, "harmony weak references")
 
 #ifdef V8_INTL_SUPPORT
-#define HARMONY_INPROGRESS(V)                   \
-  HARMONY_INPROGRESS_BASE(V)                    \
-  V(harmony_intl_add_calendar_numbering_system, \
-    "Add calendar and numberingSystem to DateTimeFormat")
+#define HARMONY_INPROGRESS(V)                             \
+  HARMONY_INPROGRESS_BASE(V)                              \
+  V(harmony_intl_add_calendar_numbering_system,           \
+    "Add calendar and numberingSystem to DateTimeFormat") \
+  V(harmony_intl_numberformat_unified, "Unified Intl.NumberFormat Features")
 #else
 #define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
 #endif

src/heap-symbols.h

@@ -18,8 +18,10 @@
   V(_, current_string, "current")                                   \
   V(_, collation_string, "collation")                               \
   V(_, compact_string, "compact")                                   \
+  V(_, compactDisplay_string, "compactDisplay")                     \
   V(_, currency_string, "currency")                                 \
   V(_, currencyDisplay_string, "currencyDisplay")                   \
+  V(_, currencySign_string, "currencySign")                         \
   V(_, dateStyle_string, "dateStyle")                               \
   V(_, day_string, "day")                                           \
   V(_, dayPeriod_string, "dayPeriod")                               \
@@ -69,6 +71,7 @@
   V(_, narrow_symbol_string, "narrow-symbol")                       \
   V(_, never_string, "never")                                       \
   V(_, none_string, "none")                                         \
+  V(_, notation_string, "notation")                                 \
   V(_, normal_string, "normal")                                     \
   V(_, numberingSystem_string, "numberingSystem")                   \
   V(_, numeric_string, "numeric")                                   \
@@ -84,6 +87,7 @@
   V(_, sensitivity_string, "sensitivity")                           \
   V(_, sep_string, "sep")                                           \
   V(_, shared_string, "shared")                                     \
+  V(_, signDisplay_string, "signDisplay")                           \
   V(_, standard_string, "standard")                                 \
   V(_, startRange_string, "startRange")                             \
   V(_, strict_string, "strict")                                     \
@@ -99,6 +103,7 @@
   V(_, useGrouping_string, "useGrouping")                           \
   V(_, UTC_string, "UTC")                                           \
   V(_, unit_string, "unit")                                         \
+  V(_, unitDisplay_string, "unitDisplay")                           \
   V(_, weekday_string, "weekday")                                   \
   V(_, year_string, "year")
 #else  // V8_INTL_SUPPORT

src/init/bootstrapper.cc

@@ -4239,6 +4239,7 @@ EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_hashbang)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_add_calendar_numbering_system)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_bigint)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_datetime_style)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_numberformat_unified)
 #endif  // V8_INTL_SUPPORT
 
 #undef EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE

test/intl/number-format/unified/compact-display.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+const testData = [
+    ["short"],
+    ["long"],
+];
+
+for (const [compactDisplay] of testData) {
+  nf = new Intl.NumberFormat("en", {compactDisplay, notation: "compact"});
+  assertEquals(compactDisplay, nf.resolvedOptions().compactDisplay);
+}

test/intl/number-format/unified/constructor-order.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+// Similar to constructor-order.js but also consider the new options
+// in https://tc39-transfer.github.io/proposal-unified-intl-numberformat/
+
+// Throws only once during construction.
+// Check for all getters to prevent regression.
+// Preserve the order of getter initialization.
+let getCount = 0;
+
+new Intl.NumberFormat(['en-US'], {
+  get localeMatcher() {
+    assertEquals(0, getCount++);
+  },
+  get style() {
+    assertEquals(1, getCount++);
+  },
+  get currency() {
+    assertEquals(2, getCount++);
+  },
+  get currencyDisplay() {
+    assertEquals(3, getCount++);
+  },
+  // Begin of new options
+  get currencySign() {
+    assertEquals(4, getCount++);
+  },
+  get unit() {
+    assertEquals(5, getCount++);
+  },
+  get unitDisplay() {
+    assertEquals(6, getCount++);
+  },
+  // End of new options
+  get minimumIntegerDigits() {
+    assertEquals(7, getCount++);
+  },
+  get minimumFractionDigits() {
+    assertEquals(8, getCount++);
+  },
+  get maximumFractionDigits() {
+    assertEquals(9, getCount++);
+  },
+  get minimumSignificantDigits() {
+    assertEquals(10, getCount++);
+  },
+  get maximumSignificantDigits() {
+    assertEquals(11, getCount++);
+  },
+  // Begin of new options
+  get notation() {
+    assertEquals(12, getCount++);
+  },
+  get compactDisplay() {
+    assertEquals(13, getCount++);
+  },
+  // End of new options
+  get useGrouping() {
+    assertEquals(14, getCount++);
+  },
+  // Begin of new options
+  get signDisplay() {
+    assertEquals(15, getCount++);
+  },
+  // End of new options
+});
+assertEquals(16, getCount);

test/intl/number-format/unified/currency-display.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Test defaults
+let nf = new Intl.NumberFormat();
+assertEquals(undefined, nf.resolvedOptions().currencyDisplay);
+
+nf = new Intl.NumberFormat("en");
+assertEquals(undefined, nf.resolvedOptions().currencyDisplay);
+
+nf = new Intl.NumberFormat("en", {style: "decimal"});
+assertEquals(undefined, nf.resolvedOptions().currencyDisplay);
+
+nf = new Intl.NumberFormat("en", {style: "percent"});
+assertEquals(undefined, nf.resolvedOptions().currencyDisplay);
+
+nf = new Intl.NumberFormat("en", {style: "unit", unit: "meter"});
+assertEquals(undefined, nf.resolvedOptions().currencyDisplay);
+
+nf = new Intl.NumberFormat("en", {style: "currency", currency: "TWD"});
+assertEquals("symbol", nf.resolvedOptions().currencyDisplay);
+
+const testData = [
+    ["name", "123.00 New Taiwan dollars"],
+    ["code", "TWD 123.00"],
+    ["symbol", "NT$123.00"],
+    ["narrow-symbol", "$123.00"],  // new
+];
+
+for (const [currencyDisplay, expectation] of testData) {
+  nf = new Intl.NumberFormat("en",
+      {style: 'currency', currency: "TWD", currencyDisplay});
+  assertEquals('currency', nf.resolvedOptions().style);
+  assertEquals(currencyDisplay, nf.resolvedOptions().currencyDisplay);
+  assertEquals(expectation, nf.format(123));
+}

test/intl/number-format/unified/currency-sign.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Test default.
+let nf = new Intl.NumberFormat();
+assertEquals(undefined, nf.resolvedOptions().currencySign);
+
+nf = new Intl.NumberFormat("en");
+assertEquals(undefined, nf.resolvedOptions().currencySign);
+
+nf = new Intl.NumberFormat("en", {style: 'decimal'});
+assertEquals(undefined, nf.resolvedOptions().currencySign);
+
+nf = new Intl.NumberFormat("en", {style: 'percent'});
+assertEquals(undefined, nf.resolvedOptions().currencySign);
+
+nf = new Intl.NumberFormat("en", {style: 'unit', unit: "meter"});
+assertEquals(undefined, nf.resolvedOptions().currencySign);
+
+
+nf = new Intl.NumberFormat("en", {style: 'currency', currency: "TWD"});
+assertEquals("standard", nf.resolvedOptions().currencySign);
+
+const testData = [
+    ["standard", "-NT$123.40", "-NT$0.00", "NT$0.00", "NT$123.40"],
+    ["accounting", "(NT$123.40)", "(NT$0.00)", "NT$0.00", "NT$123.40"],
+];
+
+for (const [currencySign, neg, negZero, zero, pos] of testData) {
+  nf = new Intl.NumberFormat("en", {style: 'currency', currency: "TWD",
+    currencySign});
+  assertEquals('currency', nf.resolvedOptions().style);
+  assertEquals(currencySign, nf.resolvedOptions().currencySign);
+  assertEquals(neg, nf.format(-123.4));
+  assertEquals(negZero, nf.format(-0));
+  assertEquals(zero, nf.format(0));
+  assertEquals(pos, nf.format(123.4));
+}

test/intl/number-format/unified/no-compact-display.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Except when the notation is "compact", the resolvedOptions().compactDisplay
+// should be undefined.
+//
+// Test default
+let nf = new Intl.NumberFormat();
+assertEquals(undefined, nf.resolvedOptions().compactDisplay);
+
+nf = new Intl.NumberFormat("en");
+assertEquals(undefined, nf.resolvedOptions().compactDisplay);
+
+const testData = [
+    ["scientific"],
+    ["engineering"],
+    ["standard"],
+];
+
+for (const [notation] of testData) {
+  nf = new Intl.NumberFormat("en", {notation});
+  assertEquals(undefined, nf.resolvedOptions().compactDisplay);
+  for (const compactDisplay of ["short", "long"]) {
+    nf = new Intl.NumberFormat("en", {compactDisplay, notation});
+    assertEquals(undefined, nf.resolvedOptions().compactDisplay);
+  }
+}

test/intl/number-format/unified/notation.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Test defaults.
+
+let nf = new Intl.NumberFormat();
+assertEquals("standard", nf.resolvedOptions().notation);
+
+nf = new Intl.NumberFormat("en");
+assertEquals("standard", nf.resolvedOptions().notation);
+
+nf = new Intl.NumberFormat("en", {style: "percent"});
+assertEquals("standard", nf.resolvedOptions().notation);
+
+const testData = [
+    ["standard", undefined, "987,654,321"],
+    ["scientific", undefined, "9.877E8"],
+    ["engineering", undefined, "987.654E6"],
+    ["compact", undefined, "987.654M"],
+    ["compact", "short", "987.654M"],
+    ["compact", "long", "987.654 million"],
+];
+
+for (const [notation, compactDisplay, expect1] of testData) {
+  nf = new Intl.NumberFormat("en", {notation, compactDisplay});
+  assertEquals(notation, nf.resolvedOptions().notation);
+  if (notation != "compact") {
+    assertEquals(undefined, nf.resolvedOptions().compactDisplay);
+  } else if (compactDisplay == "long") {
+    assertEquals("long", nf.resolvedOptions().compactDisplay);
+  } else {
+    assertEquals("short", nf.resolvedOptions().compactDisplay);
+  }
+  assertEquals(expect1, nf.format(987654321));
+}
+
+// Test Germany which has different decimal marks.
+let notation = "compact";
+nf = new Intl.NumberFormat("de", {notation, compactDisplay: "short"});
+assertEquals("987,654 Mio.", nf.format(987654321));
+assertEquals("98,765 Mio.", nf.format(98765432));
+assertEquals("98.765", nf.format(98765));
+assertEquals("9876", nf.format(9876));
+nf = new Intl.NumberFormat("de", {notation, compactDisplay: "long"});
+assertEquals("987,654 Millionen", nf.format(987654321));
+assertEquals("98,765 Millionen", nf.format(98765432));
+assertEquals("98,765 Tausend", nf.format(98765));
+assertEquals("9,876 Tausend", nf.format(9876));
+
+// Test Chinese, Japanese and Korean, which group by 4 digits.
+nf = new Intl.NumberFormat("zh-TW", {notation, compactDisplay: "short"});
+assertEquals("9.877億", nf.format(987654321));
+assertEquals("9876.543萬", nf.format(98765432));
+assertEquals("9.877萬", nf.format(98765));
+assertEquals("9876", nf.format(9876));
+nf = new Intl.NumberFormat("zh-TW", {notation, compactDisplay: "long"});
+assertEquals("9.877億", nf.format(987654321));
+assertEquals("9876.543萬", nf.format(98765432));
+assertEquals("9.877萬", nf.format(98765));
+assertEquals("9876", nf.format(9876));
+
+// Test Japanese with compact.
+nf = new Intl.NumberFormat("ja", {notation, compactDisplay: "short"});
+assertEquals("9.877億", nf.format(987654321));
+assertEquals("9876.543万", nf.format(98765432));
+assertEquals("9.877万", nf.format(98765));
+assertEquals("9876", nf.format(9876));
+nf = new Intl.NumberFormat("ja", {notation, compactDisplay: "long"});
+assertEquals("9.877億", nf.format(987654321));
+assertEquals("9876.543万", nf.format(98765432));
+assertEquals("9.877万", nf.format(98765));
+assertEquals("9876", nf.format(9876));
+
+// Test Korean with compact.
+nf = new Intl.NumberFormat("ko", {notation, compactDisplay: "short"});
+assertEquals("9.877억", nf.format(987654321));
+assertEquals("9876.543만", nf.format(98765432));
+assertEquals("9.877만", nf.format(98765));
+assertEquals("9.876천", nf.format(9876));
+assertEquals("987", nf.format(987));
+nf = new Intl.NumberFormat("ko", {notation, compactDisplay: "long"});
+assertEquals("9.877억", nf.format(987654321));
+assertEquals("9876.543만", nf.format(98765432));
+assertEquals("9.877만", nf.format(98765));
+assertEquals("9.876천", nf.format(9876));
+assertEquals("987", nf.format(987));

test/intl/number-format/unified/sign-display.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Test default.
+let nf = new Intl.NumberFormat();
+assertEquals("auto", nf.resolvedOptions().signDisplay);
+
+nf = new Intl.NumberFormat("en");
+assertEquals("auto", nf.resolvedOptions().signDisplay);
+
+const testData = [
+    ["auto",        "-123",  "-0",  "0",  "123"],
+    ["always",      "-123",  "-0", "+0", "+123"],
+    ["never",       "123",   "0",  "0",  "123"],
+    ["except-zero", "-123",  "-0",  "0",  "+123"],
+];
+
+for (const [signDisplay, neg, negZero, zero, pos] of testData) {
+  nf = new Intl.NumberFormat("en", {signDisplay});
+  assertEquals(signDisplay, nf.resolvedOptions().signDisplay);
+  assertEquals(neg, nf.format(-123));
+  assertEquals(negZero, nf.format(-0));
+  assertEquals(zero, nf.format(0));
+  assertEquals(pos, nf.format(123));
+}

test/intl/number-format/unified/style-unit.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Test default.
+
+let nf = new Intl.NumberFormat();
+assertEquals(undefined, nf.resolvedOptions().unit);
+
+nf = new Intl.NumberFormat("en");
+assertEquals(undefined, nf.resolvedOptions().unit);
+
+nf = new Intl.NumberFormat("en", {style: 'decimal'});
+assertEquals(undefined, nf.resolvedOptions().unit);
+
+nf = new Intl.NumberFormat("en", {style: 'currency', currency: 'TWD'});
+assertEquals(undefined, nf.resolvedOptions().unit);
+
+nf = new Intl.NumberFormat("en", {style: 'percent'});
+assertEquals('percent', nf.resolvedOptions().unit);
+
+assertThrows(() => new Intl.NumberFormat("en", {style: 'unit'}), TypeError);
+
+const validUnits = [
+  'acre',
+  'bit',
+  'byte',
+  'celsius',
+  'centimeter',
+  'day',
+  'degree',
+  'fahrenheit',
+  'foot',
+  'gigabit',
+  'gigabyte',
+  'gram',
+  'hectare',
+  'hour',
+  'inch',
+  'kilobit',
+  'kilobyte',
+  'kilogram',
+  'kilometer',
+  'megabit',
+  'megabyte',
+  'meter',
+  'mile-scandinavian',
+  'mile',
+  'millimeter',
+  'millisecond',
+  'minute',
+  'month',
+  'ounce',
+  'petabyte',
+  'pound',
+  'second',
+  'stone',
+  'terabit',
+  'terabyte',
+  'week',
+  'yard',
+  'year',
+  'percent',
+  'kilometer-per-hour',
+  'mile-per-hour',
+  'meter-per-second',
+  'yard-per-second',
+  'yard-per-hour',
+];
+
+for (const unit of validUnits) {
+  let resolved = new Intl.NumberFormat(
+      "en", {style: 'unit', unit}).resolvedOptions();
+  assertEquals('unit', resolved.style);
+  assertEquals(resolved.unit, unit);
+}
+
+function c(u) {
+  return new Intl.NumberFormat('en', { style: 'unit', unit: u});
+}
+assertThrows(() => c('acre-foot'), RangeError);
+assertThrows(() => c('ampere'), RangeError);
+assertThrows(() => c('arc-minute'), RangeError);
+assertThrows(() => c('arc-second'), RangeError);
+assertThrows(() => c('astronomical-unit'), RangeError);
+assertThrows(() => c('bushel'), RangeError);
+assertThrows(() => c('calorie'), RangeError);
+assertThrows(() => c('carat'), RangeError);
+assertThrows(() => c('centiliter'), RangeError);
+assertThrows(() => c('century'), RangeError);
+assertThrows(() => c('cubic-centimeter'), RangeError);
+assertThrows(() => c('cubic-foot'), RangeError);
+assertThrows(() => c('cubic-inch'), RangeError);
+assertThrows(() => c('cubic-kilometer'), RangeError);
+assertThrows(() => c('cubic-meter'), RangeError);
+assertThrows(() => c('cubic-mile'), RangeError);
+assertThrows(() => c('cubic-yard'), RangeError);
+assertThrows(() => c('cup-metric'), RangeError);
+assertThrows(() => c('cup'), RangeError);
+assertThrows(() => c('day-person'), RangeError);
+assertThrows(() => c('deciliter'), RangeError);
+assertThrows(() => c('decimeter'), RangeError);
+assertThrows(() => c('fathom'), RangeError);
+assertThrows(() => c('fluid-ounce'), RangeError);
+assertThrows(() => c('foodcalorie'), RangeError);
+assertThrows(() => c('furlong'), RangeError);
+assertThrows(() => c('g-force'), RangeError);
+assertThrows(() => c('gallon-imperial'), RangeError);
+assertThrows(() => c('gallon'), RangeError);
+assertThrows(() => c('generic'), RangeError);
+assertThrows(() => c('gigahertz'), RangeError);
+assertThrows(() => c('gigawatt'), RangeError);
+assertThrows(() => c('hectoliter'), RangeError);
+assertThrows(() => c('hectopascal'), RangeError);
+assertThrows(() => c('hertz'), RangeError);
+assertThrows(() => c('horsepower'), RangeError);
+assertThrows(() => c('inch-hg'), RangeError);
+assertThrows(() => c('joule'), RangeError);
+assertThrows(() => c('karat'), RangeError);
+assertThrows(() => c('kelvin'), RangeError);
+assertThrows(() => c('kilocalorie'), RangeError);
+assertThrows(() => c('kilohertz'), RangeError);
+assertThrows(() => c('kilojoule'), RangeError);
+assertThrows(() => c('kilowatt-hour'), RangeError);
+assertThrows(() => c('kilowatt'), RangeError);
+assertThrows(() => c('knot'), RangeError);
+assertThrows(() => c('light-year'), RangeError);
+assertThrows(() => c('liter-per-100kilometers'), RangeError);
+assertThrows(() => c('liter-per-kilometer'), RangeError);
+assertThrows(() => c('liter'), RangeError);
+assertThrows(() => c('lux'), RangeError);
+assertThrows(() => c('megahertz'), RangeError);
+assertThrows(() => c('megaliter'), RangeError);
+assertThrows(() => c('megawatt'), RangeError);
+assertThrows(() => c('meter-per-second-squared'), RangeError);
+assertThrows(() => c('metric-ton'), RangeError);
+assertThrows(() => c('microgram'), RangeError);
+assertThrows(() => c('micrometer'), RangeError);
+assertThrows(() => c('microsecond'), RangeError);
+assertThrows(() => c('mile-per-gallon-imperial'), RangeError);
+assertThrows(() => c('mile-per-gallon'), RangeError);
+assertThrows(() => c('milliampere'), RangeError);
+assertThrows(() => c('millibar'), RangeError);
+assertThrows(() => c('milligram-per-deciliter'), RangeError);
+assertThrows(() => c('milligram'), RangeError);
+assertThrows(() => c('milliliter'), RangeError);
+assertThrows(() => c('millimeter-of-mercury'), RangeError);
+assertThrows(() => c('millimole-per-liter'), RangeError);
+assertThrows(() => c('milliwatt'), RangeError);
+assertThrows(() => c('month-person'), RangeError);
+assertThrows(() => c('nanometer'), RangeError);
+assertThrows(() => c('nanosecond'), RangeError);
+assertThrows(() => c('nautical-mile'), RangeError);
+assertThrows(() => c('ohm'), RangeError);
+assertThrows(() => c('ounce-troy'), RangeError);
+assertThrows(() => c('parsec'), RangeError);
+assertThrows(() => c('part-per-million'), RangeError);
+assertThrows(() => c('picometer'), RangeError);
+assertThrows(() => c('pint-metric'), RangeError);
+assertThrows(() => c('pint'), RangeError);
+assertThrows(() => c('pound-per-square-inch'), RangeError);
+assertThrows(() => c('quart'), RangeError);
+assertThrows(() => c('radian'), RangeError);
+assertThrows(() => c('revolution'), RangeError);
+assertThrows(() => c('square-centimeter'), RangeError);
+assertThrows(() => c('square-foot'), RangeError);
+assertThrows(() => c('square-inch'), RangeError);
+assertThrows(() => c('square-kilometer'), RangeError);
+assertThrows(() => c('square-meter'), RangeError);
+assertThrows(() => c('square-mile'), RangeError);
+assertThrows(() => c('square-yard'), RangeError);
+assertThrows(() => c('tablespoon'), RangeError);
+assertThrows(() => c('teaspoon'), RangeError);
+assertThrows(() => c('ton'), RangeError);
+assertThrows(() => c('volt'), RangeError);
+assertThrows(() => c('watt'), RangeError);
+assertThrows(() => c('week-person'), RangeError);
+assertThrows(() => c('year-person'), RangeError);

test/intl/number-format/unified/unit-display.js

+// Copyright 2019 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.
+
+// Flags: --harmony-intl-numberformat-unified
+
+// Test default.
+let nf = new Intl.NumberFormat();
+assertEquals(undefined, nf.resolvedOptions().unitDisplay);
+
+nf = new Intl.NumberFormat("en");
+assertEquals(undefined, nf.resolvedOptions().unitDisplay);
+
+nf = new Intl.NumberFormat("en", {style: 'decimal'});
+assertEquals(undefined, nf.resolvedOptions().unitDisplay);
+
+nf = new Intl.NumberFormat("en", {style: 'currency', currency: 'TWD'});
+assertEquals(undefined, nf.resolvedOptions().unitDisplay);
+
+nf = new Intl.NumberFormat("en", {style: 'unit', unit: "meter"});
+assertEquals("short", nf.resolvedOptions().unitDisplay);
+
+nf = new Intl.NumberFormat("en", {style: 'percent'});
+assertEquals("short", nf.resolvedOptions().unitDisplay);
+
+const testData = [
+    ["short"],
+    ["narrow"],
+    ["long"],
+];
+
+for (const [unitDisplay] of testData) {
+  nf = new Intl.NumberFormat("en", {style: 'unit', unit: "meter", unitDisplay});
+  assertEquals('unit', nf.resolvedOptions().style);
+  assertEquals(unitDisplay, nf.resolvedOptions().unitDisplay);
+}

test/test262/testcfg.py

@@ -47,6 +47,7 @@ FEATURE_FLAGS = {
   'numeric-separator-literal': '--harmony-numeric-separator',
   'Intl.DateTimeFormat-datetimestyle': '--harmony-intl-datetime-style',
   'Intl.DateTimeFormat-formatRange': '--harmony-intl-date-format-range',
+  'Intl.NumberFormat-unified': '--harmony-intl-numberformat-unified',
   'Intl.Segmenter': '--harmony-intl-segmenter',
   'Symbol.prototype.description': '--harmony-symbol-description',
   'globalThis': '--harmony-global',
@@ -58,8 +59,7 @@ FEATURE_FLAGS = {
 }
 
 SKIPPED_FEATURES = set(['class-methods-private',
-                        'class-static-methods-private',
-                        'Intl.NumberFormat-unified'])
+                        'class-static-methods-private'])
 
 DATA = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
 

tools/v8heapconst.py

@@ -307,50 +307,50 @@ KNOWN_MAPS = {
   ("read_only_space", 0x014b1): (98, "EnumCacheMap"),
   ("read_only_space", 0x01501): (116, "ArrayBoilerplateDescriptionMap"),
   ("read_only_space", 0x016d9): (101, "InterceptorInfoMap"),
-  ("read_only_space", 0x0357d): (89, "AccessCheckInfoMap"),
-  ("read_only_space", 0x035a5): (90, "AccessorInfoMap"),
-  ("read_only_space", 0x035cd): (91, "AccessorPairMap"),
-  ("read_only_space", 0x035f5): (92, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x0361d): (93, "AllocationMementoMap"),
-  ("read_only_space", 0x03645): (94, "AsmWasmDataMap"),
-  ("read_only_space", 0x0366d): (95, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x03695): (96, "ClassPositionsMap"),
-  ("read_only_space", 0x036bd): (97, "DebugInfoMap"),
-  ("read_only_space", 0x036e5): (99, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x0370d): (100, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x03735): (102, "InterpreterDataMap"),
-  ("read_only_space", 0x0375d): (103, "ModuleInfoEntryMap"),
-  ("read_only_space", 0x03785): (104, "ModuleMap"),
-  ("read_only_space", 0x037ad): (105, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x037d5): (106, "PromiseCapabilityMap"),
-  ("read_only_space", 0x037fd): (107, "PromiseReactionMap"),
-  ("read_only_space", 0x03825): (108, "PrototypeInfoMap"),
-  ("read_only_space", 0x0384d): (109, "ScriptMap"),
-  ("read_only_space", 0x03875): (110, "SourcePositionTableWithFrameCacheMap"),
-  ("read_only_space", 0x0389d): (111, "StackFrameInfoMap"),
-  ("read_only_space", 0x038c5): (112, "StackTraceFrameMap"),
-  ("read_only_space", 0x038ed): (113, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x03915): (114, "Tuple2Map"),
-  ("read_only_space", 0x0393d): (115, "Tuple3Map"),
-  ("read_only_space", 0x03965): (117, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x0398d): (118, "WasmDebugInfoMap"),
-  ("read_only_space", 0x039b5): (119, "WasmExceptionTagMap"),
-  ("read_only_space", 0x039dd): (120, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x03a05): (121, "CallableTaskMap"),
-  ("read_only_space", 0x03a2d): (122, "CallbackTaskMap"),
-  ("read_only_space", 0x03a55): (123, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x03a7d): (124, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x03aa5): (125, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x03acd): (126, "FinalizationGroupCleanupJobTaskMap"),
-  ("read_only_space", 0x03af5): (127, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x03b1d): (127, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x03b45): (162, "LoadHandler1Map"),
-  ("read_only_space", 0x03b6d): (162, "LoadHandler2Map"),
-  ("read_only_space", 0x03b95): (162, "LoadHandler3Map"),
-  ("read_only_space", 0x03bbd): (170, "StoreHandler0Map"),
-  ("read_only_space", 0x03be5): (170, "StoreHandler1Map"),
-  ("read_only_space", 0x03c0d): (170, "StoreHandler2Map"),
-  ("read_only_space", 0x03c35): (170, "StoreHandler3Map"),
+  ("read_only_space", 0x035f5): (89, "AccessCheckInfoMap"),
+  ("read_only_space", 0x0361d): (90, "AccessorInfoMap"),
+  ("read_only_space", 0x03645): (91, "AccessorPairMap"),
+  ("read_only_space", 0x0366d): (92, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x03695): (93, "AllocationMementoMap"),
+  ("read_only_space", 0x036bd): (94, "AsmWasmDataMap"),
+  ("read_only_space", 0x036e5): (95, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x0370d): (96, "ClassPositionsMap"),
+  ("read_only_space", 0x03735): (97, "DebugInfoMap"),
+  ("read_only_space", 0x0375d): (99, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x03785): (100, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x037ad): (102, "InterpreterDataMap"),
+  ("read_only_space", 0x037d5): (103, "ModuleInfoEntryMap"),
+  ("read_only_space", 0x037fd): (104, "ModuleMap"),
+  ("read_only_space", 0x03825): (105, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x0384d): (106, "PromiseCapabilityMap"),
+  ("read_only_space", 0x03875): (107, "PromiseReactionMap"),
+  ("read_only_space", 0x0389d): (108, "PrototypeInfoMap"),
+  ("read_only_space", 0x038c5): (109, "ScriptMap"),
+  ("read_only_space", 0x038ed): (110, "SourcePositionTableWithFrameCacheMap"),
+  ("read_only_space", 0x03915): (111, "StackFrameInfoMap"),
+  ("read_only_space", 0x0393d): (112, "StackTraceFrameMap"),
+  ("read_only_space", 0x03965): (113, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x0398d): (114, "Tuple2Map"),
+  ("read_only_space", 0x039b5): (115, "Tuple3Map"),
+  ("read_only_space", 0x039dd): (117, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x03a05): (118, "WasmDebugInfoMap"),
+  ("read_only_space", 0x03a2d): (119, "WasmExceptionTagMap"),
+  ("read_only_space", 0x03a55): (120, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x03a7d): (121, "CallableTaskMap"),
+  ("read_only_space", 0x03aa5): (122, "CallbackTaskMap"),
+  ("read_only_space", 0x03acd): (123, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x03af5): (124, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x03b1d): (125, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x03b45): (126, "FinalizationGroupCleanupJobTaskMap"),
+  ("read_only_space", 0x03b6d): (127, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x03b95): (127, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x03bbd): (162, "LoadHandler1Map"),
+  ("read_only_space", 0x03be5): (162, "LoadHandler2Map"),
+  ("read_only_space", 0x03c0d): (162, "LoadHandler3Map"),
+  ("read_only_space", 0x03c35): (170, "StoreHandler0Map"),
+  ("read_only_space", 0x03c5d): (170, "StoreHandler1Map"),
+  ("read_only_space", 0x03c85): (170, "StoreHandler2Map"),
+  ("read_only_space", 0x03cad): (170, "StoreHandler3Map"),
   ("map_space", 0x00139): (1057, "ExternalMap"),
   ("map_space", 0x00161): (1073, "JSMessageObjectMap"),
 }