path: root/js/src/jsapi-tests/testGCExactRooting.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/Maybe.h"
#include "mozilla/Result.h"
#include "mozilla/ResultVariant.h"

#include "ds/TraceableFifo.h"
#include "gc/Policy.h"
#include "js/GCHashTable.h"
#include "js/GCVector.h"
#include "js/PropertyAndElement.h"  // JS_DefineProperty, JS_GetProperty, JS_SetProperty
#include "js/RootingAPI.h"

#include "jsapi-tests/tests.h"

using namespace js;

using mozilla::Maybe;
using mozilla::Some;

BEGIN_TEST(testGCExactRooting) {
  JS::RootedObject rootCx(cx, JS_NewPlainObject(cx));

  JS_GC(cx);

  /* Use the objects we just created to ensure that they are still alive. */
  JS_DefineProperty(cx, rootCx, "foo", JS::UndefinedHandleValue, 0);

  return true;
}
END_TEST(testGCExactRooting)

BEGIN_TEST(testGCSuppressions) {
  JS::AutoAssertNoGC nogc;
  JS::AutoCheckCannotGC checkgc;
  JS::AutoSuppressGCAnalysis noanalysis;

  JS::AutoAssertNoGC nogcCx(cx);
  JS::AutoCheckCannotGC checkgcCx(cx);
  JS::AutoSuppressGCAnalysis noanalysisCx(cx);

  return true;
}
END_TEST(testGCSuppressions)

struct MyContainer {
  int whichConstructor;
  HeapPtr<JSObject*> obj;
  HeapPtr<JSString*> str;

  MyContainer() : whichConstructor(1), obj(nullptr), str(nullptr) {}
  explicit MyContainer(double) : MyContainer() { whichConstructor = 2; }
  explicit MyContainer(JSContext* cx) : MyContainer() { whichConstructor = 3; }
  MyContainer(JSContext* cx, JSContext* cx2, JSContext* cx3) : MyContainer() {
    whichConstructor = 4;
  }
  MyContainer(const MyContainer& rhs)
      : whichConstructor(100 + rhs.whichConstructor),
        obj(rhs.obj),
        str(rhs.str) {}
  void trace(JSTracer* trc) {
    js::TraceNullableEdge(trc, &obj, "test container obj");
    js::TraceNullableEdge(trc, &str, "test container str");
  }
};

struct MyNonCopyableContainer {
  int whichConstructor;
  HeapPtr<JSObject*> obj;
  HeapPtr<JSString*> str;

  MyNonCopyableContainer() : whichConstructor(1), obj(nullptr), str(nullptr) {}
  explicit MyNonCopyableContainer(double) : MyNonCopyableContainer() {
    whichConstructor = 2;
  }
  explicit MyNonCopyableContainer(JSContext* cx) : MyNonCopyableContainer() {
    whichConstructor = 3;
  }
  explicit MyNonCopyableContainer(JSContext* cx, JSContext* cx2, JSContext* cx3)
      : MyNonCopyableContainer() {
    whichConstructor = 4;
  }

  MyNonCopyableContainer(const MyNonCopyableContainer&) = delete;
  MyNonCopyableContainer& operator=(const MyNonCopyableContainer&) = delete;

  void trace(JSTracer* trc) {
    js::TraceNullableEdge(trc, &obj, "test container obj");
    js::TraceNullableEdge(trc, &str, "test container str");
  }
};

namespace js {
template <typename Wrapper>
struct MutableWrappedPtrOperations<MyContainer, Wrapper> {
  HeapPtr<JSObject*>& obj() { return static_cast<Wrapper*>(this)->get().obj; }
  HeapPtr<JSString*>& str() { return static_cast<Wrapper*>(this)->get().str; }
  int constructor() {
    return static_cast<Wrapper*>(this)->get().whichConstructor;
  }
};

template <typename Wrapper>
struct MutableWrappedPtrOperations<MyNonCopyableContainer, Wrapper> {
  HeapPtr<JSObject*>& obj() { return static_cast<Wrapper*>(this)->get().obj; }
  HeapPtr<JSString*>& str() { return static_cast<Wrapper*>(this)->get().str; }
  int constructor() {
    return static_cast<Wrapper*>(this)->get().whichConstructor;
  }
};
}  // namespace js

