Bug 1317389: Change property attributes for generator and async functions to match ES2015/2017.

Tag #1287

6 files changed, 209 insertions, 12 deletions

diff --git a/js/src/tests/ecma_2017/AsyncFunctions/properties.js b/js/src/tests/ecma_2017/AsyncFunctions/properties.js
new file mode 100644
index 000000000..ca383901b
--- /dev/null
+++ b/js/src/tests/ecma_2017/AsyncFunctions/properties.js
@@ -0,0 +1,76 @@
+/* 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/. */
+
+function assertOwnDescriptor(object, propertyKey, expected) {
+  var desc = Object.getOwnPropertyDescriptor(object, propertyKey);
+  if (desc === undefined) {
+    assertEq(expected, undefined, "Property shouldn't be present");
+    return;
+  }
+
+  assertEq(desc.enumerable, expected.enumerable, `${String(propertyKey)}.[[Enumerable]]`);
+  assertEq(desc.configurable, expected.configurable, `${String(propertyKey)}.[[Configurable]]`);
+
+  if (Object.prototype.hasOwnProperty.call(desc, "value")) {
+    assertEq(desc.value, expected.value, `${String(propertyKey)}.[[Value]]`);
+    assertEq(desc.writable, expected.writable, `${String(propertyKey)}.[[Writable]]`);
+  } else {
+    assertEq(desc.get, expected.get, `${String(propertyKey)}.[[Get]]`);
+    assertEq(desc.set, expected.set, `${String(propertyKey)}.[[Set]]`);
+  }
+}
+
+async function asyncFunc(){}
+var AsyncFunctionPrototype = Object.getPrototypeOf(asyncFunc);
+var AsyncFunction = AsyncFunctionPrototype.constructor;
+
+
+// ES2017, 25.5.2 Properties of the AsyncFunction Constructor
+
+assertEqArray(Object.getOwnPropertyNames(AsyncFunction).sort(), ["length", "name", "prototype"]);
+assertEqArray(Object.getOwnPropertySymbols(AsyncFunction), []);
+
+assertOwnDescriptor(AsyncFunction, "length", {
+    value: 1, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(AsyncFunction, "name", {
+    value: "AsyncFunction", writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(AsyncFunction, "prototype", {
+    value: AsyncFunctionPrototype, writable: false, enumerable: false, configurable: false
+});
+
+
+// ES2017, 25.5.3 Properties of the AsyncFunction Prototype Object
+
+assertEqArray(Object.getOwnPropertyNames(AsyncFunctionPrototype).sort(), ["constructor"]);
+assertEqArray(Object.getOwnPropertySymbols(AsyncFunctionPrototype), [Symbol.toStringTag]);
+
+assertOwnDescriptor(AsyncFunctionPrototype, "constructor", {
+    value: AsyncFunction, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(AsyncFunctionPrototype, Symbol.toStringTag, {
+    value: "AsyncFunction", writable: false, enumerable: false, configurable: true
+});
+
+
+// ES2017, 25.5.4 AsyncFunction Instances
+
+assertEqArray(Object.getOwnPropertyNames(asyncFunc).sort(), ["length", "name"]);
+assertEqArray(Object.getOwnPropertySymbols(asyncFunc), []);
+
+assertOwnDescriptor(asyncFunc, "length", {
+    value: 0, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(asyncFunc, "name", {
+    value: "asyncFunc", writable: false, enumerable: false, configurable: true
+});
+
+
+if (typeof reportCompare == "function")
+    reportCompare(true, true);
diff --git a/js/src/tests/ecma_6/Generators/properties.js b/js/src/tests/ecma_6/Generators/properties.js
new file mode 100644
index 000000000..7782e64c0
--- /dev/null
+++ b/js/src/tests/ecma_6/Generators/properties.js
@@ -0,0 +1,111 @@
+/* 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/. */
+
+function assertOwnDescriptor(object, propertyKey, expected) {
+  var desc = Object.getOwnPropertyDescriptor(object, propertyKey);
+  if (desc === undefined) {
+    assertEq(expected, undefined, "Property shouldn't be present");
+    return;
+  }
+
+  assertEq(desc.enumerable, expected.enumerable, `${String(propertyKey)}.[[Enumerable]]`);
+  assertEq(desc.configurable, expected.configurable, `${String(propertyKey)}.[[Configurable]]`);
+
+  if (Object.prototype.hasOwnProperty.call(desc, "value")) {
+    assertEq(desc.value, expected.value, `${String(propertyKey)}.[[Value]]`);
+    assertEq(desc.writable, expected.writable, `${String(propertyKey)}.[[Writable]]`);
+  } else {
+    assertEq(desc.get, expected.get, `${String(propertyKey)}.[[Get]]`);
+    assertEq(desc.set, expected.set, `${String(propertyKey)}.[[Set]]`);
+  }
+}
+
+function* generator(){}
+var GeneratorFunctionPrototype = Object.getPrototypeOf(generator);
+var GeneratorFunction = GeneratorFunctionPrototype.constructor;
+var GeneratorPrototype = GeneratorFunctionPrototype.prototype;
+
+
+// ES2017, 25.2.2 Properties of the GeneratorFunction Constructor
+
+assertEqArray(Object.getOwnPropertyNames(GeneratorFunction).sort(), ["length", "name", "prototype"]);
+assertEqArray(Object.getOwnPropertySymbols(GeneratorFunction), []);
+
+assertOwnDescriptor(GeneratorFunction, "length", {
+    value: 1, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorFunction, "name", {
+    value: "GeneratorFunction", writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorFunction, "prototype", {
+    value: GeneratorFunctionPrototype, writable: false, enumerable: false, configurable: false
+});
+
+
+// ES2017, 25.2.3 Properties of the GeneratorFunction Prototype Object
+
+assertEqArray(Object.getOwnPropertyNames(GeneratorFunctionPrototype).sort(), ["constructor", "prototype"]);
+assertEqArray(Object.getOwnPropertySymbols(GeneratorFunctionPrototype), [Symbol.toStringTag]);
+
+assertOwnDescriptor(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorFunctionPrototype, "prototype", {
+    value: GeneratorPrototype, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorFunctionPrototype, Symbol.toStringTag, {
+    value: "GeneratorFunction", writable: false, enumerable: false, configurable: true
+});
+
+
+// ES2017, 25.2.4 GeneratorFunction Instances
+
+assertEqArray(Object.getOwnPropertyNames(generator).sort(), ["length", "name", "prototype"]);
+assertEqArray(Object.getOwnPropertySymbols(generator), []);
+
+assertOwnDescriptor(generator, "length", {
+    value: 0, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(generator, "name", {
+    value: "generator", writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(generator, "prototype", {
+    value: generator.prototype, writable: true, enumerable: false, configurable: false
+});
+
+
+// ES2017, 25.3.1 Properties of Generator Prototype
+
+assertEqArray(Object.getOwnPropertyNames(GeneratorPrototype).sort(), ["constructor", "next", "return", "throw"]);
+assertEqArray(Object.getOwnPropertySymbols(GeneratorPrototype), [Symbol.toStringTag]);
+
+assertOwnDescriptor(GeneratorPrototype, "constructor", {
+    value: GeneratorFunctionPrototype, writable: false, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorPrototype, "next", {
+    value: GeneratorPrototype.next, writable: true, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorPrototype, "return", {
+    value: GeneratorPrototype.return, writable: true, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorPrototype, "throw", {
+    value: GeneratorPrototype.throw, writable: true, enumerable: false, configurable: true
+});
+
+assertOwnDescriptor(GeneratorPrototype, Symbol.toStringTag, {
+    value: "Generator", writable: false, enumerable: false, configurable: true
+});
+
+
+if (typeof reportCompare == "function")
+    reportCompare(true, true);
diff --git a/js/src/vm/AsyncFunction.cpp b/js/src/vm/AsyncFunction.cpp
index 2bcec5465..7132ed984 100644
--- a/js/src/vm/AsyncFunction.cpp
+++ b/js/src/vm/AsyncFunction.cpp
@@ -40,8 +40,11 @@ GlobalObject::initAsyncFunction(JSContext* cx, Handle<GlobalObject*> global)
                                                         proto));
     if (!asyncFunction)
         return false;
-    if (!LinkConstructorAndPrototype(cx, asyncFunction, asyncFunctionProto))
+    if (!LinkConstructorAndPrototype(cx, asyncFunction, asyncFunctionProto,
+                                     JSPROP_PERMANENT | JSPROP_READONLY, JSPROP_READONLY))
+    {
         return false;
+    }
 
     global->setReservedSlot(ASYNC_FUNCTION, ObjectValue(*asyncFunction));
     global->setReservedSlot(ASYNC_FUNCTION_PROTO, ObjectValue(*asyncFunctionProto));
diff --git a/js/src/vm/GeneratorObject.cpp b/js/src/vm/GeneratorObject.cpp
index 11c686f28..2f5c63c28 100644
--- a/js/src/vm/GeneratorObject.cpp
+++ b/js/src/vm/GeneratorObject.cpp
@@ -316,7 +316,8 @@ GlobalObject::initStarGenerators(JSContext* cx, Handle<GlobalObject*> global)
     RootedObject genFunctionProto(cx, NewSingletonObjectWithFunctionPrototype(cx, global));
     if (!genFunctionProto || !JSObject::setDelegate(cx, genFunctionProto))
         return false;
-    if (!LinkConstructorAndPrototype(cx, genFunctionProto, genObjectProto) ||
+    if (!LinkConstructorAndPrototype(cx, genFunctionProto, genObjectProto, JSPROP_READONLY,
+                                     JSPROP_READONLY) ||
         !DefineToStringTag(cx, genFunctionProto, cx->names().GeneratorFunction))
     {
         return false;
@@ -333,8 +334,11 @@ GlobalObject::initStarGenerators(JSContext* cx, Handle<GlobalObject*> global)
                                                       SingletonObject));
     if (!genFunction)
         return false;
-    if (!LinkConstructorAndPrototype(cx, genFunction, genFunctionProto))
+    if (!LinkConstructorAndPrototype(cx, genFunction, genFunctionProto,
+                                     JSPROP_PERMANENT | JSPROP_READONLY, JSPROP_READONLY))
+    {
         return false;
+    }
 
     global->setReservedSlot(STAR_GENERATOR_OBJECT_PROTO, ObjectValue(*genObjectProto));
     global->setReservedSlot(STAR_GENERATOR_FUNCTION, ObjectValue(*genFunction));
diff --git a/js/src/vm/GlobalObject.cpp b/js/src/vm/GlobalObject.cpp
index 013208f66..70c33c647 100644
--- a/js/src/vm/GlobalObject.cpp
+++ b/js/src/vm/GlobalObject.cpp
@@ -586,17 +586,18 @@ GlobalObject::createBlankPrototypeInheriting(JSContext* cx, Handle<GlobalObject*
 }
 
 bool
-js::LinkConstructorAndPrototype(JSContext* cx, JSObject* ctor_, JSObject* proto_)
+js::LinkConstructorAndPrototype(JSContext* cx, JSObject* ctor_, JSObject* proto_,
+                                unsigned prototypeAttrs, unsigned constructorAttrs)
 {
     RootedObject ctor(cx, ctor_), proto(cx, proto_);
 
     RootedValue protoVal(cx, ObjectValue(*proto));
     RootedValue ctorVal(cx, ObjectValue(*ctor));
 
-    return DefineProperty(cx, ctor, cx->names().prototype, protoVal,
-                          nullptr, nullptr, JSPROP_PERMANENT | JSPROP_READONLY) &&
-           DefineProperty(cx, proto, cx->names().constructor, ctorVal,
-                          nullptr, nullptr, 0);
+    return DefineProperty(cx, ctor, cx->names().prototype, protoVal, nullptr, nullptr,
+                          prototypeAttrs) &&
+           DefineProperty(cx, proto, cx->names().constructor, ctorVal, nullptr, nullptr,
+                          constructorAttrs);
 }
 
 bool
diff --git a/js/src/vm/GlobalObject.h b/js/src/vm/GlobalObject.h
index 9179abbb7..dd3f23151 100644
--- a/js/src/vm/GlobalObject.h
+++ b/js/src/vm/GlobalObject.h
@@ -985,12 +985,14 @@ GlobalObject::createArrayFromBuffer<uint8_clamped>() const
 }
 
 /*
- * Define ctor.prototype = proto as non-enumerable, non-configurable, and
- * non-writable; define proto.constructor = ctor as non-enumerable but
- * configurable and writable.
+ * Unless otherwise specified, define ctor.prototype = proto as non-enumerable,
+ * non-configurable, and non-writable; and define proto.constructor = ctor as
+ * non-enumerable but configurable and writable.
  */
 extern bool
-LinkConstructorAndPrototype(JSContext* cx, JSObject* ctor, JSObject* proto);
+LinkConstructorAndPrototype(JSContext* cx, JSObject* ctor, JSObject* proto,
+                            unsigned prototypeAttrs = JSPROP_PERMANENT | JSPROP_READONLY,
+                            unsigned constructorAttrs = 0);
 
 /*
  * Define properties and/or functions on any object. Either ps or fs, or both,