Add m-esr52 at 52.6.0

1 files changed, 341 insertions, 0 deletions

diff --git a/js/src/builtin/MapObject.h b/js/src/builtin/MapObject.h
new file mode 100644
index 000000000..9473e6b70
--- /dev/null
+++ b/js/src/builtin/MapObject.h
@@ -0,0 +1,341 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * 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/. */
+
+#ifndef builtin_MapObject_h
+#define builtin_MapObject_h
+
+#include "jsobj.h"
+
+#include "builtin/SelfHostingDefines.h"
+#include "vm/GlobalObject.h"
+#include "vm/NativeObject.h"
+#include "vm/PIC.h"
+#include "vm/Runtime.h"
+
+namespace js {
+
+/*
+ * Comparing two ropes for equality can fail. The js::HashTable template
+ * requires infallible hash() and match() operations. Therefore we require
+ * all values to be converted to hashable form before being used as a key
+ * in a Map or Set object.
+ *
+ * All values except ropes are hashable as-is.
+ */
+class HashableValue
+{
+    PreBarrieredValue value;
+
+  public:
+    struct Hasher {
+        typedef HashableValue Lookup;
+        static HashNumber hash(const Lookup& v, const mozilla::HashCodeScrambler& hcs) {
+            return v.hash(hcs);
+        }
+        static bool match(const HashableValue& k, const Lookup& l) { return k == l; }
+        static bool isEmpty(const HashableValue& v) { return v.value.isMagic(JS_HASH_KEY_EMPTY); }
+        static void makeEmpty(HashableValue* vp) { vp->value = MagicValue(JS_HASH_KEY_EMPTY); }
+    };
+
+    HashableValue() : value(UndefinedValue()) {}
+
+    MOZ_MUST_USE bool setValue(JSContext* cx, HandleValue v);
+    HashNumber hash(const mozilla::HashCodeScrambler& hcs) const;
+    bool operator==(const HashableValue& other) const;
+    HashableValue mark(JSTracer* trc) const;
+    Value get() const { return value.get(); }
+
+    void trace(JSTracer* trc) {
+        TraceEdge(trc, &value, "HashableValue");
+    }
+};
+
+template <>
+class RootedBase<HashableValue> {
+  public:
+    MOZ_MUST_USE bool setValue(JSContext* cx, HandleValue v) {
+        return static_cast<JS::Rooted<HashableValue>*>(this)->get().setValue(cx, v);
+    }
+    Value value() const {
+        return static_cast<const JS::Rooted<HashableValue>*>(this)->get().get();
+    }
+};
+
+template <class Key, class Value, class OrderedHashPolicy, class AllocPolicy>
+class OrderedHashMap;
+
+template <class T, class OrderedHashPolicy, class AllocPolicy>
+class OrderedHashSet;
+
+typedef OrderedHashMap<HashableValue,
+                       HeapPtr<Value>,
+                       HashableValue::Hasher,
+                       RuntimeAllocPolicy> ValueMap;
+
+typedef OrderedHashSet<HashableValue,
+                       HashableValue::Hasher,
+                       RuntimeAllocPolicy> ValueSet;
+
+template <typename ObjectT>
+class OrderedHashTableRef;
+
+struct UnbarrieredHashPolicy;
+
+class MapObject : public NativeObject {
+  public:
+    enum IteratorKind { Keys, Values, Entries };
+    static_assert(Keys == ITEM_KIND_KEY,
+                  "IteratorKind Keys must match self-hosting define for item kind key.");
+    static_assert(Values == ITEM_KIND_VALUE,
+                  "IteratorKind Values must match self-hosting define for item kind value.");
+    static_assert(Entries == ITEM_KIND_KEY_AND_VALUE,
+                  "IteratorKind Entries must match self-hosting define for item kind "
+                  "key-and-value.");
+
+    static JSObject* initClass(JSContext* cx, JSObject* obj);
+    static const Class class_;
+
+    enum { NurseryKeysSlot, SlotCount };
+
+    static MOZ_MUST_USE bool getKeysAndValuesInterleaved(JSContext* cx, HandleObject obj,
+                                            JS::MutableHandle<GCVector<JS::Value>> entries);
+    static MOZ_MUST_USE bool entries(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool has(JSContext* cx, unsigned argc, Value* vp);
+    static MapObject* create(JSContext* cx, HandleObject proto = nullptr);
+
+    // Publicly exposed Map calls for JSAPI access (webidl maplike/setlike
+    // interfaces, etc.)
+    static uint32_t size(JSContext *cx, HandleObject obj);
+    static MOZ_MUST_USE bool get(JSContext *cx, HandleObject obj, HandleValue key,
+                                 MutableHandleValue rval);
+    static MOZ_MUST_USE bool has(JSContext *cx, HandleObject obj, HandleValue key, bool* rval);
+    static MOZ_MUST_USE bool delete_(JSContext *cx, HandleObject obj, HandleValue key, bool* rval);
+
+    // Set call for public JSAPI exposure. Does not actually return map object
+    // as stated in spec, expects caller to return a value. for instance, with
+    // webidl maplike/setlike, should return interface object.
+    static MOZ_MUST_USE bool set(JSContext *cx, HandleObject obj, HandleValue key, HandleValue val);
+    static MOZ_MUST_USE bool clear(JSContext *cx, HandleObject obj);
+    static MOZ_MUST_USE bool iterator(JSContext *cx, IteratorKind kind, HandleObject obj,
+                                      MutableHandleValue iter);
+
+    using UnbarrieredTable = OrderedHashMap<Value, Value, UnbarrieredHashPolicy, RuntimeAllocPolicy>;
+    friend class OrderedHashTableRef<MapObject>;
+
+  private:
+    static const ClassOps classOps_;
+
+    static const JSPropertySpec properties[];
+    static const JSFunctionSpec methods[];
+    static const JSPropertySpec staticProperties[];
+    ValueMap* getData() { return static_cast<ValueMap*>(getPrivate()); }
+    static ValueMap& extract(HandleObject o);
+    static ValueMap& extract(const CallArgs& args);
+    static void mark(JSTracer* trc, JSObject* obj);
+    static void finalize(FreeOp* fop, JSObject* obj);
+    static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
+
+    static bool is(HandleValue v);
+    static bool is(HandleObject o);
+
+    static MOZ_MUST_USE bool iterator_impl(JSContext* cx, const CallArgs& args, IteratorKind kind);
+
+    static MOZ_MUST_USE bool size_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool size(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool get_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool get(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool has_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool set_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool set(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool delete_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool keys_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool keys(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool values_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool values(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool entries_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool clear_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool clear(JSContext* cx, unsigned argc, Value* vp);
+};
+
+class MapIteratorObject : public NativeObject
+{
+  public:
+    static const Class class_;
+
+    enum { TargetSlot, RangeSlot, KindSlot, SlotCount };
+
+    static_assert(TargetSlot == ITERATOR_SLOT_TARGET,
+                  "TargetSlot must match self-hosting define for iterated object slot.");
+    static_assert(RangeSlot == ITERATOR_SLOT_RANGE,
+                  "RangeSlot must match self-hosting define for range or index slot.");
+    static_assert(KindSlot == ITERATOR_SLOT_ITEM_KIND,
+                  "KindSlot must match self-hosting define for item kind slot.");
+
+    static const JSFunctionSpec methods[];
+    static MapIteratorObject* create(JSContext* cx, HandleObject mapobj, ValueMap* data,
+                                     MapObject::IteratorKind kind);
+    static void finalize(FreeOp* fop, JSObject* obj);
+
+    static MOZ_MUST_USE bool next(Handle<MapIteratorObject*> mapIterator,
+                                  HandleArrayObject resultPairObj, JSContext* cx);
+
+    static JSObject* createResultPair(JSContext* cx);
+
+  private:
+    inline MapObject::IteratorKind kind() const;
+};
+
+class SetObject : public NativeObject {
+  public:
+    enum IteratorKind { Keys, Values, Entries };
+
+    static_assert(Keys == ITEM_KIND_KEY,
+                  "IteratorKind Keys must match self-hosting define for item kind key.");
+    static_assert(Values == ITEM_KIND_VALUE,
+                  "IteratorKind Values must match self-hosting define for item kind value.");
+    static_assert(Entries == ITEM_KIND_KEY_AND_VALUE,
+                  "IteratorKind Entries must match self-hosting define for item kind "
+                  "key-and-value.");
+
+    static JSObject* initClass(JSContext* cx, JSObject* obj);
+    static const Class class_;
+
+    enum { NurseryKeysSlot, SlotCount };
+
+    static MOZ_MUST_USE bool keys(JSContext *cx, HandleObject obj,
+                                  JS::MutableHandle<GCVector<JS::Value>> keys);
+    static MOZ_MUST_USE bool values(JSContext *cx, unsigned argc, Value *vp);
+    static MOZ_MUST_USE bool add(JSContext *cx, HandleObject obj, HandleValue key);
+    static MOZ_MUST_USE bool has(JSContext *cx, unsigned argc, Value *vp);
+
+    // Publicly exposed Set calls for JSAPI access (webidl maplike/setlike
+    // interfaces, etc.)
+    static SetObject* create(JSContext *cx, HandleObject proto = nullptr);
+    static uint32_t size(JSContext *cx, HandleObject obj);
+    static MOZ_MUST_USE bool has(JSContext *cx, HandleObject obj, HandleValue key, bool* rval);
+    static MOZ_MUST_USE bool clear(JSContext *cx, HandleObject obj);
+    static MOZ_MUST_USE bool iterator(JSContext *cx, IteratorKind kind, HandleObject obj,
+                                      MutableHandleValue iter);
+    static MOZ_MUST_USE bool delete_(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
+
+    using UnbarrieredTable = OrderedHashSet<Value, UnbarrieredHashPolicy, RuntimeAllocPolicy>;
+    friend class OrderedHashTableRef<SetObject>;
+
+  private:
+    static const ClassOps classOps_;
+
+    static const JSPropertySpec properties[];
+    static const JSFunctionSpec methods[];
+    static const JSPropertySpec staticProperties[];
+
+    ValueSet* getData() { return static_cast<ValueSet*>(getPrivate()); }
+    static ValueSet& extract(HandleObject o);
+    static ValueSet& extract(const CallArgs& args);
+    static void mark(JSTracer* trc, JSObject* obj);
+    static void finalize(FreeOp* fop, JSObject* obj);
+    static bool construct(JSContext* cx, unsigned argc, Value* vp);
+
+    static bool is(HandleValue v);
+    static bool is(HandleObject o);
+
+    static bool isBuiltinAdd(HandleValue add, JSContext* cx);
+
+    static MOZ_MUST_USE bool iterator_impl(JSContext* cx, const CallArgs& args, IteratorKind kind);
+
+    static MOZ_MUST_USE bool size_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool size(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool has_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool add_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool add(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool delete_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool values_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool entries_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool entries(JSContext* cx, unsigned argc, Value* vp);
+    static MOZ_MUST_USE bool clear_impl(JSContext* cx, const CallArgs& args);
+    static MOZ_MUST_USE bool clear(JSContext* cx, unsigned argc, Value* vp);
+};
+
+class SetIteratorObject : public NativeObject
+{
+  public:
+    static const Class class_;
+
+    enum { TargetSlot, RangeSlot, KindSlot, SlotCount };
+
+    static_assert(TargetSlot == ITERATOR_SLOT_TARGET,
+                  "TargetSlot must match self-hosting define for iterated object slot.");
+    static_assert(RangeSlot == ITERATOR_SLOT_RANGE,
+                  "RangeSlot must match self-hosting define for range or index slot.");
+    static_assert(KindSlot == ITERATOR_SLOT_ITEM_KIND,
+                  "KindSlot must match self-hosting define for item kind slot.");
+
+    static const JSFunctionSpec methods[];
+    static SetIteratorObject* create(JSContext* cx, HandleObject setobj, ValueSet* data,
+                                     SetObject::IteratorKind kind);
+    static void finalize(FreeOp* fop, JSObject* obj);
+
+    static MOZ_MUST_USE bool next(Handle<SetIteratorObject*> setIterator,
+                                  HandleArrayObject resultObj, JSContext* cx);
+
+    static JSObject* createResult(JSContext* cx);
+
+  private:
+    inline SetObject::IteratorKind kind() const;
+};
+
+using SetInitGetPrototypeOp = NativeObject* (*)(JSContext*, Handle<GlobalObject*>);
+using SetInitIsBuiltinOp = bool (*)(HandleValue, JSContext*);
+
+template <SetInitGetPrototypeOp getPrototypeOp, SetInitIsBuiltinOp isBuiltinOp>
+static MOZ_MUST_USE bool
+IsOptimizableInitForSet(JSContext* cx, HandleObject setObject, HandleValue iterable, bool* optimized)
+{
+    MOZ_ASSERT(!*optimized);
+
+    if (!iterable.isObject())
+        return true;
+
+    RootedObject array(cx, &iterable.toObject());
+    if (!IsPackedArray(array))
+        return true;
+
+    // Get the canonical prototype object.
+    RootedNativeObject setProto(cx, getPrototypeOp(cx, cx->global()));
+    if (!setProto)
+        return false;
+
+    // Ensures setObject's prototype is the canonical prototype.
+    if (setObject->staticPrototype() != setProto)
+        return true;
+
+    // Look up the 'add' value on the prototype object.
+    Shape* addShape = setProto->lookup(cx, cx->names().add);
+    if (!addShape || !addShape->hasSlot())
+        return true;
+
+    // Get the referred value, ensure it holds the canonical add function.
+    RootedValue add(cx, setProto->getSlot(addShape->slot()));
+    if (!isBuiltinOp(add, cx))
+        return true;
+
+    ForOfPIC::Chain* stubChain = ForOfPIC::getOrCreate(cx);
+    if (!stubChain)
+        return false;
+
+    return stubChain->tryOptimizeArray(cx, array.as<ArrayObject>(), optimized);
+}
+
+extern JSObject*
+InitMapClass(JSContext* cx, HandleObject obj);
+
+extern JSObject*
+InitSetClass(JSContext* cx, HandleObject obj);
+
+} /* namespace js */
+
+#endif /* builtin_MapObject_h */