BEGIN_TEST(testGCRootedStaticStructInternalStackStorageAugmented) {
  // Test Rooted constructors for a copyable type.
  JS::Rooted<MyContainer> r1(cx);
  JS::Rooted<MyContainer> r2(cx, 3.4);
  JS::Rooted<MyContainer> r3(cx, MyContainer(cx));
  JS::Rooted<MyContainer> r4(cx, cx);
  JS::Rooted<MyContainer> r5(cx, cx, cx, cx);

  JS::Rooted<Value> rv(cx);

  CHECK_EQUAL(r1.constructor(), 1);    // direct SafelyInitialized<T>
  CHECK_EQUAL(r2.constructor(), 2);    // direct MyContainer(3.4)
  CHECK_EQUAL(r3.constructor(), 103);  // copy of MyContainer(cx)
  CHECK_EQUAL(r4.constructor(), 3);    // direct MyContainer(cx)
  CHECK_EQUAL(r5.constructor(), 4);    // direct MyContainer(cx, cx, cx)

  // Test Rooted constructor forwarding for a non-copyable type.
  JS::Rooted<MyNonCopyableContainer> nc1(cx);
  JS::Rooted<MyNonCopyableContainer> nc2(cx, 3.4);
  // Compile error: cannot copy
  // JS::Rooted<MyNonCopyableContainer> nc3(cx, MyNonCopyableContainer(cx));
  JS::Rooted<MyNonCopyableContainer> nc4(cx, cx);
  JS::Rooted<MyNonCopyableContainer> nc5(cx, cx, cx, cx);

  CHECK_EQUAL(nc1.constructor(), 1);  // direct MyNonCopyableContainer()
  CHECK_EQUAL(nc2.constructor(), 2);  // direct MyNonCopyableContainer(3.4)
  CHECK_EQUAL(nc4.constructor(), 3);  // direct MyNonCopyableContainer(cx)
  CHECK_EQUAL(nc5.constructor(),
              4);  // direct MyNonCopyableContainer(cx, cx, cx)

  JS::Rooted<MyContainer> container(cx);
  container.obj() = JS_NewObject(cx, nullptr);
  container.str() = JS_NewStringCopyZ(cx, "Hello");

  JS_GC(cx);
  JS_GC(cx);

  JS::RootedObject obj(cx, container.obj());
  JS::RootedValue val(cx, StringValue(container.str()));
  CHECK(JS_SetProperty(cx, obj, "foo", val));
  obj = nullptr;
  val = UndefinedValue();

  {
    JS::RootedString actual(cx);
    bool same;

    // Automatic move from stack to heap.
    JS::PersistentRooted<MyContainer> heap(cx, container);

    // Copyable types in place.
    JS::PersistentRooted<MyContainer> cp1(cx);
    JS::PersistentRooted<MyContainer> cp2(cx, 7.8);
    JS::PersistentRooted<MyContainer> cp3(cx, cx);
    JS::PersistentRooted<MyContainer> cp4(cx, cx, cx, cx);

    CHECK_EQUAL(cp1.constructor(), 1);  // direct SafelyInitialized<T>
    CHECK_EQUAL(cp2.constructor(), 2);  // direct MyContainer(double)
    CHECK_EQUAL(cp3.constructor(), 3);  // direct MyContainer(cx)
    CHECK_EQUAL(cp4.constructor(), 4);  // direct MyContainer(cx, cx, cx)

    // Construct uncopyable type in place.
    JS::PersistentRooted<MyNonCopyableContainer> ncp1(cx);
    JS::PersistentRooted<MyNonCopyableContainer> ncp2(cx, 7.8);

    // We're not just using a 1-arg constructor, right?
    JS::PersistentRooted<MyNonCopyableContainer> ncp3(cx, cx);
    JS::PersistentRooted<MyNonCopyableContainer> ncp4(cx, cx, cx, cx);

    CHECK_EQUAL(ncp1.constructor(), 1);  // direct SafelyInitialized<T>
    CHECK_EQUAL(ncp2.constructor(), 2);  // direct Ctor(double)
    CHECK_EQUAL(ncp3.constructor(), 3);  // direct Ctor(cx)
    CHECK_EQUAL(ncp4.constructor(), 4);  // direct Ctor(cx, cx, cx)

    // clear prior rooting.
    container.obj() = nullptr;
    container.str() = nullptr;

    obj = heap.obj();
    CHECK(JS_GetProperty(cx, obj, "foo", &val));
    actual = val.toString();
    CHECK(JS_StringEqualsLiteral(cx, actual, "Hello", &same));
    CHECK(same);
    obj = nullptr;
    actual = nullptr;

    JS_GC(cx);
    JS_GC(cx);

    obj = heap.obj();
    CHECK(JS_GetProperty(cx, obj, "foo", &val));
    actual = val.toString();
    CHECK(JS_StringEqualsLiteral(cx, actual, "Hello", &same));
    CHECK(same);
    obj = nullptr;
    actual = nullptr;
  }

  return true;
}
END_TEST(testGCRootedStaticStructInternalStackStorageAugmented)

