--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -738,17 +738,17 @@ class CGInterfaceObjectJSClass(CGThing):
                   nullptr, /* getProperty */
                   nullptr, /* setProperty */
                   nullptr, /* getOwnPropertyDescriptor */
                   nullptr, /* deleteProperty */
                   nullptr, /* watch */
                   nullptr, /* unwatch */
                   nullptr, /* getElements */
                   nullptr, /* enumerate */
-                  nullptr, /* thisObject */
+                  nullptr, /* thisValue */
                   InterfaceObjectToString, /* funToString */
                 }
               },
               eInterface,
               ${hooks},
               "function ${name}() {\\n    [native code]\\n}",
               ${prototypeID},
               ${depth},

--- a/js/public/Class.h
+++ b/js/public/Class.h
@@ -768,17 +768,17 @@ struct Class
     ClassExtension      ext;
     ObjectOps           ops;
 
     /*
      * Objects of this class aren't native objects. They don't have Shapes that
      * describe their properties and layout. Classes using this flag must
      * provide their own property behavior, either by being proxy classes (do
      * this) or by overriding all the ObjectOps except getElements, watch,
-     * unwatch, and thisObject (don't do this).
+     * unwatch, and thisValue (don't do this).
      */
     static const uint32_t NON_NATIVE = JSCLASS_INTERNAL_FLAG2;
 
     bool isNative() const {
         return !(flags & NON_NATIVE);
     }
 
     bool hasPrivate() const {

--- a/js/src/builtin/TypedObject.cpp
+++ b/js/src/builtin/TypedObject.cpp
@@ -2260,17 +2260,17 @@ OutlineTransparentTypedObject::getOrCrea
             TypedObject::obj_hasProperty,                \
             TypedObject::obj_getProperty,                \
             TypedObject::obj_setProperty,                \
             TypedObject::obj_getOwnPropertyDescriptor,   \
             TypedObject::obj_deleteProperty,             \
             nullptr, nullptr, /* watch/unwatch */        \
             nullptr,   /* getElements */                 \
             TypedObject::obj_enumerate,                  \
-            nullptr, /* thisObject */                    \
+            nullptr, /* thisValue */                     \
         }                                                \
     }
 
 DEFINE_TYPEDOBJ_CLASS(OutlineTransparentTypedObject, OutlineTypedObject::obj_trace);
 DEFINE_TYPEDOBJ_CLASS(OutlineOpaqueTypedObject,      OutlineTypedObject::obj_trace);
 DEFINE_TYPEDOBJ_CLASS(InlineTransparentTypedObject,  InlineTypedObject::obj_trace);
 DEFINE_TYPEDOBJ_CLASS(InlineOpaqueTypedObject,       InlineTypedObject::obj_trace);
 

--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -6735,18 +6735,17 @@ class MComputeThis
     static MComputeThis* New(TempAllocator& alloc, MDefinition* def) {
         return new(alloc) MComputeThis(def);
     }
 
     bool possiblyCalls() const override {
         return true;
     }
 
-    // Note: don't override getAliasSet: the thisObject hook can be
-    // effectful.
+    // Note: don't override getAliasSet: the thisValue hook can be effectful.
 };
 
 // Load an arrow function's |this| value.
 class MLoadArrowThis
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
     explicit MLoadArrowThis(MDefinition* callee)

--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -348,17 +348,17 @@ namespace js {
             js::proxy_HasProperty,                                                      \
             js::proxy_GetProperty,                                                      \
             js::proxy_SetProperty,                                                      \
             js::proxy_GetOwnPropertyDescriptor,                                         \
             js::proxy_DeleteProperty,                                                   \
             js::proxy_Watch, js::proxy_Unwatch,                                         \
             js::proxy_GetElements,                                                      \
             nullptr,             /* enumerate       */                                  \
-            nullptr,             /* thisObject      */                                  \
+            nullptr,             /* thisValue       */                                  \
             js::proxy_FunToString,                                                      \
         }                                                                               \
     }
 
 #define PROXY_CLASS_DEF(name, flags)                                    \
   PROXY_CLASS_WITH_EXT(name, flags,                                     \
                        PROXY_MAKE_EXT(                                  \
                          nullptr, /* outerObject */                     \

--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -6769,18 +6769,18 @@ DebuggerGenericEval(JSContext* cx, const
             return false;
         thisv = iter->computedThisValue();
         env = GetDebugScopeForFrame(cx, iter->abstractFramePtr(), iter->pc());
         if (!env)
             return false;
     } else {
         /*
          * Use the global lexical scope as 'this'. If the global is an inner
-         * object, it should have a thisObject hook that returns the
-         * appropriate outer object.
+         * object, it should have a thisValue hook that returns the appropriate
+         * outer object.
          */
         if (!GetThisValue(cx, scope, &thisv))
             return false;
         env = scope;
     }
 
     /* If evalWithBindings, create the inner environment. */
     if (evalWithBindings) {

--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -519,17 +519,17 @@ js::Invoke(JSContext* cx, const Value& t
         return false;
 
     args.setCallee(fval);
     args.setThis(thisv);
     PodCopy(args.array(), argv, argc);
 
     if (args.thisv().isObject()) {
         /*
-         * We must call the thisObject hook in case we are not called from the
+         * We must call the thisValue hook in case we are not called from the
          * interpreter, where a prior bytecode has computed an appropriate
          * |this| already.  But don't do that if fval is a DOM function.
          */
         if (!fval.isObject() || !fval.toObject().is<JSFunction>() ||
             !fval.toObject().as<JSFunction>().isNative() ||
             !fval.toObject().as<JSFunction>().jitInfo() ||
             fval.toObject().as<JSFunction>().jitInfo()->needsOuterizedThisObject())
         {

--- a/js/src/vm/UnboxedObject.cpp
+++ b/js/src/vm/UnboxedObject.cpp
@@ -935,17 +935,17 @@ const Class UnboxedPlainObject::class_ =
         UnboxedPlainObject::obj_getProperty,
         UnboxedPlainObject::obj_setProperty,
         UnboxedPlainObject::obj_getOwnPropertyDescriptor,
         UnboxedPlainObject::obj_deleteProperty,
         UnboxedPlainObject::obj_watch,
         nullptr,   /* No unwatch needed, as watch() converts the object to native */
         nullptr,   /* getElements */
         UnboxedPlainObject::obj_enumerate,
-        nullptr, /* thisObject */
+        nullptr, /* thisValue */
     }
 };
 
 /////////////////////////////////////////////////////////////////////
 // UnboxedArrayObject
 /////////////////////////////////////////////////////////////////////
 
 template <JSValueType Type>
@@ -1626,17 +1626,17 @@ const Class UnboxedArrayObject::class_ =
         UnboxedArrayObject::obj_getProperty,
         UnboxedArrayObject::obj_setProperty,
         UnboxedArrayObject::obj_getOwnPropertyDescriptor,
         UnboxedArrayObject::obj_deleteProperty,
         UnboxedArrayObject::obj_watch,
         nullptr,   /* No unwatch needed, as watch() converts the object to native */
         nullptr,   /* getElements */
         UnboxedArrayObject::obj_enumerate,
-        nullptr,   /* thisObject */
+        nullptr,   /* thisValue */
     }
 };
 
 /////////////////////////////////////////////////////////////////////
 // API
 /////////////////////////////////////////////////////////////////////
 
 static bool