--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -8534,17 +8534,16 @@ bool BytecodeEmitter::emitPropertyList(L
         MOZ_CRASH("Invalid op");
     }
   }
 
   return true;
 }
 
 bool BytecodeEmitter::emitPropertyListObjLiteral(ListNode* obj,
-                                                 PropListType type,
                                                  ObjLiteralFlags flags) {
   ObjLiteralCreationData data(cx);
   data.writer().beginObject(flags);
   bool noValues = flags.contains(ObjLiteralFlag::NoValues);
   bool singleton = flags.contains(ObjLiteralFlag::Singleton);
 
   for (ParseNode* propdef : obj->contents()) {
     BinaryNode* prop = &propdef->as<BinaryNode>();
@@ -9110,17 +9109,17 @@ MOZ_NEVER_INLINE bool BytecodeEmitter::e
       flags += ObjLiteralFlag::IsInnerSingleton;
     }
 
     // Use an ObjLiteral op. This will record ObjLiteral insns in the
     // objLiteralWriter's buffer and add a fixup to the list of ObjLiteral
     // fixups so that at GC-publish time at the end of parse, the full (case 1)
     // or template-without-values (case 2) object can be allocated and the
     // bytecode can be patched to refer to it.
-    if (!emitPropertyListObjLiteral(objNode, ObjectLiteral, flags)) {
+    if (!emitPropertyListObjLiteral(objNode, flags)) {
       //              [stack] OBJ
       return false;
     }
     // Put the ObjectEmitter in the right state. This tells it that there will
     // already be an object on the stack as a result of the (eventual)
     // NewObject or Object op, and prepares it to emit values if needed.
     if (!oe.emitObjectWithTemplateOnStack()) {
       //              [stack] OBJ

--- a/js/src/frontend/BytecodeEmitter.h
+++ b/js/src/frontend/BytecodeEmitter.h
@@ -503,17 +503,17 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
   void isPropertyListObjLiteralCompatible(ListNode* obj, PropListType type,
                                           bool* withValues,
                                           bool* withoutValues);
   bool isArrayObjLiteralCompatible(ParseNode* arrayHead);
 
   MOZ_MUST_USE bool emitPropertyList(ListNode* obj, PropertyEmitter& pe,
                                      PropListType type, bool isInner = false);
 
-  MOZ_MUST_USE bool emitPropertyListObjLiteral(ListNode* obj, PropListType type,
+  MOZ_MUST_USE bool emitPropertyListObjLiteral(ListNode* obj,
                                                ObjLiteralFlags flags);
 
   MOZ_MUST_USE bool emitObjLiteralArray(ParseNode* arrayHead, bool isCow);
 
   // Is a field value OBJLITERAL-compatible?
   MOZ_MUST_USE bool isRHSObjLiteralCompatible(ParseNode* value);
 
   MOZ_MUST_USE bool emitObjLiteralValue(ObjLiteralCreationData* data,