static JS::PersistentRooted<JSObject*> sLongLived;
BEGIN_TEST(testGCPersistentRootedOutlivesRuntime) {
  sLongLived.init(cx, JS_NewObject(cx, nullptr));
  CHECK(sLongLived);
  return true;
}
END_TEST(testGCPersistentRootedOutlivesRuntime)

// Unlike the above, the following test is an example of an invalid usage: for
// performance and simplicity reasons, PersistentRooted<Traceable> is not
// allowed to outlive the container it belongs to. The following commented out
// test can be used to verify that the relevant assertion fires as expected.
static JS::PersistentRooted<MyContainer> sContainer;
BEGIN_TEST(testGCPersistentRootedTraceableCannotOutliveRuntime) {
  JS::Rooted<MyContainer> container(cx);
  container.obj() = JS_NewObject(cx, nullptr);
  container.str() = JS_NewStringCopyZ(cx, "Hello");
  sContainer.init(cx, container);

  // Commenting the following line will trigger an assertion that the
  // PersistentRooted outlives the runtime it is attached to.
  sContainer.reset();

  return true;
}
END_TEST(testGCPersistentRootedTraceableCannotOutliveRuntime)

using MyHashMap = js::GCHashMap<js::Shape*, JSObject*>;

BEGIN_TEST(testGCRootedHashMap) {
  JS::Rooted<MyHashMap> map(cx, MyHashMap(cx, 15));

  for (size_t i = 0; i < 10; ++i) {
    RootedObject obj(cx, JS_NewObject(cx, nullptr));
    RootedValue val(cx, UndefinedValue());
    // Construct a unique property name to ensure that the object creates a
    // new shape.
    char buffer[2];
    buffer[0] = 'a' + i;
    buffer[1] = '\0';
    CHECK(JS_SetProperty(cx, obj, buffer, val));
    CHECK(map.putNew(obj->shape(), obj));
  }

  JS_GC(cx);
  JS_GC(cx);

  for (auto r = map.all(); !r.empty(); r.popFront()) {
    RootedObject obj(cx, r.front().value());
    CHECK(obj->shape() == r.front().key());
  }

  return true;
}
END_TEST(testGCRootedHashMap)

// Repeat of the test above, but without rooting. This is a rooting hazard. The
// JS_EXPECT_HAZARDS annotation will cause the hazard taskcluster job to fail
// if the hazard below is *not* detected.
BEGIN_TEST_WITH_ATTRIBUTES(testUnrootedGCHashMap, JS_EXPECT_HAZARDS) {
  MyHashMap map(cx, 15);

  for (size_t i = 0; i < 10; ++i) {
    RootedObject obj(cx, JS_NewObject(cx, nullptr));
    RootedValue val(cx, UndefinedValue());
    // Construct a unique property name to ensure that the object creates a
    // new shape.
    char buffer[2];
    buffer[0] = 'a' + i;
    buffer[1] = '\0';
    CHECK(JS_SetProperty(cx, obj, buffer, val));
    CHECK(map.putNew(obj->shape(), obj));
  }

  JS_GC(cx);

  // Access map to keep it live across the GC.
  CHECK(map.count() == 10);

  return true;
}
END_TEST(testUnrootedGCHashMap)

BEGIN_TEST(testSafelyUnrootedGCHashMap) {
  // This is not rooted, but it doesn't use GC pointers as keys or values so
  // it's ok.
  js::GCHashMap<uint64_t, uint64_t> map(cx, 15);

  JS_GC(cx);
  CHECK(map.putNew(12, 13));

  return true;
}
END_TEST(testSafelyUnrootedGCHashMap)

static bool FillMyHashMap(JSContext* cx, MutableHandle<MyHashMap> map) {
  for (size_t i = 0; i < 10; ++i) {
    RootedObject obj(cx, JS_NewObject(cx, nullptr));
    RootedValue val(cx, UndefinedValue());
    // Construct a unique property name to ensure that the object creates a
    // new shape.
    char buffer[2];
    buffer[0] = 'a' + i;
    buffer[1] = '\0';
    if (!JS_SetProperty(cx, obj, buffer, val)) {
      return false;
    }
    if (!map.putNew(obj->shape(), obj)) {
      return false;
    }
  }
  return true;
}

