Changeset 221622 in webkit for trunk/Source/JavaScriptCore/parser/Nodes.cpp

Timestamp:

Sep 5, 2017, 10:43:51 AM (8 years ago)

Author:

[email protected]

Message:

test262: Completion values for control flow do not match the spec
​https://bugs.webkit.org/show_bug.cgi?id=171265

Patch by Joseph Pecoraro <Joseph Pecoraro> on 2017-09-05
Reviewed by Saam Barati.

JSTests:

• stress/completion-value.js:

Condensed test for completion values in top level statements.

• stress/super-get-by-id.js:

ClassDeclaration when evaled no longer produce values. Convert
these to ClassExpressions so they produce the class value.

• ChakraCore/test/GlobalFunctions/evalreturns3.baseline-jsc:

This is a progression for currect spec behavior.

• mozilla/mozilla-tests.yaml:

This test is now outdated, so mark it as failing for that reason.

• test262.yaml:

Passing all "cptn" completion value tests.

Source/JavaScriptCore:

• bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::shouldBeConcernedWithCompletionValue):
When we care about having proper completion values (global code
in programs, modules, and eval) insert undefined results for
control flow statements.

• bytecompiler/NodesCodegen.cpp:

(JSC::SourceElements::emitBytecode):
Reduce writing a default undefined value to the completion result to
only once before the last statement we know will produce a value.

(JSC::IfElseNode::emitBytecode):
(JSC::WithNode::emitBytecode):
(JSC::WhileNode::emitBytecode):
(JSC::ForNode::emitBytecode):
(JSC::ForInNode::emitBytecode):
(JSC::ForOfNode::emitBytecode):
(JSC::SwitchNode::emitBytecode):
Insert an undefined to handle cases where code may break out of an
if/else or with statement (break/continue).

(JSC::TryNode::emitBytecode):
Same handling for break cases. Also, finally block statement completion
values are always ignored for the try statement result.

(JSC::ClassDeclNode::emitBytecode):
Class declarations, like function declarations, produce an empty result.

• parser/Nodes.cpp:

(JSC::SourceElements::lastStatement):
(JSC::SourceElements::hasCompletionValue):
(JSC::SourceElements::hasEarlyBreakOrContinue):
(JSC::BlockNode::lastStatement):
(JSC::BlockNode::singleStatement):
(JSC::BlockNode::hasCompletionValue):
(JSC::BlockNode::hasEarlyBreakOrContinue):
(JSC::ScopeNode::singleStatement):
(JSC::ScopeNode::hasCompletionValue):
(JSC::ScopeNode::hasEarlyBreakOrContinue):
The only non-trivial cases need to loop through their list of statements
to determine if this has a completion value or not. Likewise for
determining if there is an early break / continue, meaning a break or
continue statement with no preceding statement that has a completion value.

• parser/Nodes.h:

(JSC::StatementNode::next):
(JSC::StatementNode::hasCompletionValue):
Helper to check if a statement nodes produces a completion value or not.

Tools:

• Scripts/run-jsc-stress-tests:

Include a :failDueToOutdatedOrBadTest to mark failures with justification.

LayoutTests:

• js/eval-throw-return-expected.txt:
• js/kde/completion-expected.txt:
• js/kde/script-tests/completion.js:
• js/script-tests/eval-throw-return.js:
• sputnik/Conformance/12_Statement/12.6_Iteration_Statements/12.6.3_The_for_Statement/S12.6.3_A9-expected.txt:
• sputnik/Conformance/12_Statement/12.6_Iteration_Statements/12.6.3_The_for_Statement/S12.6.3_A9.1-expected.txt:

Rebaseline expectations. These are all outdated. In fact the sputnik
tests were imported into test262 and modified for ES2015.

• js/script-tests/function-toString-vs-name.js:

ClassDeclarations on their own don't produce a value. So output
the class value so the test behaves as expected.

File:

• trunk/Source/JavaScriptCore/parser/Nodes.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/parser/Nodes.cpp

@@ -65 +65 @@
 {
     return m_head == m_tail ? m_head : nullptr;
+}
+
+StatementNode* SourceElements::lastStatement() const
+{
+    return m_tail;
+}
+
+bool SourceElements::hasCompletionValue() const
+{
+    for (StatementNode* statement = m_head; statement; statement = statement->next()) {
+        if (statement->hasCompletionValue())
+            return true;
+    }
+
+    return false;
+}
+
+bool SourceElements::hasEarlyBreakOrContinue() const
+{
+    for (StatementNode* statement = m_head; statement; statement = statement->next()) {
+        if (statement->isBreak() || statement->isContinue())
+            return true;
+        if (statement->hasCompletionValue())
+            return false;
+    }
+
+    return false;
+}
+
+// ------------------------------ BlockNode ------------------------------------
+
+StatementNode* BlockNode::lastStatement() const
+{
+    return m_statements ? m_statements->lastStatement() : nullptr;
+}
+
+StatementNode* BlockNode::singleStatement() const
+{
+    return m_statements ? m_statements->singleStatement() : nullptr;
+}
+
+bool BlockNode::hasCompletionValue() const
+{
+    return m_statements ? m_statements->hasCompletionValue() : false;
+}
+
+bool BlockNode::hasEarlyBreakOrContinue() const
+{
+    return m_statements ? m_statements->hasEarlyBreakOrContinue() : false;
 }
 
@@ -101 +150 @@
 StatementNode* ScopeNode::singleStatement() const
 {
-    return m_statements ? m_statements->singleStatement() : 0;
+    return m_statements ? m_statements->singleStatement() : nullptr;
+}
+
+bool ScopeNode::hasCompletionValue() const
+{
+    return m_statements ? m_statements->hasCompletionValue() : false;
+}
+
+bool ScopeNode::hasEarlyBreakOrContinue() const
+{
+    return m_statements ? m_statements->hasEarlyBreakOrContinue() : false;
 }