Make new Harmony constructors subclassing-friendly

src/collection.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 26 matching lines @@
 var $WeakSet = global.WeakSet;
 
 // Global sentinel to be used instead of undefined keys, which are not
 // supported internally but required for Harmony sets and maps.
 var undefined_sentinel = {};
 
 // -------------------------------------------------------------------
 // Harmony Set
 
 function SetConstructor() {
-  if (%_IsConstructCall()) {
-    %SetInitialize(this);
-  } else {
-    throw MakeTypeError('constructor_not_function', ['Set']);
-  }
+  %SetInitialize(this);
 }
 
 
 function SetAdd(key) {
   if (!IS_SET(this)) {

[arv (Not doing code reviews), 2013/08/04 16:44:28]

Remember that all of these needs to be changed to actually test that it is an
initialized Set and not just a Set.

var uninitializedSet = %NewObject(Set);
assertThrows(function() {
  Set.prototype.add.call(uninitializedSet, 'key');
}, TypeError);

At this point, the only way to get  an uninitialized Set is to use %NewObject so
and user code will not be able to trigger this. But once we expose @@create this
will need to be fixed.

[Dmitry Lomov (no reviews), 2013/08/05 10:15:22]

Do you think we should fix all of these in this CL or we can do other error
checking in later CLs? (this whole @@create thing is a can of worms, obviously)

[arv (Not doing code reviews), 2013/08/05 13:34:33]

I think it is fine to do this later. It is not observable without %NewObject

     throw MakeTypeError('incompatible_method_receiver',
                         ['Set.prototype.add', this]);
   }
   if (IS_UNDEFINED(key)) {
     key = undefined_sentinel;
   }
   return %SetAdd(this, key);
 }
 
 
@@ skipping 34 matching lines @@
   return %SetGetSize(this);
 }
 
 
 function SetClear() {
   if (!IS_SET(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['Set.prototype.clear', this]);
   }
   // Replace the internal table with a new empty table.
-  %SetInitialize(this);
+  %SetClear(this);
 }
 
 
 // -------------------------------------------------------------------
 
 function SetUpSet() {
   %CheckIsBootstrapping();
 
   %SetCode($Set, SetConstructor);
   %FunctionSetPrototype($Set, new $Object());
   %SetProperty($Set.prototype, "constructor", $Set, DONT_ENUM);
 
   // Set up the non-enumerable functions on the Set prototype object.
   InstallGetter($Set.prototype, "size", SetGetSize);
   InstallFunctions($Set.prototype, DONT_ENUM, $Array(
     "add", SetAdd,
     "has", SetHas,
     "delete", SetDelete,
     "clear", SetClear
   ));
 }
 
 SetUpSet();
 
 
 // -------------------------------------------------------------------
 // Harmony Map
 
 function MapConstructor() {
-  if (%_IsConstructCall()) {
-    %MapInitialize(this);
-  } else {
-    throw MakeTypeError('constructor_not_function', ['Map']);
-  }
+  %MapInitialize(this);
 }
 
 
 function MapGet(key) {
   if (!IS_MAP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['Map.prototype.get', this]);
   }
   if (IS_UNDEFINED(key)) {
     key = undefined_sentinel;
@@ skipping 46 matching lines @@
   return %MapGetSize(this);
 }
 
 
 function MapClear() {
   if (!IS_MAP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['Map.prototype.clear', this]);
   }
   // Replace the internal table with a new empty table.
-  %MapInitialize(this);
+  %MapClear(this);
 }
 
 
 // -------------------------------------------------------------------
 
 function SetUpMap() {
   %CheckIsBootstrapping();
 
   %SetCode($Map, MapConstructor);
   %FunctionSetPrototype($Map, new $Object());
@@ skipping 10 matching lines @@
   ));
 }
 
 SetUpMap();
 
 
 // -------------------------------------------------------------------
 // Harmony WeakMap
 
 function WeakMapConstructor() {
-  if (%_IsConstructCall()) {
-    %WeakCollectionInitialize(this);
-  } else {
-    throw MakeTypeError('constructor_not_function', ['WeakMap']);
-  }
+  %WeakMapInitialize(this);
 }
 
 
 function WeakMapGet(key) {
   if (!IS_WEAKMAP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['WeakMap.prototype.get', this]);
   }
   if (!(IS_SPEC_OBJECT(key) || IS_SYMBOL(key))) {
     throw %MakeTypeError('invalid_weakmap_key', [this, key]);
@@ skipping 37 matching lines @@
   return %WeakCollectionDelete(this, key);
 }
 
 
 function WeakMapClear() {
   if (!IS_WEAKMAP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['WeakMap.prototype.clear', this]);
   }
   // Replace the internal table with a new empty table.
-  %WeakCollectionInitialize(this);
+  %WeakCollectionClear(this);
 }
 
 
 // -------------------------------------------------------------------
 
 function SetUpWeakMap() {
   %CheckIsBootstrapping();
 
   %SetCode($WeakMap, WeakMapConstructor);
   %FunctionSetPrototype($WeakMap, new $Object());
   %SetProperty($WeakMap.prototype, "constructor", $WeakMap, DONT_ENUM);
 
   // Set up the non-enumerable functions on the WeakMap prototype object.
   InstallFunctions($WeakMap.prototype, DONT_ENUM, $Array(
     "get", WeakMapGet,
     "set", WeakMapSet,
     "has", WeakMapHas,
     "delete", WeakMapDelete,
     "clear", WeakMapClear
   ));
 }
 
 SetUpWeakMap();
 
 
 // -------------------------------------------------------------------
 // Harmony WeakSet
 
 function WeakSetConstructor() {
-  if (%_IsConstructCall()) {
-    %WeakCollectionInitialize(this);
-  } else {
-    throw MakeTypeError('constructor_not_function', ['WeakSet']);
-  }
+  %WeakSetInitialize(this);
 }
 
 
 function WeakSetAdd(value) {
   if (!IS_WEAKSET(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['WeakSet.prototype.add', this]);
   }
   if (!(IS_SPEC_OBJECT(value) || IS_SYMBOL(value))) {
     throw %MakeTypeError('invalid_weakset_value', [this, value]);
@@ skipping 25 matching lines @@
   return %WeakCollectionDelete(this, value);
 }
 
 
 function WeakSetClear() {
   if (!IS_WEAKSET(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['WeakSet.prototype.clear', this]);
   }
   // Replace the internal table with a new empty table.
-  %WeakCollectionInitialize(this);
+  %WeakCollectionClear(this);
 }
 
 
 // -------------------------------------------------------------------
 
 function SetUpWeakSet() {
   %CheckIsBootstrapping();
 
   %SetCode($WeakSet, WeakSetConstructor);
   %FunctionSetPrototype($WeakSet, new $Object());
   %SetProperty($WeakSet.prototype, "constructor", $WeakSet, DONT_ENUM);
 
   // Set up the non-enumerable functions on the WeakSet prototype object.
   InstallFunctions($WeakSet.prototype, DONT_ENUM, $Array(
     "add", WeakSetAdd,
     "has", WeakSetHas,
     "delete", WeakSetDelete,
     "clear", WeakSetClear
   ));
 }
 
 SetUpWeakSet();