static bool CheckMyHashMap(JSContext* cx, Handle<MyHashMap> map) {
  for (auto r = map.all(); !r.empty(); r.popFront()) {
    RootedObject obj(cx, r.front().value());
    if (obj->shape() != r.front().key()) {
      return false;
    }
  }
  return true;
}

BEGIN_TEST(testGCHandleHashMap) {
  JS::Rooted<MyHashMap> map(cx, MyHashMap(cx, 15));

  CHECK(FillMyHashMap(cx, &map));

  JS_GC(cx);
  JS_GC(cx);

  CHECK(CheckMyHashMap(cx, map));

  return true;
}
END_TEST(testGCHandleHashMap)

using ShapeVec = GCVector<NativeShape*>;

BEGIN_TEST(testGCRootedVector) {
  JS::Rooted<ShapeVec> shapes(cx, cx);

  for (size_t i = 0; i < 10; ++i) {
    RootedObject obj(cx, JS_NewObject(cx, nullptr));
    RootedValue val(cx, UndefinedValue());
    // Construct a unique property name to ensure that the object creates a
    // new shape.
    char buffer[2];
    buffer[0] = 'a' + i;
    buffer[1] = '\0';
    CHECK(JS_SetProperty(cx, obj, buffer, val));
    CHECK(shapes.append(obj->as<NativeObject>().shape()));
  }

  JS_GC(cx);
  JS_GC(cx);

  for (size_t i = 0; i < 10; ++i) {
    // Check the shape to ensure it did not get collected.
    char letter = 'a' + i;
    bool match;
    ShapePropertyIter<NoGC> iter(shapes[i]);
    CHECK(JS_StringEqualsAscii(cx, iter->key().toString(), &letter, 1, &match));
    CHECK(match);
  }

  // Ensure iterator enumeration works through the rooted.
  for (auto shape : shapes) {
    CHECK(shape);
  }

  CHECK(receiveConstRefToShapeVector(shapes));

  // Ensure rooted converts to handles.
  CHECK(receiveHandleToShapeVector(shapes));
  CHECK(receiveMutableHandleToShapeVector(&shapes));

  return true;
}

bool receiveConstRefToShapeVector(
    const JS::Rooted<GCVector<NativeShape*>>& rooted) {
  // Ensure range enumeration works through the reference.
  for (auto shape : rooted) {
    CHECK(shape);
  }
  return true;
}

bool receiveHandleToShapeVector(JS::Handle<GCVector<NativeShape*>> handle) {
  // Ensure range enumeration works through the handle.
  for (auto shape : handle) {
    CHECK(shape);
  }
  return true;
}

bool receiveMutableHandleToShapeVector(
    JS::MutableHandle<GCVector<NativeShape*>> handle) {
  // Ensure range enumeration works through the handle.
  for (auto shape : handle) {
    CHECK(shape);
  }
  return true;
}
END_TEST(testGCRootedVector)

BEGIN_TEST(testTraceableFifo) {
  using ShapeFifo = TraceableFifo<NativeShape*>;
  JS::Rooted<ShapeFifo> shapes(cx, ShapeFifo(cx));
  CHECK(shapes.empty());

  for (size_t i = 0; i < 10; ++i) {
    RootedObject obj(cx, JS_NewObject(cx, nullptr));
    RootedValue val(cx, UndefinedValue());
    // Construct a unique property name to ensure that the object creates a
    // new shape.
    char buffer[2];
    buffer[0] = 'a' + i;
    buffer[1] = '\0';
    CHECK(JS_SetProperty(cx, obj, buffer, val));
    CHECK(shapes.pushBack(obj->as<NativeObject>().shape()));
  }

  CHECK(shapes.length() == 10);

  JS_GC(cx);
  JS_GC(cx);

  for (size_t i = 0; i < 10; ++i) {
    // Check the shape to ensure it did not get collected.
    char letter = 'a' + i;
    bool match;
    ShapePropertyIter<NoGC> iter(shapes.front());
    CHECK(JS_StringEqualsAscii(cx, iter->key().toString(), &letter, 1, &match));
    CHECK(match);
    shapes.popFront();
  }

  CHECK(shapes.empty());
  return true;
}
END_TEST(testTraceableFifo)

using ShapeVec = GCVector<NativeShape*>;

