[es6] implement Object.assign

src/v8natives.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file relies on the fact that the following declarations have been made
 // in runtime.js:
 // var $Object = global.Object;
 // var $Boolean = global.Boolean;
 // var $Number = global.Number;
 // var $Function = global.Function;
@@ skipping 1373 matching lines @@
 
 // ECMA-262, Edition 6, section B.2.2.1.2
 function ObjectSetProto(proto) {
   CHECK_OBJECT_COERCIBLE(this, "Object.prototype.__proto__");
 
   if ((IS_SPEC_OBJECT(proto) || IS_NULL(proto)) && IS_SPEC_OBJECT(this)) {
     %SetPrototype(this, proto);
   }
 }
 
+var kError = { error: UNDEFINED };
+function TryCatch3(fn, arg1, arg2, arg3) {
+  try {
+    return fn(arg1, arg2, arg3);
+  } catch (e) {
+    kError.error = e;

[jsbell, 2014/09/08 17:22:41]

Wouldn't this "leak" the exception?

(I'm not intimately familiar with the special environment for v8natives so maybe
this is taken care of elsewhere.)

[caitp (gmail), 2014/09/08 17:48:27]

Yes, within the sandbox it would be kept alive --- a way around this would be to
explicitly null it after finishing, but it's unlikely to make a big difference

+    return kError;
+  }
+}
+
+function CopyEnumerableValue(to, from, p) {
+  var desc = ObjectGetOwnPropertyDescriptor(from, p);
+  if (!IS_UNDEFINED(desc) && desc.enumerable) {
+    // Approximately Put() (7.3.2)
+    %SetProperty(to, p, from[p], kStrictMode);
+  }
+}
+
+
+function ObjectAssign(target, sources) {
+  var to = ToObject(target);
+  var argsLen = %_ArgumentsLength();
+  if (argsLen < 2) return to;
+
+  for (var i = 1; i < argsLen; ++i) {
+    var nextSource = %_Arguments(i);
+    if (IS_NULL(nextSource) || IS_UNDEFINED(nextSource)) {
+      continue;
+    }
+
+    var from = ToObject(nextSource);
+    var keysArray = ObjectGetOwnPropertyKeys(from);
+    var len = keysArray.length;
+    var pendingException = UNDEFINED;
+
+    for (var j = 0; j < len; ++j) {
+      // Get "sort of" abrupt completion record for steps 5d i...iii
+      // TryCatch3 moved out to ensure that ObjectAssign can be optimized
+      // --- will measure if it makes a meaningful difference, but we've
+      // seen that Object.assign() is pretty slow already.
+      var record = TryCatch3(CopyEnumerableValue, to, from, keysArray[j]);
+      if (record === kError) {
+        if (IS_UNDEFINED(pendingException))
+          pendingException = kError.error;
+      }
+    }
+
+    if (!IS_UNDEFINED(pendingException))
+      throw pendingException;
+  }
+  return to;
+}
+
 
 function ObjectConstructor(x) {
   if (%_IsConstructCall()) {
     if (x == null) return this;
     return ToObject(x);
   } else {
     if (x == null) return { };
     return ToObject(x);
   }
 }
@@ skipping 36 matching lines @@
     "getPrototypeOf", ObjectGetPrototypeOf,
     "setPrototypeOf", ObjectSetPrototypeOf,
     "getOwnPropertyDescriptor", ObjectGetOwnPropertyDescriptor,
     "getOwnPropertyNames", ObjectGetOwnPropertyNames,
     // getOwnPropertySymbols is added in symbol.js.
     "is", ObjectIs,
     "isExtensible", ObjectIsExtensible,
     "isFrozen", ObjectIsFrozen,
     "isSealed", ObjectIsSealed,
     "preventExtensions", ObjectPreventExtension,
-    "seal", ObjectSeal
+    "seal", ObjectSeal,
     // deliverChangeRecords, getNotifier, observe and unobserve are added
     // in object-observe.js.
+    "assign", ObjectAssign
   ));
 }
 
 SetUpObject();
 
 
 // ----------------------------------------------------------------------------
 // Boolean
 
 function BooleanConstructor(x) {
@@ skipping 438 matching lines @@
   }
   if (!IS_SPEC_FUNCTION(method)) {
     throw MakeTypeError('not_iterable', [obj]);
   }
   var iterator = %_CallFunction(obj, method);
   if (!IS_SPEC_OBJECT(iterator)) {
     throw MakeTypeError('not_an_iterator', [iterator]);
   }
   return iterator;
 }