+#if ENABLE(ES6_CLASS_SYNTAX)
+// ------------------------------ ClassDeclNode ---------------------------------
+
+void ClassDeclNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ generator.emitNode(dst, m_classDeclaration);
+}
+
+// ------------------------------ ClassExprNode ---------------------------------
+
+RegisterID* ClassExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ RefPtr<RegisterID> superclass;
+ if (m_classHeritage) {
+ superclass = generator.newTemporary();
+ generator.emitNode(superclass.get(), m_classHeritage);
+ }
+
+ RefPtr<RegisterID> constructor;
+
+ // FIXME: Make the prototype non-configurable & non-writable.
+ if (m_constructorExpression)
+ constructor = generator.emitNode(dst, m_constructorExpression);
+ else {
+ constructor = generator.emitNewDefaultConstructor(generator.finalDestination(dst),
+ m_classHeritage ? ConstructorKind::Derived : ConstructorKind::Base, m_name);
+ }
+
+ const auto& propertyNames = generator.propertyNames();
+ RefPtr<RegisterID> prototype = generator.emitNewObject(generator.newTemporary());
+
+ if (superclass) {
+ RefPtr<RegisterID> protoParent = generator.newTemporary();
+ generator.emitLoad(protoParent.get(), jsNull());
+
+ RefPtr<RegisterID> tempRegister = generator.newTemporary();
+
+ // FIXME: Throw TypeError if it's a generator function.
+ RefPtr<Label> superclassIsUndefinedLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitIsUndefined(tempRegister.get(), superclass.get()), superclassIsUndefinedLabel.get());
+
+ RefPtr<Label> superclassIsNullLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitUnaryOp(op_eq_null, tempRegister.get(), superclass.get()), superclassIsNullLabel.get());
+
+ RefPtr<Label> superclassIsObjectLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitIsObject(tempRegister.get(), superclass.get()), superclassIsObjectLabel.get());
+ generator.emitLabel(superclassIsUndefinedLabel.get());
+ generator.emitThrowTypeError(ASCIILiteral("The superclass is not an object."));
+ generator.emitLabel(superclassIsObjectLabel.get());
+ generator.emitGetById(protoParent.get(), superclass.get(), generator.propertyNames().prototype);
+
+ RefPtr<Label> protoParentIsObjectOrNullLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitUnaryOp(op_is_object_or_null, tempRegister.get(), protoParent.get()), protoParentIsObjectOrNullLabel.get());
+ generator.emitThrowTypeError(ASCIILiteral("The superclass's prototype is not an object."));
+ generator.emitLabel(protoParentIsObjectOrNullLabel.get());
+
+ generator.emitDirectPutById(constructor.get(), generator.propertyNames().underscoreProto, superclass.get(), PropertyNode::Unknown);
+ generator.emitLabel(superclassIsNullLabel.get());
+ generator.emitDirectPutById(prototype.get(), generator.propertyNames().underscoreProto, protoParent.get(), PropertyNode::Unknown);
+
+ emitPutHomeObject(generator, constructor.get(), prototype.get());
+ }
+
+ RefPtr<RegisterID> constructorNameRegister = generator.emitLoad(generator.newTemporary(), propertyNames.constructor);
+ generator.emitCallDefineProperty(prototype.get(), constructorNameRegister.get(), constructor.get(), nullptr, nullptr,
+ BytecodeGenerator::PropertyConfigurable | BytecodeGenerator::PropertyWritable, m_position);
+
+ RefPtr<RegisterID> prototypeNameRegister = generator.emitLoad(generator.newTemporary(), propertyNames.prototype);
+ generator.emitCallDefineProperty(constructor.get(), prototypeNameRegister.get(), prototype.get(), nullptr, nullptr, 0, m_position);
+
+ if (m_staticMethods)
+ generator.emitNode(constructor.get(), m_staticMethods);
+
+ if (m_instanceMethods)
+ generator.emitNode(prototype.get(), m_instanceMethods);
+
+ return generator.moveToDestinationIfNeeded(dst, constructor.get());
+}
+#endif
+
+// ------------------------------ DestructuringAssignmentNode -----------------
+RegisterID* DestructuringAssignmentNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (RegisterID* result = m_bindings->emitDirectBinding(generator, dst, m_initializer))
+ return result;
+ RefPtr<RegisterID> initializer = generator.tempDestination(dst);
+ generator.emitNode(initializer.get(), m_initializer);
+ m_bindings->bindValue(generator, initializer.get());
+ return generator.moveToDestinationIfNeeded(dst, initializer.get());
+}
+
+DestructuringPatternNode::~DestructuringPatternNode()
+{
+}
+
+static void assignDefaultValueIfUndefined(BytecodeGenerator& generator, RegisterID* maybeUndefined, ExpressionNode* defaultValue)
+{
+ ASSERT(defaultValue);
+ RefPtr<Label> isNotUndefined = generator.newLabel();
+ generator.emitJumpIfFalse(generator.emitIsUndefined(generator.newTemporary(), maybeUndefined), isNotUndefined.get());
+ generator.emitNode(maybeUndefined, defaultValue);
+ generator.emitLabel(isNotUndefined.get());
+}
+
+void ArrayPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs) const
+{
+ RefPtr<RegisterID> iterator = generator.newTemporary();
+ {
+ generator.emitGetById(iterator.get(), rhs, generator.propertyNames().iteratorSymbol);
+ CallArguments args(generator, nullptr);
+ generator.emitMove(args.thisRegister(), rhs);
+ generator.emitCall(iterator.get(), iterator.get(), NoExpectedFunction, args, divot(), divotStart(), divotEnd());
+ }
+
+ if (m_targetPatterns.isEmpty()) {
+ generator.emitIteratorClose(iterator.get(), this);
+ return;
+ }
+
+ RefPtr<RegisterID> done;
+ for (auto& target : m_targetPatterns) {
+ switch (target.bindingType) {
+ case BindingType::Elision:
+ case BindingType::Element: {
+ RefPtr<Label> iterationSkipped = generator.newLabel();
+ if (!done)
+ done = generator.newTemporary();
+ else
+ generator.emitJumpIfTrue(done.get(), iterationSkipped.get());
+
+ RefPtr<RegisterID> value = generator.newTemporary();
+ generator.emitIteratorNext(value.get(), iterator.get(), this);
+ generator.emitGetById(done.get(), value.get(), generator.propertyNames().done);
+ generator.emitJumpIfTrue(done.get(), iterationSkipped.get());
+ generator.emitGetById(value.get(), value.get(), generator.propertyNames().value);
+
+ {
+ RefPtr<Label> valueIsSet = generator.newLabel();
+ generator.emitJump(valueIsSet.get());
+ generator.emitLabel(iterationSkipped.get());
+ generator.emitLoad(value.get(), jsUndefined());
+ generator.emitLabel(valueIsSet.get());
+ }
+
+ if (target.bindingType == BindingType::Element) {
+ if (target.defaultValue)
+ assignDefaultValueIfUndefined(generator, value.get(), target.defaultValue);
+ target.pattern->bindValue(generator, value.get());
+ }
+ break;
+ }
+
+ case BindingType::RestElement: {
+ RefPtr<RegisterID> array = generator.emitNewArray(generator.newTemporary(), 0, 0);
+
+ RefPtr<Label> iterationDone = generator.newLabel();
+ if (!done)
+ done = generator.newTemporary();
+ else
+ generator.emitJumpIfTrue(done.get(), iterationDone.get());
+
+ RefPtr<RegisterID> index = generator.newTemporary();
+ generator.emitLoad(index.get(), jsNumber(0));
+ RefPtr<Label> loopStart = generator.newLabel();
+ generator.emitLabel(loopStart.get());
+
+ RefPtr<RegisterID> value = generator.newTemporary();
+ generator.emitIteratorNext(value.get(), iterator.get(), this);
+ generator.emitGetById(done.get(), value.get(), generator.propertyNames().done);
+ generator.emitJumpIfTrue(done.get(), iterationDone.get());
+ generator.emitGetById(value.get(), value.get(), generator.propertyNames().value);
+
+ generator.emitDirectPutByVal(array.get(), index.get(), value.get());
+ generator.emitInc(index.get());
+ generator.emitJump(loopStart.get());
+
+ generator.emitLabel(iterationDone.get());
+ target.pattern->bindValue(generator, array.get());
+ break;
+ }
+ }
+ }
+
+ RefPtr<Label> iteratorClosed = generator.newLabel();
+ generator.emitJumpIfTrue(done.get(), iteratorClosed.get());
+ generator.emitIteratorClose(iterator.get(), this);
+ generator.emitLabel(iteratorClosed.get());
+}
+
+RegisterID* ArrayPatternNode::emitDirectBinding(BytecodeGenerator& generator, RegisterID* dst, ExpressionNode* rhs)
+{
+ if (!rhs->isSimpleArray())
+ return 0;
+
+ RefPtr<RegisterID> resultRegister;
+ if (dst && dst != generator.ignoredResult())
+ resultRegister = generator.emitNewArray(generator.newTemporary(), 0, 0);
+ ElementNode* elementNodes = static_cast<ArrayNode*>(rhs)->elements();
+ Vector<ExpressionNode*> elements;
+ for (; elementNodes; elementNodes = elementNodes->next())
+ elements.append(elementNodes->value());
+ if (m_targetPatterns.size() != elements.size())
+ return 0;
+ Vector<RefPtr<RegisterID>> registers;
+ registers.reserveCapacity(m_targetPatterns.size());
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ registers.uncheckedAppend(generator.newTemporary());
+ generator.emitNode(registers.last().get(), elements[i]);
+ if (m_targetPatterns[i].defaultValue)
+ assignDefaultValueIfUndefined(generator, registers.last().get(), m_targetPatterns[i].defaultValue);
+ if (resultRegister)
+ generator.emitPutByIndex(resultRegister.get(), i, registers.last().get());
+ }
+
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ if (m_targetPatterns[i].pattern)
+ m_targetPatterns[i].pattern->bindValue(generator, registers[i].get());
+ }
+ if (resultRegister)
+ return generator.moveToDestinationIfNeeded(dst, resultRegister.get());
+ return generator.emitLoad(generator.finalDestination(dst), jsUndefined());
+}
+
+void ArrayPatternNode::toString(StringBuilder& builder) const
+{
+ builder.append('[');
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ const auto& target = m_targetPatterns[i];
+
+ switch (target.bindingType) {
+ case BindingType::Elision:
+ builder.append(',');
+ break;
+
+ case BindingType::Element:
+ target.pattern->toString(builder);
+ if (i < m_targetPatterns.size() - 1)
+ builder.append(',');
+ break;
+
+ case BindingType::RestElement:
+ builder.append("...");
+ target.pattern->toString(builder);
+ break;
+ }
+ }
+ builder.append(']');
+}
+
+void ArrayPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ if (DestructuringPatternNode* node = m_targetPatterns[i].pattern.get())
+ node->collectBoundIdentifiers(identifiers);
+ }
+}
+
+void ObjectPatternNode::toString(StringBuilder& builder) const
+{
+ builder.append('{');
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ if (m_targetPatterns[i].wasString)
+ builder.appendQuotedJSONString(m_targetPatterns[i].propertyName.string());
+ else
+ builder.append(m_targetPatterns[i].propertyName.string());
+ builder.append(':');
+ m_targetPatterns[i].pattern->toString(builder);
+ if (i < m_targetPatterns.size() - 1)
+ builder.append(',');
+ }
+ builder.append('}');
+}
+
+void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs) const
+{
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ auto& target = m_targetPatterns[i];
+ RefPtr<RegisterID> temp = generator.newTemporary();
+ generator.emitGetById(temp.get(), rhs, target.propertyName);
+ if (target.defaultValue)
+ assignDefaultValueIfUndefined(generator, temp.get(), target.defaultValue);
+ target.pattern->bindValue(generator, temp.get());
+ }
+}
+
+void ObjectPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ for (size_t i = 0; i < m_targetPatterns.size(); i++)
+ m_targetPatterns[i].pattern->collectBoundIdentifiers(identifiers);
+}
+
+void BindingNode::bindValue(BytecodeGenerator& generator, RegisterID* value) const
+{
+ Variable var = generator.variable(m_boundProperty);
+ if (RegisterID* local = var.local()) {
+ if (var.isReadOnly()) {
+ generator.emitReadOnlyExceptionIfNeeded();
+ return;
+ }
+ generator.emitMove(local, value);
+ if (generator.vm()->typeProfiler())
+ generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
+ return;
+ }
+ if (generator.isStrictMode())
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ RegisterID* scope = generator.emitResolveScope(nullptr, var);
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ generator.emitPutToScope(scope, var, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound);
+ if (generator.vm()->typeProfiler()) {
+ generator.emitProfileType(value, var.isResolved() ? ProfileTypeBytecodePutToLocalScope : ProfileTypeBytecodePutToScope, &m_boundProperty);
+ generator.emitTypeProfilerExpressionInfo(divotStart(), divotEnd());
+ }
+ return;
+}
+
+void BindingNode::toString(StringBuilder& builder) const
+{
+ builder.append(m_boundProperty.string());
+}
+
+void BindingNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ identifiers.append(m_boundProperty);
+}
+
+RegisterID* SpreadExpressionNode::emitBytecode(BytecodeGenerator&, RegisterID*)
+{
+ RELEASE_ASSERT_NOT_REACHED();
+ return 0;
+}
+
projects / apple / javascriptcore.git / blobdiff