Attachment 370218 Details for Bug 196351 – Patch

[patch] Patch

bug-196351-20190518224755.patch (text/plain), 24.49 KB, created by Ross Kirsling on 2019-05-18 22:47:56 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Ross Kirsling

Created: 2019-05-18 22:47:56 PDT

Size: 24.49 KB

patch

obsolete

>Subversion Revision: 245499
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 547bd5233c9107bc7b5a9b844d7f9358126209c5..9d3e938bc8f23f6c822c5b2e9c787c3b59961447 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,34 @@
>+2019-05-18  Ross Kirsling  <ross.kirsling@sony.com>
>+
>+        [ESNext] Implement support for Numeric Separators
>+        https://bugs.webkit.org/show_bug.cgi?id=196351
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Implement the following proposal, which is now Stage 3:
>+          https://github.com/tc39/proposal-numeric-separator
>+
>+        Specifically, this allows '_' to be used as a separator in numeric literals.
>+        It may be inserted arbitrarily without semantic effect, but it may not occur:
>+          - multiple times in a row
>+          - at the beginning or end of the literal
>+          - adjacent to 0x, 0b, 0o, decimal point, or exponential indicator
>+          - after a leading zero (e.g. 0_123), even in sloppy mode
>+
>+        * parser/Lexer.cpp:
>+        (JSC::isASCIIDigitOrSeparator): Added.
>+        (JSC::isASCIIHexDigitOrSeparator): Added.
>+        (JSC::isASCIIBinaryDigitOrSeparator): Added.
>+        (JSC::isASCIIOctalDigitOrSeparator): Added.
>+        (JSC::Lexer<T>::parseHex):
>+        (JSC::Lexer<T>::parseBinary):
>+        (JSC::Lexer<T>::parseOctal):
>+        (JSC::Lexer<T>::parseDecimal):
>+        (JSC::Lexer<T>::parseNumberAfterDecimalPoint):
>+        (JSC::Lexer<T>::parseNumberAfterExponentIndicator):
>+        (JSC::Lexer<T>::lexWithoutClearingLineTerminator):
>+        * parser/Lexer.h:
>+
> 2019-05-18  Tadeu Zagallo  <tzagallo@apple.com>
> 
>         Add extra information to dumpJITMemory
>diff --git a/Source/JavaScriptCore/parser/Lexer.cpp b/Source/JavaScriptCore/parser/Lexer.cpp
>index c2f24bd8f3eaf4ec397a69d5a08b9168a5c1871c..92b63d1bdfbaef7f8e89951e6a27539f06d98395 100644
>--- a/Source/JavaScriptCore/parser/Lexer.cpp
>+++ b/Source/JavaScriptCore/parser/Lexer.cpp
>@@ -813,6 +813,30 @@ static ALWAYS_INLINE bool isIdentPartIncludingEscape(const UChar* code, const UC
>     return isIdentPartIncludingEscapeTemplate(code, codeEnd);
> }
> 
>+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 == '_';
>+}
>+
> static inline LChar singleEscape(int c)
> {
>     if (c < 128) {
>@@ -1490,20 +1514,27 @@ typename Lexer<T>::StringParseResult Lexer<T>::parseTemplateLiteral(JSTokenData*
> }
> 
> template <typename T>
>-ALWAYS_INLINE auto Lexer<T>::parseHex() -> NumberParseResult
>+ALWAYS_INLINE auto Lexer<T>::parseHex() -> Optional<NumberParseResult>
> {
>     // Optimization: most hexadecimal values fit into 4 bytes.
>     uint32_t hexValue = 0;
>     int maximumDigits = 7;
> 
>     do {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIHexDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         hexValue = (hexValue << 4) + toASCIIHexValue(m_current);
>         shift();
>         --maximumDigits;
>-    } while (isASCIIHexDigit(m_current) && maximumDigits >= 0);
>+    } while (isASCIIHexDigitOrSeparator(m_current) && maximumDigits >= 0);
> 
>     if (LIKELY(maximumDigits >= 0 && m_current != 'n'))
>-        return hexValue;
>+        return NumberParseResult { hexValue };
> 
>     // No more place in the hexValue buffer.
>     // The values are shifted out and placed into the m_buffer8 vector.
>@@ -1516,15 +1547,22 @@ ALWAYS_INLINE auto Lexer<T>::parseHex() -> NumberParseResult
>          hexValue <<= 4;
>     }
> 
>-    while (isASCIIHexDigit(m_current)) {
>+    while (isASCIIHexDigitOrSeparator(m_current)) {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIHexDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         record8(m_current);
>         shift();
>     }
> 
>     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
>-        return makeIdentifier(m_buffer8.data(), m_buffer8.size());
>+        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
>     
>-    return parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 16);
>+    return NumberParseResult { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 16) };
> }
> 
> template <typename T>
>@@ -1539,30 +1577,44 @@ ALWAYS_INLINE auto Lexer<T>::parseBinary() -> Optional<NumberParseResult>
>     LChar digits[maximumDigits];
> 
>     do {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIBinaryDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         binaryValue = (binaryValue << 1) + (m_current - '0');
>         digits[digit] = m_current;
>         shift();
>         --digit;
>-    } while (isASCIIBinaryDigit(m_current) && digit >= 0);
>+    } while (isASCIIBinaryDigitOrSeparator(m_current) && digit >= 0);
> 
>-    if (LIKELY(!isASCIIDigit(m_current) && digit >= 0 && m_current != 'n'))
>-        return Variant<double, const Identifier*> { binaryValue };
>+    if (LIKELY(!isASCIIDigitOrSeparator(m_current) && digit >= 0 && m_current != 'n'))
>+        return NumberParseResult { binaryValue };
> 
>     for (int i = maximumDigits - 1; i > digit; --i)
>         record8(digits[i]);
> 
>-    while (isASCIIBinaryDigit(m_current)) {
>+    while (isASCIIBinaryDigitOrSeparator(m_current)) {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIBinaryDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         record8(m_current);
>         shift();
>     }
> 
>     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
>-        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
>+        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
> 
>     if (isASCIIDigit(m_current))
>         return WTF::nullopt;
> 
>-    return Variant<double, const Identifier*> { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 2) };
>+    return NumberParseResult { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 2) };
> }
> 
> template <typename T>
>@@ -1577,31 +1629,44 @@ ALWAYS_INLINE auto Lexer<T>::parseOctal() -> Optional<NumberParseResult>
>     LChar digits[maximumDigits];
> 
>     do {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIOctalDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         octalValue = octalValue * 8 + (m_current - '0');
>         digits[digit] = m_current;
>         shift();
>         --digit;
>-    } while (isASCIIOctalDigit(m_current) && digit >= 0);
>-
>-    if (LIKELY(!isASCIIDigit(m_current) && digit >= 0 && m_current != 'n'))
>-        return Variant<double, const Identifier*> { octalValue };
>+    } while (isASCIIOctalDigitOrSeparator(m_current) && digit >= 0);
> 
>+    if (LIKELY(!isASCIIDigitOrSeparator(m_current) && digit >= 0 && m_current != 'n'))
>+        return NumberParseResult { octalValue };
> 
>     for (int i = maximumDigits - 1; i > digit; --i)
>          record8(digits[i]);
> 
>-    while (isASCIIOctalDigit(m_current)) {
>+    while (isASCIIOctalDigitOrSeparator(m_current)) {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIOctalDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         record8(m_current);
>         shift();
>     }
> 
>     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
>-        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
>+        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
> 
>     if (isASCIIDigit(m_current))
>         return WTF::nullopt;
> 
>-    return Variant<double, const Identifier*> { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 8) };
>+    return NumberParseResult { parseIntOverflow(m_buffer8.data(), m_buffer8.size(), 8) };
> }
> 
> template <typename T>
>@@ -1620,38 +1685,63 @@ ALWAYS_INLINE auto Lexer<T>::parseDecimal() -> Optional<NumberParseResult>
>         LChar digits[maximumDigits];
> 
>         do {
>+            if (m_current == '_') {
>+                if (UNLIKELY(!isASCIIDigit(peek(1))))
>+                    return WTF::nullopt;
>+
>+                shift();
>+            }
>+
>             decimalValue = decimalValue * 10 + (m_current - '0');
>             digits[digit] = m_current;
>             shift();
>             --digit;
>-        } while (isASCIIDigit(m_current) && digit >= 0);
>+        } while (isASCIIDigitOrSeparator(m_current) && digit >= 0);
> 
>         if (digit >= 0 && m_current != '.' && !isASCIIAlphaCaselessEqual(m_current, 'e') && m_current != 'n')
>-            return Variant<double, const Identifier*> { decimalValue };
>+            return NumberParseResult { decimalValue };
> 
>         for (int i = maximumDigits - 1; i > digit; --i)
>             record8(digits[i]);
>     }
> 
>-    while (isASCIIDigit(m_current)) {
>+    while (isASCIIDigitOrSeparator(m_current)) {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIDigit(peek(1))))
>+                return WTF::nullopt;
>+
>+            shift();
>+        }
>+
>         record8(m_current);
>         shift();
>     }
>     
>     if (UNLIKELY(Options::useBigInt() && m_current == 'n'))
>-        return Variant<double, const Identifier*> { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
>+        return NumberParseResult { makeIdentifier(m_buffer8.data(), m_buffer8.size()) };
> 
>     return WTF::nullopt;
> }
> 
> template <typename T>
>-ALWAYS_INLINE void Lexer<T>::parseNumberAfterDecimalPoint()
>+ALWAYS_INLINE bool Lexer<T>::parseNumberAfterDecimalPoint()
> {
>+    ASSERT(isASCIIDigit(m_current));
>     record8('.');
>-    while (isASCIIDigit(m_current)) {
>+
>+    do {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIDigit(peek(1))))
>+                return false;
>+
>+            shift();
>+        }
>+
>         record8(m_current);
>         shift();
>-    }
>+    } while (isASCIIDigitOrSeparator(m_current));
>+
>+    return true;
> }
> 
> template <typename T>
>@@ -1668,9 +1758,17 @@ ALWAYS_INLINE bool Lexer<T>::parseNumberAfterExponentIndicator()
>         return false;
> 
>     do {
>+        if (m_current == '_') {
>+            if (UNLIKELY(!isASCIIDigit(peek(1))))
>+                return false;
>+
>+            shift();
>+        }
>+
>         record8(m_current);
>         shift();
>-    } while (isASCIIDigit(m_current));
>+    } while (isASCIIDigitOrSeparator(m_current));
>+
>     return true;
> }
> 
>@@ -2090,7 +2188,11 @@ start:
>             token = DOT;
>             break;
>         }
>-        parseNumberAfterDecimalPoint();
>+        if (UNLIKELY(!parseNumberAfterDecimalPoint())) {
>+            m_lexErrorMessage = "Non-number found after decimal point"_s;
>+            token = INVALID_NUMERIC_LITERAL_ERRORTOK;
>+            goto returnError;
>+        }
>         token = DOUBLE;
>         if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
>             if (!parseNumberAfterExponentIndicator()) {
>@@ -2124,12 +2226,14 @@ start:
>             shift();
> 
>             auto parseNumberResult = parseHex();
>-            if (WTF::holds_alternative<double>(parseNumberResult))
>-                tokenData->doubleValue = WTF::get<double>(parseNumberResult);
>+            if (!parseNumberResult)
>+                tokenData->doubleValue = 0;
>+            else if (WTF::holds_alternative<double>(*parseNumberResult))
>+                tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
>             else {
>                 token = BIGINT;
>                 shift();
>-                tokenData->bigIntString = WTF::get<const Identifier*>(parseNumberResult);
>+                tokenData->bigIntString = WTF::get<const Identifier*>(*parseNumberResult);
>                 tokenData->radix = 16;
>             }
> 
>@@ -2209,6 +2313,12 @@ start:
>             break;
>         }
> 
>+        if (UNLIKELY(m_current == '_')) {
>+            m_lexErrorMessage = "Numeric literals may not begin with 0_"_s;
>+            token = UNTERMINATED_OCTAL_NUMBER_ERRORTOK;
>+            goto returnError;
>+        }
>+
>         record8('0');
>         if (strictMode && isASCIIDigit(m_current)) {
>             m_lexErrorMessage = "Decimal integer literals with a leading zero are forbidden in strict mode"_s;
>@@ -2240,7 +2350,11 @@ start:
>                     token = INTEGER;
>                     if (m_current == '.') {
>                         shift();
>-                        parseNumberAfterDecimalPoint();
>+                        if (UNLIKELY(isASCIIDigit(m_current) && !parseNumberAfterDecimalPoint())) {
>+                            m_lexErrorMessage = "Non-number found after decimal point"_s;
>+                            token = INVALID_NUMERIC_LITERAL_ERRORTOK;
>+                            goto returnError;
>+                        }
>                         token = DOUBLE;
>                     }
>                     if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
>diff --git a/Source/JavaScriptCore/parser/Lexer.h b/Source/JavaScriptCore/parser/Lexer.h
>index 3755437e93d2d7fcee2ef8e325e1ffe1d37f3ad9..cf3780bbc46be564ef89b30a632530051fd846c5 100644
>--- a/Source/JavaScriptCore/parser/Lexer.h
>+++ b/Source/JavaScriptCore/parser/Lexer.h
>@@ -179,11 +179,11 @@ private:
>     ALWAYS_INLINE StringParseResult parseTemplateLiteral(JSTokenData*, RawStringsBuildMode);
>     
>     using NumberParseResult = Variant<double, const Identifier*>;
>-    ALWAYS_INLINE NumberParseResult parseHex();
>+    ALWAYS_INLINE Optional<NumberParseResult> parseHex();
>     ALWAYS_INLINE Optional<NumberParseResult> parseBinary();
>     ALWAYS_INLINE Optional<NumberParseResult> parseOctal();
>     ALWAYS_INLINE Optional<NumberParseResult> parseDecimal();
>-    ALWAYS_INLINE void parseNumberAfterDecimalPoint();
>+    ALWAYS_INLINE bool parseNumberAfterDecimalPoint();
>     ALWAYS_INLINE bool parseNumberAfterExponentIndicator();
>     ALWAYS_INLINE bool parseMultilineComment();
> 
>diff --git a/JSTests/ChangeLog b/JSTests/ChangeLog
>index 0daf3b1294cafcfd0e516766b2879c85a122e0d5..b1e93546d6f422e57f65800729146a63e7374e6e 100644
>--- a/JSTests/ChangeLog
>+++ b/JSTests/ChangeLog
>@@ -1,3 +1,16 @@
>+2019-05-18  Ross Kirsling  <ross.kirsling@sony.com>
>+
>+        [ESNext] Implement support for Numeric Separators
>+        https://bugs.webkit.org/show_bug.cgi?id=196351
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * stress/numeric-literal-separators.js: Added.
>+        Add tests for feature.
>+
>+        * test262/expectations.yaml:
>+        Mark 60 test cases as passing.
>+
> 2019-05-17  Justin Michaud  <justin_michaud@apple.com>
> 
>         [WASM-References] Add support for Anyref in parameters and return types, Ref.null and Ref.is_null for Anyref values.
>diff --git a/JSTests/stress/numeric-literal-separators.js b/JSTests/stress/numeric-literal-separators.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..69c492d2d0f9e561ba784fadcd528fb0eab173a3
>--- /dev/null
>+++ b/JSTests/stress/numeric-literal-separators.js
>@@ -0,0 +1,53 @@
>+function shouldNotThrow(script) {
>+  eval(script);
>+}
>+
>+function shouldThrow(script, errorType) {
>+    let error;
>+    try {
>+        eval(script);
>+    } catch (e) {
>+        error = e;
>+    }
>+
>+    if (!(error instanceof errorType))
>+        throw new Error(`Expected ${errorType.name}!`);
>+}
>+
>+shouldNotThrow('1_2_3');
>+shouldNotThrow('0x1_1_1');
>+shouldNotThrow('0b1_1_1');
>+shouldNotThrow('0o1_1_1');
>+
>+shouldNotThrow('.1_2_3');
>+shouldNotThrow('1_2_3.4_5_6');
>+shouldNotThrow('1_2_3.4_5_6e7_8_9');
>+shouldNotThrow('1_2_3.4_5_6e+7_8_9');
>+shouldNotThrow('1_2_3.4_5_6e-7_8_9');
>+shouldNotThrow('1_2_3e4_5_6');
>+shouldNotThrow('1_2_3e+4_5_6');
>+shouldNotThrow('1_2_3e-4_5_6');
>+shouldNotThrow('1_2_3.e4_5_6');
>+shouldNotThrow('1_2_3.e+4_5_6');
>+shouldNotThrow('1_2_3.e-4_5_6');
>+
>+shouldThrow('_1', ReferenceError);
>+shouldThrow('1_', SyntaxError);
>+shouldThrow('0x_1', SyntaxError);
>+shouldThrow('0x1_', SyntaxError);
>+shouldThrow('0b_1', SyntaxError);
>+shouldThrow('0b1_', SyntaxError);
>+shouldThrow('0o_1', SyntaxError);
>+shouldThrow('0o1_', SyntaxError);
>+shouldThrow('0_1', SyntaxError);
>+
>+shouldThrow('._1', SyntaxError);
>+shouldThrow('.1_', SyntaxError);
>+shouldThrow('1_.2', SyntaxError);
>+shouldThrow('1_e2', SyntaxError);
>+shouldThrow('1e_2', SyntaxError);
>+shouldThrow('1e2_', SyntaxError);
>+shouldThrow('1e+_2', SyntaxError);
>+shouldThrow('1e+2_', SyntaxError);
>+shouldThrow('1e-_2', SyntaxError);
>+shouldThrow('1e-2_', SyntaxError);
>diff --git a/JSTests/test262/expectations.yaml b/JSTests/test262/expectations.yaml
>index e37273d811d29aa62b9a0d77c6605c638d66192d..9cbe35d3128956cbc98e38be585bb427ee201af8 100644
>--- a/JSTests/test262/expectations.yaml
>+++ b/JSTests/test262/expectations.yaml
>@@ -2586,96 +2586,6 @@ test/language/global-code/script-decl-func-err-non-extensible.js:
> test/language/global-code/script-decl-var-err.js:
>   default: 'Test262Error: Expected a TypeError to be thrown but no exception was thrown at all'
>   strict mode: 'Test262Error: Expected a TypeError to be thrown but no exception was thrown at all'
>-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'
> test/language/literals/regexp/named-groups/invalid-dangling-groupname-2-u.js:
>   default: 'Test262: This statement should not be evaluated.'
>   strict mode: 'Test262: This statement should not be evaluated.'

Actions: View | Formatted Diff | Diff

Attachments on bug 196351: 370218 | 370383 | 370426