Attachment 279579 Details for Bug 152985 – Patch

[patch] Patch

bug-152985-20160523215932.patch (text/plain), 72.50 KB, created by GSkachkov on 2016-05-23 12:58:28 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: GSkachkov

Created: 2016-05-23 12:58:28 PDT

Size: 72.50 KB

patch

obsolete

>Subversion Revision: 201013
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 715a2aa5cb8c23fd387efc125ad85764bd141dc4..f18aa88e615bc9d7f582a7db990589d92bf8d2d1 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,39 @@
>+2016-05-18  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 have own properties named "caller" or "arguments". By current path was not covered 
>+        following part of the spec and will be implemented in http://webkit.org/b/157863: 
>+        'Built-in functions, strict functions created using the Function constructor, generator functions 
>+        created using the Generator constructor, and functions created using the bind 
>+        method also must not be created with such own properties.' 
>+
>+        Also added posibility 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/JSFunction.cpp:
>+        (JSC::getThrowTypeErrorGetterSetter):
>+        (JSC::JSFunction::getOwnPropertySlotOfArgumentsOrCaller):
>+        (JSC::JSFunction::getOwnPropertySlot):
>+        (JSC::JSFunction::put):
>+        (JSC::JSFunction::deleteProperty):
>+        (JSC::JSFunction::defineOwnProperty):
>+        * runtime/JSFunction.h:
>+        * runtime/JSObject.cpp:
>+        (JSC::JSObject::getOwnPropertyDescriptor):
>+        * runtime/PropertySlot.h:
>+        (JSC::PropertySlot::PropertySlot):
>+        (JSC::PropertySlot::setIsClassMethod):
>+        (JSC::PropertySlot::isClassMethod):
>+
> 2016-05-16  Saam barati  <sbarati@apple.com>
> 
>         ShadowChicken crashes when reading a scope from the frame during a stack overflow exception
>diff --git a/Source/JavaScriptCore/runtime/Executable.h b/Source/JavaScriptCore/runtime/Executable.h
>index 016f72a0278e4ca1a702d37ac342378b7f4e938f..b64833f40f25d39cf4d769f2c35e0d81a4a52a95 100644
>--- a/Source/JavaScriptCore/runtime/Executable.h
>+++ b/Source/JavaScriptCore/runtime/Executable.h
>@@ -652,6 +652,8 @@ public:
>     ConstructAbility constructAbility() const { return m_unlinkedExecutable->constructAbility(); }
>     bool isClass() const { return !classSource().isNull(); }
>     bool isArrowFunction() const { return parseMode() == SourceParseMode::ArrowFunctionMode; }
>+    bool isGenerator() const { return parseMode() == SourceParseMode::GeneratorBodyMode || parseMode() == SourceParseMode::GeneratorWrapperFunctionMode; }
>+    bool isES6Function() const { return isClassConstructorFunction() || isArrowFunction() || isGenerator() || parseMode() == SourceParseMode::MethodMode;}
>     bool isGetter() const { return parseMode() == SourceParseMode::GetterMode; }
>     bool isSetter() const { return parseMode() == SourceParseMode::SetterMode; }
>     DerivedContextType derivedContextType() const { return m_unlinkedExecutable->derivedContextType(); }
>diff --git a/Source/JavaScriptCore/runtime/JSFunction.cpp b/Source/JavaScriptCore/runtime/JSFunction.cpp
>index 638e70526fc00cbb30c53e59fa7c77615c6b5a02..6c6bc6107a77b39a040739956b0ebb09d9ac3677 100644
>--- a/Source/JavaScriptCore/runtime/JSFunction.cpp
>+++ b/Source/JavaScriptCore/runtime/JSFunction.cpp
>@@ -321,7 +321,7 @@ static JSValue retrieveCallerFunction(ExecState* exec, JSFunction* functionObj)
> 
> static GetterSetter* getThrowTypeErrorGetterSetter(JSFunction* function)
> {
>-    return function->jsExecutable()->isClassConstructorFunction() || function->jsExecutable()->parseMode() == SourceParseMode::MethodMode
>+    return function->jsExecutable()->isES6Function()
>         ? function->globalObject()->throwTypeErrorArgumentsAndCallerInClassContextGetterSetter()
>         : function->globalObject()->throwTypeErrorArgumentsAndCallerInStrictModeGetterSetter();
> }
>@@ -345,6 +345,54 @@ EncodedJSValue JSFunction::callerGetter(ExecState* exec, EncodedJSValue thisValu
>     return JSValue::encode(throwTypeError(exec, ASCIILiteral("Function.caller used to retrieve strict caller")));
> }
> 
>+bool JSFunction::getOwnPropertySlotOfArgumentsOrCaller(JSFunction* thisObject, ExecState* exec, PropertyName propertyName, PropertySlot& slot, PropertySlot::GetValueFunc getter)
>+{
>+    ASSERT(propertyName == exec->propertyNames().caller || propertyName == exec->propertyNames().arguments);
>+
>+    if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isES6Function()) {
>+        if (slot.isClassMethod()) {
>+            // Declare of methods with name caller or arguments within the class
>+            // class A { static caller() {} }
>+            // class B { arguments() {} }
>+            VM& vm = exec->vm();
>+            unsigned attributes;
>+            PropertyOffset offset = thisObject->getDirectOffset(vm, propertyName, attributes);
>+            if (!isValidOffset(offset))
>+                return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>+        } else if (slot.internalMethodType() == PropertySlot::InternalMethodType::GetOwnProperty && thisObject->jsExecutable()->isES6Function()) {
>+            // Execure getOwnProperty of ES6 functions(Arrow function/Generators/Class methods)
>+            VM& vm = exec->vm();
>+            unsigned attributes;
>+            PropertyOffset offset = thisObject->getDirectOffset(vm, propertyName, attributes);
>+            if (isValidOffset(offset)) {
>+                // Check if value already setted, for instance by condition from above
>+                JSValue value = thisObject->getDirect(offset);
>+                GetterSetter* getterSetterValue = jsDynamicCast<GetterSetter*>(value);
>+                GetterSetter* errorGetterSetter = getThrowTypeErrorGetterSetter(thisObject);
>+                return getterSetterValue && getterSetterValue == errorGetterSetter
>+                    ? false
>+                    : Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>+            }
>+            return false;
>+        }
>+
>+        bool result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>+        if (!result) {
>+            unsigned attributes = DontEnum | Accessor;
>+            if (!thisObject->jsExecutable()->isES6Function())
>+                attributes |= DontDelete;
>+            GetterSetter* errorGetterSetter = getThrowTypeErrorGetterSetter(thisObject);
>+            thisObject->putDirectAccessor(exec, propertyName, errorGetterSetter, DontEnum | Accessor);
>+            result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>+            ASSERT(result);
>+        }
>+
>+        return result;
>+    }
>+    slot.setCacheableCustom(thisObject, ReadOnly | DontEnum | DontDelete, getter);
>+    return true;
>+}
>+
> bool JSFunction::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
> {
>     JSFunction* thisObject = jsCast<JSFunction*>(object);
>@@ -371,35 +419,11 @@ bool JSFunction::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyN
>         slot.setValue(thisObject, attributes, thisObject->getDirect(offset), offset);
>     }
> 
>-    if (propertyName == exec->propertyNames().arguments) {
>-        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isClassConstructorFunction()) {
>-            bool result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-            if (!result) {
>-                GetterSetter* errorGetterSetter = getThrowTypeErrorGetterSetter(thisObject);
>-                thisObject->putDirectAccessor(exec, propertyName, errorGetterSetter, DontDelete | DontEnum | Accessor);
>-                result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-                ASSERT(result);
>-            }
>-            return result;
>-        }
>-        slot.setCacheableCustom(thisObject, ReadOnly | DontEnum | DontDelete, argumentsGetter);
>-        return true;
>-    }
>+    if (propertyName == exec->propertyNames().arguments)
>+        return getOwnPropertySlotOfArgumentsOrCaller(thisObject, exec, propertyName, slot, argumentsGetter);
> 
>-    if (propertyName == exec->propertyNames().caller) {
>-        if (thisObject->jsExecutable()->isStrictMode() || thisObject->jsExecutable()->isClassConstructorFunction()) {
>-            bool result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-            if (!result) {
>-                GetterSetter* errorGetterSetter = getThrowTypeErrorGetterSetter(thisObject);
>-                thisObject->putDirectAccessor(exec, propertyName, errorGetterSetter, DontDelete | DontEnum | Accessor);
>-                result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
>-                ASSERT(result);
>-            }
>-            return result;
>-        }
>-        slot.setCacheableCustom(thisObject, ReadOnly | DontEnum | DontDelete, callerGetter);
>-        return true;
>-    }
>+    if (propertyName == exec->propertyNames().caller)
>+        return getOwnPropertySlotOfArgumentsOrCaller(thisObject, exec, propertyName, slot, callerGetter);
> 
>     thisObject->reifyLazyPropertyIfNeeded(exec, propertyName);
> 
>@@ -446,7 +470,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,9 +491,9 @@ bool JSFunction::deleteProperty(JSCell* cell, ExecState* exec, PropertyName prop
>     // For non-host functions, don't let these properties by deleted - except by DefineOwnProperty.
>     if (!thisObject->isHostOrBuiltinFunction() && !exec->vm().isInDefineOwnProperty()) {
>         FunctionExecutable* executable = thisObject->jsExecutable();
>-        if (propertyName == exec->propertyNames().arguments
>+        if ((propertyName == exec->propertyNames().arguments && !executable->isES6Function())
>             || (propertyName == exec->propertyNames().prototype && !executable->isArrowFunction())
>-            || propertyName == exec->propertyNames().caller)
>+            || (propertyName == exec->propertyNames().caller && !executable->isES6Function()))
>             return false;
> 
>         thisObject->reifyLazyPropertyIfNeeded(exec, propertyName);
>@@ -496,7 +520,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()->isArrowFunction()) {
>             PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>             if (!Base::getOwnPropertySlot(thisObject, exec, propertyName, slot))
>                 thisObject->putDirectAccessor(exec, propertyName, getThrowTypeErrorGetterSetter(thisObject), DontDelete | DontEnum | Accessor);
>@@ -504,7 +532,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()->isArrowFunction()) {
>             PropertySlot slot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
>             if (!Base::getOwnPropertySlot(thisObject, exec, propertyName, slot))
>                 thisObject->putDirectAccessor(exec, propertyName, getThrowTypeErrorGetterSetter(thisObject), DontDelete | DontEnum | Accessor);
>diff --git a/Source/JavaScriptCore/runtime/JSFunction.h b/Source/JavaScriptCore/runtime/JSFunction.h
>index 30070d0d61d7e2b6ad8badcbfd1971ac7757b248..718f57500c01bbeceb6c0111996de38d866e643c 100644
>--- a/Source/JavaScriptCore/runtime/JSFunction.h
>+++ b/Source/JavaScriptCore/runtime/JSFunction.h
>@@ -202,6 +202,8 @@ private:
>     static EncodedJSValue callerGetter(ExecState*, EncodedJSValue, PropertyName);
>     static EncodedJSValue lengthGetter(ExecState*, EncodedJSValue, PropertyName);
>     static EncodedJSValue nameGetter(ExecState*, EncodedJSValue, PropertyName);
>+    
>+    static bool getOwnPropertySlotOfArgumentsOrCaller(JSFunction*, ExecState*, PropertyName, PropertySlot&, PropertySlot::GetValueFunc);
> 
>     WriteBarrier<ExecutableBase> m_executable;
>     WriteBarrier<FunctionRareData> m_rareData;
>diff --git a/Source/JavaScriptCore/runtime/JSObject.cpp b/Source/JavaScriptCore/runtime/JSObject.cpp
>index 5a4e41372a3c692919c8742224f3f4e0f4514979..b452863adda8ddf1c76b1b8ca049775f7da400fe 100644
>--- a/Source/JavaScriptCore/runtime/JSObject.cpp
>+++ b/Source/JavaScriptCore/runtime/JSObject.cpp
>@@ -2825,6 +2825,12 @@ static JSBoundSlotBaseFunction* getBoundSlotBaseFunctionForGetterSetter(ExecStat
> 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 15403cdc7da738235f70142295b416d8944b7bed..501bb40ea3c0899808224045ddd3f997222b18e5 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_isTaintedByProxy(false)
>+        , m_isClassMethod(false)
>     {
>     }
> 
>@@ -110,6 +111,8 @@ public:
>     bool isCacheableCustom() const { return isCacheable() && isCustom(); }
>     void setIsTaintedByProxy() { m_isTaintedByProxy = true; }
>     bool isTaintedByProxy() const { return m_isTaintedByProxy; }
>+    void setIsClassMethod() { m_isClassMethod = true;  }
>+    bool isClassMethod() const { return m_isClassMethod;}
> 
>     InternalMethodType internalMethodType() const { return m_internalMethodType; }
> 
>@@ -287,6 +290,7 @@ private:
>     PropertyType m_propertyType;
>     InternalMethodType m_internalMethodType;
>     bool m_isTaintedByProxy;
>+    bool m_isClassMethod;
> };
> 
> ALWAYS_INLINE JSValue PropertySlot::getValue(ExecState* exec, PropertyName propertyName) const
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index c2605c9377d832638c2d6c30a9c48d08bf5100a9..f12a87483aeec8f78b25f6de15fa814631930faf 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,40 @@
>+2016-05-18  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/class-method-and-constructor-properties-expected.txt: Removed.
>+        * js/class-syntax-method-names-expected.txt:
>+        * js/es6-function-properties-expected.txt: Added.
>+        * js/es6-function-properties.html: Renamed from LayoutTests/js/class-method-and-constructor-properties.html.
>+        * js/script-tests/class-method-and-constructor-properties.js: Removed.
>+        * 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/keyword-method-names.js:
>+        (ClassWithKeywordStaticMethodNames.arguments):
>+
> 2016-05-16  Saam barati  <sbarati@apple.com>
> 
>         ShadowChicken crashes when reading a scope from the frame during a stack overflow exception
>diff --git a/LayoutTests/js/class-method-and-constructor-properties-expected.txt b/LayoutTests/js/class-method-and-constructor-properties-expected.txt
>deleted file mode 100644
>index 1243f787eb57306e4b89e2bfc4e8172a03f34efa..0000000000000000000000000000000000000000
>--- a/LayoutTests/js/class-method-and-constructor-properties-expected.txt
>+++ /dev/null
>@@ -1,31 +0,0 @@
>-Tests for ES6 class method and constructor properties
>-
>-On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>-
>-
>-PASS (new A()).constructor.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new A()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new B()).constructor.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new B()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new C()).constructor.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new C()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new D()).constructor.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new D()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new E()).getItem.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new E()).getItem.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new F()).getItem.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new F()).getItem.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new F()).getElement.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new F()).getElement.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new G()).item.caller:::undefined
>-PASS (new G()).item.arguments:::undefined
>-PASS H.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS H.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new H()).caller():::"value"
>-PASS (new H()).arguments():::"value"
>-PASS (new H()).caller.caller:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS (new H()).caller.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>-PASS successfullyParsed:::true
>-
>-TEST COMPLETE
>-
>diff --git a/LayoutTests/js/class-method-and-constructor-properties.html b/LayoutTests/js/class-method-and-constructor-properties.html
>deleted file mode 100644
>index 78d469f8e657b7c287573831c297f9c88c07bb02..0000000000000000000000000000000000000000
>--- a/LayoutTests/js/class-method-and-constructor-properties.html
>+++ /dev/null
>@@ -1,8 +0,0 @@
>-<!DOCTYPE html>
>-<html>
>-<body>
>-<script src="../resources/js-test-pre.js"></script>
>-<script src="script-tests/class-method-and-constructor-properties.js"></script>
>-<script src="../resources/js-test-post.js"></script>
>-</body>
>-</html>
>diff --git a/LayoutTests/js/class-syntax-method-names-expected.txt b/LayoutTests/js/class-syntax-method-names-expected.txt
>index d86aa41816be7af73b155b7a47af3ae55b11c6e9..59acf091f70f24a97c1b57e885c6ccc2bb69e0ff 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: 'caller' and 'arguments' cannot be accessed in class context..
>+PASS class X {static arguments() {return staticMethodValue;}}; X.caller = function(){} threw exception TypeError: 'caller' and 'arguments' cannot be accessed in class context..
>+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..79ca638e3b3e0a777e82e174752bdac4b3f959ed
>--- /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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS a.constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new A()).constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS b.constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new B()).constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS c.constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new C()).constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS d.constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new D()).constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS e.constructor["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new E()).getItem["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getItem["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS f.getElement["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getItem["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new F()).getElement["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS arr["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{}).arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{})["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{})["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{}).caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{}).arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{})["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (()=>{})["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS H["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS h.caller["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new H()).caller["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.gen["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS J.get["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.gen["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS j.get["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).gen["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get.arguments:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get["caller"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get["arguments"]:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get.caller = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get.arguments = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get["caller"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+PASS (new J).get["arguments"] = function () {}:::TypeError: 'caller' and 'arguments' cannot be accessed in class context.
>+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..2d5c02430cf6f4f273503c16728cff68b58bdc3f
>--- /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>
>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 cb84986b4149c6bc326645b211b64d72faf7b8bf..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: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new A()).constructor.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new B()).constructor.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new B()).constructor.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new C()).constructor.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new C()).constructor.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new D()).constructor.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new D()).constructor.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new E()).getItem.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new E()).getItem.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new F()).getItem.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new F()).getItem.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new F()).getElement.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new F()).getElement.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-
>-shouldBe('(new G()).item.caller', 'undefined');
>-shouldBe('(new G()).item.arguments', 'undefined');
>-
>-class H {
>-  caller() { return 'value'; }
>-  arguments() { return 'value'; }
>-}
>-
>-shouldThrow('H.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('H.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-
>-shouldBe('(new H()).caller()', '"value"');
>-shouldBe('(new H()).arguments()', '"value"');
>-
>-shouldThrow('(new H()).caller.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-shouldThrow('(new H()).caller.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>-
>-
>-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..a0378e2a047a4afea307f3edbe2b43cdd647033d 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,33 @@ 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: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+shouldThrow('class X {static arguments() {return staticMethodValue;}}; X.caller = function(){}', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+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..308b54771055c13abb04fcfa68d62874f5e68762
>--- /dev/null
>+++ b/LayoutTests/js/script-tests/es6-function-properties.js
>@@ -0,0 +1,137 @@
>+
>+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'} }
>+
>+var check = function (text) {
>+  shouldThrow(text + '.caller', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '.arguments', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '["caller"]', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '["arguments"]', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '.caller = function () {}', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '.arguments = function () {}', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '["caller"] = function () {}', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+  shouldThrow(text + '["arguments"] = function () {}', '"TypeError: \'caller\' and \'arguments\' cannot be accessed in class context."');
>+
>+  shouldBe(text + '.hasOwnProperty("caller")', 'false');
>+  shouldBe(text + '.hasOwnProperty("arguments")', 'false');
>+  var object = eval(text);
>+
>+  for (var propertyName in object) {
>+    const wrongPropertyInAList = propertyName === 'caller' || propertyName === 'arguments';
>+    if (wrongPropertyInAList)
>+      shouldBe('wrongPropertyInAList', 'false');
>+  }
>+  
>+  //debug('Object.getOwnPropertyDescriptor(' + text + ', "caller")');
>+  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/keyword-method-names.js b/LayoutTests/js/script-tests/keyword-method-names.js
>index c0213cf5af8c4e531ce1ae5b469df320ad004e88..5d94c7be579e6a12a2aa56a23af4c048e8c022a5 100644
>--- a/LayoutTests/js/script-tests/keyword-method-names.js
>+++ b/LayoutTests/js/script-tests/keyword-method-names.js
>@@ -75,8 +75,7 @@ class ClassWithKeywordMethodNames {
> class ClassWithKeywordStaticMethodNames {
>     static constructor() { }
>     static abstract() { }
>-    // FIXME: <https://webkit.org/b/152985> ES6: Classes: Should be allowed to create a static method with name "arguments"
>-    // static arguments() { }
>+    static arguments() { }
>     static boolean() { }
>     static break() { }
>     static byte() { }

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