1 files changed, 60 insertions, 12 deletions

diff --git a/Source/JavaScriptCore/runtime/WeakMapConstructor.cpp b/Source/JavaScriptCore/runtime/WeakMapConstructor.cpp
index f3540faaa..175899b59 100644
--- a/Source/JavaScriptCore/runtime/WeakMapConstructor.cpp
+++ b/Source/JavaScriptCore/runtime/WeakMapConstructor.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Apple, Inc. All rights reserved.
+ * Copyright (C) 2013, 2016 Apple, Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -26,39 +26,87 @@
 #include "config.h"
 #include "WeakMapConstructor.h"
 
-#include "JSCJSValueInlines.h"
-#include "JSCellInlines.h"
+#include "Error.h"
+#include "IteratorOperations.h"
+#include "JSCInlines.h"
 #include "JSGlobalObject.h"
+#include "JSObjectInlines.h"
 #include "JSWeakMap.h"
 #include "WeakMapPrototype.h"
 
 namespace JSC {
 
-const ClassInfo WeakMapConstructor::s_info = { "Function", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(WeakMapConstructor) };
+const ClassInfo WeakMapConstructor::s_info = { "Function", &Base::s_info, 0, CREATE_METHOD_TABLE(WeakMapConstructor) };
 
 void WeakMapConstructor::finishCreation(VM& vm, WeakMapPrototype* prototype)
 {
-    Base::finishCreation(vm, prototype->classInfo()->className);
+    Base::finishCreation(vm, prototype->classInfo(vm)->className);
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, DontEnum | DontDelete | ReadOnly);
-    putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum | DontDelete);
+    putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(0), DontEnum | ReadOnly);
+}
+
+static EncodedJSValue JSC_HOST_CALL callWeakMap(ExecState* exec)
+{
+    VM& vm = exec->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    return JSValue::encode(throwConstructorCannotBeCalledAsFunctionTypeError(exec, scope, "WeakMap"));
 }
 
 static EncodedJSValue JSC_HOST_CALL constructWeakMap(ExecState* exec)
 {
-    JSGlobalObject* globalObject = asInternalFunction(exec->callee())->globalObject();
-    Structure* structure = globalObject->weakMapStructure();
-    return JSValue::encode(JSWeakMap::create(exec, structure));
+    VM& vm = exec->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSGlobalObject* globalObject = asInternalFunction(exec->jsCallee())->globalObject();
+    Structure* weakMapStructure = InternalFunction::createSubclassStructure(exec, exec->newTarget(), globalObject->weakMapStructure());
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+    JSWeakMap* weakMap = JSWeakMap::create(exec, weakMapStructure);
+    JSValue iterable = exec->argument(0);
+    if (iterable.isUndefinedOrNull())
+        return JSValue::encode(weakMap);
+
+    JSValue adderFunction = weakMap->JSObject::get(exec, vm.propertyNames->set);
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+
+    CallData adderFunctionCallData;
+    CallType adderFunctionCallType = getCallData(adderFunction, adderFunctionCallData);
+    if (adderFunctionCallType == CallType::None)
+        return JSValue::encode(throwTypeError(exec, scope));
+
+    scope.release();
+    forEachInIterable(exec, iterable, [&](VM& vm, ExecState* exec, JSValue nextItem) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        if (!nextItem.isObject()) {
+            throwTypeError(exec, scope);
+            return;
+        }
+
+        JSValue key = nextItem.get(exec, static_cast<unsigned>(0));
+        RETURN_IF_EXCEPTION(scope, void());
+
+        JSValue value = nextItem.get(exec, static_cast<unsigned>(1));
+        RETURN_IF_EXCEPTION(scope, void());
+
+        MarkedArgumentBuffer arguments;
+        arguments.append(key);
+        arguments.append(value);
+        scope.release();
+        call(exec, adderFunction, adderFunctionCallType, adderFunctionCallData, weakMap, arguments);
+    });
+
+    return JSValue::encode(weakMap);
 }
 
 ConstructType WeakMapConstructor::getConstructData(JSCell*, ConstructData& constructData)
 {
     constructData.native.function = constructWeakMap;
-    return ConstructTypeHost;
+    return ConstructType::Host;
 }
 
-CallType WeakMapConstructor::getCallData(JSCell*, CallData&)
+CallType WeakMapConstructor::getCallData(JSCell*, CallData& callData)
 {
-    return CallTypeNone;
+    callData.native.function = callWeakMap;
+    return CallType::Host;
 }
 
 }