static bool FillVector(JSContext* cx, MutableHandle<ShapeVec> shapes) {
  for (size_t i = 0; i < 10; ++i) {
    RootedObject obj(cx, JS_NewObject(cx, nullptr));
    RootedValue val(cx, UndefinedValue());
    // Construct a unique property name to ensure that the object creates a
    // new shape.
    char buffer[2];
    buffer[0] = 'a' + i;
    buffer[1] = '\0';
    if (!JS_SetProperty(cx, obj, buffer, val)) {
      return false;
    }
    if (!shapes.append(obj->as<NativeObject>().shape())) {
      return false;
    }
  }

  // Ensure iterator enumeration works through the mutable handle.
  for (auto shape : shapes) {
    if (!shape) {
      return false;
    }
  }

  return true;
}

static bool CheckVector(JSContext* cx, Handle<ShapeVec> shapes) {
  for (size_t i = 0; i < 10; ++i) {
    // Check the shape to ensure it did not get collected.
    char letter = 'a' + i;
    bool match;
    ShapePropertyIter<NoGC> iter(shapes[i]);
    if (!JS_StringEqualsAscii(cx, iter->key().toString(), &letter, 1, &match)) {
      return false;
    }
    if (!match) {
      return false;
    }
  }

  // Ensure iterator enumeration works through the handle.
  for (auto shape : shapes) {
    if (!shape) {
      return false;
    }
  }

  return true;
}

BEGIN_TEST(testGCHandleVector) {
  JS::Rooted<ShapeVec> vec(cx, ShapeVec(cx));

  CHECK(FillVector(cx, &vec));

  JS_GC(cx);
  JS_GC(cx);

  CHECK(CheckVector(cx, vec));

  return true;
}
END_TEST(testGCHandleVector)

class Foo {
 public:
  Foo(int, int) {}
  void trace(JSTracer*) {}
};

using FooVector = JS::GCVector<Foo>;

BEGIN_TEST(testGCVectorEmplaceBack) {
  JS::Rooted<FooVector> vector(cx, FooVector(cx));

  CHECK(vector.emplaceBack(1, 2));

  return true;
}
END_TEST(testGCVectorEmplaceBack)

BEGIN_TEST(testRootedMaybeValue) {
  JS::Rooted<Maybe<Value>> maybeNothing(cx);
  CHECK(maybeNothing.isNothing());
  CHECK(!maybeNothing.isSome());

  JS::Rooted<Maybe<Value>> maybe(cx, Some(UndefinedValue()));
  CHECK(CheckConstOperations<Rooted<Maybe<Value>>&>(maybe));
  CHECK(CheckConstOperations<Handle<Maybe<Value>>>(maybe));
  CHECK(CheckConstOperations<MutableHandle<Maybe<Value>>>(&maybe));

  maybe = Some(JS::TrueValue());
  CHECK(CheckMutableOperations<Rooted<Maybe<Value>>&>(maybe));

  maybe = Some(JS::TrueValue());
  CHECK(CheckMutableOperations<MutableHandle<Maybe<Value>>>(&maybe));

  CHECK(JS::NothingHandleValue.isNothing());

  return true;
}

template <typename T>
bool CheckConstOperations(T someUndefinedValue) {
  CHECK(someUndefinedValue.isSome());
  CHECK(someUndefinedValue.value().isUndefined());
  CHECK(someUndefinedValue->isUndefined());
  CHECK((*someUndefinedValue).isUndefined());
  return true;
}

template <typename T>
bool CheckMutableOperations(T maybe) {
  CHECK(maybe->isTrue());

  *maybe = JS::FalseValue();
  CHECK(maybe->isFalse());

  maybe.reset();
  CHECK(maybe.isNothing());

  return true;
}

END_TEST(testRootedMaybeValue)

struct TestErr {};
struct OtherTestErr {};

struct SimpleTraceable {
  // I'm using plain objects rather than Heap<T> because Heap<T> would get
  // traced via the store buffer. Heap<T> would be a more realistic example,
  // but would require compaction to test for tracing.
  JSObject* obj;
  JS::Value val;

  void trace(JSTracer* trc) {
    TraceRoot(trc, &obj, "obj");
    TraceRoot(trc, &val, "val");
  }
};

namespace JS {
template <>
struct GCPolicy<TestErr> : public IgnoreGCPolicy<TestErr> {};
}  // namespace JS

