Attachment #408781 for bug #216521

View Details Raw Unified Return to Bug 216521

| Differences between



2020-09-14  Yusuke Suzuki  <ysuzuki@apple.com>

        [JSC] Apply Intl.DateTimeFormat hour-cycle correctly when timeStyle is used
        https://bugs.webkit.org/show_bug.cgi?id=216521

        Reviewed by NOBODY (OOPS!).

        * runtime/IntlDateTimeFormat.cpp:
        (JSC::IntlDateTimeFormat::setFormatsFromPattern):
        (JSC::IntlDateTimeFormat::parseHourCycle):
        (JSC::IntlDateTimeFormat::hourCycleFromPattern):
        (JSC::IntlDateTimeFormat::replaceHourCycleInSkeleton):
        (JSC::IntlDateTimeFormat::replaceHourCycleInPattern):
        (JSC::IntlDateTimeFormat::initializeDateTimeFormat):
        (JSC::IntlDateTimeFormat::hourCycleString):
        (JSC::IntlDateTimeFormat::resolvedOptions const):
        (JSC::IntlDateTimeFormat::createDateIntervalFormatIfNecessary):
        * runtime/IntlDateTimeFormat.h:

2020-09-11  Yusuke Suzuki  <ysuzuki@apple.com>

        [JSC] Canonicalize "true" unicode extension type value to ""



            ++i;
        }

        // If hourCycle was null, this sets it to the locale default.
        if (m_hourCycle.isNull()) {
            if (currentCharacter == 'h')
                m_hourCycle = "h12"_s;
            else if (currentCharacter == 'H')
                m_hourCycle = "h23"_s;
            else if (currentCharacter == 'k')
                m_hourCycle = "h24"_s;
            else if (currentCharacter == 'K')
                m_hourCycle = "h11"_s;
        }

        switch (currentCharacter) {
        case 'G':
            if (count <= 3)

        case 'h':
        case 'H':
        case 'k':
        case 'K': {
            // Populate hourCycle from actually generated patterns. It is possible that locale or option is specifying hourCycle explicitly,
            // but the generated pattern does not include related part since the pattern does not include hours.
            // This is tested in test262/test/intl402/DateTimeFormat/prototype/resolvedOptions/hourCycle-dateStyle.js and our stress tests.
            // Example:
            //     new Intl.DateTimeFormat(`de-u-hc-h11`, {
            //         dateStyle: "full"
            //     }).resolvedOptions().hourCycle === undefined
            switch (currentCharacter) {
            case 'h':
                m_hourCycle = HourCycle::H12;
                break;
            case 'H':
                m_hourCycle = HourCycle::H23;
                break;
            case 'k':
                m_hourCycle = HourCycle::H24;
                break;
            case 'K':
                m_hourCycle = HourCycle::H11;
                break;
            }
            if (count == 1)
                m_hour = Hour::Numeric;
            else if (count == 2)
                m_hour = Hour::TwoDigit;
            break;
        }
        case 'm':
            if (count == 1)
                m_minute = Minute::Numeric;

    }
}

IntlDateTimeFormat::HourCycle IntlDateTimeFormat::parseHourCycle(const String& hourCycle)
{
    if (hourCycle == "h11"_s)
        return HourCycle::H11;
    if (hourCycle == "h12"_s)
        return HourCycle::H12;
    if (hourCycle == "h23"_s)
        return HourCycle::H23;
    if (hourCycle == "h24"_s)
        return HourCycle::H24;
    return HourCycle::None;
}

IntlDateTimeFormat::HourCycle IntlDateTimeFormat::hourCycleFromPattern(const Vector<UChar, 32>& pattern)
{
    for (auto character : pattern) {
        switch (character) {
        case 'K':
            return HourCycle::H11;
        case 'h':
            return HourCycle::H12;
        case 'H':
            return HourCycle::H23;
        case 'k':
            return HourCycle::H24;
        }
    }
    return HourCycle::None;
}

void IntlDateTimeFormat::replaceHourCycleInSkeleton(Vector<UChar, 32>& skeleton, bool isHour12)
{
    UChar skeletonCharacter = 'H';
    if (isHour12)
        skeletonCharacter = 'h';
    for (auto& character : skeleton) {
        switch (character) {
        case 'h':
        case 'H':
        case 'j':
            character = skeletonCharacter;
            break;
        }
    }
}

