<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[245648] trunk</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/245648">245648</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2019-05-22 14:52:58 -0700 (Wed, 22 May 2019)</dd>
</dl>

<h3>Log Message</h3>
<pre>Unreviewed, rolling out <a href="http://trac.webkit.org/projects/webkit/changeset/245634">r245634</a>.
https://bugs.webkit.org/show_bug.cgi?id=198140

'This patch makes JSC crash on launch in debug builds'
(Requested by tadeuzagallo on #webkit).

Reverted changeset:

"[ESNext] Implement support for Numeric Separators"
https://bugs.webkit.org/show_bug.cgi?id=196351
https://trac.webkit.org/changeset/245634</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJSTestsChangeLog">trunk/JSTests/ChangeLog</a></li>
<li><a href="#trunkJSTeststest262expectationsyaml">trunk/JSTests/test262/expectations.yaml</a></li>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreparserLexercpp">trunk/Source/JavaScriptCore/parser/Lexer.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreparserLexerh">trunk/Source/JavaScriptCore/parser/Lexer.h</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJSTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/ChangeLog (245647 => 245648)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/ChangeLog  2019-05-22 21:39:11 UTC (rev 245647)
+++ trunk/JSTests/ChangeLog     2019-05-22 21:52:58 UTC (rev 245648)
</span><span class="lines">@@ -1,3 +1,17 @@
</span><ins>+2019-05-22  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r245634.
+        https://bugs.webkit.org/show_bug.cgi?id=198140
+
+        'This patch makes JSC crash on launch in debug builds'
+        (Requested by tadeuzagallo on #webkit).
+
+        Reverted changeset:
+
+        "[ESNext] Implement support for Numeric Separators"
+        https://bugs.webkit.org/show_bug.cgi?id=196351
+        https://trac.webkit.org/changeset/245634
+
</ins><span class="cx"> 2019-05-22  Tadeu Zagallo  <tzagallo@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Stack-buffer-overflow in decodeURIComponent
</span></span></pre></div>
<a id="trunkJSTeststest262expectationsyaml"></a>
<div class="modfile"><h4>Modified: trunk/JSTests/test262/expectations.yaml (245647 => 245648)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JSTests/test262/expectations.yaml  2019-05-22 21:39:11 UTC (rev 245647)
+++ trunk/JSTests/test262/expectations.yaml     2019-05-22 21:52:58 UTC (rev 245648)
</span><span class="lines">@@ -2586,6 +2586,96 @@
</span><span class="cx"> test/language/global-code/script-decl-var-err.js:
</span><span class="cx">   default: 'Test262Error: Expected a TypeError to be thrown but no exception was thrown at all'
</span><span class="cx">   strict mode: 'Test262Error: Expected a TypeError to be thrown but no exception was thrown at all'
</span><ins>+test/language/literals/numeric/numeric-separator-literal-bil-bd-nsl-bd.js:
+  default: 'SyntaxError: No space between binary literal and identifier'
+  strict mode: 'SyntaxError: No space between binary literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-bil-bd-nsl-bds.js:
+  default: 'SyntaxError: No space between binary literal and identifier'
+  strict mode: 'SyntaxError: No space between binary literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-bil-bds-nsl-bd.js:
+  default: 'SyntaxError: No space between binary literal and identifier'
+  strict mode: 'SyntaxError: No space between binary literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-bil-bds-nsl-bds.js:
+  default: 'SyntaxError: No space between binary literal and identifier'
+  strict mode: 'SyntaxError: No space between binary literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dd-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dds-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dd-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dds-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dd-nsl-dd-one-of.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dds-dot-dd-nsl-dd-ep-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dds-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dot-dd-nsl-dd-ep.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dot-dd-nsl-dds-ep.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dot-dds-nsl-dd-ep.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-dot-dds-nsl-dds-ep.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-hil-hd-nsl-hd.js:
+  default: 'SyntaxError: No space between hexadecimal literal and identifier'
+  strict mode: 'SyntaxError: No space between hexadecimal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-hil-hd-nsl-hds.js:
+  default: 'SyntaxError: No space between hexadecimal literal and identifier'
+  strict mode: 'SyntaxError: No space between hexadecimal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-hil-hds-nsl-hd.js:
+  default: 'SyntaxError: No space between hexadecimal literal and identifier'
+  strict mode: 'SyntaxError: No space between hexadecimal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-hil-hds-nsl-hds.js:
+  default: 'SyntaxError: No space between hexadecimal literal and identifier'
+  strict mode: 'SyntaxError: No space between hexadecimal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-hil-od-nsl-od-one-of.js:
+  default: 'SyntaxError: No space between hexadecimal literal and identifier'
+  strict mode: 'SyntaxError: No space between hexadecimal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-nzd-nsl-dd-one-of.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-nzd-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-nzd-nsl-dds.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-oil-od-nsl-od-one-of.js:
+  default: 'SyntaxError: No space between octal literal and identifier'
+  strict mode: 'SyntaxError: No space between octal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-oil-od-nsl-od.js:
+  default: 'SyntaxError: No space between octal literal and identifier'
+  strict mode: 'SyntaxError: No space between octal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-oil-od-nsl-ods.js:
+  default: 'SyntaxError: No space between octal literal and identifier'
+  strict mode: 'SyntaxError: No space between octal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-oil-ods-nsl-od.js:
+  default: 'SyntaxError: No space between octal literal and identifier'
+  strict mode: 'SyntaxError: No space between octal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-oil-ods-nsl-ods.js:
+  default: 'SyntaxError: No space between octal literal and identifier'
+  strict mode: 'SyntaxError: No space between octal literal and identifier'
+test/language/literals/numeric/numeric-separator-literal-sign-minus-dds-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
+test/language/literals/numeric/numeric-separator-literal-sign-plus-dds-nsl-dd.js:
+  default: 'SyntaxError: No identifiers allowed directly after numeric literal'
+  strict mode: 'SyntaxError: No identifiers allowed directly after numeric literal'
</ins><span class="cx"> test/language/literals/regexp/named-groups/invalid-dangling-groupname-2-u.js:
</span><span class="cx">   default: 'Test262: This statement should not be evaluated.'
</span><span class="cx">   strict mode: 'Test262: This statement should not be evaluated.'
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (245647 => 245648)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog    2019-05-22 21:39:11 UTC (rev 245647)
+++ trunk/Source/JavaScriptCore/ChangeLog       2019-05-22 21:52:58 UTC (rev 245648)
</span><span class="lines">@@ -1,3 +1,17 @@
</span><ins>+2019-05-22  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r245634.
+        https://bugs.webkit.org/show_bug.cgi?id=198140
+
+        'This patch makes JSC crash on launch in debug builds'
+        (Requested by tadeuzagallo on #webkit).
+
+        Reverted changeset:
+
+        "[ESNext] Implement support for Numeric Separators"
+        https://bugs.webkit.org/show_bug.cgi?id=196351
+        https://trac.webkit.org/changeset/245634
+
</ins><span class="cx"> 2019-05-22 Zagallo  <tzagallo@apple.com>
</span><span class="cx"> 
</span><span class="cx">         Fix validateExceptionChecks for CLoop
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreparserLexercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/parser/Lexer.cpp (245647 => 245648)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/parser/Lexer.cpp     2019-05-22 21:39:11 UTC (rev 245647)
+++ trunk/Source/JavaScriptCore/parser/Lexer.cpp        2019-05-22 21:52:58 UTC (rev 245648)
</span><span class="lines">@@ -813,30 +813,6 @@
</span><span class="cx">     return isIdentPartIncludingEscapeTemplate(code, codeEnd);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-template<typename CharacterType>
-static inline bool isASCIIDigitOrSeparator(CharacterType character)
-{
-    return isASCIIDigit(character) || character == '_';
-}
-
-template<typename CharacterType>
-static inline bool isASCIIHexDigitOrSeparator(CharacterType character)
-{
-    return isASCIIHexDigit(character) || character == '_';
-}
-
-template<typename CharacterType>
-static inline bool isASCIIBinaryDigitOrSeparator(CharacterType character)
-{
-    return isASCIIBinaryDigit(character) || character == '_';
-}
-
-template<typename CharacterType>
-static inline bool isASCIIOctalDigitOrSeparator(CharacterType character)
-{
-    return isASCIIOctalDigit(character) || character == '_';
-}
-
</del><span class="cx"> static inline LChar singleEscape(int c)
</span><span class="cx"> {
</span><span class="cx">     if (c < 128) {
</span><span class="lines">@@ -1514,29 +1490,20 @@
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> template <typename T>
</span><del>-ALWAYS_INLINE auto Lexer<T>::parseHex() -> Optional<NumberParseResult>
</del><ins>+ALWAYS_INLINE auto Lexer<T>::parseHex() -> NumberParseResult
</ins><span class="cx"> {
</span><del>-    ASSERT(isASCIIHexDigit(m_current));
-
</del><span class="cx">     // Optimization: most hexadecimal values fit into 4 bytes.
</span><span class="cx">     uint32_t hexValue = 0;
</span><span class="cx">     int maximumDigits = 7;
</span><span class="cx"> 
</span><span class="cx">     do {
</span><del>-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIHexDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><span class="cx">         hexValue = (hexValue << 4) + toASCIIHexValue(m_current);
</span><span class="cx">         shift();
</span><span class="cx">         --maximumDigits;
</span><del>-    } while (isASCIIHexDigitOrSeparator(m_current) && maximumDigits >= 0);
</del><ins>+    } while (isASCIIHexDigit(m_current) && maximumDigits >= 0);
</ins><span class="cx"> 
</span><span class="cx">     if (LIKELY(maximumDigits >= 0 && m_current != 'n'))
</span><del>-        return NumberParseResult { hexValue };
</del><ins>+        return hexValue;
</ins><span class="cx"> 
</span><span class="cx">     // No more place in the hexValue buffer.
</span><span class="cx">     // The values are shifted out and placed into the m_buffer8 vector.
</span><span class="lines">@@ -1549,29 +1516,20 @@
</span><span class="cx">          hexValue <<= 4;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    while (isASCIIHexDigitOrSeparator(m_current)) {
-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIHexDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><ins>+    while (isASCIIHexDigit(m_current)) {
</ins><span class="cx">         record8(m_current);
</span><span class="cx">         shift();
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
</span><del>-        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</del><ins>+        return makeIdentifier(m_buffer8.data(), m_buffer8.size());
</ins><span class="cx">     
</span><del>-    return NumberParseResult { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 16) };
</del><ins>+    return parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 16);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> template <typename T>
</span><span class="cx"> ALWAYS_INLINE auto Lexer<T>::parseBinary() -> Optional<NumberParseResult>
</span><span class="cx"> {
</span><del>-    ASSERT(isASCIIBinaryDigit(m_current));
-
</del><span class="cx">     // Optimization: most binary values fit into 4 bytes.
</span><span class="cx">     uint32_t binaryValue = 0;
</span><span class="cx">     const unsigned maximumDigits = 32;
</span><span class="lines">@@ -1581,51 +1539,35 @@
</span><span class="cx">     LChar digits[maximumDigits];
</span><span class="cx"> 
</span><span class="cx">     do {
</span><del>-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIBinaryDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><span class="cx">         binaryValue = (binaryValue << 1) + (m_current - '0');
</span><span class="cx">         digits[digit] = m_current;
</span><span class="cx">         shift();
</span><span class="cx">         --digit;
</span><del>-    } while (isASCIIBinaryDigitOrSeparator(m_current) && digit >= 0);
</del><ins>+    } while (isASCIIBinaryDigit(m_current) && digit >= 0);
</ins><span class="cx"> 
</span><del>-    if (LIKELY(!isASCIIDigitOrSeparator(m_current) && digit >= 0 && m_current != 'n'))
-        return NumberParseResult { binaryValue };
</del><ins>+    if (LIKELY(!isASCIIDigit(m_current) && digit >= 0 && m_current != 'n'))
+        return Variant<double, const Identifier*> { binaryValue };
</ins><span class="cx"> 
</span><span class="cx">     for (int i = maximumDigits - 1; i > digit; --i)
</span><span class="cx">         record8(digits[i]);
</span><span class="cx"> 
</span><del>-    while (isASCIIBinaryDigitOrSeparator(m_current)) {
-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIBinaryDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><ins>+    while (isASCIIBinaryDigit(m_current)) {
</ins><span class="cx">         record8(m_current);
</span><span class="cx">         shift();
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
</span><del>-        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</del><ins>+        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</ins><span class="cx"> 
</span><span class="cx">     if (isASCIIDigit(m_current))
</span><span class="cx">         return WTF::nullopt;
</span><span class="cx"> 
</span><del>-    return NumberParseResult { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 2) };
</del><ins>+    return Variant<double, const Identifier*> { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 2) };
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> template <typename T>
</span><span class="cx"> ALWAYS_INLINE auto Lexer<T>::parseOctal() -> Optional<NumberParseResult>
</span><span class="cx"> {
</span><del>-    ASSERT(isASCIIOctalDigit(m_current));
-
</del><span class="cx">     // Optimization: most octal values fit into 4 bytes.
</span><span class="cx">     uint32_t octalValue = 0;
</span><span class="cx">     const unsigned maximumDigits = 10;
</span><span class="lines">@@ -1635,51 +1577,36 @@
</span><span class="cx">     LChar digits[maximumDigits];
</span><span class="cx"> 
</span><span class="cx">     do {
</span><del>-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIOctalDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><span class="cx">         octalValue = octalValue * 8 + (m_current - '0');
</span><span class="cx">         digits[digit] = m_current;
</span><span class="cx">         shift();
</span><span class="cx">         --digit;
</span><del>-    } while (isASCIIOctalDigitOrSeparator(m_current) && digit >= 0);
</del><ins>+    } while (isASCIIOctalDigit(m_current) && digit >= 0);
</ins><span class="cx"> 
</span><del>-    if (LIKELY(!isASCIIDigitOrSeparator(m_current) && digit >= 0 && m_current != 'n'))
-        return NumberParseResult { octalValue };
</del><ins>+    if (LIKELY(!isASCIIDigit(m_current) && digit >= 0 && m_current != 'n'))
+        return Variant<double, const Identifier*> { octalValue };
</ins><span class="cx"> 
</span><ins>+
</ins><span class="cx">     for (int i = maximumDigits - 1; i > digit; --i)
</span><span class="cx">          record8(digits[i]);
</span><span class="cx"> 
</span><del>-    while (isASCIIOctalDigitOrSeparator(m_current)) {
-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIOctalDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><ins>+    while (isASCIIOctalDigit(m_current)) {
</ins><span class="cx">         record8(m_current);
</span><span class="cx">         shift();
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
</span><del>-        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</del><ins>+        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</ins><span class="cx"> 
</span><span class="cx">     if (isASCIIDigit(m_current))
</span><span class="cx">         return WTF::nullopt;
</span><span class="cx"> 
</span><del>-    return NumberParseResult { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 8) };
</del><ins>+    return Variant<double, const Identifier*> { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 8) };
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> template <typename T>
</span><span class="cx"> ALWAYS_INLINE auto Lexer<T>::parseDecimal() -> Optional<NumberParseResult>
</span><span class="cx"> {
</span><del>-    ASSERT(isASCIIDigit(m_current));
-
</del><span class="cx">     // Optimization: most decimal values fit into 4 bytes.
</span><span class="cx">     uint32_t decimalValue = 0;
</span><span class="cx"> 
</span><span class="lines">@@ -1693,63 +1620,38 @@
</span><span class="cx">         LChar digits[maximumDigits];
</span><span class="cx"> 
</span><span class="cx">         do {
</span><del>-            if (m_current == '_') {
-                if (UNLIKELY(!isASCIIDigit(peek(1))))
-                    return WTF::nullopt;
-
-                shift();
-            }
-
</del><span class="cx">             decimalValue = decimalValue * 10 + (m_current - '0');
</span><span class="cx">             digits[digit] = m_current;
</span><span class="cx">             shift();
</span><span class="cx">             --digit;
</span><del>-        } while (isASCIIDigitOrSeparator(m_current) && digit >= 0);
</del><ins>+        } while (isASCIIDigit(m_current) && digit >= 0);
</ins><span class="cx"> 
</span><span class="cx">         if (digit >= 0 && m_current != '.' && !isASCIIAlphaCaselessEqual(m_current, 'e') && m_current != 'n')
</span><del>-            return NumberParseResult { decimalValue };
</del><ins>+            return Variant<double, const Identifier*> { decimalValue };
</ins><span class="cx"> 
</span><span class="cx">         for (int i = maximumDigits - 1; i > digit; --i)
</span><span class="cx">             record8(digits[i]);
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    while (isASCIIDigitOrSeparator(m_current)) {
-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIDigit(peek(1))))
-                return WTF::nullopt;
-
-            shift();
-        }
-
</del><ins>+    while (isASCIIDigit(m_current)) {
</ins><span class="cx">         record8(m_current);
</span><span class="cx">         shift();
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
</span><del>-        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</del><ins>+        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
</ins><span class="cx"> 
</span><span class="cx">     return WTF::nullopt;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> template <typename T>
</span><del>-ALWAYS_INLINE bool Lexer<T>::parseNumberAfterDecimalPoint()
</del><ins>+ALWAYS_INLINE void Lexer<T>::parseNumberAfterDecimalPoint()
</ins><span class="cx"> {
</span><del>-    ASSERT(isASCIIDigit(m_current));
</del><span class="cx">     record8('.');
</span><del>-
-    do {
-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIDigit(peek(1))))
-                return false;
-
-            shift();
-        }
-
</del><ins>+    while (isASCIIDigit(m_current)) {
</ins><span class="cx">         record8(m_current);
</span><span class="cx">         shift();
</span><del>-    } while (isASCIIDigitOrSeparator(m_current));
-
-    return true;
</del><ins>+    }
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> template <typename T>
</span><span class="lines">@@ -1766,17 +1668,9 @@
</span><span class="cx">         return false;
</span><span class="cx"> 
</span><span class="cx">     do {
</span><del>-        if (m_current == '_') {
-            if (UNLIKELY(!isASCIIDigit(peek(1))))
-                return false;
-
-            shift();
-        }
-
</del><span class="cx">         record8(m_current);
</span><span class="cx">         shift();
</span><del>-    } while (isASCIIDigitOrSeparator(m_current));
-
</del><ins>+    } while (isASCIIDigit(m_current));
</ins><span class="cx">     return true;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -2196,11 +2090,7 @@
</span><span class="cx">             token = DOT;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><del>-        if (UNLIKELY(!parseNumberAfterDecimalPoint())) {
-            m_lexErrorMessage = "Non-number found after decimal point"_s;
-            token = INVALID_NUMERIC_LITERAL_ERRORTOK;
-            goto returnError;
-        }
</del><ins>+        parseNumberAfterDecimalPoint();
</ins><span class="cx">         token = DOUBLE;
</span><span class="cx">         if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
</span><span class="cx">             if (!parseNumberAfterExponentIndicator()) {
</span><span class="lines">@@ -2234,14 +2124,12 @@
</span><span class="cx">             shift();
</span><span class="cx"> 
</span><span class="cx">             auto parseNumberResult = parseHex();
</span><del>-            if (!parseNumberResult)
-                tokenData->doubleValue = 0;
-            else if (WTF::holds_alternative<double>(*parseNumberResult))
-                tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
</del><ins>+            if (WTF::holds_alternative<double>(parseNumberResult))
+                tokenData->doubleValue = WTF::get<double>(parseNumberResult);
</ins><span class="cx">             else {
</span><span class="cx">                 token = BIGINT;
</span><span class="cx">                 shift();
</span><del>-                tokenData->bigIntString = WTF::get<const Identifier*>(*parseNumberResult);
</del><ins>+                tokenData->bigIntString = WTF::get<const Identifier*>(parseNumberResult);
</ins><span class="cx">                 tokenData->radix = 16;
</span><span class="cx">             }
</span><span class="cx"> 
</span><span class="lines">@@ -2321,12 +2209,6 @@
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        if (UNLIKELY(m_current == '_')) {
-            m_lexErrorMessage = "Numeric literals may not begin with 0_"_s;
-            token = UNTERMINATED_OCTAL_NUMBER_ERRORTOK;
-            goto returnError;
-        }
-
</del><span class="cx">         record8('0');
</span><span class="cx">         if (strictMode && isASCIIDigit(m_current)) {
</span><span class="cx">             m_lexErrorMessage = "Decimal integer literals with a leading zero are forbidden in strict mode"_s;
</span><span class="lines">@@ -2358,11 +2240,7 @@
</span><span class="cx">                     token = INTEGER;
</span><span class="cx">                     if (m_current == '.') {
</span><span class="cx">                         shift();
</span><del>-                        if (UNLIKELY(isASCIIDigit(m_current) && !parseNumberAfterDecimalPoint())) {
-                            m_lexErrorMessage = "Non-number found after decimal point"_s;
-                            token = INVALID_NUMERIC_LITERAL_ERRORTOK;
-                            goto returnError;
-                        }
</del><ins>+                        parseNumberAfterDecimalPoint();
</ins><span class="cx">                         token = DOUBLE;
</span><span class="cx">                     }
</span><span class="cx">                     if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreparserLexerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/parser/Lexer.h (245647 => 245648)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/parser/Lexer.h       2019-05-22 21:39:11 UTC (rev 245647)
+++ trunk/Source/JavaScriptCore/parser/Lexer.h  2019-05-22 21:52:58 UTC (rev 245648)
</span><span class="lines">@@ -179,11 +179,11 @@
</span><span class="cx">     ALWAYS_INLINE StringParseResult parseTemplateLiteral(JSTokenData*, RawStringsBuildMode);
</span><span class="cx">     
</span><span class="cx">     using NumberParseResult = Variant<double, const Identifier*>;
</span><del>-    ALWAYS_INLINE Optional<NumberParseResult> parseHex();
</del><ins>+    ALWAYS_INLINE NumberParseResult parseHex();
</ins><span class="cx">     ALWAYS_INLINE Optional<NumberParseResult> parseBinary();
</span><span class="cx">     ALWAYS_INLINE Optional<NumberParseResult> parseOctal();
</span><span class="cx">     ALWAYS_INLINE Optional<NumberParseResult> parseDecimal();
</span><del>-    ALWAYS_INLINE bool parseNumberAfterDecimalPoint();
</del><ins>+    ALWAYS_INLINE void parseNumberAfterDecimalPoint();
</ins><span class="cx">     ALWAYS_INLINE bool parseNumberAfterExponentIndicator();
</span><span class="cx">     ALWAYS_INLINE bool parseMultilineComment();
</span><span class="cx"> 
</span></span></pre>
</div>
</div>

</body>
</html>