Attachment 286999 Details for Bug 152985 – Patch

[patch] Patch

bug-152985-20160825231614.patch (text/plain), 94.32 KB, created by GSkachkov on 2016-08-25 13:18:18 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: GSkachkov

Created: 2016-08-25 13:18:18 PDT

Size: 94.32 KB

patch

obsolete

>Subversion Revision: 204958
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index bc82a1b45939c67ef9db5d38430f28bc1c9afd35..f773ba2609bc43f34ee6414043e273a6c8f79b23 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,66 @@
>+2016-08-25  Skachkov Oleksandr  <gskachkov@gmail.com>
>+
>+        ES6: Classes: Should be allowed to create a static method with name "arguments"
>+        https://bugs.webkit.org/show_bug.cgi?id=152985
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Current patch covered 16.2 Forbidden Extensions - first topic 
>+        (https://tc39.github.io/ecma262/#sec-forbidden-extensions) ECMAScript Functions 
>+        should not have own properties named "caller" or "arguments".
>+        Also added possibility to declare static methods and getters with 
>+        name 'arguments' and 'caller' for classes. i.e.:
>+        class A { static arguments() { return 'value'; } }
>+        A.arguments() === 'value';
>+
>+        * runtime/Executable.h:
>+        * runtime/FunctionPrototype.cpp:
>+        (JSC::FunctionPrototype::defineOwnProperty):
>+        (JSC::FunctionPrototype::getThrowTypeErrorOwnPropertySlot):
>+        (JSC::FunctionPrototype::getOwnPropertySlot):
>+        (JSC::FunctionPrototype::getOwnNonIndexPropertyNames):
>+        (JSC::functionProtoFuncBind): Deleted.
>+        * runtime/FunctionPrototype.h:
>+        * runtime/JSFunction.cpp:
>+        (JSC::JSFunction::getOwnPropertySlot):
>+        (JSC::JSFunction::getOwnNonIndexPropertyNames):
>+        (JSC::JSFunction::put):
>+        (JSC::JSFunction::deleteProperty):
>+        (JSC::JSFunction::defineOwnProperty):
>+        * runtime/JSFunction.h:
>+        * runtime/JSObject.cpp:
>+        (JSC::ordinarySetSlow):
>+        (JSC::JSObject::getOwnPropertyDescriptor):
>+        * runtime/PropertySlot.h:
>+        (JSC::PropertySlot::PropertySlot):
>+        (JSC::PropertySlot::se:tIsClassMethod):
>+        (JSC::PropertySlot::isClassMethod):
>+        (JSC::PropertySlot::isTaintedByOpaqueObject): Deleted.
>+
>+        * runtime/Executable.h:
>+        * runtime/FunctionPrototype.cpp:
>+        (JSC::FunctionPrototype::defineOwnProperty):
>+        (JSC::FunctionPrototype::getThrowTypeErrorOwnPropertySlot):
>+        (JSC::FunctionPrototype::getOwnPropertySlot):
>+        (JSC::FunctionPrototype::getOwnNonIndexPropertyNames):
>+        (JSC::functionProtoFuncBind): Deleted.
>+        * runtime/FunctionPrototype.h:
>+        * runtime/JSFunction.cpp:
>+        (JSC::JSFunction::getOwnPropertySlot):
>+        (JSC::JSFunction::getOwnNonIndexPropertyNames):
>+        (JSC::JSFunction::put):
>+        (JSC::JSFunction::deleteProperty):
>+        (JSC::JSFunction::defineOwnProperty):
>+        * runtime/JSFunction.h:
>+        * runtime/JSObject.cpp:
>+        (JSC::ordinarySetSlow):
>+        (JSC::JSObject::getOwnPropertyDescriptor):
>+        * runtime/PropertySlot.h:
>+        (JSC::PropertySlot::PropertySlot):
>+        (JSC::PropertySlot::setIsClassMethod):
>+        (JSC::PropertySlot::isClassMethod):
>+        (JSC::PropertySlot::isTaintedByOpaqueObject): Deleted.
>+
> 2016-08-25  Caio Lima  <ticaiolima@gmail.com>
> 
>         NewRegexp should not prevent inlining
>diff --git a/Source/JavaScriptCore/runtime/Executable.h b/Source/JavaScriptCore/runtime/Executable.h
>index bd2c144e169fb117605b04c6739e1e4909c2612c..ac8ab6fd0be316880c3e400f2bbb536ac298b265 100644
>--- a/Source/JavaScriptCore/runtime/Executable.h
>+++ b/Source/JavaScriptCore/runtime/Executable.h
>@@ -654,6 +654,8 @@ public:
>     bool isArrowFunction() const { return parseMode() == SourceParseMode::ArrowFunctionMode; }
>     bool isGetter() const { return parseMode() == SourceParseMode::GetterMode; }
>     bool isSetter() const { return parseMode() == SourceParseMode::SetterMode; }
>+    bool isGenerator() const { return parseMode() == SourceParseMode::GeneratorBodyMode || parseMode() == SourceParseMode::GeneratorWrapperFunctionMode; }
>+    bool isES6Function() const { return isClassConstructorFunction() || isArrowFunction() || isGenerator() || parseMode() == SourceParseMode::MethodMode;}
>     DerivedContextType derivedContextType() const { return m_unlinkedExecutable->derivedContextType(); }
>     bool isClassConstructorFunction() const { return m_unlinkedExecutable->isClassConstructorFunction(); }
>     const Identifier& name() { return m_unlinkedExecutable->name(); }
>diff --git a/Source/JavaScriptCore/runtime/FunctionPrototype.cpp b/Source/JavaScriptCore/runtime/FunctionPrototype.cpp
>index 4f4214c0f004ad31d8d037f5e593bd5a219f34a5..948641bc4bdc97c0d9855a31e25788c02aa66ff1 100644
>--- a/Source/JavaScriptCore/runtime/FunctionPrototype.cpp
>+++ b/Source/JavaScriptCore/runtime/FunctionPrototype.cpp
>@@ -23,10 +23,13 @@
> 
> #include "BuiltinExecutables.h"
> #include "BuiltinNames.h"
>+#include "ClonedArguments.h"
> #include "Error.h"
>+#include "GetterSetter.h"
> #include "JSArray.h"
> #include "JSBoundFunction.h"
> #include "JSFunction.h"
>+#include "JSGlobalObjectFunctions.h"
> #include "JSString.h"
> #include "JSStringBuilder.h"
> #include "Interpreter.h"
>@@ -174,5 +177,77 @@ EncodedJSValue JSC_HOST_CALL functionProtoFuncBind(ExecState* exec)
>     JSString* name = nameProp.isString() ? nameProp.toString(exec) : jsEmptyString(exec);
>     return JSValue::encode(JSBoundFunction::create(vm, exec, globalObject, targetObject, exec->argument(0), boundArgs, length, name->value(exec)));
> }
>+    
>+bool FunctionPrototype::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool throwException)
>+{
>+    if (!object->inherits(JSFunction::info()))
>+        return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+
>+    JSFunction* thisObject = jsCast<JSFunction*>(object);
>+    if (thisObject->isHostOrBuiltinFunction())
>+        return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+
>+    if (propertyName == exec->propertyNames().arguments) {
>+        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isArrowFunction()) {
>+            PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>+            if (!Base::getOwnPropertySlot(thisObject, exec, propertyName, slot))
>+                thisObject->putDirectAccessor(exec, propertyName, thisObject->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter(), DontDelete | DontEnum | Accessor);
>+            return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+        }
>+    } else if (propertyName == exec->propertyNames().caller) {
>+        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isArrowFunction()) {
>+            PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>+            if (!Base::getOwnPropertySlot(thisObject, exec, propertyName, slot))
>+                thisObject->putDirectAccessor(exec, propertyName, thisObject->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter(), DontDelete | DontEnum | Accessor);
>+            return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+        }
>+    }
>+    thisObject->reifyLazyPropertyIfNeeded(exec, propertyName);
>+    return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+}
>+    
>+bool FunctionPrototype::getThrowTypeErrorOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
>+{
>+    bool result = Base::getOwnPropertySlot(object, exec, propertyName, slot);
>+    if (!result) {
>+        GetterSetter* errorGetterSetter = object->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter();
>+        object->putDirectAccessor(exec, propertyName, errorGetterSetter, DontDelete | DontEnum | Accessor);
>+        result = Base::getOwnPropertySlot(object, exec, propertyName, slot);
>+        ASSERT(result);
>+    }
>+    return result;
>+}
>+
>+bool FunctionPrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
>+{
>+    if (propertyName == exec->propertyNames().caller || propertyName == exec->propertyNames().arguments) {
>+        // For non-host functions, don't let these properties by deleted - except by DefineOwnProperty.
>+        if (slot.thisValue().inherits(JSFunction::info())) {
>+            JSFunction* thisObject = jsDynamicCast<JSFunction*>(slot.thisValue());
>+            if (!thisObject->isHostOrBuiltinFunction())
>+                return getThrowTypeErrorOwnPropertySlot(object, exec, propertyName, slot);
>+        } else if (slot.thisValue().inherits(FunctionPrototype::info()))
>+            return getThrowTypeErrorOwnPropertySlot(object, exec, propertyName, slot);
>+    }
>+    
>+    return Base::getOwnPropertySlot(object, exec, propertyName, slot);
>+}
>+
>+void FunctionPrototype::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
>+{
>+    FunctionPrototype* thisObject = jsCast<FunctionPrototype*>(object);
>+    if (mode.includeDontEnumProperties()) {
>+        VM& vm = exec->vm();
>+        // Make sure prototype has been reified.
>+        PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>+        thisObject->methodTable(vm)->getOwnPropertySlot(thisObject, exec, vm.propertyNames->prototype, slot);
>+        
>+        propertyNames.add(vm.propertyNames->arguments);
>+        propertyNames.add(vm.propertyNames->caller);
>+    }
>+    Base::getOwnNonIndexPropertyNames(thisObject, exec, propertyNames, mode);
>+}
>+    
>+
> 
> } // namespace JSC
>diff --git a/Source/JavaScriptCore/runtime/FunctionPrototype.h b/Source/JavaScriptCore/runtime/FunctionPrototype.h
>index abe533a33a1f378fedb8214f56cc5afe0fa1e69e..5024d90f9dad031254a78940ad99cc83c5cd5be4 100644
>--- a/Source/JavaScriptCore/runtime/FunctionPrototype.h
>+++ b/Source/JavaScriptCore/runtime/FunctionPrototype.h
>@@ -29,6 +29,8 @@ class FunctionPrototype : public InternalFunction {
> public:
>     typedef InternalFunction Base;
> 
>+    const static unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames;
>+
>     static FunctionPrototype* create(VM& vm, Structure* structure)
>     {
>         FunctionPrototype* prototype = new (NotNull, allocateCell<FunctionPrototype>(vm.heap)) FunctionPrototype(vm, structure);
>@@ -48,6 +50,11 @@ public:
> protected:
>     void finishCreation(VM&, const String& name);
> 
>+    static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
>+    static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool);
>+    static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
>+    static bool getThrowTypeErrorOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
>+
> private:
>     FunctionPrototype(VM&, Structure*);
>     static CallType getCallData(JSCell*, CallData&);
>diff --git a/Source/JavaScriptCore/runtime/JSFunction.cpp b/Source/JavaScriptCore/runtime/JSFunction.cpp
>index b7517c1a46c5758f12a686e141d79c0d75202541..db13c0989d460aa9e47bb9764ab027a5126b4676 100644
>--- a/Source/JavaScriptCore/runtime/JSFunction.cpp
>+++ b/Source/JavaScriptCore/runtime/JSFunction.cpp
>@@ -367,31 +367,17 @@ bool JSFunction::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyN
>     }
> 
>     if (propertyName == exec->propertyNames().arguments) {
>-        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isClassConstructorFunction()) {
>-            bool result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-            if (!result) {
>-                GetterSetter* errorGetterSetter = thisObject->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter();
>-                thisObject->putDirectAccessor(exec, propertyName, errorGetterSetter, DontDelete | DontEnum | Accessor);
>-                result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-                ASSERT(result);
>-            }
>-            return result;
>-        }
>+        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isES6Function())
>+            return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>+
>         slot.setCacheableCustom(thisObject, ReadOnly | DontEnum | DontDelete, argumentsGetter);
>         return true;
>     }
> 
>     if (propertyName == exec->propertyNames().caller) {
>-        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isClassConstructorFunction()) {
>-            bool result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-            if (!result) {
>-                GetterSetter* errorGetterSetter = thisObject->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter();
>-                thisObject->putDirectAccessor(exec, propertyName, errorGetterSetter, DontDelete | DontEnum | Accessor);
>-                result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-                ASSERT(result);
>-            }
>-            return result;
>-        }
>+        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isES6Function())
>+            return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>+
>         slot.setCacheableCustom(thisObject, ReadOnly | DontEnum | DontDelete, callerGetter);
>         return true;
>     }
>@@ -410,8 +396,10 @@ void JSFunction::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec,
>         PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>         thisObject->methodTable(vm)->getOwnPropertySlot(thisObject, exec, vm.propertyNames->prototype, slot);
> 
>-        propertyNames.add(vm.propertyNames->arguments);
>-        propertyNames.add(vm.propertyNames->caller);
>+        if (!thisObject->jsExecutable()->isStrictMode()) {
>+            propertyNames.add(vm.propertyNames->arguments);
>+            propertyNames.add(vm.propertyNames->caller);
>+        }
>         if (!thisObject->hasReifiedLength())
>             propertyNames.add(vm.propertyNames->length);
>         if (!thisObject->hasReifiedName())
>@@ -444,7 +432,7 @@ bool JSFunction::put(JSCell* cell, ExecState* exec, PropertyName propertyName, J
>         PutPropertySlot dontCache(thisObject);
>         return Base::put(thisObject, exec, propertyName, value, dontCache);
>     }
>-    if (thisObject->jsExecutable()->isStrictMode() && (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().caller)) {
>+    if ((thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isES6Function()) && (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().caller)) {
>         // This will trigger the property to be reified, if this is not already the case!
>         bool okay = thisObject->hasProperty(exec, propertyName);
>         ASSERT_UNUSED(okay, okay);
>@@ -467,10 +455,15 @@ bool JSFunction::deleteProperty(JSCell* cell, ExecState* exec, PropertyName prop
>     else if (exec->vm().deletePropertyMode() != VM::DeletePropertyMode::IgnoreConfigurable) {
>         // For non-host functions, don't let these properties by deleted - except by DefineOwnProperty.
>         FunctionExecutable* executable = thisObject->jsExecutable();
>-        if (propertyName == exec->propertyNames().arguments
>+        bool isES6OrStrictMode = executable->isStrictMode() || executable->isES6Function();
>+        if ((propertyName == exec->propertyNames().arguments && !isES6OrStrictMode)
>             || (propertyName == exec->propertyNames().prototype && !executable->isArrowFunction())
>-            || propertyName == exec->propertyNames().caller)
>+            || (propertyName == exec->propertyNames().caller && !isES6OrStrictMode))
>             return false;
>+        
>+        if ((propertyName == exec->propertyNames().arguments && isES6OrStrictMode)
>+            || (propertyName == exec->propertyNames().caller && isES6OrStrictMode))
>+            return true;
> 
>         thisObject->reifyLazyPropertyIfNeeded(exec, propertyName);
>     }
>@@ -498,7 +491,11 @@ bool JSFunction::defineOwnProperty(JSObject* object, ExecState* exec, PropertyNa
> 
>     bool valueCheck;
>     if (propertyName == exec->propertyNames().arguments) {
>-        if (thisObject->jsExecutable()->isStrictMode()) {
>+        if (thisObject->jsExecutable()->isClass()) {
>+            thisObject->reifyLazyPropertyIfNeeded(exec, propertyName);
>+            return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+        }
>+        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isES6Function()) {
>             PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>             if (!Base::getOwnPropertySlot(thisObject, exec, propertyName, slot))
>                 thisObject->putDirectAccessor(exec, propertyName, thisObject->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter(), DontDelete | DontEnum | Accessor);
>@@ -506,7 +503,11 @@ bool JSFunction::defineOwnProperty(JSObject* object, ExecState* exec, PropertyNa
>         }
>         valueCheck = !descriptor.value() || sameValue(exec, descriptor.value(), retrieveArguments(exec, thisObject));
>     } else if (propertyName == exec->propertyNames().caller) {
>-        if (thisObject->jsExecutable()->isStrictMode()) {
>+        if (thisObject->jsExecutable()->isClass()) {
>+            thisObject->reifyLazyPropertyIfNeeded(exec, propertyName);
>+            return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
>+        }
>+        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isES6Function()) {
>             PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>             if (!Base::getOwnPropertySlot(thisObject, exec, propertyName, slot))
>                 thisObject->putDirectAccessor(exec, propertyName, thisObject->globalObject()->throwTypeErrorArgumentsCalleeAndCallerGetterSetter(), DontDelete | DontEnum | Accessor);
>diff --git a/Source/JavaScriptCore/runtime/JSFunction.h b/Source/JavaScriptCore/runtime/JSFunction.h
>index fa946f23c37e00742c55942c2859807031fda775..193bdaac548b5093d2ec7f98924cc765c4ed7f2c 100644
>--- a/Source/JavaScriptCore/runtime/JSFunction.h
>+++ b/Source/JavaScriptCore/runtime/JSFunction.h
>@@ -151,7 +151,7 @@ public:
>     bool isClassConstructorFunction() const;
> 
>     void setFunctionName(ExecState*, JSValue name);
>-
>+    void reifyLazyPropertyIfNeeded(ExecState*, PropertyName);
> protected:
>     JS_EXPORT_PRIVATE JSFunction(VM&, JSGlobalObject*, Structure*);
>     JSFunction(VM&, FunctionExecutable*, JSScope*, Structure*);
>@@ -193,7 +193,6 @@ private:
>     void reifyName(ExecState*);
>     void reifyBoundNameIfNeeded(ExecState*, PropertyName);
>     void reifyName(ExecState*, String name);
>-    void reifyLazyPropertyIfNeeded(ExecState*, PropertyName propertyName);
> 
>     friend class LLIntOffsetsExtractor;
> 
>diff --git a/Source/JavaScriptCore/runtime/JSObject.cpp b/Source/JavaScriptCore/runtime/JSObject.cpp
>index e3ec1b1b9e4aec68ccb5edfb1ae045b65f283d18..d377dbef190e1a622683fa46b1def5affc855b5d 100644
>--- a/Source/JavaScriptCore/runtime/JSObject.cpp
>+++ b/Source/JavaScriptCore/runtime/JSObject.cpp
>@@ -513,6 +513,12 @@ bool ordinarySetSlow(ExecState* exec, JSObject* object, PropertyName propertyNam
>     if (!setter.isObject())
>         return reject(exec, shouldThrow, StrictModeReadonlyPropertyWriteError);
> 
>+    if (propertyName == vm.propertyNames->arguments || propertyName == vm.propertyNames->caller) {
>+        // We do not update the value of caller & arguments properties in function
>+        if (object->inherits(JSFunction::info()))
>+            return reject(exec, shouldThrow, StrictModeReadonlyPropertyWriteError);
>+    }
>+
>     // 9.1.9.1-8 Perform ? Call(setter, Receiver, << V >>).
>     JSObject* setterObject = asObject(setter);
>     MarkedArgumentBuffer args;
>@@ -2844,6 +2850,12 @@ static JSCustomGetterSetterFunction* getCustomGetterSetterFunctionForGetterSette
> bool JSObject::getOwnPropertyDescriptor(ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
> {
>     JSC::PropertySlot slot(this, PropertySlot::InternalMethodType::GetOwnProperty);
>+    if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().caller) {
>+        if (auto thisObject = jsDynamicCast<JSFunction*>(this)) {
>+            if (!thisObject->isHostFunctionNonInline() && thisObject->jsExecutable()->isClass() && !thisObject->jsExecutable()->isClassConstructorFunction())
>+                slot.setIsClassMethod();
>+        }
>+    }
>     if (!methodTable(exec->vm())->getOwnPropertySlot(this, exec, propertyName, slot))
>         return false;
> 
>diff --git a/Source/JavaScriptCore/runtime/PropertySlot.h b/Source/JavaScriptCore/runtime/PropertySlot.h
>index 503d086f7470c7cea932a5d704b9f87fa2fd3938..39e260d69eb369bb129cf4305df2a110b208a70f 100644
>--- a/Source/JavaScriptCore/runtime/PropertySlot.h
>+++ b/Source/JavaScriptCore/runtime/PropertySlot.h
>@@ -91,6 +91,7 @@ public:
>         , m_propertyType(TypeUnset)
>         , m_internalMethodType(internalMethodType)
>         , m_isTaintedByOpaqueObject(false)
>+        , m_isClassMethod(false)
>     {
>     }
> 
>@@ -112,6 +113,8 @@ public:
>     bool isCacheableCustom() const { return isCacheable() && isCustom(); }
>     void setIsTaintedByOpaqueObject() { m_isTaintedByOpaqueObject = true; }
>     bool isTaintedByOpaqueObject() const { return m_isTaintedByOpaqueObject; }
>+    void setIsClassMethod() { m_isClassMethod = true;  }
>+    bool isClassMethod() const { return m_isClassMethod;}
> 
>     InternalMethodType internalMethodType() const { return m_internalMethodType; }
> 
>@@ -294,6 +297,7 @@ private:
>     PropertyType m_propertyType;
>     InternalMethodType m_internalMethodType;
>     bool m_isTaintedByOpaqueObject;
>+    bool m_isClassMethod;
> };
> 
> ALWAYS_INLINE JSValue PropertySlot::getValue(ExecState* exec, PropertyName propertyName) const
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index c8820255eb75f7fb7a5b687f00493b801d2a4438..d6cf1675d98c819ea828e9eaecf15af7b2ac929e 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,66 @@
>+2016-08-25  Skachkov Oleksandr  <gskachkov@gmail.com>
>+
>+        ES6: Classes: Should be allowed to create a static method with name "arguments"
>+        https://bugs.webkit.org/show_bug.cgi?id=152985
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * js/Object-getOwnPropertyNames-expected.txt:
>+        * js/basic-strict-mode-expected.txt:
>+        * js/class-syntax-method-names-expected.txt:
>+        * js/es6-function-properties-expected.txt: Added.
>+        * js/es6-function-properties.html: Added.
>+        * js/kde/script-tests/function_arguments.js:
>+        (f):
>+        * js/non-strict-function-properties-expected.txt: Added.
>+        * js/non-strict-function-properties.html: Added.
>+        * js/script-tests/Object-getOwnPropertyNames.js:
>+        * js/script-tests/basic-strict-mode.js:
>+        * js/script-tests/class-method-and-constructor-properties.js: Removed.
>+        (shouldThrow): Deleted.
>+        (shouldBe): Deleted.
>+        (A): Deleted.
>+        (B): Deleted.
>+        (C): Deleted.
>+        (D): Deleted.
>+        (E.prototype.getItem): Deleted.
>+        (E): Deleted.
>+        (F.prototype.getElement): Deleted.
>+        (F): Deleted.
>+        (G.prototype.get item): Deleted.
>+        (G): Deleted.
>+        (H.prototype.caller): Deleted.
>+        (H.prototype.arguments): Deleted.
>+        (H): Deleted.
>+        * js/script-tests/class-syntax-method-names.js:
>+        * js/script-tests/es6-function-properties.js: Added.
>+        (shouldThrow):
>+        (shouldBe):
>+        (A):
>+        (B):
>+        (C):
>+        (D):
>+        (E.prototype.getItem):
>+        (E):
>+        (F.prototype.getElement):
>+        (F):
>+        (G.prototype.get item):
>+        (G):
>+        (check):
>+        (arr):
>+        (H.prototype.caller):
>+        (H.prototype.arguments):
>+        (H):
>+        (J.prototype.gen):
>+        (J.gen):
>+        (J):
>+        * js/script-tests/non-strict-function-properties.js: Added.
>+        (foo):
>+        (boo):
>+        (f):
>+        (g):
>+        * js/script-tests/strict-throw-type-error.js:
>+
> 2016-08-24  Chris Dumez  <cdumez@apple.com>
> 
>         WorkerLocation.prototype.toString() should be enumerable
>diff --git a/LayoutTests/js/Object-getOwnPropertyNames-expected.txt b/LayoutTests/js/Object-getOwnPropertyNames-expected.txt
>index ffbd9159f81bf5c55f43f1304870ff247cb76fc9..c22575f7d38ea7f011a6113b465389bcc02ea38c 100644
>--- a/LayoutTests/js/Object-getOwnPropertyNames-expected.txt
>+++ b/LayoutTests/js/Object-getOwnPropertyNames-expected.txt
>@@ -44,7 +44,7 @@ PASS getSortedOwnPropertyNames(encodeURIComponent) is ['length', 'name']
> PASS getSortedOwnPropertyNames(Object) is ['assign', 'create', 'defineProperties', 'defineProperty', 'entries', 'freeze', 'getOwnPropertyDescriptor', 'getOwnPropertyDescriptors', 'getOwnPropertyNames', 'getOwnPropertySymbols', 'getPrototypeOf', 'is', 'isExtensible', 'isFrozen', 'isSealed', 'keys', 'length', 'name', 'preventExtensions', 'prototype', 'seal', 'setPrototypeOf', 'values']
> PASS getSortedOwnPropertyNames(Object.prototype) is ['__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf']
> PASS getSortedOwnPropertyNames(Function) is ['length', 'name', 'prototype']
>-PASS getSortedOwnPropertyNames(Function.prototype) is ['apply', 'bind', 'call', 'constructor', 'length', 'name', 'toString']
>+PASS getSortedOwnPropertyNames(Function.prototype) is ['apply', 'arguments', 'bind', 'call', 'caller', 'constructor', 'length', 'name', 'toString']
> PASS getSortedOwnPropertyNames(Array) is ['from', 'isArray', 'length', 'name', 'of', 'prototype']
> PASS getSortedOwnPropertyNames(Array.prototype) is ['concat', 'constructor', 'copyWithin', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift', 'values']
> PASS getSortedOwnPropertyNames(String) is ['fromCharCode', 'fromCodePoint', 'length', 'name', 'prototype', 'raw']
>diff --git a/LayoutTests/js/basic-strict-mode-expected.txt b/LayoutTests/js/basic-strict-mode-expected.txt
>index 528e421e98531933d578d4f6ed1a7f6db693253e..a305ecc9c58e0cc497e8837075b4d0019a203a85 100644
>--- a/LayoutTests/js/basic-strict-mode-expected.txt
>+++ b/LayoutTests/js/basic-strict-mode-expected.txt
>@@ -72,9 +72,11 @@ PASS (function a(a){'use strict'; return a+2; })(40) is 42
> PASS var foo = function a(a){'use strict'; return a+2; }; foo(40) is 42
> PASS var o = {foo: function a(a){'use strict'; return a+2; } }; o.foo(40) is 42
> PASS "caller" in function(){"use strict"} is true
>-PASS (function(){"use strict";}).hasOwnProperty("caller") is true
>+PASS (function(){"use strict";}).hasOwnProperty("caller") is false
>+PASS (function(){"use strict";}).__proto__.hasOwnProperty("caller") is true
> PASS "arguments" in function(){"use strict"} is true
>-PASS (function(){"use strict";}).hasOwnProperty("arguments") is true
>+PASS (function(){"use strict";}).hasOwnProperty("arguments") is false
>+PASS (function(){"use strict";}).__proto__.hasOwnProperty("arguments") is true
> PASS 'use strict'; (function (){with(1){};}) threw exception SyntaxError: 'with' statements are not valid in strict mode..
> PASS (function(){'use strict'; (function (){with(1){};})}) threw exception SyntaxError: 'with' statements are not valid in strict mode..
> PASS 'use strict'; (function (){var a; delete a;}) threw exception SyntaxError: Cannot delete unqualified property 'a' in strict mode..
>@@ -179,14 +181,14 @@ PASS (function (a){'use strict'; var local; (function (){local;})(); arguments[0
> PASS (function (){'use strict';  var local; (function (){local;})(); arguments[0]=true; return arguments; })()[0] is true
> PASS 'use strict'; (function (){var a = true; eval('var a = false'); return a; })() is true
> PASS (function (){var a = true; eval('"use strict"; var a = false'); return a; })() is true
>-PASS (function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f, 'arguments').value; })() is undefined.
>-PASS (function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f, 'caller').value; })() is undefined.
>+PASS (function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f.__proto__, 'arguments').value; })() is undefined.
>+PASS (function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f.__proto__, 'caller').value; })() is undefined.
> PASS (function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(arguments, 'callee').value; })() is undefined.
> PASS (function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(arguments, 'caller').value; })() is undefined.
> PASS (function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(arguments, 'caller'); return descriptor.get === descriptor.set; })() is true
> PASS (function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(arguments, 'callee'); return descriptor.get === descriptor.set; })() is true
>-PASS (function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f, 'caller'); return descriptor.get === descriptor.set; })() is true
>-PASS (function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f, 'arguments'); return descriptor.get === descriptor.set; })() is true
>+PASS (function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f.__proto__, 'caller'); return descriptor.get === descriptor.set; })() is true
>+PASS (function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f.__proto__, 'arguments'); return descriptor.get === descriptor.set; })() is true
> PASS 'use strict'; (function f() { for(var i in this); })(); true; is true
> PASS 'use strict'Ì» threw exception SyntaxError: Invalid character '\u0827'.
> PASS (function(){'use strict'Ì»}) threw exception SyntaxError: Invalid character '\u0827'.
>@@ -212,7 +214,7 @@ PASS (function () {'use strict';  try { throw 1; } catch (e) { aGlobal = true; }
> PASS try { throw 1; } catch (e) { aGlobal = true; } is true
> PASS (function () { try { throw 1; } catch (e) { aGlobal = true; }})(); aGlobal; is true
> PASS (function () {try { throw 1; } catch (e) { aGlobal = true; }})(); aGlobal; is true
>-PASS String(Object.getOwnPropertyDescriptor(function() { "use strict"; }, "caller").get) is 'function () {\n    [native code]\n}'
>+PASS String(Object.getOwnPropertyDescriptor((function() { "use strict"; }).__proto__, "caller").get) is 'function () {\n    [native code]\n}'
> PASS successfullyParsed is true
> 
> TEST COMPLETE
>diff --git a/LayoutTests/js/class-syntax-method-names-expected.txt b/LayoutTests/js/class-syntax-method-names-expected.txt
>index d86aa41816be7af73b155b7a47af3ae55b11c6e9..aecfb071f99c0943c68bbef5ff9524c9b157f190 100644
>--- a/LayoutTests/js/class-syntax-method-names-expected.txt
>+++ b/LayoutTests/js/class-syntax-method-names-expected.txt
>@@ -20,6 +20,32 @@ PASS class A { static get get() { return 104; } }; A.get is 104
> PASS class A { static get set() { return 105; } }; A.set is 105
> PASS setterValue = undefined; class A { static set get(x) { setterValue = x; } }; A.get = 106; setterValue is 106
> PASS setterValue = undefined; class A { static set set(x) { setterValue = x; } }; A.set = 107; setterValue is 107
>+PASS class X {static arguments() {}} did not throw exception.
>+PASS class X {static caller() {}} did not throw exception.
>+PASS (class X {static arguments() {return staticMethodValue;}}).arguments() is staticMethodValue
>+PASS (class X {static caller() {return staticMethodValue;}}).caller() is staticMethodValue
>+PASS (class X {static arguments() {return staticMethodValue;}}).hasOwnProperty('arguments') is true
>+PASS (class X {static caller() {return staticMethodValue;}}).hasOwnProperty('caller') is true
>+PASS class X {static get arguments() {}} did not throw exception.
>+PASS class X {static get caller() {}} did not throw exception.
>+PASS (class X {static get arguments() {return staticMethodValue;}}).arguments is staticMethodValue
>+PASS (class X {static get caller() {return staticMethodValue;}}).caller is staticMethodValue
>+PASS (class X {static get arguments() {return staticMethodValue;}}).hasOwnProperty('arguments') is true
>+PASS (class X {static get caller() {return staticMethodValue;}}).hasOwnProperty('caller') is true
>+PASS class X {static caller() {return staticMethodValue;}};X.arguments = function(){} threw exception TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode..
>+PASS class X {static arguments() {return staticMethodValue;}}; X.caller = function(){} threw exception TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode..
>+PASS class X {static caller() {return "";}} X.caller = function(){ return staticMethodValue; };X.caller() is staticMethodValue
>+PASS class X {static arguments() {return "";}}; X.arguments = function(){ return staticMethodValue; };X.arguments() is staticMethodValue
>+PASS class X {static caller() {return "";}} X["caller"] = function(){ return staticMethodValue; };X.caller() is staticMethodValue
>+PASS class X {static arguments() {return "";}}; X["arguments"] = function(){ return staticMethodValue; };X.arguments() is staticMethodValue
>+PASS class X {static *caller() {yield staticMethodValue;}}; X.caller().next().value is staticMethodValue
>+PASS class X {static *arguments() {yield staticMethodValue;}}; X.arguments().next().value is staticMethodValue
>+PASS class X {static *caller() {yield;}}; X["caller"] = function*(){yield staticMethodValue;}; X.caller().next().value is staticMethodValue
>+PASS class X {static *arguments() {yield;}}; X["arguments"] = function*(){yield staticMethodValue;}; X.arguments().next().value is staticMethodValue
>+PASS class X {*caller() {yield staticMethodValue;}}; let x = new X; x.caller().next().value is staticMethodValue
>+PASS class X {*arguments() {yield staticMethodValue;}}; let x = new X; x.arguments().next().value is staticMethodValue
>+PASS class X {*caller() {yield;}}; let x = new X; x["caller"] = function*(){yield staticMethodValue;}; x.caller().next().value is staticMethodValue
>+PASS class X {*arguments() {yield;}}; let x = new X; x["arguments"] = function*(){yield staticMethodValue;}; x.arguments().next().value is staticMethodValue
> 
> Instance methods with computed names
> PASS class A { ['a' + 'b']() { return 211; } }; (new A).ab() is 211
>diff --git a/LayoutTests/js/es6-function-properties-expected.txt b/LayoutTests/js/es6-function-properties-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..a6e7172f7d0d5c91cbe07255576b45a8d3256ca4
>--- /dev/null
>+++ b/LayoutTests/js/es6-function-properties-expected.txt
>@@ -0,0 +1,433 @@
>+Tests for ES6 class method and constructor properties
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+PASS a.constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.hasOwnProperty("caller"):::false
>+PASS a.constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(a.constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(a.constructor, "arguments"):::undefined
>+PASS delete a.constructor.caller:::true
>+PASS delete a.constructor["caller"]:::true
>+PASS delete a.constructor.arguments:::true
>+PASS delete a.constructor["arguments"]:::true
>+PASS a.constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS a.constructor.hasOwnProperty("caller"):::false
>+PASS a.constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(a.constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(a.constructor, "arguments"):::undefined
>+PASS delete a.constructor.caller:::true
>+PASS delete a.constructor["caller"]:::true
>+PASS delete a.constructor.arguments:::true
>+PASS delete a.constructor["arguments"]:::true
>+PASS (new A()).constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new A()).constructor.hasOwnProperty("caller"):::false
>+PASS (new A()).constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new A()).constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new A()).constructor, "arguments"):::undefined
>+PASS delete (new A()).constructor.caller:::true
>+PASS delete (new A()).constructor["caller"]:::true
>+PASS delete (new A()).constructor.arguments:::true
>+PASS delete (new A()).constructor["arguments"]:::true
>+PASS b.constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS b.constructor.hasOwnProperty("caller"):::false
>+PASS b.constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(b.constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(b.constructor, "arguments"):::undefined
>+PASS delete b.constructor.caller:::true
>+PASS delete b.constructor["caller"]:::true
>+PASS delete b.constructor.arguments:::true
>+PASS delete b.constructor["arguments"]:::true
>+PASS (new B()).constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new B()).constructor.hasOwnProperty("caller"):::false
>+PASS (new B()).constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new B()).constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new B()).constructor, "arguments"):::undefined
>+PASS delete (new B()).constructor.caller:::true
>+PASS delete (new B()).constructor["caller"]:::true
>+PASS delete (new B()).constructor.arguments:::true
>+PASS delete (new B()).constructor["arguments"]:::true
>+PASS c.constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS c.constructor.hasOwnProperty("caller"):::false
>+PASS c.constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(c.constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(c.constructor, "arguments"):::undefined
>+PASS delete c.constructor.caller:::true
>+PASS delete c.constructor["caller"]:::true
>+PASS delete c.constructor.arguments:::true
>+PASS delete c.constructor["arguments"]:::true
>+PASS (new C()).constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new C()).constructor.hasOwnProperty("caller"):::false
>+PASS (new C()).constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new C()).constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new C()).constructor, "arguments"):::undefined
>+PASS delete (new C()).constructor.caller:::true
>+PASS delete (new C()).constructor["caller"]:::true
>+PASS delete (new C()).constructor.arguments:::true
>+PASS delete (new C()).constructor["arguments"]:::true
>+PASS d.constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS d.constructor.hasOwnProperty("caller"):::false
>+PASS d.constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(d.constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(d.constructor, "arguments"):::undefined
>+PASS delete d.constructor.caller:::true
>+PASS delete d.constructor["caller"]:::true
>+PASS delete d.constructor.arguments:::true
>+PASS delete d.constructor["arguments"]:::true
>+PASS (new D()).constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new D()).constructor.hasOwnProperty("caller"):::false
>+PASS (new D()).constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new D()).constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new D()).constructor, "arguments"):::undefined
>+PASS delete (new D()).constructor.caller:::true
>+PASS delete (new D()).constructor["caller"]:::true
>+PASS delete (new D()).constructor.arguments:::true
>+PASS delete (new D()).constructor["arguments"]:::true
>+PASS e.constructor.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS e.constructor.hasOwnProperty("caller"):::false
>+PASS e.constructor.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(e.constructor, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(e.constructor, "arguments"):::undefined
>+PASS delete e.constructor.caller:::true
>+PASS delete e.constructor["caller"]:::true
>+PASS delete e.constructor.arguments:::true
>+PASS delete e.constructor["arguments"]:::true
>+PASS (new E()).getItem.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new E()).getItem.hasOwnProperty("caller"):::false
>+PASS (new E()).getItem.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new E()).getItem, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new E()).getItem, "arguments"):::undefined
>+PASS delete (new E()).getItem.caller:::true
>+PASS delete (new E()).getItem["caller"]:::true
>+PASS delete (new E()).getItem.arguments:::true
>+PASS delete (new E()).getItem["arguments"]:::true
>+PASS f.getItem.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getItem.hasOwnProperty("caller"):::false
>+PASS f.getItem.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(f.getItem, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(f.getItem, "arguments"):::undefined
>+PASS delete f.getItem.caller:::true
>+PASS delete f.getItem["caller"]:::true
>+PASS delete f.getItem.arguments:::true
>+PASS delete f.getItem["arguments"]:::true
>+PASS f.getElement.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS f.getElement.hasOwnProperty("caller"):::false
>+PASS f.getElement.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(f.getElement, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(f.getElement, "arguments"):::undefined
>+PASS delete f.getElement.caller:::true
>+PASS delete f.getElement["caller"]:::true
>+PASS delete f.getElement.arguments:::true
>+PASS delete f.getElement["arguments"]:::true
>+PASS (new F()).getItem.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getItem.hasOwnProperty("caller"):::false
>+PASS (new F()).getItem.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new F()).getItem, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new F()).getItem, "arguments"):::undefined
>+PASS delete (new F()).getItem.caller:::true
>+PASS delete (new F()).getItem["caller"]:::true
>+PASS delete (new F()).getItem.arguments:::true
>+PASS delete (new F()).getItem["arguments"]:::true
>+PASS (new F()).getElement.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new F()).getElement.hasOwnProperty("caller"):::false
>+PASS (new F()).getElement.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new F()).getElement, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new F()).getElement, "arguments"):::undefined
>+PASS delete (new F()).getElement.caller:::true
>+PASS delete (new F()).getElement["caller"]:::true
>+PASS delete (new F()).getElement.arguments:::true
>+PASS delete (new F()).getElement["arguments"]:::true
>+PASS arr.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS arr.hasOwnProperty("caller"):::false
>+PASS arr.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(arr, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(arr, "arguments"):::undefined
>+PASS delete arr.caller:::true
>+PASS delete arr["caller"]:::true
>+PASS delete arr.arguments:::true
>+PASS delete arr["arguments"]:::true
>+PASS (()=>{}).caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{}).arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{})["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{})["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{}).caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{}).arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{})["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{})["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (()=>{}).hasOwnProperty("caller"):::false
>+PASS (()=>{}).hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((()=>{}), "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((()=>{}), "arguments"):::undefined
>+PASS delete (()=>{}).caller:::true
>+PASS delete (()=>{})["caller"]:::true
>+PASS delete (()=>{}).arguments:::true
>+PASS delete (()=>{})["arguments"]:::true
>+PASS g.item.caller:::undefined
>+PASS g.item.arguments:::undefined
>+PASS (new G()).item.caller:::undefined
>+PASS (new G()).item.arguments:::undefined
>+PASS H.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS H.hasOwnProperty("caller"):::false
>+PASS H.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(H, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(H, "arguments"):::undefined
>+PASS delete H.caller:::true
>+PASS delete H["caller"]:::true
>+PASS delete H.arguments:::true
>+PASS delete H["arguments"]:::true
>+PASS h.caller():::"value"
>+PASS h.arguments():::"value"
>+PASS h.caller.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS h.caller.hasOwnProperty("caller"):::false
>+PASS h.caller.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(h.caller, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(h.caller, "arguments"):::undefined
>+PASS delete h.caller.caller:::true
>+PASS delete h.caller["caller"]:::true
>+PASS delete h.caller.arguments:::true
>+PASS delete h.caller["arguments"]:::true
>+PASS (new H()).caller():::"value"
>+PASS (new H()).arguments():::"value"
>+PASS (new H()).caller.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new H()).caller.hasOwnProperty("caller"):::false
>+PASS (new H()).caller.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new H()).caller, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new H()).caller, "arguments"):::undefined
>+PASS delete (new H()).caller.caller:::true
>+PASS delete (new H()).caller["caller"]:::true
>+PASS delete (new H()).caller.arguments:::true
>+PASS delete (new H()).caller["arguments"]:::true
>+PASS J.gen.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.gen.hasOwnProperty("caller"):::false
>+PASS J.gen.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(J.gen, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(J.gen, "arguments"):::undefined
>+PASS delete J.gen.caller:::true
>+PASS delete J.gen["caller"]:::true
>+PASS delete J.gen.arguments:::true
>+PASS delete J.gen["arguments"]:::true
>+PASS J.get.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS J.get.hasOwnProperty("caller"):::false
>+PASS J.get.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(J.get, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(J.get, "arguments"):::undefined
>+PASS delete J.get.caller:::true
>+PASS delete J.get["caller"]:::true
>+PASS delete J.get.arguments:::true
>+PASS delete J.get["arguments"]:::true
>+PASS j.gen.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.gen.hasOwnProperty("caller"):::false
>+PASS j.gen.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(j.gen, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(j.gen, "arguments"):::undefined
>+PASS delete j.gen.caller:::true
>+PASS delete j.gen["caller"]:::true
>+PASS delete j.gen.arguments:::true
>+PASS delete j.gen["arguments"]:::true
>+PASS j.get.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS j.get.hasOwnProperty("caller"):::false
>+PASS j.get.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor(j.get, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor(j.get, "arguments"):::undefined
>+PASS delete j.get.caller:::true
>+PASS delete j.get["caller"]:::true
>+PASS delete j.get.arguments:::true
>+PASS delete j.get["arguments"]:::true
>+PASS (new J).gen.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).gen.hasOwnProperty("caller"):::false
>+PASS (new J).gen.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new J).gen, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new J).gen, "arguments"):::undefined
>+PASS delete (new J).gen.caller:::true
>+PASS delete (new J).gen["caller"]:::true
>+PASS delete (new J).gen.arguments:::true
>+PASS delete (new J).gen["arguments"]:::true
>+PASS (new J).get.caller:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get.arguments:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get["caller"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get["arguments"]:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get.caller = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get.arguments = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get["caller"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get["arguments"] = function () {}:::TypeError: 'arguments', 'callee', and 'caller' cannot be accessed in strict mode.
>+PASS (new J).get.hasOwnProperty("caller"):::false
>+PASS (new J).get.hasOwnProperty("arguments"):::false
>+PASS Object.getOwnPropertyDescriptor((new J).get, "caller"):::undefined
>+PASS Object.getOwnPropertyDescriptor((new J).get, "arguments"):::undefined
>+PASS delete (new J).get.caller:::true
>+PASS delete (new J).get["caller"]:::true
>+PASS delete (new J).get.arguments:::true
>+PASS delete (new J).get["arguments"]:::true
>+PASS successfullyParsed:::true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/es6-function-properties.html b/LayoutTests/js/es6-function-properties.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..c125daf0df2540b5762ecc55678277e92f24ec0a
>--- /dev/null
>+++ b/LayoutTests/js/es6-function-properties.html
>@@ -0,0 +1,8 @@
>+<!DOCTYPE html>
>+<html>
>+<body>
>+<script src="../resources/js-test-pre.js"></script>
>+<script src="script-tests/es6-function-properties.js"></script>
>+<script src="../resources/js-test-post.js"></script>
>+</body>
>+</html>
>\ No newline at end of file
>diff --git a/LayoutTests/js/kde/script-tests/function_arguments.js b/LayoutTests/js/kde/script-tests/function_arguments.js
>index 664988cf189a8c1ce9cb09d802c24fa69e3c22c7..f56a943be72a3dffb218a045e1a85d531e914b0f 100644
>--- a/LayoutTests/js/kde/script-tests/function_arguments.js
>+++ b/LayoutTests/js/kde/script-tests/function_arguments.js
>@@ -37,7 +37,7 @@ function f(a,b,c) {
> 
>   // DontDelete
>   DontDeleteOK = !delete(f.arguments);
>-  if (f.arguments == undefined || !f.hasOwnProperty("arguments"))
>+  if (f.arguments == undefined || !f.__proto__.hasOwnProperty("arguments"))
>     DontDeleteOK = false;
> 
>   // DontEnum
>diff --git a/LayoutTests/js/non-strict-function-properties-expected.txt b/LayoutTests/js/non-strict-function-properties-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..ad8d02a707fc68635087aa8290c273d172fcf4ef
>--- /dev/null
>+++ b/LayoutTests/js/non-strict-function-properties-expected.txt
>@@ -0,0 +1,25 @@
>+Test caller and arguments properties in function in non strict mode
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+PASS Object.getOwnPropertyNames(function () {}).length is 5
>+PASS Object.getOwnPropertyNames(function () {}).includes("caller") is true
>+PASS Object.getOwnPropertyNames(function () {}).includes("arguments") is true
>+PASS (function(){}).hasOwnProperty("caller") is true
>+PASS (function(){}).__proto__.hasOwnProperty("caller") is true
>+PASS (function(){}).hasOwnProperty("arguments") is true
>+PASS (function(){}).__proto__.hasOwnProperty("arguments") is true
>+PASS typeof Object.getOwnPropertyDescriptor(foo, "arguments") is "object"
>+PASS typeof Object.getOwnPropertyDescriptor(foo, "caller") is "object"
>+PASS foo.caller is null
>+PASS foo.arguments is null
>+PASS foo.caller is null
>+PASS foo.arguments is null
>+PASS boo("abc")[0] is "abc"
>+PASS boo("expected-value")[0] is "expected-value"
>+PASS g(f) is g
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/non-strict-function-properties.html b/LayoutTests/js/non-strict-function-properties.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..96742dd3c969154ec98689945ae6c7b7131f85e1
>--- /dev/null
>+++ b/LayoutTests/js/non-strict-function-properties.html
>@@ -0,0 +1,8 @@
>+<DOCTYPE html>
>+<html>
>+<body>
>+<script src="../resources/js-test-pre.js"></script>
>+<script src="script-tests/non-strict-function-properties.js"></script>
>+<script src="../resources/js-test-post.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/script-tests/Object-getOwnPropertyNames.js b/LayoutTests/js/script-tests/Object-getOwnPropertyNames.js
>index 28dfa5294384cd4176f033aac834b4e523530f3f..769451f820ee8d40eccd267101ef89b76183c4e0 100644
>--- a/LayoutTests/js/script-tests/Object-getOwnPropertyNames.js
>+++ b/LayoutTests/js/script-tests/Object-getOwnPropertyNames.js
>@@ -53,7 +53,7 @@ var expectedPropertyNamesSet = {
>     "Object": "['assign', 'create', 'defineProperties', 'defineProperty', 'entries', 'freeze', 'getOwnPropertyDescriptor', 'getOwnPropertyDescriptors', 'getOwnPropertyNames', 'getOwnPropertySymbols', 'getPrototypeOf', 'is', 'isExtensible', 'isFrozen', 'isSealed', 'keys', 'length', 'name', 'preventExtensions', 'prototype', 'seal', 'setPrototypeOf', 'values']",
>     "Object.prototype": "['__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf']",
>     "Function": "['length', 'name', 'prototype']",
>-    "Function.prototype": "['apply', 'bind', 'call', 'constructor', 'length', 'name', 'toString']",
>+    "Function.prototype": "['apply', 'arguments', 'bind', 'call', 'caller', 'constructor', 'length', 'name', 'toString']",
>     "Array": "['from', 'isArray', 'length', 'name', 'of', 'prototype']",
>     "Array.prototype": "['concat', 'constructor', 'copyWithin', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift', 'values']",
>     "String": "['fromCharCode', 'fromCodePoint', 'length', 'name', 'prototype', 'raw']",
>diff --git a/LayoutTests/js/script-tests/basic-strict-mode.js b/LayoutTests/js/script-tests/basic-strict-mode.js
>index c35de26b1eaad87fc768a6ea836d489c30f93ea9..0019f218ab4f1e25c2123c8995b39657d34261e4 100644
>--- a/LayoutTests/js/script-tests/basic-strict-mode.js
>+++ b/LayoutTests/js/script-tests/basic-strict-mode.js
>@@ -91,9 +91,11 @@ shouldBe("var o = {foo: function a(a){'use strict'; return a+2; } }; o.foo(40)",
> 
> // arguments/caller poisoning should be visible but not throw with 'in' & 'hasOwnProperty'.
> shouldBeTrue('"caller" in function(){"use strict"}');
>-shouldBeTrue('(function(){"use strict";}).hasOwnProperty("caller")');
>+shouldBeFalse('(function(){"use strict";}).hasOwnProperty("caller")');
>+shouldBeTrue('(function(){"use strict";}).__proto__.hasOwnProperty("caller")');
> shouldBeTrue('"arguments" in function(){"use strict"}');
>-shouldBeTrue('(function(){"use strict";}).hasOwnProperty("arguments")');
>+shouldBeFalse('(function(){"use strict";}).hasOwnProperty("arguments")');
>+shouldBeTrue('(function(){"use strict";}).__proto__.hasOwnProperty("arguments")');
>  
> shouldBeSyntaxError("'use strict'; (function (){with(1){};})");
> shouldBeSyntaxError("'use strict'; (function (){var a; delete a;})");
>@@ -176,14 +178,14 @@ shouldBeTrue("(function (){'use strict';  var local; (function (){local;})(); ar
> shouldBeTrue("'use strict'; (function (){var a = true; eval('var a = false'); return a; })()");
> shouldBeTrue("(function (){var a = true; eval('\"use strict\"; var a = false'); return a; })()");
> 
>-shouldBeUndefined("(function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f, 'arguments').value; })()");
>-shouldBeUndefined("(function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f, 'caller').value; })()");
>+shouldBeUndefined("(function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f.__proto__, 'arguments').value; })()");
>+shouldBeUndefined("(function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(f.__proto__, 'caller').value; })()");
> shouldBeUndefined("(function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(arguments, 'callee').value; })()");
> shouldBeUndefined("(function f(arg){'use strict'; return Object.getOwnPropertyDescriptor(arguments, 'caller').value; })()");
> shouldBeTrue("(function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(arguments, 'caller'); return descriptor.get === descriptor.set; })()");
> shouldBeTrue("(function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(arguments, 'callee'); return descriptor.get === descriptor.set; })()");
>-shouldBeTrue("(function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f, 'caller'); return descriptor.get === descriptor.set; })()");
>-shouldBeTrue("(function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f, 'arguments'); return descriptor.get === descriptor.set; })()");
>+shouldBeTrue("(function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f.__proto__, 'caller'); return descriptor.get === descriptor.set; })()");
>+shouldBeTrue("(function f(arg){'use strict'; var descriptor = Object.getOwnPropertyDescriptor(f.__proto__, 'arguments'); return descriptor.get === descriptor.set; })()");
> shouldBeTrue("'use strict'; (function f() { for(var i in this); })(); true;")
> 
> shouldBeSyntaxError("'use strict'\u033b");
>@@ -210,4 +212,4 @@ aGlobal = false;
> shouldBeTrue("(function () {try { throw 1; } catch (e) { aGlobal = true; }})(); aGlobal;");
> 
> // Make sure this doesn't crash!
>-shouldBe('String(Object.getOwnPropertyDescriptor(function() { "use strict"; }, "caller").get)', "'function () {\\n    [native code]\\n}'");
>+shouldBe('String(Object.getOwnPropertyDescriptor((function() { "use strict"; }).__proto__, "caller").get)', "'function () {\\n    [native code]\\n}'");
>\ No newline at end of file
>diff --git a/LayoutTests/js/script-tests/class-method-and-constructor-properties.js b/LayoutTests/js/script-tests/class-method-and-constructor-properties.js
>deleted file mode 100644
>index 6c919a2c641e9ec43fa296ddd9155a9d3d115a4b..0000000000000000000000000000000000000000
>--- a/LayoutTests/js/script-tests/class-method-and-constructor-properties.js
>+++ /dev/null
>@@ -1,69 +0,0 @@
>-
>-description('Tests for ES6 class method and constructor properties');
>-
>-function shouldThrow(s, message) {
>-    var threw = false;
>-    try {
>-        eval(s);
>-    } catch(e) {
>-        threw = true;
>-        if (!message || e.toString() === eval(message))
>-            testPassed(s + ":::" + e.toString());
>-        else
>-            testFailed(s);
>-    }
>-    if (!threw)
>-        testFailed(s);
>-}
>-
>-function shouldBe(a, b) {
>-    var r1 = eval(a);
>-    var r2 = eval(b)
>-    if (r1 === r2)
>-        testPassed(a + ":::" + b);
>-    else
>-        testFailed(r1 + ":::" + r2);
>-}
>-
>-class A { };
>-class B extends A { };
>-class C extends A { constructor () {super();}}
>-class D { constructor () {}}
>-class E { getItem() { return 'text';} }
>-class F extends E { getElement() { return 'text'}}
>-class G extends E { get item() { return 'text'} }
>-
>-shouldThrow('(new A()).constructor.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new A()).constructor.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new B()).constructor.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new B()).constructor.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new C()).constructor.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new C()).constructor.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new D()).constructor.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new D()).constructor.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new E()).getItem.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new E()).getItem.arguments', '');
>-shouldThrow('(new F()).getItem.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new F()).getItem.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new F()).getElement.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new F()).getElement.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-
>-shouldBe('(new G()).item.caller', 'undefined');
>-shouldBe('(new G()).item.arguments', 'undefined');
>-
>-class H {
>-  caller() { return 'value'; }
>-  arguments() { return 'value'; }
>-}
>-
>-shouldThrow('H.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('H.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-
>-shouldBe('(new H()).caller()', '"value"');
>-shouldBe('(new H()).arguments()', '"value"');
>-
>-shouldThrow('(new H()).caller.caller', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-shouldThrow('(new H()).caller.arguments', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>-
>-
>-var successfullyParsed = true;
>diff --git a/LayoutTests/js/script-tests/class-syntax-method-names.js b/LayoutTests/js/script-tests/class-syntax-method-names.js
>index 6643cedcad9b532ddfd6ded6a8b727efb9b398ca..af7ddcb134c3a4aab198937258cb2e5b497ce599 100644
>--- a/LayoutTests/js/script-tests/class-syntax-method-names.js
>+++ b/LayoutTests/js/script-tests/class-syntax-method-names.js
>@@ -10,6 +10,7 @@ shouldBe("setterValue = undefined; class A { set get(x) { setterValue = x; } };
> shouldBe("setterValue = undefined; class A { set set(x) { setterValue = x; } }; (new A).set = 7; setterValue", "7");
> 
> debug('');
>+var staticMethodValue = 'value';
> debug('Static methods');
> shouldBe("class A { static 0.1() { return 101; } }; A[0.1]()", "101");
> shouldBe("class A { static get() { return 102; } }; A.get()", "102");
>@@ -18,6 +19,32 @@ shouldBe("class A { static get get() { return 104; } }; A.get", "104");
> shouldBe("class A { static get set() { return 105; } }; A.set", "105");
> shouldBe("setterValue = undefined; class A { static set get(x) { setterValue = x; } }; A.get = 106; setterValue", "106");
> shouldBe("setterValue = undefined; class A { static set set(x) { setterValue = x; } }; A.set = 107; setterValue", "107");
>+shouldNotThrow("class X {static arguments() {}}");
>+shouldNotThrow("class X {static caller() {}}");
>+shouldBe("(class X {static arguments() {return staticMethodValue;}}).arguments()", "staticMethodValue");
>+shouldBe("(class X {static caller() {return staticMethodValue;}}).caller()", "staticMethodValue");
>+shouldBe("(class X {static arguments() {return staticMethodValue;}}).hasOwnProperty('arguments')", "true");
>+shouldBe("(class X {static caller() {return staticMethodValue;}}).hasOwnProperty('caller')", "true");
>+shouldNotThrow("class X {static get arguments() {}}");
>+shouldNotThrow("class X {static get caller() {}}");
>+shouldBe("(class X {static get arguments() {return staticMethodValue;}}).arguments", "staticMethodValue");
>+shouldBe("(class X {static get caller() {return staticMethodValue;}}).caller", "staticMethodValue");
>+shouldBe("(class X {static get arguments() {return staticMethodValue;}}).hasOwnProperty('arguments')", "true");
>+shouldBe("(class X {static get caller() {return staticMethodValue;}}).hasOwnProperty('caller')", "true");
>+shouldThrow('class X {static caller() {return staticMethodValue;}};X.arguments = function(){}', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>+shouldThrow('class X {static arguments() {return staticMethodValue;}}; X.caller = function(){}', '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."');
>+shouldBe('class X {static caller() {return "";}} X.caller = function(){ return staticMethodValue; };X.caller()', 'staticMethodValue');
>+shouldBe('class X {static arguments() {return "";}}; X.arguments = function(){ return staticMethodValue; };X.arguments()', 'staticMethodValue');
>+shouldBe('class X {static caller() {return "";}} X["caller"] = function(){ return staticMethodValue; };X.caller()', 'staticMethodValue');
>+shouldBe('class X {static arguments() {return "";}}; X["arguments"] = function(){ return staticMethodValue; };X.arguments()', 'staticMethodValue');
>+shouldBe('class X {static *caller() {yield staticMethodValue;}}; X.caller().next().value', 'staticMethodValue');
>+shouldBe('class X {static *arguments() {yield staticMethodValue;}}; X.arguments().next().value', 'staticMethodValue');
>+shouldBe('class X {static *caller() {yield;}}; X["caller"] = function*(){yield staticMethodValue;}; X.caller().next().value', 'staticMethodValue');
>+shouldBe('class X {static *arguments() {yield;}}; X["arguments"] = function*(){yield staticMethodValue;}; X.arguments().next().value', 'staticMethodValue');
>+shouldBe('class X {*caller() {yield staticMethodValue;}}; let x = new X; x.caller().next().value', 'staticMethodValue');
>+shouldBe('class X {*arguments() {yield staticMethodValue;}}; let x = new X; x.arguments().next().value', 'staticMethodValue');
>+shouldBe('class X {*caller() {yield;}}; let x = new X; x["caller"] = function*(){yield staticMethodValue;}; x.caller().next().value', 'staticMethodValue');
>+shouldBe('class X {*arguments() {yield;}}; let x = new X; x["arguments"] = function*(){yield staticMethodValue;}; x.arguments().next().value', 'staticMethodValue');
> 
> debug('');
> debug('Instance methods with computed names');
>diff --git a/LayoutTests/js/script-tests/es6-function-properties.js b/LayoutTests/js/script-tests/es6-function-properties.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..5b2312c4e178e51496af144d007ba810f98e9dc7
>--- /dev/null
>+++ b/LayoutTests/js/script-tests/es6-function-properties.js
>@@ -0,0 +1,139 @@
>+description('Tests for ES6 class method and constructor properties');
>+
>+function shouldThrow(s, message) {
>+    var threw = false;
>+    try {
>+        eval(s);
>+    } catch(e) {
>+        threw = true;
>+        if (!message || e.toString() === eval(message))
>+            testPassed(s + ":::" + e.toString());
>+        else
>+            testFailed(s);
>+    }
>+    if (!threw)
>+        testFailed(s);
>+}
>+
>+function shouldBe(a, b) {
>+    var r1 = eval(a);
>+    var r2 = eval(b)
>+    if (r1 === r2)
>+        testPassed(a + ":::" + b);
>+    else
>+        testFailed(r1 + ":::" + r2);
>+}
>+
>+ var typeErrorText = '"TypeError: \'arguments\', \'callee\', and \'caller\' cannot be accessed in strict mode."';
>+
>+class A { };
>+class B extends A { };
>+class C extends A { constructor () {super();}}
>+class D { constructor () {}}
>+class E { getItem() { return 'text';} }
>+class F extends E { getElement() { return 'text'}}
>+class G extends E { get item() { return 'text'} }
>+
>+var wrongPropertyInAList = '';
>+
>+var check = function (text) {
>+    shouldThrow(text + '.caller', typeErrorText);
>+    shouldThrow(text + '.arguments', typeErrorText);
>+    shouldThrow(text + '["caller"]', typeErrorText);
>+    shouldThrow(text + '["arguments"]', typeErrorText);
>+    shouldThrow(text + '.caller = function () {}', typeErrorText);
>+    shouldThrow(text + '.arguments = function () {}', typeErrorText);
>+    shouldThrow(text + '["caller"] = function () {}', typeErrorText);
>+    shouldThrow(text + '["arguments"] = function () {}', typeErrorText);
>+
>+    shouldBe(text + '.hasOwnProperty("caller")', 'false');
>+    shouldBe(text + '.hasOwnProperty("arguments")', 'false');
>+    var object = eval(text);
>+
>+    for (var propertyName in object) {
>+        wrongPropertyInAList = propertyName === 'caller' || propertyName === 'arguments';
>+        if (wrongPropertyInAList)
>+           shouldBe('wrongPropertyInAList', 'false');
>+    }
>+
>+    shouldBe('Object.getOwnPropertyDescriptor(' + text + ', "caller")', 'undefined');
>+    shouldBe('Object.getOwnPropertyDescriptor(' + text + ', "arguments")', 'undefined');
>+    shouldBe('delete ' + text +'.caller', true);
>+    shouldBe('delete ' + text +'["caller"]', true);
>+    shouldBe('delete ' + text +'.arguments', true);
>+    shouldBe('delete ' + text +'["arguments"]', true);
>+}
>+
>+var a = new A;
>+check('a.constructor');
>+check('a.constructor');
>+check('(new A()).constructor');
>+
>+var b = new B;
>+check('b.constructor');
>+check('(new B()).constructor');
>+
>+var c = new C;
>+check('c.constructor');
>+check('(new C()).constructor');
>+
>+var d = new D;
>+check('d.constructor');
>+check('(new D()).constructor');
>+
>+var e = new E;
>+check('e.constructor');
>+check('(new E()).getItem');
>+
>+var f = new F;
>+check('f.getItem');
>+check('f.getElement');
>+
>+check('(new F()).getItem');
>+check('(new F()).getElement');
>+
>+var arr = ()=>{};
>+check('arr');
>+check('(()=>{})');
>+
>+var g = new G;
>+shouldBe('g.item.caller', 'undefined');
>+shouldBe('g.item.arguments', 'undefined');
>+shouldBe('(new G()).item.caller', 'undefined');
>+shouldBe('(new G()).item.arguments', 'undefined');
>+
>+class H {
>+  caller() { return 'value'; }
>+  arguments() { return 'value'; }
>+}
>+
>+check('H');
>+
>+var h = new H;
>+shouldBe('h.caller()', '"value"');
>+shouldBe('h.arguments()', '"value"');
>+
>+check('h.caller');
>+
>+shouldBe('(new H()).caller()', '"value"');
>+shouldBe('(new H()).arguments()', '"value"');
>+
>+check('(new H()).caller');
>+
>+class J {
>+  *gen() {yield;}
>+  static *gen() {yield;}
>+  *get() {}
>+  static *get() {}
>+}
>+
>+check('J.gen');
>+check('J.get');
>+
>+var j = new J;
>+check('j.gen');
>+check('j.get');
>+check('(new J).gen');
>+check('(new J).get');
>+
>+var successfullyParsed = true;
>diff --git a/LayoutTests/js/script-tests/non-strict-function-properties.js b/LayoutTests/js/script-tests/non-strict-function-properties.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..f3b1970d56f02d201674f875faab1b148c9f69a0
>--- /dev/null
>+++ b/LayoutTests/js/script-tests/non-strict-function-properties.js
>@@ -0,0 +1,40 @@
>+description('Test caller and arguments properties in function in non strict mode');
>+
>+function foo() {
>+    return 1;
>+}
>+
>+shouldBe('Object.getOwnPropertyNames(function () {}).length','5');
>+
>+shouldBeTrue('Object.getOwnPropertyNames(function () {}).includes("caller")');
>+shouldBeTrue('Object.getOwnPropertyNames(function () {}).includes("arguments")');
>+
>+shouldBeTrue('(function(){}).hasOwnProperty("caller")');
>+shouldBeTrue('(function(){}).__proto__.hasOwnProperty("caller")');
>+
>+shouldBeTrue('(function(){}).hasOwnProperty("arguments")');
>+shouldBeTrue('(function(){}).__proto__.hasOwnProperty("arguments")');
>+
>+shouldBe('typeof Object.getOwnPropertyDescriptor(foo, "arguments")', '"object"');
>+shouldBe('typeof Object.getOwnPropertyDescriptor(foo, "caller")', '"object"');
>+
>+shouldBe('foo.caller', 'null');
>+shouldBe('foo.arguments', 'null');
>+
>+foo.caller = 10;
>+foo.arguments = 10;
>+
>+shouldBe('foo.caller', 'null');
>+shouldBe('foo.arguments', 'null');
>+
>+var boo = function () { return boo.arguments; };
>+
>+shouldBe('boo("abc")[0]','"abc"');
>+
>+boo.arguments = 'not-expected-value';
>+shouldBe('boo("expected-value")[0]','"expected-value"');
>+
>+var f = function () { return f.caller;  };
>+var g = function (cb) { return cb(); };
>+
>+shouldBe('g(f)','g');
>diff --git a/LayoutTests/js/script-tests/strict-throw-type-error.js b/LayoutTests/js/script-tests/strict-throw-type-error.js
>index 734a6904e04a8fba0b4f5cb62f420bcb8eccc16a..a54ea092b8ef416cf86be66bb110a1b800c87fcf 100644
>--- a/LayoutTests/js/script-tests/strict-throw-type-error.js
>+++ b/LayoutTests/js/script-tests/strict-throw-type-error.js
>@@ -12,8 +12,8 @@ function strictArgumentsFunction1()
> }
> var strictArguments1 = strictArgumentsFunction1();
> var boundFunction1 = strictArgumentsFunction1.bind();
>-var functionCaller1 = getter(strictArgumentsFunction1, "caller");
>-var functionArguments1 = getter(strictArgumentsFunction1, "arguments");
>+var functionCaller1 = getter(strictArgumentsFunction1.__proto__, "caller");
>+var functionArguments1 = getter(strictArgumentsFunction1.__proto__, "arguments");
> var argumentsCaller1 = getter(strictArguments1, "caller");
> var argumentsCallee1 = getter(strictArguments1, "callee");
> var boundCaller1 = getter(boundFunction1, "caller");
>@@ -26,8 +26,8 @@ function strictArgumentsFunction2()
> }
> var strictArguments2 = strictArgumentsFunction2();
> var boundFunction2 = strictArgumentsFunction2.bind();
>-var functionCaller2 = getter(strictArgumentsFunction2, "caller");
>-var functionArguments2 = getter(strictArgumentsFunction2, "arguments");
>+var functionCaller2 = getter(strictArgumentsFunction2.__proto__, "caller");
>+var functionArguments2 = getter(strictArgumentsFunction2.__proto__, "arguments");
> var argumentsCaller2 = getter(strictArguments2, "caller");
> var argumentsCallee2 = getter(strictArguments2, "callee");
> var boundCaller2 = getter(boundFunction2, "caller");

Actions: View | Formatted Diff | Diff

Attachments on bug 152985: 277870 | 277905 | 278348 | 278358 | 278360 | 279291 | 279313 | 279579 | 279797 | 281184 | 281186 | 281189 | 281190 | 281191 | 281193 | 281274 | 281276 | 286891 | 286904 | 286917 | 286918 | 286920 | 286921 | 286952 | 286955 | 286956 | 286957 | 286958 | 286999 | 287017 | 287018 | 287020 | 287042 | 287129 | 287871 | 288449 | 288454 | 288469 | 288471 | 288474 | 288480 | 288483