void IntlDateTimeFormat::replaceHourCycleInPattern(Vector<UChar, 32>& pattern, HourCycle hourCycle)
{
    UChar hourFromHourCycle = 'H';
    switch (hourCycle) {
    case HourCycle::H11:
        hourFromHourCycle = 'K';
        break;
    case HourCycle::H12:
        hourFromHourCycle = 'h';
        break;
    case HourCycle::H23:
        hourFromHourCycle = 'H';
        break;
    case HourCycle::H24:
        hourFromHourCycle = 'k';
        break;
    case HourCycle::None:
        return;
    }

    for (auto& character : pattern) {
        switch (character) {
        case 'K':
        case 'h':
        case 'H':
        case 'k':
            character = hourFromHourCycle;
            break;
        }
    }
}

// https://tc39.github.io/ecma402/#sec-initializedatetimeformat
void IntlDateTimeFormat::initializeDateTimeFormat(JSGlobalObject* globalObject, JSValue locales, JSValue originalOptions)
{


    TriState hour12 = intlBooleanOption(globalObject, options, vm.propertyNames->hour12);
    RETURN_IF_EXCEPTION(scope, void());
    bool isHour12Undefined = (hour12 == TriState::Indeterminate);

    HourCycle hourCycle = intlOption<HourCycle>(globalObject, options, vm.propertyNames->hourCycle, { { "h11"_s, HourCycle::H11 }, { "h12"_s, HourCycle::H12 }, { "h23"_s, HourCycle::H23 }, { "h24"_s, HourCycle::H24 } }, "hourCycle must be \"h11\", \"h12\", \"h23\", or \"h24\""_s, HourCycle::None);
    RETURN_IF_EXCEPTION(scope, void());
    if (hour12 == TriState::Indeterminate) {
        if (hourCycle != HourCycle::None)
            localeOptions[static_cast<unsigned>(RelevantExtensionKey::Hc)] = String(hourCycleString(hourCycle));
    } else {
        // If there is hour12, hourCycle is ignored.
    } else
        localeOptions[static_cast<unsigned>(RelevantExtensionKey::Hc)] = String();
    }

    const HashSet<String>& availableLocales = intlDateTimeFormatAvailableLocales();
    auto resolved = resolveLocale(globalObject, availableLocales, requestedLocales, localeMatcher, localeOptions, { RelevantExtensionKey::Ca, RelevantExtensionKey::Hc, RelevantExtensionKey::Nu }, localeData);

    else if (m_calendar == "ethioaa")
        m_calendar = "ethiopic-amete-alem"_s;

    hourCycle = parseHourCycle(resolved.extensions[static_cast<unsigned>(RelevantExtensionKey::Hc)]);
    m_numberingSystem = resolved.extensions[static_cast<unsigned>(RelevantExtensionKey::Nu)];
    m_dataLocale = resolved.dataLocale;
    CString dataLocaleWithExtensions = makeString(m_dataLocale, "-u-ca-", m_calendar, "-nu-", m_numberingSystem).utf8();


    Hour hour = intlOption<Hour>(globalObject, options, vm.propertyNames->hour, { { "2-digit"_s, Hour::TwoDigit }, { "numeric"_s, Hour::Numeric } }, "hour must be \"2-digit\" or \"numeric\""_s, Hour::None);
    RETURN_IF_EXCEPTION(scope, void());
    {
        // In skeleton construction, there is no way to specify h11 v.s. h12, h23 v.s. h24. They are enforced after generating pattern.
        UChar skeletonCharacter = 'j';
        if (hour12 == TriState::Indeterminate) {
            switch (hourCycle) {
            case HourCycle::None:
                skeletonCharacter = 'j';
                break;
            case HourCycle::H11:
            case HourCycle::H12:
                skeletonCharacter = 'h';
                break;
            case HourCycle::H23:
            case HourCycle::H24:
                skeletonCharacter = 'H';
                break;
            }
        } else {
            // We prefer hour12 over hourCycle. If hour12 is specified, we ignore hourCycle.
            if (hour12 == TriState::True)
                skeletonCharacter = 'h';
            else
                skeletonCharacter = 'H';
        }

        switch (hour) {
        case Hour::TwoDigit:
            skeletonBuilder.append(skeletonCharacter);
            skeletonBuilder.append(skeletonCharacter);
            break;
        case Hour::Numeric:
            skeletonBuilder.append(skeletonCharacter);
            break;
        case Hour::None:
            break;
        }
    }

    if (Options::useIntlDateTimeFormatDayPeriod()) {

    m_timeStyle = intlOption<DateTimeStyle>(globalObject, options, vm.propertyNames->timeStyle, { { "full"_s, DateTimeStyle::Full }, { "long"_s, DateTimeStyle::Long }, { "medium"_s, DateTimeStyle::Medium }, { "short"_s, DateTimeStyle::Short } }, "timeStyle must be \"full\", \"long\", \"medium\", or \"short\""_s, DateTimeStyle::None);
    RETURN_IF_EXCEPTION(scope, void());


    auto patternFromSkeleton = [&](const UChar* skeleton, unsigned skeletonSize, Vector<UChar, 32>& patternBuffer, UErrorCode& status) {
        // Always use ICU date format generator, rather than our own pattern list and matcher.
        auto generator = std::unique_ptr<UDateTimePatternGenerator, ICUDeleter<udatpg_close>>(udatpg_open(dataLocaleWithExtensions.data(), &status));
        if (U_FAILURE(status))
            return;

        status = callBufferProducingFunction(udatpg_getBestPatternWithOptions, generator.get(), skeleton, skeletonSize, UDATPG_MATCH_HOUR_FIELD_LENGTH, patternBuffer);
        if (U_FAILURE(status))
            return;
    };

    Vector<UChar, 32> patternBuffer;
    if (m_dateStyle != DateTimeStyle::None || m_timeStyle != DateTimeStyle::None) {
        // 30. For each row in Table 1, except the header row, do

            return;
        }

        // If timeStyle is not specified, m_hourCycle does not matter. Let's skip enforcing step.
        if (m_timeStyle == DateTimeStyle::None) {
            canIncludeHour = false;
            m_hourCycle = String();
        }

        auto parseUDateFormatStyle = [](DateTimeStyle style) {
            switch (style) {
            case DateTimeStyle::Full:


        // We cannot use this UDateFormat directly yet because we need to enforce specified hourCycle.
        // First, we create UDateFormat via dateStyle and timeStyle. And then convert it to pattern string.
        // After updating this pattern string with hourCycle, we create a final UDateFormat with the updated pattern string.
        UErrorCode status = U_ZERO_ERROR;
        StringView timeZoneView(m_timeZone);
        auto dateFormatFromStyle = std::unique_ptr<UDateFormat, UDateFormatDeleter>(udat_open(parseUDateFormatStyle(m_timeStyle), parseUDateFormatStyle(m_dateStyle), dataLocaleWithExtensions.data(), timeZoneView.upconvertedCharacters(), timeZoneView.length(), nullptr, -1, &status));

            throwTypeError(globalObject, scope, "failed to initialize DateTimeFormat"_s);
            return;
        }
    } else {
        // If hour is not specified, m_hourCycle does not matter. Let's skip enforcing step.
        if (hour == Hour::None) {
            canIncludeHour = false;
            m_hourCycle = String();
        }

        // It is possible that timeStyle includes dayPeriod, which is sensitive to hour-cycle.
        // If dayPeriod is included, just replacing hour based on hourCycle / hour12 produces strange results.
        // Let's consider about the example. The formatted result looks like "02:12:47 PM Coordinated Universal Time"
        // If we simply replace 02 to 14, this becomes "14:12:47 PM Coordinated Universal Time", this looks strange.
        // We should retrieve skeleton from the pattern, enforcing hour-cycle, and re-generating the best pattern from the modified skeleton to get non-strange result.
        if (m_timeStyle != DateTimeStyle::None) {
            if (hourCycle != HourCycle::None || hour12 != TriState::Indeterminate) {
                auto isHour12 = [](HourCycle hourCycle) {
                    return hourCycle == HourCycle::H11 || hourCycle == HourCycle::H12;
                };
                bool specifiedHour12 = false;
                // If hour12 is specified, we prefer it and dignore hourCycle.
                if (hour12 != TriState::Indeterminate)
                    specifiedHour12 = hour12 == TriState::True;
                else
                    specifiedHour12 = isHour12(hourCycle);
                if (isHour12(hourCycleFromPattern(patternBuffer)) != specifiedHour12) {
                    Vector<UChar, 32> skeleton;
                    auto status = callBufferProducingFunction(udatpg_getSkeleton, nullptr, patternBuffer.data(), patternBuffer.size(), skeleton);
                    if (U_FAILURE(status)) {
                        throwTypeError(globalObject, scope, "failed to initialize DateIntervalFormat"_s);
                        return;
                    }
                    replaceHourCycleInSkeleton(skeleton, specifiedHour12);
                    dataLogLnIf(IntlDateTimeFormatInternal::verbose, "replaced:(", StringView(skeleton.data(), skeleton.size()), ")");
                    patternBuffer.clear();
                    patternFromSkeleton(skeleton.data(), skeleton.size(), patternBuffer, status);
                    if (U_FAILURE(status)) {
                        throwTypeError(globalObject, scope, "failed to initialize DateIntervalFormat"_s);
                        return;
                    }
                }
            }
        }
    } else {
        UErrorCode status = U_ZERO_ERROR;
        String skeleton = skeletonBuilder.toString();
        patternFromSkeleton(StringView(skeleton).upconvertedCharacters().get(), skeleton.length(), patternBuffer, status);
        status = callBufferProducingFunction(udatpg_getBestPatternWithOptions, generator, skeletonView.upconvertedCharacters().get(), skeletonView.length(), UDATPG_MATCH_HOUR_FIELD_LENGTH, patternBuffer);
        udatpg_close(generator);
        if (U_FAILURE(status)) {
            throwTypeError(globalObject, scope, "failed to initialize DateTimeFormat"_s);
            return;
        }
    }

    // In skeleton construction, there is no way to specify h11 v.s. h12, or h23 v.s. h24.
    // After generating pattern from skeleton, we need to change h11 and h12 / h23 and h24 if hourCycle is specified.
    if (hourCycle != HourCycle::None)
        replaceHourCycleInPattern(patternBuffer, hourCycle);
    if (canIncludeHour) {
        bool hasHour = false;
        if (!m_hourCycle.isNull() || !isHour12Undefined) {
            UChar hourFromHourCycle = 'H'; // H23
            if (m_hourCycle == "h11")
                hourFromHourCycle = 'K';
            else if (m_hourCycle == "h12")
                hourFromHourCycle = 'h';
            else if (m_hourCycle == "h24")
                hourFromHourCycle = 'k';

            bool isEscaped = false;
            for (auto& c : patternBuffer) {
                if (c == '\'')
                    isEscaped = !isEscaped;
                else if (!isEscaped && (c == 'h' || c == 'H' || c == 'k' || c == 'K')) {
                    switch (c) {
                    case 'K':
                    case 'H': {
                        if (isHour12Undefined)
                            c = hourFromHourCycle;
                        else if (hour12 == TriState::True)
                            c = 'K';
                        else
                            c = 'H';
                        break;
                    }
                    case 'h':
                    case 'k': {
                        if (isHour12Undefined)
                            c = hourFromHourCycle;
                        else if (hour12 == TriState::True)
                            c = 'h';
                        else
                            c = 'k';
                        break;
                    }
                    default:
                        ASSERT_NOT_REACHED();
                    }
                    hasHour = true;
                }
            }
        }
        if (!hasHour)
            m_hourCycle = String();
    }

    StringView pattern(patternBuffer.data(), patternBuffer.size());
    setFormatsFromPattern(pattern);

    ucal_setGregorianChange(cal, minECMAScriptTime, &status);
}