BEGIN_TEST_WITH_ATTRIBUTES(testGCRootedResult, JS_EXPECT_HAZARDS) {
  AutoLeaveZeal noZeal(cx);

  JSObject* unrootedObj = JS_NewPlainObject(cx);
  CHECK(js::gc::IsInsideNursery(unrootedObj));
  Value unrootedVal = ObjectValue(*unrootedObj);

  RootedObject obj(cx, unrootedObj);
  RootedValue val(cx, unrootedVal);

  Result<Value, TestErr> unrootedValerr(val);
  Rooted<Result<Value, TestErr>> valerr(cx, val);

  Result<mozilla::Ok, Value> unrootedOkval(val);
  Rooted<Result<mozilla::Ok, Value>> okval(cx, val);

  Result<mozilla::Ok, TestErr> simple{mozilla::Ok()};

  Result<Value, JSObject*> unrootedValobj1(val);
  Rooted<Result<Value, JSObject*>> valobj1(cx, val);
  Result<Value, JSObject*> unrootedValobj2(obj);
  Rooted<Result<Value, JSObject*>> valobj2(cx, obj);

  // Test nested traceable structures.
  Result<mozilla::Maybe<mozilla::Ok>, JSObject*> maybeobj(
      mozilla::Some(mozilla::Ok()));
  Rooted<Result<mozilla::Maybe<mozilla::Ok>, JSObject*>> rooted_maybeobj(
      cx, mozilla::Some(mozilla::Ok()));

  // This would fail to compile because Result<> deletes its copy constructor,
  // which prevents updating after tracing:
  //
  // Rooted<Result<Result<mozilla::Ok, JS::Value>, JSObject*>>

  // But this should be fine when no tracing is required.
  Result<Result<mozilla::Ok, int>, double> dummy(3.4);

  // One thing I didn't realize initially about Result<>: unwrap() takes
  // ownership of a value. In the case of Result<Maybe>, that means the
  // contained Maybe is reset to Nothing.
  Result<mozilla::Maybe<int>, int> confusing(mozilla::Some(7));
  CHECK(confusing.unwrap().isSome());
  CHECK(!confusing.unwrap().isSome());

  Result<mozilla::Maybe<JS::Value>, JSObject*> maybevalobj(
      mozilla::Some(val.get()));
  Rooted<Result<mozilla::Maybe<JS::Value>, JSObject*>> rooted_maybevalobj(
      cx, mozilla::Some(val.get()));

  // Custom types that haven't had GCPolicy explicitly specialized.
  SimpleTraceable s1{obj, val};
  Result<SimpleTraceable, TestErr> custom(s1);
  SimpleTraceable s2{obj, val};
  Rooted<Result<SimpleTraceable, TestErr>> rootedCustom(cx, s2);

  CHECK(obj == unrootedObj);
  CHECK(val == unrootedVal);
  CHECK(simple.isOk());
  CHECK(unrootedValerr.inspect() == unrootedVal);
  CHECK(valerr.get().inspect() == val);
  CHECK(unrootedOkval.inspectErr() == unrootedVal);
  CHECK(okval.get().inspectErr() == val);
  CHECK(unrootedValobj1.inspect() == unrootedVal);
  CHECK(valobj1.get().inspect() == val);
  CHECK(unrootedValobj2.inspectErr() == unrootedObj);
  CHECK(valobj2.get().inspectErr() == obj);
  CHECK(*maybevalobj.inspect() == unrootedVal);
  CHECK(*rooted_maybevalobj.get().inspect() == val);
  CHECK(custom.inspect().obj == unrootedObj);
  CHECK(custom.inspect().val == unrootedVal);
  CHECK(rootedCustom.get().inspect().obj == obj);
  CHECK(rootedCustom.get().inspect().val == val);

  JS_GC(cx);

  CHECK(obj != unrootedObj);
  CHECK(val != unrootedVal);
  CHECK(unrootedValerr.inspect() == unrootedVal);
  CHECK(valerr.get().inspect() == val);
  CHECK(unrootedOkval.inspectErr() == unrootedVal);
  CHECK(okval.get().inspectErr() == val);
  CHECK(unrootedValobj1.inspect() == unrootedVal);
  CHECK(valobj1.get().inspect() == val);
  CHECK(unrootedValobj2.inspectErr() == unrootedObj);
  CHECK(valobj2.get().inspectErr() == obj);
  CHECK(*maybevalobj.inspect() == unrootedVal);
  CHECK(*rooted_maybevalobj.get().inspect() == val);
  MOZ_ASSERT(custom.inspect().obj == unrootedObj);
  CHECK(custom.inspect().obj == unrootedObj);
  CHECK(custom.inspect().val == unrootedVal);
  CHECK(rootedCustom.get().inspect().obj == obj);
  CHECK(rootedCustom.get().inspect().val == val);

  mozilla::Result<OtherTestErr, mozilla::Ok> r(mozilla::Ok{});
  (void)r;

  return true;
}
END_TEST(testGCRootedResult)

