Changeset 247819 in webkit for trunk/Source/JavaScriptCore/parser/ParserTokens.h

Timestamp:

Jul 25, 2019, 12:50:46 AM (6 years ago)

Author:

Ross Kirsling

Message:

[ESNext] Implement nullish coalescing
​https://bugs.webkit.org/show_bug.cgi?id=200072

Reviewed by Darin Adler.

JSTests:

• stress/nullish-coalescing.js: Added.

Source/JavaScriptCore:

Implement the nullish coalescing proposal, which has now reached Stage 3 at TC39.

This introduces a ?? operator which:

acts like

but checks for nullishness instead of truthiness

has a precedence lower than

(or any other binary operator)

must be disambiguated with parentheses when combined with

or &&

• bytecompiler/NodesCodegen.cpp:

(JSC::CoalesceNode::emitBytecode): Added.
Bytecode must use OpIsUndefinedOrNull and not OpNeqNull because of document.all.

• parser/ASTBuilder.h:

(JSC::ASTBuilder::makeBinaryNode):

• parser/Lexer.cpp:

(JSC::Lexer<T>::lexWithoutClearingLineTerminator):

• parser/NodeConstructors.h:

(JSC::CoalesceNode::CoalesceNode): Added.

• parser/Nodes.h:

Introduce new token and AST node.

• parser/Parser.cpp:

(JSC::Parser<LexerType>::parseBinaryExpression):
Implement early error.

• parser/ParserTokens.h:

Since this patch needs to shift the value of every binary operator token anyway,
let's only bother to increment their LSBs when we actually have a precedence conflict.

• parser/ResultType.h:

(JSC::ResultType::definitelyIsNull const): Added.
(JSC::ResultType::mightBeUndefinedOrNull const): Added.
(JSC::ResultType::forCoalesce): Added.
We can do better than forLogicalOp here; let's be as accurate as possible.

• runtime/Options.h:

Add runtime feature flag.

Tools:

• Scripts/run-jsc-stress-tests:

File:

• trunk/Source/JavaScriptCore/parser/ParserTokens.h (modified) (1 diff)

trunk/Source/JavaScriptCore/parser/ParserTokens.h

@@ -149 +149 @@
     VOIDTOKEN = 7 | UnaryOpTokenFlag | KeywordTokenFlag,
     DELETETOKEN = 8 | UnaryOpTokenFlag | KeywordTokenFlag,
-    OR = 0 | BINARY_OP_PRECEDENCE(1),
-    AND = 1 | BINARY_OP_PRECEDENCE(2),
-    BITOR = 2 | BINARY_OP_PRECEDENCE(3),
-    BITXOR = 3 | BINARY_OP_PRECEDENCE(4),
-    BITAND = 4 | BINARY_OP_PRECEDENCE(5),
-    EQEQ = 5 | BINARY_OP_PRECEDENCE(6),
-    NE = 6 | BINARY_OP_PRECEDENCE(6),
-    STREQ = 7 | BINARY_OP_PRECEDENCE(6),
-    STRNEQ = 8 | BINARY_OP_PRECEDENCE(6),
-    LT = 9 | BINARY_OP_PRECEDENCE(7),
-    GT = 10 | BINARY_OP_PRECEDENCE(7),
-    LE = 11 | BINARY_OP_PRECEDENCE(7),
-    GE = 12 | BINARY_OP_PRECEDENCE(7),
-    INSTANCEOF = 13 | BINARY_OP_PRECEDENCE(7) | KeywordTokenFlag,
-    INTOKEN = 14 | IN_OP_PRECEDENCE(7) | KeywordTokenFlag,
-    LSHIFT = 15 | BINARY_OP_PRECEDENCE(8),
-    RSHIFT = 16 | BINARY_OP_PRECEDENCE(8),
-    URSHIFT = 17 | BINARY_OP_PRECEDENCE(8),
-    PLUS = 18 | BINARY_OP_PRECEDENCE(9) | UnaryOpTokenFlag,
-    MINUS = 19 | BINARY_OP_PRECEDENCE(9) | UnaryOpTokenFlag,
-    TIMES = 20 | BINARY_OP_PRECEDENCE(10),
-    DIVIDE = 21 | BINARY_OP_PRECEDENCE(10),
-    MOD = 22 | BINARY_OP_PRECEDENCE(10),
-    POW = 23 | BINARY_OP_PRECEDENCE(11) | RightAssociativeBinaryOpTokenFlag, // Make sure that POW has the highest operator precedence.
+    COALESCE = 0 | BINARY_OP_PRECEDENCE(1),
+    OR = 0 | BINARY_OP_PRECEDENCE(2),
+    AND = 0 | BINARY_OP_PRECEDENCE(3),
+    BITOR = 0 | BINARY_OP_PRECEDENCE(4),
+    BITXOR = 0 | BINARY_OP_PRECEDENCE(5),
+    BITAND = 0 | BINARY_OP_PRECEDENCE(6),
+    EQEQ = 0 | BINARY_OP_PRECEDENCE(7),
+    NE = 1 | BINARY_OP_PRECEDENCE(7),
+    STREQ = 2 | BINARY_OP_PRECEDENCE(7),
+    STRNEQ = 3 | BINARY_OP_PRECEDENCE(7),
+    LT = 0 | BINARY_OP_PRECEDENCE(8),
+    GT = 1 | BINARY_OP_PRECEDENCE(8),
+    LE = 2 | BINARY_OP_PRECEDENCE(8),
+    GE = 3 | BINARY_OP_PRECEDENCE(8),
+    INSTANCEOF = 4 | BINARY_OP_PRECEDENCE(8) | KeywordTokenFlag,
+    INTOKEN = 5 | IN_OP_PRECEDENCE(8) | KeywordTokenFlag,
+    LSHIFT = 0 | BINARY_OP_PRECEDENCE(9),
+    RSHIFT = 1 | BINARY_OP_PRECEDENCE(9),
+    URSHIFT = 2 | BINARY_OP_PRECEDENCE(9),
+    PLUS = 0 | BINARY_OP_PRECEDENCE(10) | UnaryOpTokenFlag,
+    MINUS = 1 | BINARY_OP_PRECEDENCE(10) | UnaryOpTokenFlag,
+    TIMES = 0 | BINARY_OP_PRECEDENCE(11),
+    DIVIDE = 1 | BINARY_OP_PRECEDENCE(11),
+    MOD = 2 | BINARY_OP_PRECEDENCE(11),
+    POW = 0 | BINARY_OP_PRECEDENCE(12) | RightAssociativeBinaryOpTokenFlag, // Make sure that POW has the highest operator precedence.
     ERRORTOK = 0 | ErrorTokenFlag,
     UNTERMINATED_IDENTIFIER_ESCAPE_ERRORTOK = 0 | ErrorTokenFlag | UnterminatedErrorTokenFlag,