ASCIILiteral IntlDateTimeFormat::hourCycleString(HourCycle hourCycle)
{
    switch (hourCycle) {
    case HourCycle::H11:
        return "h11"_s;
    case HourCycle::H12:
        return "h12"_s;
    case HourCycle::H23:
        return "h23"_s;
    case HourCycle::H24:
        return "h24"_s;
    case HourCycle::None:
        ASSERT_NOT_REACHED();
        return ASCIILiteral::null();
    }
    ASSERT_NOT_REACHED();
    return ASCIILiteral::null();
}

ASCIILiteral IntlDateTimeFormat::weekdayString(Weekday weekday)
{
    switch (weekday) {

    options->putDirect(vm, vm.propertyNames->numberingSystem, jsNontrivialString(vm, m_numberingSystem));
    options->putDirect(vm, vm.propertyNames->timeZone, jsNontrivialString(vm, m_timeZone));

    if (m_hourCycle != HourCycle::None) {
        options->putDirect(vm, vm.propertyNames->hourCycle, jsNontrivialString(vm, hourCycleString(m_hourCycle)));
        options->putDirect(vm, vm.propertyNames->hour12, jsBoolean(m_hourCycle == HourCycle::H11 || m_hourCycle == HourCycle::H12));
    }

    if (m_weekday != Weekday::None)

    // We need to enforce HourCycle by setting "hc" extension if it is specified.
    StringBuilder localeBuilder;
    localeBuilder.append(m_dataLocale, "-u-ca-", m_calendar, "-nu-", m_numberingSystem);
    if (m_hourCycle != HourCycle::None)
        localeBuilder.append("-hc-", hourCycleString(m_hourCycle));
    CString dataLocaleWithExtensions = localeBuilder.toString().utf8();

    UErrorCode status = U_ZERO_ERROR;

Lines 78-83 class IntlDateTimeFormat final : public JSNonFinalObject { a/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h_sec1
- a/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h -1 / +8 lines
78		78
79	UDateIntervalFormat* createDateIntervalFormatIfNecessary(JSGlobalObject*);	79	UDateIntervalFormat* createDateIntervalFormatIfNecessary(JSGlobalObject*);
80		80
		81	enum class HourCycle : uint8_t { None, H11, H12, H23, H24 };
81	enum class Weekday : uint8_t { None, Narrow, Short, Long };	82	enum class Weekday : uint8_t { None, Narrow, Short, Long };
82	enum class Era : uint8_t { None, Narrow, Short, Long };	83	enum class Era : uint8_t { None, Narrow, Short, Long };
83	enum class Year : uint8_t { None, TwoDigit, Numeric };	84	enum class Year : uint8_t { None, TwoDigit, Numeric };
Lines 91-96 class IntlDateTimeFormat final : public JSNonFinalObject { a/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h_sec2
91	enum class DateTimeStyle : uint8_t { None, Full, Long, Medium, Short };	92	enum class DateTimeStyle : uint8_t { None, Full, Long, Medium, Short };
92		93
93	void setFormatsFromPattern(const StringView&);	94	void setFormatsFromPattern(const StringView&);
		95	static ASCIILiteral hourCycleString(HourCycle);
94	static ASCIILiteral weekdayString(Weekday);	96	static ASCIILiteral weekdayString(Weekday);
95	static ASCIILiteral eraString(Era);	97	static ASCIILiteral eraString(Era);
96	static ASCIILiteral yearString(Year);	98	static ASCIILiteral yearString(Year);
Lines 103-108 class IntlDateTimeFormat final : public JSNonFinalObject { a/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h_sec3
103	static ASCIILiteral timeZoneNameString(TimeZoneName);	105	static ASCIILiteral timeZoneNameString(TimeZoneName);
104	static ASCIILiteral formatStyleString(DateTimeStyle);	106	static ASCIILiteral formatStyleString(DateTimeStyle);
105		107
		108	static HourCycle parseHourCycle(const String&);
		109	static HourCycle hourCycleFromPattern(const Vector<UChar, 32>&);
		110	static void replaceHourCycleInSkeleton(Vector<UChar, 32>&, bool hour12);
		111	static void replaceHourCycleInPattern(Vector<UChar, 32>&, HourCycle);
		112
106	using UDateFormatDeleter = ICUDeleter<udat_close>;	113	using UDateFormatDeleter = ICUDeleter<udat_close>;
107	using UDateIntervalFormatDeleter = ICUDeleter<udtitvfmt_close>;	114	using UDateIntervalFormatDeleter = ICUDeleter<udtitvfmt_close>;
108		115
Lines 115-121 class IntlDateTimeFormat final : public JSNonFinalObject { a/Source/JavaScriptCore/runtime/IntlDateTimeFormat.h_sec4
115	String m_calendar;	122	String m_calendar;
116	String m_numberingSystem;	123	String m_numberingSystem;
117	String m_timeZone;	124	String m_timeZone;
118	String m_hourCycle;	125	HourCycle m_hourCycle { HourCycle::None };
119	Weekday m_weekday { Weekday::None };	126	Weekday m_weekday { Weekday::None };
120	Era m_era { Era::None };	127	Era m_era { Era::None };
121	Year m_year { Year::None };	128	Year m_year { Year::None };



2020-09-14  Yusuke Suzuki  <ysuzuki@apple.com>

        [JSC] Apply Intl.DateTimeFormat hour-cycle correctly when timeStyle is used
        https://bugs.webkit.org/show_bug.cgi?id=216521

        Reviewed by NOBODY (OOPS!).

        * stress/intl-datetimeformat.js:
        * test262/expectations.yaml:

2020-09-11  Yusuke Suzuki  <ysuzuki@apple.com>

        [JSC] Canonicalize "true" unicode extension type value to ""

Lines 748-750 get formatMatcher() { a/JSTests/stress/intl-datetimeformat.js_sec1
- a/JSTests/stress/intl-datetimeformat.js +7 lines
748	{	748	{
749	shouldBe(new Date(0).toLocaleTimeString('zh-Hans-CN', { timeZone: 'UTC', numberingSystem: 'hanidec', hour: "numeric", minute: "numeric", second: "numeric", fractionalSecondDigits: 2 }), "上午一二:〇〇:〇〇.〇〇");	749	shouldBe(new Date(0).toLocaleTimeString('zh-Hans-CN', { timeZone: 'UTC', numberingSystem: 'hanidec', hour: "numeric", minute: "numeric", second: "numeric", fractionalSecondDigits: 2 }), "上午一二:〇〇:〇〇.〇〇");
750	}	750	}
		751	{
		752	let options = new Intl.DateTimeFormat(`de-u-hc-h11`, {
		753	dateStyle: "short"
		754	}).resolvedOptions();
		755	shouldBe(options.hourCycle, undefined);
		756	shouldBe(options.hour12, undefined);
		757	}



  default: 'TypeError: TypedArray.of requires its this argument to subclass a TypedArray constructor (Testing with Float64Array.)'
  strict mode: 'TypeError: TypedArray.of requires its this argument to subclass a TypedArray constructor (Testing with Float64Array.)'
test/intl402/DateTimeFormat/prototype/format/timedatestyle-en.js:
  default: 'Test262Error: Result for date=medium and time=full Expected SameValue(«May 1, 1886 at 2:12:47 PM Coordinated Universal Time», «May 1, 1886, 2:12:47 PM Coordinated Universal Time») to be true'
  strict mode: 'Test262Error: Result for date=medium and time=full Expected SameValue(«May 1, 1886 at 2:12:47 PM Coordinated Universal Time», «May 1, 1886, 2:12:47 PM Coordinated Universal Time») to be true'
test/intl402/DateTimeFormat/prototype/formatRange/en-US.js:
  default: 'Test262Error: Expected SameValue(«1/3/2019 – 1/5/2019», «1/3/2019 – 1/5/2019») to be true'
  strict mode: 'Test262Error: Expected SameValue(«1/3/2019 – 1/5/2019», «1/3/2019 – 1/5/2019») to be true'

Return to Bug 216521

Lines 1453-1460 test/built-ins/TypedArrayConstructors/of/new-instance-using-custom-ctor.js: a/JSTests/test262/expectations.yaml_sec1
- a/JSTests/test262/expectations.yaml -2 / +2 lines
1453	default: 'TypeError: TypedArray.of requires its this argument to subclass a TypedArray constructor (Testing with Float64Array.)'	1453	default: 'TypeError: TypedArray.of requires its this argument to subclass a TypedArray constructor (Testing with Float64Array.)'
1454	strict mode: 'TypeError: TypedArray.of requires its this argument to subclass a TypedArray constructor (Testing with Float64Array.)'	1454	strict mode: 'TypeError: TypedArray.of requires its this argument to subclass a TypedArray constructor (Testing with Float64Array.)'
1455	test/intl402/DateTimeFormat/prototype/format/timedatestyle-en.js:	1455	test/intl402/DateTimeFormat/prototype/format/timedatestyle-en.js:
1456	default: 'Test262Error: Result for full with {} Expected SameValue(«14:12:47 PM Coordinated Universal Time», «14:12:47 Coordinated Universal Time») to be true'	1456	default: 'Test262Error: Result for date=medium and time=full Expected SameValue(«May 1, 1886 at 2:12:47 PM Coordinated Universal Time», «May 1, 1886, 2:12:47 PM Coordinated Universal Time») to be true'
1457	strict mode: 'Test262Error: Result for full with {} Expected SameValue(«14:12:47 PM Coordinated Universal Time», «14:12:47 Coordinated Universal Time») to be true'	1457	strict mode: 'Test262Error: Result for date=medium and time=full Expected SameValue(«May 1, 1886 at 2:12:47 PM Coordinated Universal Time», «May 1, 1886, 2:12:47 PM Coordinated Universal Time») to be true'
1458	test/intl402/DateTimeFormat/prototype/formatRange/en-US.js:	1458	test/intl402/DateTimeFormat/prototype/formatRange/en-US.js:
1459	default: 'Test262Error: Expected SameValue(«1/3/2019 – 1/5/2019», «1/3/2019 – 1/5/2019») to be true'	1459	default: 'Test262Error: Expected SameValue(«1/3/2019 – 1/5/2019», «1/3/2019 – 1/5/2019») to be true'
1460	strict mode: 'Test262Error: Expected SameValue(«1/3/2019 – 1/5/2019», «1/3/2019 – 1/5/2019») to be true'	1460	strict mode: 'Test262Error: Expected SameValue(«1/3/2019 – 1/5/2019», «1/3/2019 – 1/5/2019») to be true'

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +19 lines
		1	2020-09-14 Yusuke Suzuki <ysuzuki@apple.com>
		2
		3	[JSC] Apply Intl.DateTimeFormat hour-cycle correctly when timeStyle is used
		4	https://bugs.webkit.org/show_bug.cgi?id=216521
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* runtime/IntlDateTimeFormat.cpp:
		9	(JSC::IntlDateTimeFormat::setFormatsFromPattern):
		10	(JSC::IntlDateTimeFormat::parseHourCycle):
		11	(JSC::IntlDateTimeFormat::hourCycleFromPattern):
		12	(JSC::IntlDateTimeFormat::replaceHourCycleInSkeleton):
		13	(JSC::IntlDateTimeFormat::replaceHourCycleInPattern):
		14	(JSC::IntlDateTimeFormat::initializeDateTimeFormat):
		15	(JSC::IntlDateTimeFormat::hourCycleString):
		16	(JSC::IntlDateTimeFormat::resolvedOptions const):
		17	(JSC::IntlDateTimeFormat::createDateIntervalFormatIfNecessary):
		18	* runtime/IntlDateTimeFormat.h:
		19
1	2020-09-11 Yusuke Suzuki <ysuzuki@apple.com>	20	2020-09-11 Yusuke Suzuki <ysuzuki@apple.com>
2		21
3	[JSC] Canonicalize "true" unicode extension type value to ""	22	[JSC] Canonicalize "true" unicode extension type value to ""

Lines 1-3 a/JSTests/ChangeLog_sec1
- a/JSTests/ChangeLog +10 lines
		1	2020-09-14 Yusuke Suzuki <ysuzuki@apple.com>
		2
		3	[JSC] Apply Intl.DateTimeFormat hour-cycle correctly when timeStyle is used
		4	https://bugs.webkit.org/show_bug.cgi?id=216521
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* stress/intl-datetimeformat.js:
		9	* test262/expectations.yaml:
		10
1	2020-09-11 Yusuke Suzuki <ysuzuki@apple.com>	11	2020-09-11 Yusuke Suzuki <ysuzuki@apple.com>
2		12
3	[JSC] Canonicalize "true" unicode extension type value to ""	13	[JSC] Canonicalize "true" unicode extension type value to ""