Diff
Modified: trunk/LayoutTests/ChangeLog (186245 => 186246)
--- trunk/LayoutTests/ChangeLog 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/ChangeLog 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,3 +1,37 @@
+2015-07-02 Saam barati <saambara...@gmail.com>
+
+ Rename "Deconstruction" to "Destructuring" throughout JSC
+ https://bugs.webkit.org/show_bug.cgi?id=146100
+
+ Reviewed by Mark Lam.
+
+ * js/deconstructing-parameters-should-be-locals-expected.txt: Removed.
+ * js/deconstructing-parameters-should-be-locals.html: Removed.
+ * js/destructuring-assignment-expected.txt:
+ * js/destructuring-parameters-should-be-locals-expected.txt: Copied from LayoutTests/js/deconstructing-parameters-should-be-locals-expected.txt.
+ * js/destructuring-parameters-should-be-locals.html: Copied from LayoutTests/js/deconstructing-parameters-should-be-locals.html.
+ * js/regress/deconstructing-parameters-overridden-by-function-expected.txt: Removed.
+ * js/regress/deconstructing-parameters-overridden-by-function.html: Removed.
+ * js/regress/destructuring-parameters-overridden-by-function-expected.txt: Copied from LayoutTests/js/regress/deconstructing-parameters-overridden-by-function-expected.txt.
+ * js/regress/destructuring-parameters-overridden-by-function.html: Copied from LayoutTests/js/regress/deconstructing-parameters-overridden-by-function.html.
+ * js/regress/script-tests/deconstructing-parameters-overridden-by-function.js: Removed.
+ * js/regress/script-tests/destructuring-parameters-overridden-by-function.js: Copied from LayoutTests/js/regress/script-tests/deconstructing-parameters-overridden-by-function.js.
+ * js/script-tests/deconstructing-parameters-should-be-locals.js: Removed.
+ * js/script-tests/destructuring-assignment.js:
+ (testDestructuredArgs):
+ (testDestructuredArgLength):
+ (testDeconstructArgs): Deleted.
+ (testDeconstructArgLength): Deleted.
+ * js/script-tests/destructuring-parameters-should-be-locals.js: Copied from LayoutTests/js/script-tests/deconstructing-parameters-should-be-locals.js.
+ (description.value.string_appeared_here.readDestructuredParameter):
+ (overwriteDestructuredParameter):
+ (readCapturedDestructuredParameter):
+ (overwriteCapturedDestructuredParameter):
+ (description.value.string_appeared_here.readDeconstructedParameter): Deleted.
+ (overwriteDeconstructedParameter): Deleted.
+ (readCapturedDeconstructedParameter): Deleted.
+ (overwriteCapturedDeconstructedParameter): Deleted.
+
2015-07-02 Brady Eidson <beid...@apple.com>
Add preference to disable all http-equiv.
Deleted: trunk/LayoutTests/js/deconstructing-parameters-should-be-locals-expected.txt (186245 => 186246)
--- trunk/LayoutTests/js/deconstructing-parameters-should-be-locals-expected.txt 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/deconstructing-parameters-should-be-locals-expected.txt 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,14 +0,0 @@
-This tests to ensure that ddeconstructing parameters behave like regular locals
-
-On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
-
-
-PASS readDeconstructedParameter(['inner']) is 'inner'
-PASS overwriteDeconstructedParameter(['unused']); value; is 'outer'
-PASS readCapturedDeconstructedParameter(['inner']) is 'inner'
-PASS overwriteCapturedDeconstructedParameter(['unused']); is 'innermost'
-PASS value is 'outer'
-PASS successfullyParsed is true
-
-TEST COMPLETE
-
Deleted: trunk/LayoutTests/js/deconstructing-parameters-should-be-locals.html (186245 => 186246)
--- trunk/LayoutTests/js/deconstructing-parameters-should-be-locals.html 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/deconstructing-parameters-should-be-locals.html 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,10 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
-<head>
-<script src=""
-</head>
-<body>
-<script src=""
-<script src=""
-</body>
-</html>
Modified: trunk/LayoutTests/js/destructuring-assignment-expected.txt (186245 => 186246)
--- trunk/LayoutTests/js/destructuring-assignment-expected.txt 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/destructuring-assignment-expected.txt 2015-07-02 23:53:10 UTC (rev 186246)
@@ -78,9 +78,9 @@
PASS ({'a':a,'b':b}=anObject); var r=a+b; r is '12'
PASS a+b is '1122'
PASS a+b is '2211'
-PASS testDeconstructArgs('1', '2') is '12'
-PASS testDeconstructArgLength('1', '2') is 2
-PASS testDeconstructArgs('2') is '2undefined'
+PASS testDestructuredArgs('1', '2') is '12'
+PASS testDestructuredArgLength('1', '2') is 2
+PASS testDestructuredArgs('2') is '2undefined'
PASS a is 1
PASS b is 2
PASS c is 3
Added: trunk/LayoutTests/js/destructuring-parameters-should-be-locals-expected.txt (0 => 186246)
--- trunk/LayoutTests/js/destructuring-parameters-should-be-locals-expected.txt (rev 0)
+++ trunk/LayoutTests/js/destructuring-parameters-should-be-locals-expected.txt 2015-07-02 23:53:10 UTC (rev 186246)
@@ -0,0 +1,14 @@
+This tests to ensure that destructuring parameters behave like regular locals
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS readDestructuredParameter(['inner']) is 'inner'
+PASS overwriteDestructuredParameter(['unused']); value; is 'outer'
+PASS readCapturedDestructuredParameter(['inner']) is 'inner'
+PASS overwriteCapturedDestructuredParameter(['unused']); is 'innermost'
+PASS value is 'outer'
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
Copied: trunk/LayoutTests/js/destructuring-parameters-should-be-locals.html (from rev 186245, trunk/LayoutTests/js/deconstructing-parameters-should-be-locals.html) (0 => 186246)
--- trunk/LayoutTests/js/destructuring-parameters-should-be-locals.html (rev 0)
+++ trunk/LayoutTests/js/destructuring-parameters-should-be-locals.html 2015-07-02 23:53:10 UTC (rev 186246)
@@ -0,0 +1,10 @@
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+<head>
+<script src=""
+</head>
+<body>
+<script src=""
+<script src=""
+</body>
+</html>
Deleted: trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function-expected.txt (186245 => 186246)
--- trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function-expected.txt 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function-expected.txt 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,10 +0,0 @@
-JSRegress/deconstructing-parameters-overridden-by-function
-
-On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
-
-
-PASS no exception thrown
-PASS successfullyParsed is true
-
-TEST COMPLETE
-
Deleted: trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function.html (186245 => 186246)
--- trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function.html 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function.html 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,12 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
-<head>
-<script src=""
-</head>
-<body>
-<script src=""
-<script src=""
-<script src=""
-<script src=""
-</body>
-</html>
Copied: trunk/LayoutTests/js/regress/destructuring-parameters-overridden-by-function-expected.txt (from rev 186245, trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function-expected.txt) (0 => 186246)
--- trunk/LayoutTests/js/regress/destructuring-parameters-overridden-by-function-expected.txt (rev 0)
+++ trunk/LayoutTests/js/regress/destructuring-parameters-overridden-by-function-expected.txt 2015-07-02 23:53:10 UTC (rev 186246)
@@ -0,0 +1,10 @@
+JSRegress/destructuring-parameters-overridden-by-function
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS no exception thrown
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
Copied: trunk/LayoutTests/js/regress/destructuring-parameters-overridden-by-function.html (from rev 186245, trunk/LayoutTests/js/regress/deconstructing-parameters-overridden-by-function.html) (0 => 186246)
--- trunk/LayoutTests/js/regress/destructuring-parameters-overridden-by-function.html (rev 0)
+++ trunk/LayoutTests/js/regress/destructuring-parameters-overridden-by-function.html 2015-07-02 23:53:10 UTC (rev 186246)
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+<head>
+<script src=""
+</head>
+<body>
+<script src=""
+<script src=""
+<script src=""
+<script src=""
+</body>
+</html>
Deleted: trunk/LayoutTests/js/regress/script-tests/deconstructing-parameters-overridden-by-function.js (186245 => 186246)
--- trunk/LayoutTests/js/regress/script-tests/deconstructing-parameters-overridden-by-function.js 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/regress/script-tests/deconstructing-parameters-overridden-by-function.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,11 +0,0 @@
-function f() { return 40; }
-function test({arg}) {
- function arg() { return 41; }
- return arg;
-}
-noInline(test);
-
-for (var i = 0; i < 1000; i++) {
- if (test({arg: f})() !== 41)
- throw new Error("bad value");
-}
Copied: trunk/LayoutTests/js/regress/script-tests/destructuring-parameters-overridden-by-function.js (from rev 186245, trunk/LayoutTests/js/regress/script-tests/deconstructing-parameters-overridden-by-function.js) (0 => 186246)
--- trunk/LayoutTests/js/regress/script-tests/destructuring-parameters-overridden-by-function.js (rev 0)
+++ trunk/LayoutTests/js/regress/script-tests/destructuring-parameters-overridden-by-function.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -0,0 +1,11 @@
+function f() { return 40; }
+function test({arg}) {
+ function arg() { return 41; }
+ return arg;
+}
+noInline(test);
+
+for (var i = 0; i < 1000; i++) {
+ if (test({arg: f})() !== 41)
+ throw new Error("bad value");
+}
Deleted: trunk/LayoutTests/js/script-tests/deconstructing-parameters-should-be-locals.js (186245 => 186246)
--- trunk/LayoutTests/js/script-tests/deconstructing-parameters-should-be-locals.js 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/script-tests/deconstructing-parameters-should-be-locals.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,35 +0,0 @@
-description("This tests to ensure that ddeconstructing parameters behave like regular locals")
-
-var value="outer"
-function readDeconstructedParameter([value]) {
- return value;
-}
-
-function overwriteDeconstructedParameter([value]) {
- value = "inner"
-}
-
-function readCapturedDeconstructedParameter([value]) {
- return (function () {
- return value;
- })()
-}
-
-function overwriteCapturedDeconstructedParameter([value]) {
- (function () {
- value = "innermost";
- })()
- return value
-}
-
-shouldBe("readDeconstructedParameter(['inner'])", "'inner'")
-overwriteDeconstructedParameter(['inner'])
-
-shouldBe("overwriteDeconstructedParameter(['unused']); value;", "'outer'")
-
-shouldBe("readCapturedDeconstructedParameter(['inner'])", "'inner'")
-overwriteDeconstructedParameter(['inner'])
-
-shouldBe("overwriteCapturedDeconstructedParameter(['unused']);", "'innermost'")
-shouldBe("value", "'outer'")
-
Modified: trunk/LayoutTests/js/script-tests/destructuring-assignment.js (186245 => 186246)
--- trunk/LayoutTests/js/script-tests/destructuring-assignment.js 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/LayoutTests/js/script-tests/destructuring-assignment.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -35,20 +35,20 @@
shouldBe("a+b", "'1122'")
var [b,a] = [a,b];
shouldBe("a+b", "'2211'")
-function testDeconstructArgs() {
+function testDestructuredArgs() {
var [a,b] = arguments;
return a+b;
}
-function testDeconstructArgLength() {
+function testDestructuredArgLength() {
var {length} = arguments;
return length;
}
-shouldBe("testDeconstructArgs('1', '2')", "'12'");
-shouldBe("testDeconstructArgLength('1', '2')", "2");
+shouldBe("testDestructuredArgs('1', '2')", "'12'");
+shouldBe("testDestructuredArgLength('1', '2')", "2");
var text = '3';
Object.prototype.__defineGetter__(1, function(){ var r = text; text = "fail"; return r; })
-shouldBe("testDeconstructArgs('2')", "'2undefined'");
+shouldBe("testDestructuredArgs('2')", "'2undefined'");
var [a,b] = [1,2], [c,d] = [3,4]
Added: trunk/LayoutTests/js/script-tests/destructuring-parameters-should-be-locals.js (0 => 186246)
--- trunk/LayoutTests/js/script-tests/destructuring-parameters-should-be-locals.js (rev 0)
+++ trunk/LayoutTests/js/script-tests/destructuring-parameters-should-be-locals.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -0,0 +1,35 @@
+description("This tests to ensure that destructuring parameters behave like regular locals")
+
+var value="outer"
+function readDestructuredParameter([value]) {
+ return value;
+}
+
+function overwriteDestructuredParameter([value]) {
+ value = "inner"
+}
+
+function readCapturedDestructuredParameter([value]) {
+ return (function () {
+ return value;
+ })()
+}
+
+function overwriteCapturedDestructuredParameter([value]) {
+ (function () {
+ value = "innermost";
+ })()
+ return value
+}
+
+shouldBe("readDestructuredParameter(['inner'])", "'inner'")
+overwriteDestructuredParameter(['inner'])
+
+shouldBe("overwriteDestructuredParameter(['unused']); value;", "'outer'")
+
+shouldBe("readCapturedDestructuredParameter(['inner'])", "'inner'")
+overwriteDestructuredParameter(['inner'])
+
+shouldBe("overwriteCapturedDestructuredParameter(['unused']);", "'innermost'")
+shouldBe("value", "'outer'")
+
Modified: trunk/Source/_javascript_Core/ChangeLog (186245 => 186246)
--- trunk/Source/_javascript_Core/ChangeLog 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/ChangeLog 2015-07-02 23:53:10 UTC (rev 186246)
@@ -1,3 +1,115 @@
+2015-07-02 Saam barati <saambara...@gmail.com>
+
+ Rename "Deconstruction" to "Destructuring" throughout JSC
+ https://bugs.webkit.org/show_bug.cgi?id=146100
+
+ Reviewed by Mark Lam.
+
+ It is good to use the same naming conventions as the ES6
+ spec because it is the de facto way of speaking about these
+ language features. This also has the benefit of improving JSC's
+ hackability because it improves code readability for newcomers
+ to JSC or newcomers to this part of the code base.
+
+ * bytecompiler/BytecodeGenerator.cpp:
+ (JSC::BytecodeGenerator::generate):
+ (JSC::BytecodeGenerator::BytecodeGenerator):
+ (JSC::BytecodeGenerator::initializeNextParameter):
+ (JSC::BytecodeGenerator::visibleNameForParameter):
+ * bytecompiler/BytecodeGenerator.h:
+ (JSC::BytecodeGenerator::registerFor):
+ * bytecompiler/NodesCodegen.cpp:
+ (JSC::ForInNode::tryGetBoundLocal):
+ (JSC::ForInNode::emitLoopHeader):
+ (JSC::ForOfNode::emitBytecode):
+ (JSC::ClassExprNode::emitBytecode):
+ (JSC::DestructuringAssignmentNode::emitBytecode):
+ (JSC::DestructuringPatternNode::~DestructuringPatternNode):
+ (JSC::ArrayPatternNode::collectBoundIdentifiers):
+ (JSC::DeconstructingAssignmentNode::emitBytecode): Deleted.
+ (JSC::DeconstructionPatternNode::~DeconstructionPatternNode): Deleted.
+ * parser/ASTBuilder.h:
+ (JSC::ASTBuilder::createElementList):
+ (JSC::ASTBuilder::createFormalParameterList):
+ (JSC::ASTBuilder::createClause):
+ (JSC::ASTBuilder::createClauseList):
+ (JSC::ASTBuilder::createForInLoop):
+ (JSC::ASTBuilder::createForOfLoop):
+ (JSC::ASTBuilder::isBindingNode):
+ (JSC::ASTBuilder::isResolve):
+ (JSC::ASTBuilder::createDestructuringAssignment):
+ (JSC::ASTBuilder::createArrayPattern):
+ (JSC::ASTBuilder::appendArrayPatternSkipEntry):
+ (JSC::ASTBuilder::appendArrayPatternEntry):
+ (JSC::ASTBuilder::appendArrayPatternRestEntry):
+ (JSC::ASTBuilder::createObjectPattern):
+ (JSC::ASTBuilder::appendObjectPatternEntry):
+ (JSC::ASTBuilder::createDeconstructingAssignment): Deleted.
+ * parser/NodeConstructors.h:
+ (JSC::TryNode::TryNode):
+ (JSC::ParameterNode::ParameterNode):
+ (JSC::ForOfNode::ForOfNode):
+ (JSC::DestructuringPatternNode::DestructuringPatternNode):
+ (JSC::ArrayPatternNode::ArrayPatternNode):
+ (JSC::ArrayPatternNode::create):
+ (JSC::ObjectPatternNode::ObjectPatternNode):
+ (JSC::BindingNode::create):
+ (JSC::BindingNode::BindingNode):
+ (JSC::DestructuringAssignmentNode::DestructuringAssignmentNode):
+ (JSC::DeconstructionPatternNode::DeconstructionPatternNode): Deleted.
+ (JSC::DeconstructingAssignmentNode::DeconstructingAssignmentNode): Deleted.
+ * parser/Nodes.cpp:
+ (JSC::FunctionParameters::create):
+ * parser/Nodes.h:
+ (JSC::ExpressionNode::isResolveNode):
+ (JSC::ExpressionNode::isBracketAccessorNode):
+ (JSC::ExpressionNode::isDotAccessorNode):
+ (JSC::ExpressionNode::isDestructuringNode):
+ (JSC::ExpressionNode::isFuncExprNode):
+ (JSC::ExpressionNode::isCommaNode):
+ (JSC::ExpressionNode::isSimpleArray):
+ (JSC::ParameterNode::pattern):
+ (JSC::ParameterNode::nextParam):
+ (JSC::FunctionParameters::size):
+ (JSC::FunctionParameters::at):
+ (JSC::FunctionParameters::patterns):
+ (JSC::DestructuringPatternNode::isBindingNode):
+ (JSC::DestructuringPatternNode::emitDirectBinding):
+ (JSC::ArrayPatternNode::appendIndex):
+ (JSC::ObjectPatternNode::appendEntry):
+ (JSC::BindingNode::boundProperty):
+ (JSC::DestructuringAssignmentNode::bindings):
+ (JSC::ExpressionNode::isDeconstructionNode): Deleted.
+ (JSC::DeconstructionPatternNode::isBindingNode): Deleted.
+ (JSC::DeconstructionPatternNode::emitDirectBinding): Deleted.
+ (JSC::DeconstructingAssignmentNode::bindings): Deleted.
+ * parser/Parser.cpp:
+ (JSC::Parser<LexerType>::parseVarDeclaration):
+ (JSC::Parser<LexerType>::parseWhileStatement):
+ (JSC::Parser<LexerType>::parseVarDeclarationList):
+ (JSC::Parser<LexerType>::createBindingPattern):
+ (JSC::Parser<LexerType>::tryParseDestructuringPatternExpression):
+ (JSC::Parser<LexerType>::parseDestructuringPattern):
+ (JSC::Parser<LexerType>::parseDefaultValueForDestructuringPattern):
+ (JSC::Parser<LexerType>::parseForStatement):
+ (JSC::Parser<LexerType>::parseFormalParameters):
+ (JSC::Parser<LexerType>::parseFunctionParameters):
+ (JSC::Parser<LexerType>::parseAssignmentExpression):
+ (JSC::Parser<LexerType>::tryParseDeconstructionPatternExpression): Deleted.
+ (JSC::Parser<LexerType>::parseDeconstructionPattern): Deleted.
+ (JSC::Parser<LexerType>::parseDefaultValueForDeconstructionPattern): Deleted.
+ * parser/Parser.h:
+ (JSC::isEvalNode):
+ * parser/SyntaxChecker.h:
+ (JSC::SyntaxChecker::createPropertyList):
+ (JSC::SyntaxChecker::createElementList):
+ (JSC::SyntaxChecker::createFormalParameterList):
+ (JSC::SyntaxChecker::createClause):
+ (JSC::SyntaxChecker::createClauseList):
+ (JSC::SyntaxChecker::operatorStackPop):
+ * tests/stress/reserved-word-with-escape.js:
+ * tests/stress/rest-elements.js:
+
2015-07-02 Mark Lam <mark....@apple.com>
Build fix for Win EWS bot.
Modified: trunk/Source/_javascript_Core/bytecompiler/BytecodeGenerator.cpp (186245 => 186246)
--- trunk/Source/_javascript_Core/bytecompiler/BytecodeGenerator.cpp 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/bytecompiler/BytecodeGenerator.cpp 2015-07-02 23:53:10 UTC (rev 186246)
@@ -71,8 +71,8 @@
if (m_needToInitializeArguments)
initializeVariable(variable(propertyNames().arguments), m_argumentsRegister);
- for (size_t i = 0; i < m_deconstructedParameters.size(); i++) {
- auto& entry = m_deconstructedParameters[i];
+ for (size_t i = 0; i < m_destructuringParameters.size(); i++) {
+ auto& entry = m_destructuringParameters[i];
entry.second->bindValue(*this, entry.first.get());
}
@@ -257,14 +257,14 @@
}
// Make sure the code block knows about all of our parameters, and make sure that parameters
- // needing deconstruction are noted.
+ // needing destructuring are noted.
m_parameters.grow(parameters.size() + 1); // reserve space for "this"
m_thisRegister.setIndex(initializeNextParameter()->index()); // this
for (unsigned i = 0; i < parameters.size(); ++i) {
auto pattern = parameters.at(i);
RegisterID* reg = initializeNextParameter();
if (!pattern->isBindingNode())
- m_deconstructedParameters.append(std::make_pair(reg, pattern));
+ m_destructuringParameters.append(std::make_pair(reg, pattern));
}
// Figure out some interesting facts about our arguments.
@@ -419,7 +419,7 @@
// But some arguments are already initialized by default, since if they aren't captured and we
// don't have "arguments" then we just point the symbol table at the stack slot of those
// arguments. We end up initializing the rest of the arguments that have an uncomplicated
- // binding (i.e. don't involve deconstruction) above when figuring out how to lay them out,
+ // binding (i.e. don't involve destructuring) above when figuring out how to lay them out,
// because that's just the simplest thing. This means that when we initialize them, we have to
// watch out for the things that override arguments (namely, functions).
//
@@ -455,10 +455,10 @@
// This is our final act of weirdness. "arguments" is overridden by everything except the
// callee. We add it to the symbol table if it's not already there and it's not an argument.
if (needsArguments) {
- // If "arguments" is overridden by a function or deconstructed parameter name, then it's
+ // If "arguments" is overridden by a function or destructuring parameter name, then it's
// OK for us to call createVariable() because it won't change anything. It's also OK for
// us to them tell BytecodeGenerator::generate() to write to it because it will do so
- // before it initializes functions and deconstructed parameters. But if "arguments" is
+ // before it initializes functions and destructuring parameters. But if "arguments" is
// overridden by a "simple" function parameter, then we have to bail: createVariable()
// would assert and BytecodeGenerator::generate() would write the "arguments" after the
// argument value had already been properly initialized.
@@ -545,7 +545,7 @@
return ¶meter;
}
-UniquedStringImpl* BytecodeGenerator::visibleNameForParameter(DeconstructionPatternNode* pattern)
+UniquedStringImpl* BytecodeGenerator::visibleNameForParameter(DestructuringPatternNode* pattern)
{
if (pattern->isBindingNode()) {
const Identifier& ident = static_cast<const BindingNode*>(pattern)->boundProperty();
Modified: trunk/Source/_javascript_Core/bytecompiler/BytecodeGenerator.h (186245 => 186246)
--- trunk/Source/_javascript_Core/bytecompiler/BytecodeGenerator.h 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/bytecompiler/BytecodeGenerator.h 2015-07-02 23:53:10 UTC (rev 186246)
@@ -653,7 +653,7 @@
// Initializes the stack form the parameter; does nothing for the symbol table.
RegisterID* initializeNextParameter();
- UniquedStringImpl* visibleNameForParameter(DeconstructionPatternNode*);
+ UniquedStringImpl* visibleNameForParameter(DestructuringPatternNode*);
RegisterID& registerFor(VirtualRegister reg)
{
@@ -756,7 +756,7 @@
Vector<SwitchInfo> m_switchContextStack;
Vector<std::unique_ptr<ForInContext>> m_forInContextStack;
Vector<TryContext> m_tryContextStack;
- Vector<std::pair<RefPtr<RegisterID>, const DeconstructionPatternNode*>> m_deconstructedParameters;
+ Vector<std::pair<RefPtr<RegisterID>, const DestructuringPatternNode*>> m_destructuringParameters;
enum FunctionVariableType : uint8_t { NormalFunctionVariable, GlobalFunctionVariable };
Vector<std::pair<FunctionBodyNode*, FunctionVariableType>> m_functionsToInitialize;
bool m_needToInitializeArguments { false };
Modified: trunk/Source/_javascript_Core/bytecompiler/NodesCodegen.cpp (186245 => 186246)
--- trunk/Source/_javascript_Core/bytecompiler/NodesCodegen.cpp 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/bytecompiler/NodesCodegen.cpp 2015-07-02 23:53:10 UTC (rev 186246)
@@ -2256,8 +2256,8 @@
return generator.variable(ident).local();
}
- if (m_lexpr->isDeconstructionNode()) {
- DeconstructingAssignmentNode* assignNode = static_cast<DeconstructingAssignmentNode*>(m_lexpr);
+ if (m_lexpr->isDestructuringNode()) {
+ DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr);
auto binding = assignNode->bindings();
if (!binding->isBindingNode())
return nullptr;
@@ -2318,8 +2318,8 @@
return;
}
- if (m_lexpr->isDeconstructionNode()) {
- DeconstructingAssignmentNode* assignNode = static_cast<DeconstructingAssignmentNode*>(m_lexpr);
+ if (m_lexpr->isDestructuringNode()) {
+ DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr);
auto binding = assignNode->bindings();
if (!binding->isBindingNode()) {
assignNode->bindings()->bindValue(generator, propertyName);
@@ -2536,8 +2536,8 @@
generator.emitTypeProfilerExpressionInfo(assignNode->divotStart(), assignNode->divotEnd());
}
} else {
- ASSERT(m_lexpr->isDeconstructionNode());
- DeconstructingAssignmentNode* assignNode = static_cast<DeconstructingAssignmentNode*>(m_lexpr);
+ ASSERT(m_lexpr->isDestructuringNode());
+ DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr);
assignNode->bindings()->bindValue(generator, value);
}
generator.emitProfileControlFlow(m_statement->startOffset());
@@ -3105,8 +3105,8 @@
}
#endif
-// ------------------------------ DeconstructingAssignmentNode -----------------
-RegisterID* DeconstructingAssignmentNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+// ------------------------------ DestructuringAssignmentNode -----------------
+RegisterID* DestructuringAssignmentNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
if (RegisterID* result = m_bindings->emitDirectBinding(generator, dst, m_initializer))
return result;
@@ -3116,7 +3116,7 @@
return generator.moveToDestinationIfNeeded(dst, initializer.get());
}
-DeconstructionPatternNode::~DeconstructionPatternNode()
+DestructuringPatternNode::~DestructuringPatternNode()
{
}
@@ -3277,7 +3277,7 @@
void ArrayPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
{
for (size_t i = 0; i < m_targetPatterns.size(); i++) {
- if (DeconstructionPatternNode* node = m_targetPatterns[i].pattern.get())
+ if (DestructuringPatternNode* node = m_targetPatterns[i].pattern.get())
node->collectBoundIdentifiers(identifiers);
}
}
Modified: trunk/Source/_javascript_Core/parser/ASTBuilder.h (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/ASTBuilder.h 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/ASTBuilder.h 2015-07-02 23:53:10 UTC (rev 186246)
@@ -119,7 +119,7 @@
typedef CaseClauseNode* Clause;
typedef ConstDeclNode* ConstDeclList;
typedef std::pair<ExpressionNode*, BinaryOpInfo> BinaryOperand;
- typedef RefPtr<DeconstructionPatternNode> DeconstructionPattern;
+ typedef RefPtr<DestructuringPatternNode> DestructuringPattern;
typedef RefPtr<ArrayPatternNode> ArrayPattern;
typedef RefPtr<ObjectPatternNode> ObjectPattern;
typedef RefPtr<BindingNode> BindingPattern;
@@ -420,8 +420,8 @@
ElementNode* createElementList(int elisions, ExpressionNode* expr) { return new (m_parserArena) ElementNode(elisions, expr); }
ElementNode* createElementList(ElementNode* elems, int elisions, ExpressionNode* expr) { return new (m_parserArena) ElementNode(elems, elisions, expr); }
- ParameterNode* createFormalParameterList(DeconstructionPattern pattern) { return new (m_parserArena) ParameterNode(pattern); }
- ParameterNode* createFormalParameterList(ParameterNode* list, DeconstructionPattern pattern) { return new (m_parserArena) ParameterNode(list, pattern); }
+ ParameterNode* createFormalParameterList(DestructuringPattern pattern) { return new (m_parserArena) ParameterNode(pattern); }
+ ParameterNode* createFormalParameterList(ParameterNode* list, DestructuringPattern pattern) { return new (m_parserArena) ParameterNode(list, pattern); }
CaseClauseNode* createClause(ExpressionNode* expr, JSC::SourceElements* statements) { return new (m_parserArena) CaseClauseNode(expr, statements); }
ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_parserArena) ClauseListNode(clause); }
@@ -486,9 +486,9 @@
return result;
}
- StatementNode* createForInLoop(const JSTokenLocation& location, PassRefPtr<DeconstructionPatternNode> pattern, ExpressionNode* iter, StatementNode* statements, const JSTextPosition& eStart, const JSTextPosition& eDivot, const JSTextPosition& eEnd, int start, int end)
+ StatementNode* createForInLoop(const JSTokenLocation& location, PassRefPtr<DestructuringPatternNode> pattern, ExpressionNode* iter, StatementNode* statements, const JSTextPosition& eStart, const JSTextPosition& eDivot, const JSTextPosition& eEnd, int start, int end)
{
- auto lexpr = new (m_parserArena) DeconstructingAssignmentNode(location, pattern.get(), 0);
+ auto lexpr = new (m_parserArena) DestructuringAssignmentNode(location, pattern.get(), 0);
return createForInLoop(location, lexpr, iter, statements, eStart, eDivot, eEnd, start, end);
}
@@ -500,13 +500,13 @@
return result;
}
- StatementNode* createForOfLoop(const JSTokenLocation& location, PassRefPtr<DeconstructionPatternNode> pattern, ExpressionNode* iter, StatementNode* statements, const JSTextPosition& eStart, const JSTextPosition& eDivot, const JSTextPosition& eEnd, int start, int end)
+ StatementNode* createForOfLoop(const JSTokenLocation& location, PassRefPtr<DestructuringPatternNode> pattern, ExpressionNode* iter, StatementNode* statements, const JSTextPosition& eStart, const JSTextPosition& eDivot, const JSTextPosition& eEnd, int start, int end)
{
- auto lexpr = new (m_parserArena) DeconstructingAssignmentNode(location, pattern.get(), 0);
+ auto lexpr = new (m_parserArena) DestructuringAssignmentNode(location, pattern.get(), 0);
return createForOfLoop(location, lexpr, iter, statements, eStart, eDivot, eEnd, start, end);
}
- bool isBindingNode(const DeconstructionPattern& pattern)
+ bool isBindingNode(const DestructuringPattern& pattern)
{
return pattern->isBindingNode();
}
@@ -738,9 +738,9 @@
bool isResolve(ExpressionNode* expr) const { return expr->isResolveNode(); }
- ExpressionNode* createDeconstructingAssignment(const JSTokenLocation& location, PassRefPtr<DeconstructionPatternNode> pattern, ExpressionNode* initializer)
+ ExpressionNode* createDestructuringAssignment(const JSTokenLocation& location, PassRefPtr<DestructuringPatternNode> pattern, ExpressionNode* initializer)
{
- return new (m_parserArena) DeconstructingAssignmentNode(location, pattern.get(), initializer);
+ return new (m_parserArena) DestructuringAssignmentNode(location, pattern.get(), initializer);
}
ArrayPattern createArrayPattern(const JSTokenLocation&)
@@ -753,12 +753,12 @@
node->appendIndex(ArrayPatternNode::BindingType::Elision, location, 0, nullptr);
}
- void appendArrayPatternEntry(ArrayPattern node, const JSTokenLocation& location, DeconstructionPattern pattern, ExpressionNode* defaultValue)
+ void appendArrayPatternEntry(ArrayPattern node, const JSTokenLocation& location, DestructuringPattern pattern, ExpressionNode* defaultValue)
{
node->appendIndex(ArrayPatternNode::BindingType::Element, location, pattern.get(), defaultValue);
}
- void appendArrayPatternRestEntry(ArrayPattern node, const JSTokenLocation& location, DeconstructionPattern pattern)
+ void appendArrayPatternRestEntry(ArrayPattern node, const JSTokenLocation& location, DestructuringPattern pattern)
{
node->appendIndex(ArrayPatternNode::BindingType::RestElement, location, pattern.get(), nullptr);
}
@@ -773,7 +773,7 @@
return ObjectPatternNode::create();
}
- void appendObjectPatternEntry(ObjectPattern node, const JSTokenLocation& location, bool wasString, const Identifier& identifier, DeconstructionPattern pattern, ExpressionNode* defaultValue)
+ void appendObjectPatternEntry(ObjectPattern node, const JSTokenLocation& location, bool wasString, const Identifier& identifier, DestructuringPattern pattern, ExpressionNode* defaultValue)
{
node->appendEntry(location, identifier, wasString, pattern.get(), defaultValue);
}
Modified: trunk/Source/_javascript_Core/parser/NodeConstructors.h (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/NodeConstructors.h 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/NodeConstructors.h 2015-07-02 23:53:10 UTC (rev 186246)
@@ -820,20 +820,20 @@
{
}
- inline ParameterNode::ParameterNode(PassRefPtr<DeconstructionPatternNode> pattern)
+ inline ParameterNode::ParameterNode(PassRefPtr<DestructuringPatternNode> pattern)
: m_pattern(pattern)
, m_next(0)
{
ASSERT(m_pattern);
}
- inline ParameterNode::ParameterNode(ParameterNode* l, PassRefPtr<DeconstructionPatternNode> pattern)
+ inline ParameterNode::ParameterNode(ParameterNode* previous, PassRefPtr<DestructuringPatternNode> pattern)
: m_pattern(pattern)
, m_next(0)
{
- l->m_next = this;
+ previous->m_next = this;
ASSERT(m_pattern);
- ASSERT(l->m_pattern);
+ ASSERT(previous->m_pattern);
}
inline FuncExprNode::FuncExprNode(const JSTokenLocation& location, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
@@ -934,12 +934,12 @@
{
}
- inline DeconstructionPatternNode::DeconstructionPatternNode()
+ inline DestructuringPatternNode::DestructuringPatternNode()
{
}
inline ArrayPatternNode::ArrayPatternNode()
- : DeconstructionPatternNode()
+ : DestructuringPatternNode()
{
}
@@ -949,7 +949,7 @@
}
inline ObjectPatternNode::ObjectPatternNode()
- : DeconstructionPatternNode()
+ : DestructuringPatternNode()
{
}
@@ -964,14 +964,14 @@
}
inline BindingNode::BindingNode(const Identifier& boundProperty, const JSTextPosition& start, const JSTextPosition& end)
- : DeconstructionPatternNode()
+ : DestructuringPatternNode()
, m_divotStart(start)
, m_divotEnd(end)
, m_boundProperty(boundProperty)
{
}
- inline DeconstructingAssignmentNode::DeconstructingAssignmentNode(const JSTokenLocation& location, PassRefPtr<DeconstructionPatternNode> bindings, ExpressionNode* initializer)
+ inline DestructuringAssignmentNode::DestructuringAssignmentNode(const JSTokenLocation& location, PassRefPtr<DestructuringPatternNode> bindings, ExpressionNode* initializer)
: ExpressionNode(location)
, m_bindings(bindings)
, m_initializer(initializer)
Modified: trunk/Source/_javascript_Core/parser/Nodes.cpp (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/Nodes.cpp 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/Nodes.cpp 2015-07-02 23:53:10 UTC (rev 186246)
@@ -145,7 +145,7 @@
for (ParameterNode* parameter = firstParameter; parameter; parameter = parameter->nextParam())
++parameterCount;
- size_t objectSize = sizeof(FunctionParameters) - sizeof(void*) + sizeof(DeconstructionPatternNode*) * parameterCount;
+ size_t objectSize = sizeof(FunctionParameters) - sizeof(void*) + sizeof(DestructuringPatternNode*) * parameterCount;
void* slot = fastMalloc(objectSize);
return adoptRef(*new (slot) FunctionParameters(firstParameter, parameterCount));
}
Modified: trunk/Source/_javascript_Core/parser/Nodes.h (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/Nodes.h 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/Nodes.h 2015-07-02 23:53:10 UTC (rev 186246)
@@ -156,7 +156,7 @@
virtual bool isResolveNode() const { return false; }
virtual bool isBracketAccessorNode() const { return false; }
virtual bool isDotAccessorNode() const { return false; }
- virtual bool isDeconstructionNode() const { return false; }
+ virtual bool isDestructuringNode() const { return false; }
virtual bool isFuncExprNode() const { return false; }
virtual bool isCommaNode() const { return false; }
virtual bool isSimpleArray() const { return false; }
@@ -1399,7 +1399,7 @@
StatementNode* m_statement;
};
- class DeconstructionPatternNode;
+ class DestructuringPatternNode;
class EnumerationNode : public StatementNode, public ThrowableExpressionData {
public:
@@ -1518,14 +1518,14 @@
class ParameterNode : public ParserArenaDeletable {
public:
- ParameterNode(PassRefPtr<DeconstructionPatternNode>);
- ParameterNode(ParameterNode*, PassRefPtr<DeconstructionPatternNode>);
+ ParameterNode(PassRefPtr<DestructuringPatternNode>);
+ ParameterNode(ParameterNode*, PassRefPtr<DestructuringPatternNode>);
- DeconstructionPatternNode* pattern() const { return m_pattern.get(); }
+ DestructuringPatternNode* pattern() const { return m_pattern.get(); }
ParameterNode* nextParam() const { return m_next; }
private:
- RefPtr<DeconstructionPatternNode> m_pattern;
+ RefPtr<DestructuringPatternNode> m_pattern;
ParameterNode* m_next;
};
@@ -1638,15 +1638,15 @@
~FunctionParameters();
unsigned size() const { return m_size; }
- DeconstructionPatternNode* at(unsigned index) { ASSERT(index < m_size); return patterns()[index]; }
+ DestructuringPatternNode* at(unsigned index) { ASSERT(index < m_size); return patterns()[index]; }
private:
FunctionParameters(ParameterNode*, unsigned size);
- DeconstructionPatternNode** patterns() { return &m_storage; }
+ DestructuringPatternNode** patterns() { return &m_storage; }
unsigned m_size;
- DeconstructionPatternNode* m_storage;
+ DestructuringPatternNode* m_storage;
};
class FunctionBodyNode final : public StatementNode, public ParserArenaDeletable {
@@ -1762,8 +1762,8 @@
};
#endif
- class DeconstructionPatternNode : public RefCounted<DeconstructionPatternNode> {
- WTF_MAKE_NONCOPYABLE(DeconstructionPatternNode);
+ class DestructuringPatternNode : public RefCounted<DestructuringPatternNode> {
+ WTF_MAKE_NONCOPYABLE(DestructuringPatternNode);
WTF_MAKE_FAST_ALLOCATED;
public:
@@ -1774,13 +1774,13 @@
virtual bool isBindingNode() const { return false; }
virtual RegisterID* emitDirectBinding(BytecodeGenerator&, RegisterID*, ExpressionNode*) { return 0; }
- virtual ~DeconstructionPatternNode() = 0;
+ virtual ~DestructuringPatternNode() = 0;
protected:
- DeconstructionPatternNode();
+ DestructuringPatternNode();
};
- class ArrayPatternNode : public DeconstructionPatternNode, public ThrowableExpressionData {
+ class ArrayPatternNode : public DestructuringPatternNode, public ThrowableExpressionData {
public:
enum class BindingType {
Elision,
@@ -1789,7 +1789,7 @@
};
static Ref<ArrayPatternNode> create();
- void appendIndex(BindingType bindingType, const JSTokenLocation&, DeconstructionPatternNode* node, ExpressionNode* defaultValue)
+ void appendIndex(BindingType bindingType, const JSTokenLocation&, DestructuringPatternNode* node, ExpressionNode* defaultValue)
{
m_targetPatterns.append({ bindingType, node, defaultValue });
}
@@ -1797,7 +1797,7 @@
private:
struct Entry {
BindingType bindingType;
- RefPtr<DeconstructionPatternNode> pattern;
+ RefPtr<DestructuringPatternNode> pattern;
ExpressionNode* defaultValue;
};
ArrayPatternNode();
@@ -1809,10 +1809,10 @@
Vector<Entry> m_targetPatterns;
};
- class ObjectPatternNode : public DeconstructionPatternNode {
+ class ObjectPatternNode : public DestructuringPatternNode {
public:
static Ref<ObjectPatternNode> create();
- void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DeconstructionPatternNode* pattern, ExpressionNode* defaultValue)
+ void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DestructuringPatternNode* pattern, ExpressionNode* defaultValue)
{
m_targetPatterns.append(Entry{ identifier, wasString, pattern, defaultValue });
}
@@ -1825,13 +1825,13 @@
struct Entry {
Identifier propertyName;
bool wasString;
- RefPtr<DeconstructionPatternNode> pattern;
+ RefPtr<DestructuringPatternNode> pattern;
ExpressionNode* defaultValue;
};
Vector<Entry> m_targetPatterns;
};
- class BindingNode : public DeconstructionPatternNode {
+ class BindingNode : public DestructuringPatternNode {
public:
static Ref<BindingNode> create(const Identifier& boundProperty, const JSTextPosition& start, const JSTextPosition& end);
const Identifier& boundProperty() const { return m_boundProperty; }
@@ -1853,19 +1853,19 @@
Identifier m_boundProperty;
};
- class DeconstructingAssignmentNode : public ExpressionNode, public ParserArenaDeletable {
+ class DestructuringAssignmentNode : public ExpressionNode, public ParserArenaDeletable {
public:
- DeconstructingAssignmentNode(const JSTokenLocation&, PassRefPtr<DeconstructionPatternNode>, ExpressionNode*);
- DeconstructionPatternNode* bindings() { return m_bindings.get(); }
+ DestructuringAssignmentNode(const JSTokenLocation&, PassRefPtr<DestructuringPatternNode>, ExpressionNode*);
+ DestructuringPatternNode* bindings() { return m_bindings.get(); }
using ParserArenaDeletable::operator new;
private:
virtual bool isAssignmentLocation() const override { return true; }
- virtual bool isDeconstructionNode() const override { return true; }
+ virtual bool isDestructuringNode() const override { return true; }
virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
- RefPtr<DeconstructionPatternNode> m_bindings;
+ RefPtr<DestructuringPatternNode> m_bindings;
ExpressionNode* m_initializer;
};
Modified: trunk/Source/_javascript_Core/parser/Parser.cpp (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/Parser.cpp 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/Parser.cpp 2015-07-02 23:53:10 UTC (rev 186246)
@@ -411,7 +411,7 @@
int start = tokenLine();
int end = 0;
int scratch;
- TreeDeconstructionPattern scratch1 = 0;
+ TreeDestructuringPattern scratch1 = 0;
TreeExpression scratch2 = 0;
JSTextPosition scratch3;
TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3, VarDeclarationContext);
@@ -483,7 +483,7 @@
}
template <typename LexerType>
-template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext declarationListContext)
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext declarationListContext)
{
TreeExpression head = 0;
TreeExpression tail = 0;
@@ -522,15 +522,15 @@
node = context.createEmptyVarExpression(varStartLocation, *name);
} else {
lastIdent = 0;
- auto pattern = parseDeconstructionPattern(context, DeconstructToVariables);
- failIfFalse(pattern, "Cannot parse this deconstruction pattern");
+ auto pattern = parseDestructuringPattern(context, DestructureToVariables);
+ failIfFalse(pattern, "Cannot parse this destructuring pattern");
hasInitializer = match(EQUAL);
failIfTrue(declarationListContext == VarDeclarationContext && !hasInitializer, "Expected an initializer in destructuring variable declaration");
lastPattern = pattern;
if (hasInitializer) {
next(TreeBuilder::DontBuildStrings); // consume '='
TreeExpression rhs = parseAssignmentExpression(context);
- node = context.createDeconstructingAssignment(location, pattern, rhs);
+ node = context.createDestructuringAssignment(location, pattern, rhs);
lastInitializer = rhs;
}
}
@@ -544,50 +544,50 @@
tail = context.appendToCommaExpr(location, head, tail, node);
} while (match(COMMA));
if (lastIdent)
- lastPattern = createBindingPattern(context, DeconstructToVariables, *lastIdent, 0, lastIdentToken);
+ lastPattern = createBindingPattern(context, DestructureToVariables, *lastIdent, 0, lastIdentToken);
return head;
}
template <typename LexerType>
-template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DeconstructionKind kind, const Identifier& name, int depth, JSToken token)
+template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DestructuringKind kind, const Identifier& name, int depth, JSToken token)
{
ASSERT(!name.isNull());
ASSERT(name.impl()->isAtomic() || name.impl()->isSymbol());
if (depth) {
- if (kind == DeconstructToVariables)
- failIfFalseIfStrict(declareVariable(&name), "Cannot deconstruct to a variable named '", name.impl(), "' in strict mode");
- if (kind == DeconstructToParameters) {
+ if (kind == DestructureToVariables)
+ failIfFalseIfStrict(declareVariable(&name), "Cannot destructure to a variable named '", name.impl(), "' in strict mode");
+ if (kind == DestructureToParameters) {
auto bindingResult = declareBoundParameter(&name);
if (bindingResult == Scope::StrictBindingFailed && strictMode()) {
- semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");
+ semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot destructure to a parameter name '", name.impl(), "' in strict mode");
if (m_lastFunctionName && name == *m_lastFunctionName)
- semanticFail("Cannot deconstruct to '", name.impl(), "' as it shadows the name of a strict mode function");
+ semanticFail("Cannot destructure to '", name.impl(), "' as it shadows the name of a strict mode function");
semanticFailureDueToKeyword("bound parameter name");
if (hasDeclaredParameter(name))
- semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");
+ semanticFail("Cannot destructure to '", name.impl(), "' as it has already been declared");
semanticFail("Cannot bind to a parameter named '", name.impl(), "' in strict mode");
}
if (bindingResult == Scope::BindingFailed) {
semanticFailureDueToKeyword("bound parameter name");
if (hasDeclaredParameter(name))
- semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");
- semanticFail("Cannot deconstruct to a parameter named '", name.impl(), "'");
+ semanticFail("Cannot destructure to '", name.impl(), "' as it has already been declared");
+ semanticFail("Cannot destructure to a parameter named '", name.impl(), "'");
}
}
- if (kind != DeconstructToExpressions)
+ if (kind != DestructureToExpressions)
context.addVar(&name, DeclarationStacks::HasInitializer);
} else {
- if (kind == DeconstructToVariables) {
+ if (kind == DestructureToVariables) {
failIfFalseIfStrict(declareVariable(&name), "Cannot declare a variable named '", name.impl(), "' in strict mode");
context.addVar(&name, DeclarationStacks::HasInitializer);
}
- if (kind == DeconstructToParameters) {
+ if (kind == DestructureToParameters) {
bool declarationResult = declareParameter(&name);
if (!declarationResult && strictMode()) {
- semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");
+ semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot destructure to a parameter name '", name.impl(), "' in strict mode");
if (m_lastFunctionName && name == *m_lastFunctionName)
semanticFail("Cannot declare a parameter named '", name.impl(), "' as it shadows the name of a strict mode function");
semanticFailureDueToKeyword("parameter name");
@@ -637,17 +637,17 @@
#endif
template <typename LexerType>
-template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::tryParseDeconstructionPatternExpression(TreeBuilder& context)
+template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::tryParseDestructuringPatternExpression(TreeBuilder& context)
{
- return parseDeconstructionPattern(context, DeconstructToExpressions);
+ return parseDestructuringPattern(context, DestructureToExpressions);
}
template <typename LexerType>
-template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::parseDeconstructionPattern(TreeBuilder& context, DeconstructionKind kind, int depth)
+template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseDestructuringPattern(TreeBuilder& context, DestructuringKind kind, int depth)
{
failIfStackOverflow();
int nonLHSCount = m_nonLHSCount;
- TreeDeconstructionPattern pattern;
+ TreeDestructuringPattern pattern;
switch (m_token.m_type) {
case OPENBRACKET: {
JSTextPosition divotStart = tokenStartPosition();
@@ -669,12 +669,12 @@
if (UNLIKELY(match(DOTDOTDOT))) {
JSTokenLocation location = m_token.m_location;
next();
- auto innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
- if (kind == DeconstructToExpressions && !innerPattern)
+ auto innerPattern = parseDestructuringPattern(context, kind, depth + 1);
+ if (kind == DestructureToExpressions && !innerPattern)
return 0;
- failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
+ failIfFalse(innerPattern, "Cannot parse this destructuring pattern");
- failIfTrue(kind != DeconstructToExpressions && !context.isBindingNode(innerPattern), "Expected identifier for a rest element deconstruction pattern");
+ failIfTrue(kind != DestructureToExpressions && !context.isBindingNode(innerPattern), "Expected identifier for a rest element destructuring pattern");
context.appendArrayPatternRestEntry(arrayPattern, location, innerPattern);
restElementWasFound = true;
@@ -682,18 +682,18 @@
}
JSTokenLocation location = m_token.m_location;
- auto innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
- if (kind == DeconstructToExpressions && !innerPattern)
+ auto innerPattern = parseDestructuringPattern(context, kind, depth + 1);
+ if (kind == DestructureToExpressions && !innerPattern)
return 0;
- failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
- TreeExpression defaultValue = parseDefaultValueForDeconstructionPattern(context);
- failIfTrue(kind == DeconstructToParameters && defaultValue, "Default values in destructuring parameters are currently not supported");
+ failIfFalse(innerPattern, "Cannot parse this destructuring pattern");
+ TreeExpression defaultValue = parseDefaultValueForDestructuringPattern(context);
+ failIfTrue(kind == DestructureToParameters && defaultValue, "Default values in destructuring parameters are currently not supported");
context.appendArrayPatternEntry(arrayPattern, location, innerPattern, defaultValue);
} while (consume(COMMA));
- if (kind == DeconstructToExpressions && !match(CLOSEBRACKET))
+ if (kind == DestructureToExpressions && !match(CLOSEBRACKET))
return 0;
- consumeOrFail(CLOSEBRACKET, restElementWasFound ? "Expected a closing ']' following a rest element deconstruction pattern" : "Expected either a closing ']' or a ',' following an element deconstruction pattern");
+ consumeOrFail(CLOSEBRACKET, restElementWasFound ? "Expected a closing ']' following a rest element destructuring pattern" : "Expected either a closing ']' or a ',' following an element destructuring pattern");
context.finishArrayPattern(arrayPattern, divotStart, divotStart, lastTokenEndPosition());
pattern = arrayPattern;
break;
@@ -709,14 +709,14 @@
break;
Identifier propertyName;
- TreeDeconstructionPattern innerPattern = 0;
+ TreeDestructuringPattern innerPattern = 0;
JSTokenLocation location = m_token.m_location;
if (match(IDENT)) {
propertyName = *m_token.m_data.ident;
JSToken identifierToken = m_token;
next();
if (consume(COLON))
- innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
+ innerPattern = parseDestructuringPattern(context, kind, depth + 1);
else
innerPattern = createBindingPattern(context, kind, propertyName, depth, identifierToken);
} else {
@@ -732,7 +732,7 @@
break;
default:
if (m_token.m_type != RESERVED && m_token.m_type != RESERVED_IF_STRICT && !(m_token.m_type & KeywordTokenFlag)) {
- if (kind == DeconstructToExpressions)
+ if (kind == DestructureToExpressions)
return 0;
failWithMessage("Expected a property name");
}
@@ -741,34 +741,34 @@
}
next();
if (!consume(COLON)) {
- if (kind == DeconstructToExpressions)
+ if (kind == DestructureToExpressions)
return 0;
- semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "'");
- semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "' in strict mode");
- semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated deconstruction syntax for keyword '", propertyName.impl(), "'");
+ semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated destructuring syntax for reserved name '", propertyName.impl(), "'");
+ semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated destructuring syntax for reserved name '", propertyName.impl(), "' in strict mode");
+ semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated destructuring syntax for keyword '", propertyName.impl(), "'");
- failWithMessage("Expected a ':' prior to named property deconstruction");
+ failWithMessage("Expected a ':' prior to a named destructuring property");
}
- innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
+ innerPattern = parseDestructuringPattern(context, kind, depth + 1);
}
- if (kind == DeconstructToExpressions && !innerPattern)
+ if (kind == DestructureToExpressions && !innerPattern)
return 0;
- failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
- TreeExpression defaultValue = parseDefaultValueForDeconstructionPattern(context);
- failIfTrue(kind == DeconstructToParameters && defaultValue, "Default values in destructuring parameters are currently not supported");
+ failIfFalse(innerPattern, "Cannot parse this destructuring pattern");
+ TreeExpression defaultValue = parseDefaultValueForDestructuringPattern(context);
+ failIfTrue(kind == DestructureToParameters && defaultValue, "Default values in destructuring parameters are currently not supported");
context.appendObjectPatternEntry(objectPattern, location, wasString, propertyName, innerPattern, defaultValue);
} while (consume(COMMA));
- if (kind == DeconstructToExpressions && !match(CLOSEBRACE))
+ if (kind == DestructureToExpressions && !match(CLOSEBRACE))
return 0;
- consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property deconstruction pattern");
+ consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property destructuring pattern");
pattern = objectPattern;
break;
}
default: {
if (!match(IDENT)) {
- if (kind == DeconstructToExpressions)
+ if (kind == DestructureToExpressions)
return 0;
semanticFailureDueToKeyword("variable name");
failWithMessage("Expected a parameter pattern or a ')' in parameter list");
@@ -783,7 +783,7 @@
}
template <typename LexerType>
-template <class TreeBuilder> TreeExpression Parser<LexerType>::parseDefaultValueForDeconstructionPattern(TreeBuilder& context)
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseDefaultValueForDestructuringPattern(TreeBuilder& context)
{
if (!match(EQUAL))
return 0;
@@ -834,13 +834,13 @@
JSTextPosition declsStart;
JSTextPosition declsEnd;
TreeExpression decls = 0;
- TreeDeconstructionPattern pattern = 0;
+ TreeDestructuringPattern pattern = 0;
if (match(VAR)) {
/*
for (var IDENT in _expression_) statement
for (var varDeclarationList; expressionOpt; expressionOpt)
*/
- TreeDeconstructionPattern forInTarget = 0;
+ TreeDestructuringPattern forInTarget = 0;
TreeExpression forInInitializer = 0;
m_allowsIn = false;
JSTextPosition initStart;
@@ -890,7 +890,7 @@
if (match(OPENBRACE) || match(OPENBRACKET)) {
SavePoint savePoint = createSavePoint();
declsStart = tokenStartPosition();
- pattern = tryParseDeconstructionPatternExpression(context);
+ pattern = tryParseDestructuringPatternExpression(context);
declsEnd = lastTokenEndPosition();
if (pattern && (match(INTOKEN) || (match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of)))
goto enumerationLoop;
@@ -1349,12 +1349,12 @@
template <typename LexerType>
template <class TreeBuilder> TreeFormalParameterList Parser<LexerType>::parseFormalParameters(TreeBuilder& context)
{
- auto parameter = parseDeconstructionPattern(context, DeconstructToParameters);
+ auto parameter = parseDestructuringPattern(context, DestructureToParameters);
failIfFalse(parameter, "Cannot parse parameter pattern");
TreeFormalParameterList list = context.createFormalParameterList(parameter);
TreeFormalParameterList tail = list;
while (consume(COMMA)) {
- parameter = parseDeconstructionPattern(context, DeconstructToParameters);
+ parameter = parseDestructuringPattern(context, DestructureToParameters);
failIfFalse(parameter, "Cannot parse parameter pattern");
tail = context.createFormalParameterList(tail, parameter);
}
@@ -1429,7 +1429,7 @@
consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration");
} else {
- auto parameter = parseDeconstructionPattern(context, DeconstructToParameters);
+ auto parameter = parseDestructuringPattern(context, DestructureToParameters);
failIfFalse(parameter, "Cannot parse parameter pattern");
info.parameters = context.createFormalParameterList(parameter);
failIfFalse(info.parameters, "Cannot parse parameters for this ", stringForFunctionMode(mode));
@@ -1449,7 +1449,7 @@
consumeOrFail(CLOSEPAREN, "getter functions must have no parameters");
else if (mode == SetterMode) {
failIfTrue(match(CLOSEPAREN), "setter functions must have one parameter");
- auto parameter = parseDeconstructionPattern(context, DeconstructToParameters);
+ auto parameter = parseDestructuringPattern(context, DestructureToParameters);
failIfFalse(parameter, "setter functions must have one parameter");
info.parameters = context.createFormalParameterList(parameter);
failIfTrue(match(COMMA), "setter functions must have one parameter");
@@ -2074,11 +2074,11 @@
int initialNonLHSCount = m_nonLHSCount;
if (match(OPENBRACE) || match(OPENBRACKET)) {
SavePoint savePoint = createSavePoint();
- auto pattern = tryParseDeconstructionPatternExpression(context);
+ auto pattern = tryParseDestructuringPatternExpression(context);
if (pattern && consume(EQUAL)) {
auto rhs = parseAssignmentExpression(context);
if (rhs)
- return context.createDeconstructingAssignment(location, pattern, rhs);
+ return context.createDestructuringAssignment(location, pattern, rhs);
}
restoreSavePoint(savePoint);
}
Modified: trunk/Source/_javascript_Core/parser/Parser.h (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/Parser.h 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/Parser.h 2015-07-02 23:53:10 UTC (rev 186246)
@@ -75,7 +75,7 @@
#endif
#define TreeProperty typename TreeBuilder::Property
#define TreePropertyList typename TreeBuilder::PropertyList
-#define TreeDeconstructionPattern typename TreeBuilder::DeconstructionPattern
+#define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern
COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
@@ -95,10 +95,10 @@
ArrowFunctionMode
#endif
};
-enum DeconstructionKind {
- DeconstructToVariables,
- DeconstructToParameters,
- DeconstructToExpressions
+enum DestructuringKind {
+ DestructureToVariables,
+ DestructureToParameters,
+ DestructureToExpressions
};
template <typename T> inline bool isEvalNode() { return false; }
@@ -809,7 +809,7 @@
template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, FunctionParseType);
template <class TreeBuilder> ALWAYS_INLINE TreeFormalParameterList parseFormalParameters(TreeBuilder&);
enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
- template <class TreeBuilder> TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext);
+ template <class TreeBuilder> TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext);
template <class TreeBuilder> NEVER_INLINE TreeConstDeclList parseConstDeclarationList(TreeBuilder&);
#if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
@@ -817,10 +817,10 @@
template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
#endif
- template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern createBindingPattern(TreeBuilder&, DeconstructionKind, const Identifier&, int depth, JSToken);
- template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern parseDeconstructionPattern(TreeBuilder&, DeconstructionKind, int depth = 0);
- template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern tryParseDeconstructionPatternExpression(TreeBuilder&);
- template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDeconstructionPattern(TreeBuilder&);
+ template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, const Identifier&, int depth, JSToken);
+ template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseDestructuringPattern(TreeBuilder&, DestructuringKind, int depth = 0);
+ template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern tryParseDestructuringPatternExpression(TreeBuilder&);
+ template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDestructuringPattern(TreeBuilder&);
template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, FunctionParseMode, bool nameIsInContainingScope, ConstructorKind, SuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>&, FunctionParseType);
Modified: trunk/Source/_javascript_Core/parser/SyntaxChecker.h (186245 => 186246)
--- trunk/Source/_javascript_Core/parser/SyntaxChecker.h 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/parser/SyntaxChecker.h 2015-07-02 23:53:10 UTC (rev 186246)
@@ -76,12 +76,12 @@
FunctionExpr, ClassExpr, SuperExpr, BracketExpr, DotExpr, CallExpr,
NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr,
ConditionalExpr, AssignmentExpr, TypeofExpr,
- DeleteExpr, ArrayLiteralExpr, BindingDeconstruction,
- ArrayDeconstruction, ObjectDeconstruction, SourceElementsResult,
+ DeleteExpr, ArrayLiteralExpr, BindingDestructuring,
+ ArrayDestructuring, ObjectDestructuring, SourceElementsResult,
FunctionBodyResult, SpreadExpr, ArgumentsResult,
PropertyListResult, ArgumentsListResult, ElementsListResult,
StatementResult, FormalParameterListResult, ClauseResult,
- ClauseListResult, CommaExpr, DeconstructingAssignment,
+ ClauseListResult, CommaExpr, DestructuringAssignment,
TemplateStringResult, TemplateStringListResult,
TemplateExpressionListResult, TemplateExpr,
TaggedTemplateExpr
@@ -130,9 +130,9 @@
typedef int Clause;
typedef int ConstDeclList;
typedef int BinaryOperand;
- typedef int DeconstructionPattern;
- typedef DeconstructionPattern ArrayPattern;
- typedef DeconstructionPattern ObjectPattern;
+ typedef int DestructuringPattern;
+ typedef DestructuringPattern ArrayPattern;
+ typedef DestructuringPattern ObjectPattern;
static const bool CreatesAST = false;
static const bool NeedsFreeVariableInfo = false;
@@ -220,8 +220,8 @@
int createPropertyList(const JSTokenLocation&, Property, int) { return PropertyListResult; }
int createElementList(int, int) { return ElementsListResult; }
int createElementList(int, int, int) { return ElementsListResult; }
- int createFormalParameterList(DeconstructionPattern) { return FormalParameterListResult; }
- int createFormalParameterList(int, DeconstructionPattern) { return FormalParameterListResult; }
+ int createFormalParameterList(DestructuringPattern) { return FormalParameterListResult; }
+ int createFormalParameterList(int, DestructuringPattern) { return FormalParameterListResult; }
int createClause(int, int) { return ClauseResult; }
int createClauseList(int) { return ClauseListResult; }
int createClauseList(int, int) { return ClauseListResult; }
@@ -300,22 +300,22 @@
const Identifier* getName(const Property& property) const { return property.name; }
PropertyNode::Type getType(const Property& property) const { return property.type; }
bool isResolve(ExpressionType expr) const { return expr == ResolveExpr || expr == ResolveEvalExpr; }
- ExpressionType createDeconstructingAssignment(const JSTokenLocation&, int, ExpressionType)
+ ExpressionType createDestructuringAssignment(const JSTokenLocation&, int, ExpressionType)
{
- return DeconstructingAssignment;
+ return DestructuringAssignment;
}
ArrayPattern createArrayPattern(const JSTokenLocation&)
{
- return ArrayDeconstruction;
+ return ArrayDestructuring;
}
void appendArrayPatternSkipEntry(ArrayPattern, const JSTokenLocation&)
{
}
- void appendArrayPatternEntry(ArrayPattern, const JSTokenLocation&, DeconstructionPattern, int)
+ void appendArrayPatternEntry(ArrayPattern, const JSTokenLocation&, DestructuringPattern, int)
{
}
- void appendArrayPatternRestEntry(ArrayPattern, const JSTokenLocation&, DeconstructionPattern)
+ void appendArrayPatternRestEntry(ArrayPattern, const JSTokenLocation&, DestructuringPattern)
{
}
void finishArrayPattern(ArrayPattern, const JSTextPosition&, const JSTextPosition&, const JSTextPosition&)
@@ -323,19 +323,19 @@
}
ObjectPattern createObjectPattern(const JSTokenLocation&)
{
- return ObjectDeconstruction;
+ return ObjectDestructuring;
}
- void appendObjectPatternEntry(ArrayPattern, const JSTokenLocation&, bool, const Identifier&, DeconstructionPattern, int)
+ void appendObjectPatternEntry(ArrayPattern, const JSTokenLocation&, bool, const Identifier&, DestructuringPattern, int)
{
}
- DeconstructionPattern createBindingLocation(const JSTokenLocation&, const Identifier&, const JSTextPosition&, const JSTextPosition&)
+ DestructuringPattern createBindingLocation(const JSTokenLocation&, const Identifier&, const JSTextPosition&, const JSTextPosition&)
{
- return BindingDeconstruction;
+ return BindingDestructuring;
}
- bool isBindingNode(DeconstructionPattern pattern)
+ bool isBindingNode(DestructuringPattern pattern)
{
- return pattern == BindingDeconstruction;
+ return pattern == BindingDestructuring;
}
void setEndOffset(int, int) { }
Modified: trunk/Source/_javascript_Core/tests/stress/reserved-word-with-escape.js (186245 => 186246)
--- trunk/Source/_javascript_Core/tests/stress/reserved-word-with-escape.js 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/tests/stress/reserved-word-with-escape.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -32,9 +32,9 @@
testSyntaxError(String.raw`var v\u0061r = 2000000;`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
testSyntaxError(String.raw`var v\u{0061}r = 2000000`, String.raw`SyntaxError: Cannot use the keyword 'v\u{0061}r' as a variable name.`);
-testSyntaxError(String.raw`var {var} = obj)`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`var {v\u0061r} = obj`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`var {v\u{0061}r} = obj`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
+testSyntaxError(String.raw`var {var} = obj)`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`var {v\u0061r} = obj`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`var {v\u{0061}r} = obj`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
testSyntaxError(String.raw`var {var:var} = obj)`, String.raw`SyntaxError: Cannot use the keyword 'var' as a variable name.`);
testSyntaxError(String.raw`var {var:v\u0061r} = obj`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
@@ -56,9 +56,9 @@
testSyntaxError(String.raw`function a(v\u0061r) { }`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
testSyntaxError(String.raw`function a(v\u{0061}r) { }`, String.raw`SyntaxError: Cannot use the keyword 'v\u{0061}r' as a variable name.`);
-testSyntaxError(String.raw`function a({var}) { }`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`function a({v\u0061r}) { }`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`function a({v\u{0061}r}) { }`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
+testSyntaxError(String.raw`function a({var}) { }`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`function a({v\u0061r}) { }`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`function a({v\u{0061}r}) { }`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
testSyntaxError(String.raw`function a({var:var}) { }`, String.raw`SyntaxError: Cannot use the keyword 'var' as a variable name.`);
testSyntaxError(String.raw`function a({var:v\u0061r}) { }`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
@@ -76,9 +76,9 @@
testSyntaxError(String.raw`(function a(v\u0061r) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
testSyntaxError(String.raw`(function a(v\u{0061}r) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u{0061}r' as a variable name.`);
-testSyntaxError(String.raw`(function a({var}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a({v\u0061r}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a({v\u{0061}r}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({var}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({v\u0061r}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({v\u{0061}r}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
testSyntaxError(String.raw`(function a({var:var}) { })`, String.raw`SyntaxError: Cannot use the keyword 'var' as a variable name.`);
testSyntaxError(String.raw`(function a({var:v\u0061r}) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
@@ -88,9 +88,9 @@
testSyntaxError(String.raw`(function a([v\u0061r]) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
testSyntaxError(String.raw`(function a([v\u{0061}r]) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u{0061}r' as a variable name.`);
-testSyntaxError(String.raw`(function a([{var}]) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a([{v\u0061r}]) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a([{v\u{0061}r}]) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a([{var}]) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a([{v\u0061r}]) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a([{v\u{0061}r}]) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
testSyntaxError(String.raw`(function a([{var:var}]) { })`, String.raw`SyntaxError: Cannot use the keyword 'var' as a variable name.`);
testSyntaxError(String.raw`(function a([{var:v\u0061r}]) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
@@ -100,9 +100,9 @@
testSyntaxError(String.raw`(function a([[v\u0061r]]) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
testSyntaxError(String.raw`(function a([[v\u{0061}r]]) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u{0061}r' as a variable name.`);
-testSyntaxError(String.raw`(function a({ hello: {var}}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a({ hello: {v\u0061r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a({ hello: {v\u{0061}r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({ hello: {var}}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({ hello: {v\u0061r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({ hello: {v\u{0061}r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
testSyntaxError(String.raw`(function a({ hello: {var:var}}) { })`, String.raw`SyntaxError: Cannot use the keyword 'var' as a variable name.`);
testSyntaxError(String.raw`(function a({ hello: {var:v\u0061r}}) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
@@ -112,9 +112,9 @@
testSyntaxError(String.raw`(function a({ hello: [v\u0061r]}) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
testSyntaxError(String.raw`(function a({ hello: [v\u{0061}r]}) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u{0061}r' as a variable name.`);
-testSyntaxError(String.raw`(function a({ 0: {var} }) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a({ 0: {v\u0061r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
-testSyntaxError(String.raw`(function a({ 0: {v\u{0061}r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated deconstruction syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({ 0: {var} }) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({ 0: {v\u0061r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
+testSyntaxError(String.raw`(function a({ 0: {v\u{0061}r}}) { })`, String.raw`SyntaxError: Cannot use abbreviated destructuring syntax for keyword 'var'.`);
testSyntaxError(String.raw`(function a({ 0: {var:var}}) { })`, String.raw`SyntaxError: Cannot use the keyword 'var' as a variable name.`);
testSyntaxError(String.raw`(function a({ 0: {var:v\u0061r}}) { })`, String.raw`SyntaxError: Cannot use the keyword 'v\u0061r' as a variable name.`);
Modified: trunk/Source/_javascript_Core/tests/stress/rest-elements.js (186245 => 186246)
--- trunk/Source/_javascript_Core/tests/stress/rest-elements.js 2015-07-02 23:40:59 UTC (rev 186245)
+++ trunk/Source/_javascript_Core/tests/stress/rest-elements.js 2015-07-02 23:53:10 UTC (rev 186246)
@@ -95,19 +95,19 @@
shouldBe(JSON.stringify(c), String.raw`[]`);
}("C"));
-testSyntaxError(String.raw`var [a, ...b, c] = 20`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`var [a, ...b,] = 20`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`var [a, ...b,,] = 20`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`var [a, ...b = 20] = 20`, String.raw`SyntaxError: Unexpected token '='. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`var [a, ...[b, c]] = 20`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`var [a, ...{ b, c }] = 20`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element deconstruction pattern.`);
+testSyntaxError(String.raw`var [a, ...b, c] = 20`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`var [a, ...b,] = 20`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`var [a, ...b,,] = 20`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`var [a, ...b = 20] = 20`, String.raw`SyntaxError: Unexpected token '='. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`var [a, ...[b, c]] = 20`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element destructuring pattern.`);
+testSyntaxError(String.raw`var [a, ...{ b, c }] = 20`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element destructuring pattern.`);
-testSyntaxError(String.raw`(function ([a, ...b, c]) { })`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`(function ([a, ...b,]) { })`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`(function ([a, ...b,,]) { })`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`(function ([a, ...b = 20,,]) { })`, String.raw`SyntaxError: Unexpected token '='. Expected a closing ']' following a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`(function ([a, ...[b, c]]) { })`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element deconstruction pattern.`);
-testSyntaxError(String.raw`(function ([a, ...{ b, c }]) { })`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element deconstruction pattern.`);
+testSyntaxError(String.raw`(function ([a, ...b, c]) { })`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`(function ([a, ...b,]) { })`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`(function ([a, ...b,,]) { })`, String.raw`SyntaxError: Unexpected token ','. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`(function ([a, ...b = 20,,]) { })`, String.raw`SyntaxError: Unexpected token '='. Expected a closing ']' following a rest element destructuring pattern.`);
+testSyntaxError(String.raw`(function ([a, ...[b, c]]) { })`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element destructuring pattern.`);
+testSyntaxError(String.raw`(function ([a, ...{ b, c }]) { })`, String.raw`SyntaxError: Unexpected token ']'. Expected identifier for a rest element destructuring pattern.`);
shouldThrow(function () {
[a, ...b, c] = 20;
