Bug 1619008: Switch emitCallSiteObject() to use the ObjLiteral writer. r=mgaudet

Differential Revision: https://phabricator.services.mozilla.com/D65806

--HG--
extra : moz-landing-system : lando

js/src/frontend/BytecodeEmitter.cpp

@@ -924,14 +924,9 @@ bool BytecodeEmitter::emitInternedObjectOp(uint32_t index, JSOp op) {
   return emitIndexOp(op, index);
 }
 
-bool BytecodeEmitter::emitObjectPairOp(ObjectBox* objbox1, ObjectBox* objbox2,
+bool BytecodeEmitter::emitObjectPairOp(uint32_t index1, uint32_t index2,
                                        JSOp op) {
-  uint32_t index1, index2;
-  if (!perScriptData().gcThingList().append(objbox1, &index1) ||
-      !perScriptData().gcThingList().append(objbox2, &index2)) {
-    return false;
-  }
-
+  MOZ_ASSERT(index1 + 1 == index2, "object pair indices must be adjacent");
   return emitInternedObjectOp(index1, op);
 }
 
@@ -4369,7 +4364,8 @@ bool BytecodeEmitter::emitAssignmentOrInit(ParseNodeKind kind, ParseNode* lhs,
   return true;
 }
 
-ArrayObject* CallSiteNode::getArrayValue(JSContext* cx, ListNode* cookedOrRaw) {
+bool BytecodeEmitter::emitCallSiteObjectArray(ListNode* cookedOrRaw,
+                                              uint32_t* arrayIndex) {
   uint32_t count = cookedOrRaw->count();
   ParseNode* pn = cookedOrRaw->head();
 
@@ -4382,49 +4378,39 @@ ArrayObject* CallSiteNode::getArrayValue(JSContext* cx, ListNode* cookedOrRaw) {
     MOZ_ASSERT(cookedOrRaw->isKind(ParseNodeKind::ArrayExpr));
   }
 
-  RootedValueVector values(cx);
-  if (!values.appendN(MagicValue(JS_ELEMENTS_HOLE), count)) {
-    return nullptr;
-  }
+  ObjLiteralCreationData data(cx);
+  ObjLiteralFlags flags(ObjLiteralFlag::Array);
+  data.writer().beginObject(flags);
+  data.writer().beginDenseArrayElements();
+
   size_t idx;
   for (idx = 0; pn; idx++, pn = pn->pn_next) {
-    if (pn->isKind(ParseNodeKind::TemplateStringExpr)) {
-      values[idx].setString(pn->as<NameNode>().atom());
-    } else {
-      MOZ_ASSERT(pn->isKind(ParseNodeKind::RawUndefinedExpr));
-      values[idx].setUndefined();
+    MOZ_ASSERT(pn->isKind(ParseNodeKind::TemplateStringExpr) ||
+               pn->isKind(ParseNodeKind::RawUndefinedExpr));
+
+    if (!emitObjLiteralValue(&data, pn)) {
+      return false;
     }
   }
   MOZ_ASSERT(idx == count);
 
-  return ObjectGroup::newArrayObject(cx, values.begin(), values.length(),
-                                     TenuredObject);
+  return perScriptData().gcThingList().append(std::move(data), arrayIndex);
 }
 
 bool BytecodeEmitter::emitCallSiteObject(CallSiteNode* callSiteObj) {
-  ArrayObject* cookedValues = callSiteObj->getCookedArrayValue(cx);
-  if (!cookedValues) {
+  uint32_t cookedIndex;
+  if (!emitCallSiteObjectArray(callSiteObj, &cookedIndex)) {
     return false;
   }
 
-  ObjectBox* objbox1 = parser->newObjectBox(cookedValues);
-  if (!objbox1) {
-    return false;
-  }
-
-  ArrayObject* rawValues = callSiteObj->getRawArrayValue(cx);
-  if (!rawValues) {
-    return false;
-  }
-
-  ObjectBox* objbox2 = parser->newObjectBox(rawValues);
-  if (!objbox2) {
+  uint32_t rawIndex;
+  if (!emitCallSiteObjectArray(callSiteObj->rawNodes(), &rawIndex)) {
     return false;
   }
 
   MOZ_ASSERT(sc->hasCallSiteObj());
 
-  return emitObjectPairOp(objbox1, objbox2, JSOp::CallSiteObj);
+  return emitObjectPairOp(cookedIndex, rawIndex, JSOp::CallSiteObj);
 }
 
 bool BytecodeEmitter::emitCatch(BinaryNode* catchClause) {

js/src/frontend/BytecodeEmitter.h

@@ -482,8 +482,7 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
 
   MOZ_MUST_USE bool emitInternedScopeOp(uint32_t index, JSOp op);
   MOZ_MUST_USE bool emitInternedObjectOp(uint32_t index, JSOp op);
-  MOZ_MUST_USE bool emitObjectPairOp(ObjectBox* objbox1, ObjectBox* objbox2,
-                                     JSOp op);
+  MOZ_MUST_USE bool emitObjectPairOp(uint32_t index1, uint32_t index2, JSOp op);
   MOZ_MUST_USE bool emitRegExp(uint32_t index);
 
   MOZ_NEVER_INLINE MOZ_MUST_USE bool emitFunction(
@@ -706,6 +705,8 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
   MOZ_MUST_USE bool setFunName(FunctionBox* fun, JSAtom* name);
   MOZ_MUST_USE bool emitInitializer(ParseNode* initializer, ParseNode* pattern);
 
+  MOZ_MUST_USE bool emitCallSiteObjectArray(ListNode* cookedOrRaw,
+                                            uint32_t* arrayIndex);
   MOZ_MUST_USE bool emitCallSiteObject(CallSiteNode* callSiteObj);
   MOZ_MUST_USE bool emitTemplateString(ListNode* templateString);
   MOZ_MUST_USE bool emitAssignmentOrInit(ParseNodeKind kind, ParseNode* lhs,

js/src/frontend/ParseNode.h

@@ -45,8 +45,6 @@
 
 namespace js {
 
-class ArrayObject;
-
 namespace frontend {
 
 class ParseContext;
@@ -2027,8 +2025,6 @@ class OptionalPropertyByValue : public PropertyByValueBase {
  * TaggedTemplate.
  */
 class CallSiteNode : public ListNode {
-  MOZ_MUST_USE ArrayObject* getArrayValue(JSContext* cx, ListNode* cookedOrRaw);
-
  public:
   explicit CallSiteNode(uint32_t begin)
       : ListNode(ParseNodeKind::CallSiteObj, TokenPos(begin, begin + 1)) {}
@@ -2039,14 +2035,6 @@ class CallSiteNode : public ListNode {
     return match;
   }
 
-  MOZ_MUST_USE ArrayObject* getCookedArrayValue(JSContext* cx) {
-    return getArrayValue(cx, this);
-  }
-
-  MOZ_MUST_USE ArrayObject* getRawArrayValue(JSContext* cx) {
-    return getArrayValue(cx, rawNodes());
-  }
-
   ListNode* rawNodes() const {
     MOZ_ASSERT(head());
     return &head()->as<ListNode>();