static int copies = 0;

struct DontCopyMe_Variant {
  JSObject* obj;
  explicit DontCopyMe_Variant(JSObject* objArg) : obj(objArg) {}
  DontCopyMe_Variant(const DontCopyMe_Variant& other) : obj(other.obj) {
    copies++;
  }
  DontCopyMe_Variant(DontCopyMe_Variant&& other) : obj(std::move(other.obj)) {
    other.obj = nullptr;
  }
  void trace(JSTracer* trc) { TraceRoot(trc, &obj, "obj"); }
};

enum struct TestUnusedZeroEnum : int16_t { Ok = 0, NotOk = 1 };

namespace mozilla::detail {
template <>
struct UnusedZero<TestUnusedZeroEnum> : UnusedZeroEnum<TestUnusedZeroEnum> {};
}  // namespace mozilla::detail

namespace JS {
template <>
struct GCPolicy<TestUnusedZeroEnum>
    : public IgnoreGCPolicy<TestUnusedZeroEnum> {};
}  // namespace JS

struct DontCopyMe_NullIsOk {
  JS::Value val;
  DontCopyMe_NullIsOk() : val(UndefinedValue()) {}
  explicit DontCopyMe_NullIsOk(const JS::Value& valArg) : val(valArg) {}
  DontCopyMe_NullIsOk(const DontCopyMe_NullIsOk& other) = delete;
  DontCopyMe_NullIsOk(DontCopyMe_NullIsOk&& other)
      : val(std::move(other.val)) {}
  DontCopyMe_NullIsOk& operator=(DontCopyMe_NullIsOk&& other) {
    val = std::move(other.val);
    other.val = UndefinedValue();
    return *this;
  }
  void trace(JSTracer* trc) { TraceRoot(trc, &val, "val"); }
};

struct Failed {};

namespace mozilla::detail {
template <>
struct UnusedZero<Failed> {
  using StorageType = uintptr_t;

  static constexpr bool value = true;
  static constexpr StorageType nullValue = 0;
  static constexpr StorageType GetDefaultValue() { return 2; }

  static constexpr void AssertValid(StorageType aValue) {}
  static constexpr Failed Inspect(const StorageType& aValue) {
    return Failed{};
  }
  static constexpr Failed Unwrap(StorageType aValue) { return Failed{}; }
  static constexpr StorageType Store(Failed aValue) {
    return GetDefaultValue();
  }
};
}  // namespace mozilla::detail

namespace JS {
template <>
struct GCPolicy<Failed> : public IgnoreGCPolicy<Failed> {};
}  // namespace JS

struct TriviallyCopyable_LowBitTagIsError {
  JSObject* obj;
  TriviallyCopyable_LowBitTagIsError() : obj(nullptr) {}
  explicit TriviallyCopyable_LowBitTagIsError(JSObject* objArg) : obj(objArg) {}
  TriviallyCopyable_LowBitTagIsError(
      const TriviallyCopyable_LowBitTagIsError& other) = default;
  void trace(JSTracer* trc) { TraceRoot(trc, &obj, "obj"); }
};

namespace mozilla::detail {
template <>
struct HasFreeLSB<TriviallyCopyable_LowBitTagIsError> : HasFreeLSB<JSObject*> {
};
}  // namespace mozilla::detail

BEGIN_TEST_WITH_ATTRIBUTES(testRootedResultCtors, JS_EXPECT_HAZARDS) {
  JSObject* unrootedObj = JS_NewPlainObject(cx);
  CHECK(unrootedObj);
  Rooted<JSObject*> obj(cx, unrootedObj);

  using mozilla::detail::PackingStrategy;

  static_assert(Result<DontCopyMe_Variant, TestErr>::Strategy ==
                PackingStrategy::Variant);
  Rooted<Result<DontCopyMe_Variant, TestErr>> vv(cx, DontCopyMe_Variant{obj});
  static_assert(Result<mozilla::Ok, DontCopyMe_Variant>::Strategy ==
                PackingStrategy::Variant);
  Rooted<Result<mozilla::Ok, DontCopyMe_Variant>> ve(cx,
                                                     DontCopyMe_Variant{obj});

  static_assert(Result<DontCopyMe_NullIsOk, TestUnusedZeroEnum>::Strategy ==
                PackingStrategy::NullIsOk);
  Rooted<Result<DontCopyMe_NullIsOk, TestUnusedZeroEnum>> nv(
      cx, DontCopyMe_NullIsOk{JS::ObjectValue(*obj)});

  static_assert(Result<TriviallyCopyable_LowBitTagIsError, Failed>::Strategy ==
                PackingStrategy::LowBitTagIsError);
  Rooted<Result<TriviallyCopyable_LowBitTagIsError, Failed>> lv(
      cx, TriviallyCopyable_LowBitTagIsError{obj});

  CHECK(obj == unrootedObj);

  CHECK(vv.get().inspect().obj == obj);
  CHECK(ve.get().inspectErr().obj == obj);
  CHECK(nv.get().inspect().val.toObjectOrNull() == obj);
  CHECK(lv.get().inspect().obj == obj);

  JS_GC(cx);
  CHECK(obj != unrootedObj);

  CHECK(vv.get().inspect().obj == obj);
  CHECK(ve.get().inspectErr().obj == obj);
  CHECK(nv.get().inspect().val.toObjectOrNull() == obj);
  CHECK(lv.get().inspect().obj == obj);
  CHECK(copies == 0);
  return true;
}
END_TEST(testRootedResultCtors)

