[ESnext] Implement Object Rest - Implementing Object Rest Destructuring
https://bugs.webkit.org/show_bug.cgi?id=167962
Patch by Caio Lima <ticaiolima@gmail.com> on 2017-03-09
Reviewed by Keith Miller.
JSTests:
* stress/object-rest-deconstruct.js: Added.
(let.assert):
(let.assertPropDescriptor):
(catch):
(get 3):
(foo):
(let.src.get y):
(let.src.set y):
(let.gen):
Source/JavaScriptCore:
Object Rest/Spread Destructing proposal is in stage 3[1] and this
Patch is a prototype implementation of it. A simple change over the
parser was necessary to support the new '...' token on Object Pattern
destruction rule. In the bytecode generator side, We changed the
bytecode generated on ObjectPatternNode::bindValue to store in an
array identifiers of already destructed properties, following spec draft
section[2], and then pass it as excludedNames to CopyDataProperties.
The rest destruction the calls copyDataProperties to perform the
copy of rest properties in rhs.
We also implemented CopyDataProperties as private JS global operation
on builtins/GlobalOperations.js following it's specification on [3].
It is implemented using Set object to verify if a property is on
excludedNames to keep this algorithm with O(n + m) complexity, where n
= number of source's own properties and m = excludedNames.length.
As a requirement to use JSSets as constants, a change in
CodeBlock::create API was necessary, because JSSet creation can throws OOM
exception. Now, CodeBlock::finishCreation returns ```false``` if an
execption is throwed by
CodeBlock::setConstantIdentifierSetRegisters and then we return
nullptr to ScriptExecutable::newCodeBlockFor. It is responsible to
check if CodeBlock was constructed properly and then, throw OOM
exception to the correct scope.
[1] - https://github.com/sebmarkbage/ecmascript-rest-spread
[2] - http://sebmarkbage.github.io/ecmascript-rest-spread/#Rest-RuntimeSemantics-PropertyDestructuringAssignmentEvaluation
[3] - http://sebmarkbage.github.io/ecmascript-rest-spread/#AbstractOperations-CopyDataProperties
* builtins/BuiltinNames.h:
* builtins/GlobalOperations.js:
(globalPrivate.copyDataProperties):
* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::finishCreation):
(JSC::CodeBlock::setConstantIdentifierSetRegisters):
* bytecode/CodeBlock.h:
* bytecode/EvalCodeBlock.h:
(JSC::EvalCodeBlock::create):
* bytecode/FunctionCodeBlock.h:
(JSC::FunctionCodeBlock::create):
* bytecode/ModuleProgramCodeBlock.h:
(JSC::ModuleProgramCodeBlock::create):
* bytecode/ProgramCodeBlock.h:
(JSC::ProgramCodeBlock::create):
* bytecode/UnlinkedCodeBlock.h:
(JSC::UnlinkedCodeBlock::addSetConstant):
(JSC::UnlinkedCodeBlock::constantIdentifierSets):
* bytecompiler/BytecodeGenerator.cpp:
(JSC::BytecodeGenerator::emitLoad):
* bytecompiler/BytecodeGenerator.h:
* bytecompiler/NodesCodegen.cpp:
(JSC::ObjectPatternNode::bindValue):
* parser/ASTBuilder.h:
(JSC::ASTBuilder::appendObjectPatternEntry):
(JSC::ASTBuilder::appendObjectPatternRestEntry):
(JSC::ASTBuilder::setContainsObjectRestElement):
* parser/Nodes.h:
(JSC::ObjectPatternNode::appendEntry):
(JSC::ObjectPatternNode::setContainsRestElement):
* parser/Parser.cpp:
(JSC::Parser<LexerType>::parseDestructuringPattern):
(JSC::Parser<LexerType>::parseProperty):
* parser/SyntaxChecker.h:
(JSC::SyntaxChecker::operatorStackPop):
* runtime/JSGlobalObject.cpp:
(JSC::JSGlobalObject::init):
* runtime/JSGlobalObjectFunctions.cpp:
(JSC::privateToObject):
* runtime/JSGlobalObjectFunctions.h:
* runtime/ScriptExecutable.cpp:
(JSC::ScriptExecutable::newCodeBlockFor):
Source/WTF:
* wtf/HashSet.h:
(WTF::=):
LayoutTests:
* js/parser-syntax-check-expected.txt:
* js/script-tests/parser-syntax-check.js:
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@213697 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
index 22cee68..0223655 100644
--- a/Source/JavaScriptCore/ChangeLog
+++ b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,82 @@
+2017-03-09 Caio Lima <ticaiolima@gmail.com>
+
+ [ESnext] Implement Object Rest - Implementing Object Rest Destructuring
+ https://bugs.webkit.org/show_bug.cgi?id=167962
+
+ Reviewed by Keith Miller.
+
+ Object Rest/Spread Destructing proposal is in stage 3[1] and this
+ Patch is a prototype implementation of it. A simple change over the
+ parser was necessary to support the new '...' token on Object Pattern
+ destruction rule. In the bytecode generator side, We changed the
+ bytecode generated on ObjectPatternNode::bindValue to store in an
+ array identifiers of already destructed properties, following spec draft
+ section[2], and then pass it as excludedNames to CopyDataProperties.
+ The rest destruction the calls copyDataProperties to perform the
+ copy of rest properties in rhs.
+
+ We also implemented CopyDataProperties as private JS global operation
+ on builtins/GlobalOperations.js following it's specification on [3].
+ It is implemented using Set object to verify if a property is on
+ excludedNames to keep this algorithm with O(n + m) complexity, where n
+ = number of source's own properties and m = excludedNames.length.
+
+ As a requirement to use JSSets as constants, a change in
+ CodeBlock::create API was necessary, because JSSet creation can throws OOM
+ exception. Now, CodeBlock::finishCreation returns ```false``` if an
+ execption is throwed by
+ CodeBlock::setConstantIdentifierSetRegisters and then we return
+ nullptr to ScriptExecutable::newCodeBlockFor. It is responsible to
+ check if CodeBlock was constructed properly and then, throw OOM
+ exception to the correct scope.
+
+ [1] - https://github.com/sebmarkbage/ecmascript-rest-spread
+ [2] - http://sebmarkbage.github.io/ecmascript-rest-spread/#Rest-RuntimeSemantics-PropertyDestructuringAssignmentEvaluation
+ [3] - http://sebmarkbage.github.io/ecmascript-rest-spread/#AbstractOperations-CopyDataProperties
+
+ * builtins/BuiltinNames.h:
+ * builtins/GlobalOperations.js:
+ (globalPrivate.copyDataProperties):
+ * bytecode/CodeBlock.cpp:
+ (JSC::CodeBlock::finishCreation):
+ (JSC::CodeBlock::setConstantIdentifierSetRegisters):
+ * bytecode/CodeBlock.h:
+ * bytecode/EvalCodeBlock.h:
+ (JSC::EvalCodeBlock::create):
+ * bytecode/FunctionCodeBlock.h:
+ (JSC::FunctionCodeBlock::create):
+ * bytecode/ModuleProgramCodeBlock.h:
+ (JSC::ModuleProgramCodeBlock::create):
+ * bytecode/ProgramCodeBlock.h:
+ (JSC::ProgramCodeBlock::create):
+ * bytecode/UnlinkedCodeBlock.h:
+ (JSC::UnlinkedCodeBlock::addSetConstant):
+ (JSC::UnlinkedCodeBlock::constantIdentifierSets):
+ * bytecompiler/BytecodeGenerator.cpp:
+ (JSC::BytecodeGenerator::emitLoad):
+ * bytecompiler/BytecodeGenerator.h:
+ * bytecompiler/NodesCodegen.cpp:
+ (JSC::ObjectPatternNode::bindValue):
+ * parser/ASTBuilder.h:
+ (JSC::ASTBuilder::appendObjectPatternEntry):
+ (JSC::ASTBuilder::appendObjectPatternRestEntry):
+ (JSC::ASTBuilder::setContainsObjectRestElement):
+ * parser/Nodes.h:
+ (JSC::ObjectPatternNode::appendEntry):
+ (JSC::ObjectPatternNode::setContainsRestElement):
+ * parser/Parser.cpp:
+ (JSC::Parser<LexerType>::parseDestructuringPattern):
+ (JSC::Parser<LexerType>::parseProperty):
+ * parser/SyntaxChecker.h:
+ (JSC::SyntaxChecker::operatorStackPop):
+ * runtime/JSGlobalObject.cpp:
+ (JSC::JSGlobalObject::init):
+ * runtime/JSGlobalObjectFunctions.cpp:
+ (JSC::privateToObject):
+ * runtime/JSGlobalObjectFunctions.h:
+ * runtime/ScriptExecutable.cpp:
+ (JSC::ScriptExecutable::newCodeBlockFor):
+
2017-03-09 Mark Lam <mark.lam@apple.com>
Implement a StackTrace utility object that can capture stack traces for debugging.
diff --git a/Source/JavaScriptCore/builtins/BuiltinNames.h b/Source/JavaScriptCore/builtins/BuiltinNames.h
index 03aa44c..df93e0f 100644
--- a/Source/JavaScriptCore/builtins/BuiltinNames.h
+++ b/Source/JavaScriptCore/builtins/BuiltinNames.h
@@ -158,6 +158,7 @@
macro(stringIncludesInternal) \
macro(stringSplitFast) \
macro(stringSubstrInternal) \
+ macro(toObject) \
macro(makeBoundFunction) \
macro(hasOwnLengthProperty) \
macro(importModule) \
diff --git a/Source/JavaScriptCore/builtins/GlobalOperations.js b/Source/JavaScriptCore/builtins/GlobalOperations.js
index 22220cf..2044068 100644
--- a/Source/JavaScriptCore/builtins/GlobalOperations.js
+++ b/Source/JavaScriptCore/builtins/GlobalOperations.js
@@ -79,3 +79,29 @@
return constructor;
@throwTypeError("|this|.constructor[Symbol.species] is not a constructor");
}
+
+@globalPrivate
+function copyDataProperties(target, source, excludedSet)
+{
+ if (!@isObject(target))
+ @throwTypeError("target needs to be an object");
+
+ if (source === @undefined || source === null)
+ return target;
+
+ let from = @toObject(source);
+ let keys = @Object.@getOwnPropertyNames(from);
+ let keysLength = keys.length;
+ for (let i = 0; i < keysLength; i++) {
+ let nextKey = keys[i];
+ if (!excludedSet.@has(nextKey)) {
+ let desc = @Object.@getOwnPropertyDescriptor(from, nextKey);
+ if (desc.enumerable && desc !== @undefined) {
+ let propValue = from[nextKey];
+ @Object.@defineProperty(target, nextKey, {value: propValue, enumerable: true, writable: true, configurable: true});
+ }
+ }
+ }
+
+ return target;
+}
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
index bb8cc38..5283399 100644
--- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp
+++ b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
@@ -58,6 +58,8 @@
#include "JSFunction.h"
#include "JSLexicalEnvironment.h"
#include "JSModuleEnvironment.h"
+#include "JSSet.h"
+#include "JSString.h"
#include "LLIntData.h"
#include "LLIntEntrypoint.h"
#include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"
@@ -393,7 +395,7 @@
setNumParameters(unlinkedCodeBlock->numParameters());
}
-void CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlinkedCodeBlock,
+bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlinkedCodeBlock,
JSScope* scope)
{
Base::finishCreation(vm);
@@ -402,6 +404,8 @@
vm.functionHasExecutedCache()->removeUnexecutedRange(ownerExecutable->sourceID(), ownerExecutable->typeProfilingStartOffset(), ownerExecutable->typeProfilingEndOffset());
setConstantRegisters(unlinkedCodeBlock->constantRegisters(), unlinkedCodeBlock->constantsSourceCodeRepresentation());
+ if (!setConstantIdentifierSetRegisters(vm, unlinkedCodeBlock->constantIdentifierSets()))
+ return false;
if (unlinkedCodeBlock->usesGlobalObject())
m_constantRegisters[unlinkedCodeBlock->globalObjectRegister().toConstantIndex()].set(*m_vm, this, m_globalObject.get());
@@ -822,6 +826,8 @@
heap()->m_codeBlocks->add(this);
heap()->reportExtraMemoryAllocated(m_instructions.size() * sizeof(Instruction));
+
+ return true;
}
CodeBlock::~CodeBlock()
@@ -857,6 +863,31 @@
#endif // ENABLE(JIT)
}
+bool CodeBlock::setConstantIdentifierSetRegisters(VM& vm, const Vector<ConstantIndentifierSetEntry>& constants)
+{
+ auto scope = DECLARE_THROW_SCOPE(vm);
+ JSGlobalObject* globalObject = m_globalObject.get();
+ ExecState* exec = globalObject->globalExec();
+
+ for (const auto& entry : constants) {
+ Structure* setStructure = globalObject->setStructure();
+ RETURN_IF_EXCEPTION(scope, false);
+ JSSet* jsSet = JSSet::create(exec, vm, setStructure);
+ RETURN_IF_EXCEPTION(scope, false);
+
+ const HashSet<UniquedStringImpl*>& set = entry.first;
+ for (auto setEntry : set) {
+ JSString* jsString = jsOwnedString(&vm, setEntry);
+ jsSet->add(exec, JSValue(jsString));
+ RETURN_IF_EXCEPTION(scope, false);
+ }
+ m_constantRegisters[entry.second].set(vm, this, JSValue(jsSet));
+ }
+
+ scope.release();
+ return true;
+}
+
void CodeBlock::setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation)
{
ASSERT(constants.size() == constantsSourceCodeRepresentation.size());
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.h b/Source/JavaScriptCore/bytecode/CodeBlock.h
index 75aefbf..566c489 100644
--- a/Source/JavaScriptCore/bytecode/CodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/CodeBlock.h
@@ -121,7 +121,7 @@
CodeBlock(VM*, Structure*, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*, RefPtr<SourceProvider>&&, unsigned sourceOffset, unsigned firstLineColumnOffset);
void finishCreation(VM&, CopyParsedBlockTag, CodeBlock& other);
- void finishCreation(VM&, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*);
+ bool finishCreation(VM&, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*);
WriteBarrier<JSGlobalObject> m_globalObject;
@@ -917,6 +917,8 @@
void updateAllPredictionsAndCountLiveness(unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles);
+ bool setConstantIdentifierSetRegisters(VM&, const Vector<ConstantIndentifierSetEntry>& constants);
+
void setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation);
void replaceConstant(int index, JSValue value)
diff --git a/Source/JavaScriptCore/bytecode/EvalCodeBlock.h b/Source/JavaScriptCore/bytecode/EvalCodeBlock.h
index fde7b11..3a63817 100644
--- a/Source/JavaScriptCore/bytecode/EvalCodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/EvalCodeBlock.h
@@ -51,7 +51,8 @@
{
EvalCodeBlock* instance = new (NotNull, allocateCell<EvalCodeBlock>(vm->heap))
EvalCodeBlock(vm, vm->evalCodeBlockStructure.get(), ownerExecutable, unlinkedCodeBlock, scope, WTFMove(sourceProvider));
- instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope);
+ if (!instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope))
+ return nullptr;
return instance;
}
diff --git a/Source/JavaScriptCore/bytecode/FunctionCodeBlock.h b/Source/JavaScriptCore/bytecode/FunctionCodeBlock.h
index 4f58d09..1a6c0ba 100644
--- a/Source/JavaScriptCore/bytecode/FunctionCodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/FunctionCodeBlock.h
@@ -52,7 +52,8 @@
{
FunctionCodeBlock* instance = new (NotNull, allocateCell<FunctionCodeBlock>(vm->heap))
FunctionCodeBlock(vm, vm->functionCodeBlockStructure.get(), ownerExecutable, unlinkedCodeBlock, scope, WTFMove(sourceProvider), sourceOffset, firstLineColumnOffset);
- instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope);
+ if (!instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope))
+ return nullptr;
return instance;
}
diff --git a/Source/JavaScriptCore/bytecode/ModuleProgramCodeBlock.h b/Source/JavaScriptCore/bytecode/ModuleProgramCodeBlock.h
index 62674ea..1994b52 100644
--- a/Source/JavaScriptCore/bytecode/ModuleProgramCodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/ModuleProgramCodeBlock.h
@@ -52,7 +52,8 @@
{
ModuleProgramCodeBlock* instance = new (NotNull, allocateCell<ModuleProgramCodeBlock>(vm->heap))
ModuleProgramCodeBlock(vm, vm->moduleProgramCodeBlockStructure.get(), ownerExecutable, unlinkedCodeBlock, scope, WTFMove(sourceProvider), firstLineColumnOffset);
- instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope);
+ if (!instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope))
+ return nullptr;
return instance;
}
diff --git a/Source/JavaScriptCore/bytecode/ProgramCodeBlock.h b/Source/JavaScriptCore/bytecode/ProgramCodeBlock.h
index 8504ac4..2aac5d9 100644
--- a/Source/JavaScriptCore/bytecode/ProgramCodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/ProgramCodeBlock.h
@@ -52,7 +52,8 @@
{
ProgramCodeBlock* instance = new (NotNull, allocateCell<ProgramCodeBlock>(vm->heap))
ProgramCodeBlock(vm, vm->programCodeBlockStructure.get(), ownerExecutable, unlinkedCodeBlock, scope, WTFMove(sourceProvider), firstLineColumnOffset);
- instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope);
+ if (!instance->finishCreation(*vm, ownerExecutable, unlinkedCodeBlock, scope))
+ return nullptr;
return instance;
}
diff --git a/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h b/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h
index f9c9c37..669cc64 100644
--- a/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h
@@ -41,9 +41,12 @@
#include "UnlinkedFunctionExecutable.h"
#include "VariableEnvironment.h"
#include "VirtualRegister.h"
+#include <algorithm>
#include <wtf/BitVector.h>
+#include <wtf/HashSet.h>
#include <wtf/TriState.h>
#include <wtf/Vector.h>
+#include <wtf/text/UniquedStringImpl.h>
namespace JSC {
@@ -65,6 +68,7 @@
typedef unsigned UnlinkedArrayAllocationProfile;
typedef unsigned UnlinkedObjectAllocationProfile;
typedef unsigned UnlinkedLLIntCallLinkInfo;
+typedef std::pair<HashSet<UniquedStringImpl*>, unsigned> ConstantIndentifierSetEntry;
struct UnlinkedStringJumpTable {
struct OffsetLocation {
@@ -182,6 +186,16 @@
m_bitVectors.append(WTFMove(bitVector));
return m_bitVectors.size() - 1;
}
+
+ void addSetConstant(HashSet<UniquedStringImpl*>& set)
+ {
+ VM& vm = *this->vm();
+ auto locker = lockDuringMarking(vm.heap, *this);
+ unsigned result = m_constantRegisters.size();
+ m_constantRegisters.append(WriteBarrier<Unknown>());
+ m_constantsSourceCodeRepresentation.append(SourceCodeRepresentation::Other);
+ m_constantIdentifierSets.append(ConstantIndentifierSetEntry(set, result));
+ }
unsigned addConstant(JSValue v, SourceCodeRepresentation sourceCodeRepresentation = SourceCodeRepresentation::Other)
{
@@ -213,6 +227,7 @@
return m_linkTimeConstants[index];
}
const Vector<WriteBarrier<Unknown>>& constantRegisters() { return m_constantRegisters; }
+ const Vector<ConstantIndentifierSetEntry>& constantIdentifierSets() { return m_constantIdentifierSets; }
const WriteBarrier<Unknown>& constantRegister(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
ALWAYS_INLINE bool isConstantRegisterIndex(int index) const { return index >= FirstConstantRegisterIndex; }
ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].get(); }
@@ -446,6 +461,7 @@
Vector<Identifier> m_identifiers;
Vector<BitVector> m_bitVectors;
Vector<WriteBarrier<Unknown>> m_constantRegisters;
+ Vector<ConstantIndentifierSetEntry> m_constantIdentifierSets;
Vector<SourceCodeRepresentation> m_constantsSourceCodeRepresentation;
typedef Vector<WriteBarrier<UnlinkedFunctionExecutable>> FunctionExpressionVector;
FunctionExpressionVector m_functionDecls;
diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
index ece9a03..1721006 100644
--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
@@ -1920,6 +1920,27 @@
return constantID;
}
+RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, HashSet<UniquedStringImpl*>& set)
+{
+ for (ConstantIndentifierSetEntry entry : m_codeBlock->constantIdentifierSets()) {
+ if (entry.first != set)
+ continue;
+
+ return &m_constantPoolRegisters[entry.second];
+ }
+
+ unsigned index = m_nextConstantOffset;
+ m_constantPoolRegisters.append(FirstConstantRegisterIndex + m_nextConstantOffset);
+ ++m_nextConstantOffset;
+ m_codeBlock->addSetConstant(set);
+ RegisterID* m_setRegister = &m_constantPoolRegisters[index];
+
+ if (dst)
+ return emitMove(dst, m_setRegister);
+
+ return m_setRegister;
+}
+
RegisterID* BytecodeGenerator::emitLoadGlobalObject(RegisterID* dst)
{
if (!m_globalObjectRegister) {
diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
index 26c1d25..69ba10b 100644
--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
@@ -587,6 +587,7 @@
RegisterID* emitLoad(RegisterID* dst, bool);
RegisterID* emitLoad(RegisterID* dst, const Identifier&);
RegisterID* emitLoad(RegisterID* dst, JSValue, SourceCodeRepresentation = SourceCodeRepresentation::Other);
+ RegisterID* emitLoad(RegisterID* dst, HashSet<UniquedStringImpl*>& excludedList);
RegisterID* emitLoadGlobalObject(RegisterID* dst);
RegisterID* emitUnaryOp(OpcodeID, RegisterID* dst, RegisterID* src);
diff --git a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
index f8f08b8..9d31e13 100644
--- a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
+++ b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
@@ -41,8 +41,10 @@
#include "Parser.h"
#include "StackAlignment.h"
#include <wtf/Assertions.h>
+#include <wtf/HashSet.h>
#include <wtf/Threading.h>
#include <wtf/text/StringBuilder.h>
+#include <wtf/text/UniquedStringImpl.h>
using namespace WTF;
@@ -4027,25 +4029,56 @@
void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs) const
{
generator.emitRequireObjectCoercible(rhs, ASCIILiteral("Right side of assignment cannot be destructured"));
- for (const auto& target : m_targetPatterns) {
- RefPtr<RegisterID> temp = generator.newTemporary();
- if (!target.propertyExpression) {
- // Should not emit get_by_id for indexed ones.
- std::optional<uint32_t> optionalIndex = parseIndex(target.propertyName);
- if (!optionalIndex)
- generator.emitGetById(temp.get(), rhs, target.propertyName);
- else {
- RefPtr<RegisterID> index = generator.emitLoad(nullptr, jsNumber(optionalIndex.value()));
- generator.emitGetByVal(temp.get(), rhs, index.get());
- }
- } else {
- RefPtr<RegisterID> propertyName = generator.emitNode(target.propertyExpression);
- generator.emitGetByVal(temp.get(), rhs, propertyName.get());
- }
+
+ HashSet<UniquedStringImpl*> excludedSet;
- if (target.defaultValue)
- assignDefaultValueIfUndefined(generator, temp.get(), target.defaultValue);
- target.pattern->bindValue(generator, temp.get());
+ for (const auto& target : m_targetPatterns) {
+ if (target.bindingType == BindingType::Element) {
+ RefPtr<RegisterID> temp = generator.newTemporary();
+ if (!target.propertyExpression) {
+
+ // Should not emit get_by_id for indexed ones.
+ std::optional<uint32_t> optionalIndex = parseIndex(target.propertyName);
+ if (!optionalIndex)
+ generator.emitGetById(temp.get(), rhs, target.propertyName);
+ else {
+ RefPtr<RegisterID> pIndex = generator.emitLoad(nullptr, jsNumber(optionalIndex.value()));
+ generator.emitGetByVal(temp.get(), rhs, pIndex.get());
+ }
+ } else {
+ RefPtr<RegisterID> propertyName = generator.emitNode(target.propertyExpression);
+ generator.emitGetByVal(temp.get(), rhs, propertyName.get());
+ }
+
+ if (UNLIKELY(m_containsRestElement))
+ excludedSet.add(target.propertyName.impl());
+
+ if (target.defaultValue)
+ assignDefaultValueIfUndefined(generator, temp.get(), target.defaultValue);
+ target.pattern->bindValue(generator, temp.get());
+ } else {
+ RefPtr<RegisterID> excludedSetReg = generator.emitLoad(generator.newTemporary(), excludedSet);
+
+ RefPtr<RegisterID> newObject = generator.emitNewObject(generator.newTemporary());
+
+ // load and call @copyDataProperties
+ auto var = generator.variable(generator.propertyNames().builtinNames().copyDataPropertiesPrivateName());
+
+ RefPtr<RegisterID> scope = generator.newTemporary();
+ generator.moveToDestinationIfNeeded(scope.get(), generator.emitResolveScope(scope.get(), var));
+ RefPtr<RegisterID> copyDataProperties = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
+
+ CallArguments args(generator, nullptr, 3);
+ unsigned argumentCount = 0;
+ generator.emitLoad(args.thisRegister(), jsUndefined());
+ generator.emitMove(args.argumentRegister(argumentCount++), newObject.get());
+ generator.emitMove(args.argumentRegister(argumentCount++), rhs);
+ generator.emitMove(args.argumentRegister(argumentCount++), excludedSetReg.get());
+
+ RefPtr<RegisterID> result = generator.newTemporary();
+ generator.emitCall(result.get(), copyDataProperties.get(), NoExpectedFunction, args, divot(), divotStart(), divotEnd(), DebuggableCall::No);
+ target.pattern->bindValue(generator, result.get());
+ }
}
}
diff --git a/Source/JavaScriptCore/parser/ASTBuilder.h b/Source/JavaScriptCore/parser/ASTBuilder.h
index 801a364..2036e9d 100644
--- a/Source/JavaScriptCore/parser/ASTBuilder.h
+++ b/Source/JavaScriptCore/parser/ASTBuilder.h
@@ -942,15 +942,25 @@
void appendObjectPatternEntry(ObjectPattern node, const JSTokenLocation& location, bool wasString, const Identifier& identifier, DestructuringPattern pattern, ExpressionNode* defaultValue)
{
- node->appendEntry(location, identifier, wasString, pattern, defaultValue);
+ node->appendEntry(location, identifier, wasString, pattern, defaultValue, ObjectPatternNode::BindingType::Element);
tryInferNameInPattern(pattern, defaultValue);
}
void appendObjectPatternEntry(ObjectPattern node, const JSTokenLocation& location, ExpressionNode* propertyExpression, DestructuringPattern pattern, ExpressionNode* defaultValue)
{
- node->appendEntry(location, propertyExpression, pattern, defaultValue);
+ node->appendEntry(location, propertyExpression, pattern, defaultValue, ObjectPatternNode::BindingType::Element);
tryInferNameInPattern(pattern, defaultValue);
}
+
+ void appendObjectPatternRestEntry(ObjectPattern node, const JSTokenLocation& location, DestructuringPattern pattern)
+ {
+ node->appendEntry(location, nullptr, pattern, nullptr, ObjectPatternNode::BindingType::RestElement);
+ }
+
+ void setContainsObjectRestElement(ObjectPattern node, bool containsRestElement)
+ {
+ node->setContainsRestElement(containsRestElement);
+ }
BindingPattern createBindingLocation(const JSTokenLocation&, const Identifier& boundProperty, const JSTextPosition& start, const JSTextPosition& end, AssignmentContext context)
{
diff --git a/Source/JavaScriptCore/parser/Nodes.h b/Source/JavaScriptCore/parser/Nodes.h
index 84a4cfb..6f2cd6d 100644
--- a/Source/JavaScriptCore/parser/Nodes.h
+++ b/Source/JavaScriptCore/parser/Nodes.h
@@ -2129,19 +2129,28 @@
Vector<Entry> m_targetPatterns;
};
- class ObjectPatternNode : public DestructuringPatternNode, public ParserArenaDeletable {
+ class ObjectPatternNode : public DestructuringPatternNode, public ThrowableExpressionData, public ParserArenaDeletable {
public:
using ParserArenaDeletable::operator new;
ObjectPatternNode();
- void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DestructuringPatternNode* pattern, ExpressionNode* defaultValue)
+ enum class BindingType {
+ Element,
+ RestElement
+ };
+ void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DestructuringPatternNode* pattern, ExpressionNode* defaultValue, BindingType bindingType)
{
- m_targetPatterns.append(Entry{ identifier, nullptr, wasString, pattern, defaultValue });
+ m_targetPatterns.append(Entry{ identifier, nullptr, wasString, pattern, defaultValue, bindingType });
}
- void appendEntry(const JSTokenLocation&, ExpressionNode* propertyExpression, DestructuringPatternNode* pattern, ExpressionNode* defaultValue)
+ void appendEntry(const JSTokenLocation&, ExpressionNode* propertyExpression, DestructuringPatternNode* pattern, ExpressionNode* defaultValue, BindingType bindingType)
{
- m_targetPatterns.append(Entry{ Identifier(), propertyExpression, false, pattern, defaultValue });
+ m_targetPatterns.append(Entry{ Identifier(), propertyExpression, false, pattern, defaultValue, bindingType });
+ }
+
+ void setContainsRestElement(bool containsRestElement)
+ {
+ m_containsRestElement = containsRestElement;
}
private:
@@ -2154,7 +2163,9 @@
bool wasString;
DestructuringPatternNode* pattern;
ExpressionNode* defaultValue;
+ BindingType bindingType;
};
+ bool m_containsRestElement { false };
Vector<Entry> m_targetPatterns;
};
diff --git a/Source/JavaScriptCore/parser/Parser.cpp b/Source/JavaScriptCore/parser/Parser.cpp
index 1b75858..2a9408b 100644
--- a/Source/JavaScriptCore/parser/Parser.cpp
+++ b/Source/JavaScriptCore/parser/Parser.cpp
@@ -1002,12 +1002,27 @@
if (hasDestructuringPattern)
*hasDestructuringPattern = true;
+ bool restElementWasFound = false;
+
do {
bool wasString = false;
if (match(CLOSEBRACE))
break;
+ if (UNLIKELY(match(DOTDOTDOT))) {
+ JSTokenLocation location = m_token.m_location;
+ next();
+ auto innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
+ if (kind == DestructuringKind::DestructureToExpressions && !innerPattern)
+ return 0;
+ propagateError();
+ context.appendObjectPatternRestEntry(objectPattern, location, innerPattern);
+ restElementWasFound = true;
+ context.setContainsObjectRestElement(objectPattern, restElementWasFound);
+ break;
+ }
+
const Identifier* propertyName = nullptr;
TreeExpression propertyExpression = 0;
TreeDestructuringPattern innerPattern = 0;
@@ -1082,7 +1097,7 @@
if (kind == DestructuringKind::DestructureToExpressions && !match(CLOSEBRACE))
return 0;
- consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property destructuring pattern");
+ consumeOrFail(CLOSEBRACE, restElementWasFound ? "Expected a closing '}' following a rest element destructuring pattern" : "Expected either a closing '}' or an ',' after a property destructuring pattern");
pattern = objectPattern;
break;
}
@@ -3763,6 +3778,10 @@
context.setEndOffset(node, m_lexer->currentOffset());
return context.createProperty(propertyName, node, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed), PropertyNode::Unknown, complete, SuperBinding::NotNeeded, isClassProperty);
}
+ case DOTDOTDOT: {
+ classifyExpressionError(ErrorIndicatesPattern);
+ FALLTHROUGH;
+ }
default:
failIfFalse(m_token.m_type & KeywordTokenFlag, "Expected a property name");
wasIdent = true; // Treat keyword token as an identifier
diff --git a/Source/JavaScriptCore/parser/SyntaxChecker.h b/Source/JavaScriptCore/parser/SyntaxChecker.h
index 324cccf..56d6737 100644
--- a/Source/JavaScriptCore/parser/SyntaxChecker.h
+++ b/Source/JavaScriptCore/parser/SyntaxChecker.h
@@ -352,6 +352,12 @@
void appendObjectPatternEntry(ArrayPattern, const JSTokenLocation&, Expression, DestructuringPattern, Expression)
{
}
+ void appendObjectPatternRestEntry(ObjectPattern, const JSTokenLocation&, DestructuringPattern)
+ {
+ }
+ void setContainsObjectRestElement(ObjectPattern, bool)
+ {
+ }
DestructuringPattern createBindingLocation(const JSTokenLocation&, const Identifier&, const JSTextPosition&, const JSTextPosition&, AssignmentContext)
{
diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
index 27abc17..edc5782 100644
--- a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
+++ b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
@@ -735,6 +735,7 @@
JSFunction* privateFuncGetTemplateObject = JSFunction::create(vm, this, 0, String(), getTemplateObject);
JSFunction* privateFuncImportModule = JSFunction::create(vm, this, 0, String(), globalFuncImportModule);
+ JSFunction* privateFuncToObject = JSFunction::create(vm, this, 0, String(), privateToObject);
JSFunction* privateFuncTypedArrayLength = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncLength);
JSFunction* privateFuncTypedArrayGetOriginalConstructor = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncGetOriginalConstructor);
JSFunction* privateFuncTypedArraySort = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncSort);
@@ -789,6 +790,7 @@
GlobalPropertyInfo(vm.propertyNames->builtinNames().ownEnumerablePropertyKeysPrivateName(), JSFunction::create(vm, this, 0, String(), ownEnumerablePropertyKeys), DontEnum | DontDelete | ReadOnly),
GlobalPropertyInfo(vm.propertyNames->builtinNames().getTemplateObjectPrivateName(), privateFuncGetTemplateObject, DontEnum | DontDelete | ReadOnly),
GlobalPropertyInfo(vm.propertyNames->builtinNames().importModulePrivateName(), privateFuncImportModule, DontEnum | DontDelete | ReadOnly),
+ GlobalPropertyInfo(vm.propertyNames->builtinNames().toObjectPrivateName(), privateFuncToObject, DontEnum | DontDelete | ReadOnly),
GlobalPropertyInfo(vm.propertyNames->builtinNames().enqueueJobPrivateName(), JSFunction::create(vm, this, 0, String(), enqueueJob), DontEnum | DontDelete | ReadOnly),
GlobalPropertyInfo(vm.propertyNames->builtinNames().ErrorPrivateName(), m_errorConstructor.get(), DontEnum | DontDelete | ReadOnly),
GlobalPropertyInfo(vm.propertyNames->builtinNames().RangeErrorPrivateName(), m_rangeErrorConstructor.get(), DontEnum | DontDelete | ReadOnly),
diff --git a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp b/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
index 84a9b93..3a47aea 100644
--- a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
+++ b/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
@@ -735,6 +735,11 @@
thisObject->setPrototype(vm, exec, value, shouldThrowIfCantSet);
return JSValue::encode(jsUndefined());
}
+
+EncodedJSValue JSC_HOST_CALL privateToObject(ExecState* exec)
+{
+ return JSValue::encode(JSValue(exec->argument(0).toObject(exec)));
+}
EncodedJSValue JSC_HOST_CALL globalFuncBuiltinLog(ExecState* exec)
{
diff --git a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.h b/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.h
index d69b4d7..c9a6d53 100644
--- a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.h
+++ b/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.h
@@ -50,6 +50,7 @@
EncodedJSValue JSC_HOST_CALL globalFuncProtoGetter(ExecState*);
EncodedJSValue JSC_HOST_CALL globalFuncProtoSetter(ExecState*);
EncodedJSValue JSC_HOST_CALL globalFuncBuiltinLog(ExecState*);
+EncodedJSValue JSC_HOST_CALL privateToObject(ExecState*);
EncodedJSValue JSC_HOST_CALL globalFuncImportModule(ExecState*);
double jsToNumber(StringView);
diff --git a/Source/JavaScriptCore/runtime/ObjectConstructor.cpp b/Source/JavaScriptCore/runtime/ObjectConstructor.cpp
index 73011a0..72e2f4c 100644
--- a/Source/JavaScriptCore/runtime/ObjectConstructor.cpp
+++ b/Source/JavaScriptCore/runtime/ObjectConstructor.cpp
@@ -105,6 +105,7 @@
JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().definePropertyPrivateName(), objectConstructorDefineProperty, DontEnum, 3);
JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().getPrototypeOfPrivateName(), objectConstructorGetPrototypeOf, DontEnum, 1);
JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().getOwnPropertyNamesPrivateName(), objectConstructorGetOwnPropertyNames, DontEnum, 1);
+ JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().getOwnPropertyDescriptorPrivateName(), objectConstructorGetOwnPropertyDescriptor, DontEnum, 1);
}
// ES 19.1.1.1 Object([value])
diff --git a/Source/JavaScriptCore/runtime/ScriptExecutable.cpp b/Source/JavaScriptCore/runtime/ScriptExecutable.cpp
index 7b5d636..285fbcd 100644
--- a/Source/JavaScriptCore/runtime/ScriptExecutable.cpp
+++ b/Source/JavaScriptCore/runtime/ScriptExecutable.cpp
@@ -176,14 +176,24 @@
ASSERT(vm->heap.isDeferred());
ASSERT(endColumn() != UINT_MAX);
+ JSGlobalObject* globalObject = scope->globalObject();
+ ExecState* exec = globalObject->globalExec();
+
if (classInfo(*vm) == EvalExecutable::info()) {
EvalExecutable* executable = jsCast<EvalExecutable*>(this);
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_evalCodeBlock);
RELEASE_ASSERT(!function);
- return EvalCodeBlock::create(vm,
+ auto codeBlock = EvalCodeBlock::create(vm,
executable, executable->m_unlinkedEvalCodeBlock.get(), scope,
executable->source().provider());
+ if (!codeBlock) {
+ exception = throwException(
+ exec, throwScope,
+ createOutOfMemoryError(exec));
+ return nullptr;
+ }
+ return codeBlock;
}
if (classInfo(*vm) == ProgramExecutable::info()) {
@@ -191,9 +201,16 @@
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_programCodeBlock);
RELEASE_ASSERT(!function);
- return ProgramCodeBlock::create(vm,
+ auto codeBlock = ProgramCodeBlock::create(vm,
executable, executable->m_unlinkedProgramCodeBlock.get(), scope,
executable->source().provider(), startColumn());
+ if (!codeBlock) {
+ exception = throwException(
+ exec, throwScope,
+ createOutOfMemoryError(exec));
+ return nullptr;
+ }
+ return codeBlock;
}
if (classInfo(*vm) == ModuleProgramExecutable::info()) {
@@ -201,16 +218,22 @@
RELEASE_ASSERT(kind == CodeForCall);
RELEASE_ASSERT(!executable->m_moduleProgramCodeBlock);
RELEASE_ASSERT(!function);
- return ModuleProgramCodeBlock::create(vm,
+ auto codeBlock = ModuleProgramCodeBlock::create(vm,
executable, executable->m_unlinkedModuleProgramCodeBlock.get(), scope,
executable->source().provider(), startColumn());
+ if (!codeBlock) {
+ exception = throwException(
+ exec, throwScope,
+ createOutOfMemoryError(exec));
+ return nullptr;
+ }
+ return codeBlock;
}
RELEASE_ASSERT(classInfo(*vm) == FunctionExecutable::info());
RELEASE_ASSERT(function);
FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
RELEASE_ASSERT(!executable->codeBlockFor(kind));
- JSGlobalObject* globalObject = scope->globalObject();
ParserError error;
DebuggerMode debuggerMode = globalObject->hasInteractiveDebugger() ? DebuggerOn : DebuggerOff;
UnlinkedFunctionCodeBlock* unlinkedCodeBlock =
diff --git a/Source/JavaScriptCore/runtime/SetPrototype.cpp b/Source/JavaScriptCore/runtime/SetPrototype.cpp
index 9ed08c4..1db99f9 100644
--- a/Source/JavaScriptCore/runtime/SetPrototype.cpp
+++ b/Source/JavaScriptCore/runtime/SetPrototype.cpp
@@ -67,6 +67,7 @@
JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->clear, setProtoFuncClear, DontEnum, 0);
JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->deleteKeyword, setProtoFuncDelete, DontEnum, 1);
JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->has, setProtoFuncHas, DontEnum, 1, JSSetHasIntrinsic);
+ JSC_NATIVE_INTRINSIC_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().hasPrivateName(), setProtoFuncHas, DontEnum, 1, JSSetHasIntrinsic);
JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().entriesPublicName(), setProtoFuncEntries, DontEnum, 0);
JSFunction* values = JSFunction::create(vm, globalObject, 0, vm.propertyNames->builtinNames().valuesPublicName().string(), setProtoFuncValues);