#if defined(HAVE_64BIT_BUILD) && !defined(XP_WIN)

// This depends on a pointer fitting in 48 bits, leaving space for an empty
// struct and a bool in a packed struct. Windows doesn't seem to do this
// packing, so we'll skip this test here. We're primarily checking whether
// copy constructors get called, which should be cross-platform, and
// secondarily making sure that the Rooted/tracing stuff is compiled and
// executed properly. There are certainly more clever ways to do this that
// would work cross-platform, but it doesn't seem worth the bother right now.

struct __attribute__((packed)) DontCopyMe_PackedVariant {
  uintptr_t obj : 48;
  static JSObject* Unwrap(uintptr_t packed) {
    return reinterpret_cast<JSObject*>(packed);
  }
  static uintptr_t Store(JSObject* obj) {
    return reinterpret_cast<uintptr_t>(obj);
  }

  DontCopyMe_PackedVariant() : obj(0) {}
  explicit DontCopyMe_PackedVariant(JSObject* objArg)
      : obj(reinterpret_cast<uintptr_t>(objArg)) {}
  DontCopyMe_PackedVariant(const DontCopyMe_PackedVariant& other)
      : obj(other.obj) {
    copies++;
  }
  DontCopyMe_PackedVariant(DontCopyMe_PackedVariant&& other) : obj(other.obj) {
    other.obj = 0;
  }
  void trace(JSTracer* trc) {
    JSObject* realObj = Unwrap(obj);
    TraceRoot(trc, &realObj, "obj");
    obj = Store(realObj);
  }
};

static_assert(std::is_default_constructible_v<DontCopyMe_PackedVariant>);
static_assert(std::is_default_constructible_v<TestErr>);
static_assert(mozilla::detail::IsPackableVariant<DontCopyMe_PackedVariant,
                                                 TestErr>::value);

BEGIN_TEST_WITH_ATTRIBUTES(testResultPackedVariant, JS_EXPECT_HAZARDS) {
  JSObject* unrootedObj = JS_NewPlainObject(cx);
  CHECK(unrootedObj);
  Rooted<JSObject*> obj(cx, unrootedObj);

  using mozilla::detail::PackingStrategy;

  static_assert(Result<DontCopyMe_PackedVariant, TestErr>::Strategy ==
                PackingStrategy::PackedVariant);
  Rooted<Result<DontCopyMe_PackedVariant, TestErr>> pv(
      cx, DontCopyMe_PackedVariant{obj});
  static_assert(Result<mozilla::Ok, DontCopyMe_PackedVariant>::Strategy ==
                PackingStrategy::PackedVariant);
  Rooted<Result<mozilla::Ok, DontCopyMe_PackedVariant>> pe(
      cx, DontCopyMe_PackedVariant{obj});

  CHECK(obj == unrootedObj);

  CHECK(DontCopyMe_PackedVariant::Unwrap(pv.get().inspect().obj) == obj);
  CHECK(DontCopyMe_PackedVariant::Unwrap(pe.get().inspectErr().obj) == obj);

  JS_GC(cx);
  CHECK(obj != unrootedObj);

  CHECK(DontCopyMe_PackedVariant::Unwrap(pv.get().inspect().obj) == obj);
  CHECK(DontCopyMe_PackedVariant::Unwrap(pe.get().inspectErr().obj) == obj);

  return true;
}
END_TEST(testResultPackedVariant)

#endif  // HAVE_64BIT_BUILD