diff --git a/test/annexB/__proto__/fn-name.js b/test/annexB/__proto__/fn-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..41e0816fb67d456c61130ef77ac1c69e2aac2fe3
--- /dev/null
+++ b/test/annexB/__proto__/fn-name.js
@@ -0,0 +1,27 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: B.3.1
+description: Function name is not assigned based on the property name
+info: >
+    [...]
+    6. If propKey is the String value "__proto__" and if
+       IsComputedPropertyKey(propKey) is false, then
+       a. If Type(propValue) is either Object or Null, then
+          i. Return object.[[SetPrototypeOf]](propValue).
+       b. Return NormalCompletion(empty).
+    7. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue, propKey).
+includes: [propertyHelper.js]
+---*/
+
+var o;
+
+o = {
+  __proto__: function() {}
+};
+
+assert(o.__proto__.name !== '__proto__');
diff --git a/test/built-ins/Function/instance-name.js b/test/built-ins/Function/instance-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..1748b3bc6b2f86e5bd1f43a9c6e01a7849db6276
--- /dev/null
+++ b/test/built-ins/Function/instance-name.js
@@ -0,0 +1,22 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 19.2.1.1
+description: Assignment of function `name` attribute
+info: >
+    [...]
+    3. Return CreateDynamicFunction(C, NewTarget, "normal", args).
+
+    ES6 19.2.1.1.1
+        RuntimeSemantics: CreateDynamicFunction(constructor, newTarget, kind, args)
+
+    [...]
+    29. Perform SetFunctionName(F, "anonymous").
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Function().name, 'anonymous');
+verifyNotEnumerable(Function(), 'name');
+verifyNotWritable(Function(), 'name');
+verifyConfigurable(Function(), 'name');
diff --git a/test/built-ins/Function/prototype/bind/instance-name-chained.js b/test/built-ins/Function/prototype/bind/instance-name-chained.js
new file mode 100644
index 0000000000000000000000000000000000000000..6014848231c09c13191993396e4ac52b4853c984
--- /dev/null
+++ b/test/built-ins/Function/prototype/bind/instance-name-chained.js
@@ -0,0 +1,21 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 19.2.3.2
+description: >
+    Assignment of function `name` attribute (previously-bound function)
+info: >
+    12. Let targetName be Get(Target, "name").
+    13. ReturnIfAbrupt(targetName).
+    14. If Type(targetName) is not String, let targetName be the empty string.
+    15. Perform SetFunctionName(F, targetName, "bound").
+includes: [propertyHelper.js]
+---*/
+
+var target = Object.defineProperty(function() {}, 'name', { value: 'target' });
+
+assert.sameValue(target.bind().bind().name, 'bound bound target');
+verifyNotEnumerable(target.bind().bind(), 'name');
+verifyNotWritable(target.bind().bind(), 'name');
+verifyConfigurable(target.bind().bind(), 'name');
diff --git a/test/built-ins/Function/prototype/bind/instance-name-error.js b/test/built-ins/Function/prototype/bind/instance-name-error.js
new file mode 100644
index 0000000000000000000000000000000000000000..29135ab061567ae49b424dcd4780756b3bc50960
--- /dev/null
+++ b/test/built-ins/Function/prototype/bind/instance-name-error.js
@@ -0,0 +1,20 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 19.2.3.2
+description: Error thrown when accessing target's `name` property
+info: >
+    12. Let targetName be Get(Target, "name").
+    13. ReturnIfAbrupt(targetName).
+---*/
+
+var target = Object.defineProperty(function() {}, 'name', {
+  get: function() {
+    throw new Test262Error();
+  }
+});
+
+assert.throws(Test262Error, function() {
+  target.bind();
+});
diff --git a/test/built-ins/Function/prototype/bind/instance-name-non-string.js b/test/built-ins/Function/prototype/bind/instance-name-non-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6686134cbf78f838ba49803869387df5da1d301
--- /dev/null
+++ b/test/built-ins/Function/prototype/bind/instance-name-non-string.js
@@ -0,0 +1,58 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 19.2.3.2
+description: >
+    Assignment of function `name` attribute (target has non-string name)
+info: >
+    12. Let targetName be Get(Target, "name").
+    13. ReturnIfAbrupt(targetName).
+    14. If Type(targetName) is not String, let targetName be the empty string.
+    15. Perform SetFunctionName(F, targetName, "bound").
+includes: [propertyHelper.js]
+---*/
+
+var target;
+
+target = Object.defineProperty(function() {}, 'name', { value: undefined });
+
+assert.sameValue(target.bind().name, 'bound ');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
+
+target = Object.defineProperty(function() {}, 'name', { value: null });
+
+assert.sameValue(target.bind().name, 'bound ');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
+
+target = Object.defineProperty(function() {}, 'name', { value: true });
+
+assert.sameValue(target.bind().name, 'bound ');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
+
+target = Object.defineProperty(function() {}, 'name', { value: Symbol('s') });
+
+assert.sameValue(target.bind().name, 'bound ');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
+
+target = Object.defineProperty(function() {}, 'name', { value: 23 });
+
+assert.sameValue(target.bind().name, 'bound ');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
+
+target = Object.defineProperty(function() {}, 'name', { value: {} });
+
+assert.sameValue(target.bind().name, 'bound ');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
diff --git a/test/built-ins/Function/prototype/bind/instance-name.js b/test/built-ins/Function/prototype/bind/instance-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..57b20ef2035727fb0728313a002237217b65a023
--- /dev/null
+++ b/test/built-ins/Function/prototype/bind/instance-name.js
@@ -0,0 +1,20 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 19.2.3.2
+description: Assignment of function `name` attribute
+info: >
+    12. Let targetName be Get(Target, "name").
+    13. ReturnIfAbrupt(targetName).
+    14. If Type(targetName) is not String, let targetName be the empty string.
+    15. Perform SetFunctionName(F, targetName, "bound").
+includes: [propertyHelper.js]
+---*/
+
+var target = Object.defineProperty(function() {}, 'name', { value: 'target' });
+
+assert.sameValue(target.bind().name, 'bound target');
+verifyNotEnumerable(target.bind(), 'name');
+verifyNotWritable(target.bind(), 'name');
+verifyConfigurable(target.bind(), 'name');
diff --git a/test/built-ins/Function/prototype/name.js b/test/built-ins/Function/prototype/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ceb0feb75d6769399f9b9a99cd6c4393bffe6a3
--- /dev/null
+++ b/test/built-ins/Function/prototype/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 19.2.3
+description: FunctionPrototype `name` property
+info: >
+    The value of the name property of the Function prototype object is the
+    empty String.
+
+    ES6 Section 17:
+
+    Unless otherwise specified, the name property of a built-in Function
+    object, if it exists, has the attributes { [[Writable]]: false,
+    [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Function.prototype.name, '');
+verifyNotEnumerable(Function.prototype, 'name');
+verifyNotWritable(Function.prototype, 'name');
+verifyConfigurable(Function.prototype, 'name');
diff --git a/test/built-ins/GeneratorFunction/instance-name.js b/test/built-ins/GeneratorFunction/instance-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..5400645ccd930e59732b93184b7782306d3c1b71
--- /dev/null
+++ b/test/built-ins/GeneratorFunction/instance-name.js
@@ -0,0 +1,24 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 25.2.1.1
+description: Assignment of function `name` attribute
+info: >
+    [...]
+    3. Return CreateDynamicFunction(C, NewTarget, "generator", args).
+
+    ES6 19.2.1.1.1
+        RuntimeSemantics: CreateDynamicFunction(constructor, newTarget, kind, args)
+
+    [...]
+    29. Perform SetFunctionName(F, "anonymous").
+includes: [propertyHelper.js]
+---*/
+
+var GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;
+
+assert.sameValue(GeneratorFunction().name, 'anonymous');
+verifyNotEnumerable(GeneratorFunction(), 'name');
+verifyNotWritable(GeneratorFunction(), 'name');
+verifyConfigurable(GeneratorFunction(), 'name');
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-arrow.js b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..d729c2a89552efd20f32fcb020f3e75368b7821b
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-arrow.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (ArrowFunction)
+es6id: 12.14.5.3
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and value is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(v, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(v,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var arrow;
+
+[ arrow = () => {} ] = [];
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-class.js b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..d781dd593cbbb6dd3c3c9c6a85cd07caed1b44fc
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-class.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (ClassExpression)
+es6id: 12.14.5.3
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and value is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(v, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(v,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+var xCls, cls;
+
+[ xCls = class x {} ] = [];;
+[ cls = class {} ] = [];
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-cover.js b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e4b39351666d7d991d79e76f1876a52b37254e3
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-cover.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+es6id: 12.14.5.3
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and value is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(v, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(v,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var xCover, cover;
+
+[ xCover = (0, function() {}) ] = [];
+[ cover = (function() {}) ] = [];
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-fn.js b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..70e29b56ab4a5a4a77cade15634e77f5ef9eee75
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-fn.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (FunctionExpression)
+es6id: 12.14.5.3
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and value is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(v, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(v,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+var xFn, fn;
+
+[ xFn = function x() {} ] = [];;
+[ fn = function() {} ] = [];
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-gen.js b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d17fc64903eeca3af21e7997378bc09ae05f4fa
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/array-elem-init-fn-name-gen.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression)
+es6id: 12.14.5.3
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and value is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(v, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(v,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+var xGen, gen;
+
+[ xGen = function* x() {} ] = [];
+[ gen = function*() {} ] = [];;
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-arrow.js b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..53075d76e6c9a9246b955dea3e3c8fde8dce94ea
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-arrow.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (ArrowFunction)
+es6id: 12.14.5.2
+info: >
+    AssignmentProperty : IdentifierReference Initializeropt
+
+    [...]
+    6. If Initializeropt is present and v is undefined, then
+       [...]
+       d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+          i. Let hasNameProperty be HasOwnProperty(v, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(v, P).
+includes: [propertyHelper.js]
+---*/
+
+var arrow;
+
+({ arrow = () => {} } = {});
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-class.js b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..3c20598cb5b6b69430b79c20d8ca3420c5e5354c
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-class.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (ClassExpression)
+es6id: 12.14.5.2
+info: >
+    AssignmentProperty : IdentifierReference Initializeropt
+
+    [...]
+    6. If Initializeropt is present and v is undefined, then
+       [...]
+       d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+          i. Let hasNameProperty be HasOwnProperty(v, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(v, P).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+var xCls, cls;
+
+({ xCls = class x {} } = {});
+({ cls = class {} } = {});
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-cover.js b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..c220f3740825c98a8ed3d260d98fc0301a599ba1
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-cover.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+es6id: 12.14.5.2
+info: >
+    AssignmentProperty : IdentifierReference Initializeropt
+
+    [...]
+    6. If Initializeropt is present and v is undefined, then
+       [...]
+       d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+          i. Let hasNameProperty be HasOwnProperty(v, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(v, P).
+includes: [propertyHelper.js]
+---*/
+
+var xCover, cover;
+
+({ xCover = (0, function() {}) } = {});
+({ cover = (function() {}) } = {});
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-fn.js b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..269960e3bbfc200c6b8a93acfc1ccd7650aec1c0
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-fn.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (FunctionExpression)
+es6id: 12.14.5.2
+info: >
+    AssignmentProperty : IdentifierReference Initializeropt
+
+    [...]
+    6. If Initializeropt is present and v is undefined, then
+       [...]
+       d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+          i. Let hasNameProperty be HasOwnProperty(v, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(v, P).
+includes: [propertyHelper.js]
+---*/
+
+var xFn, fn;
+
+({ xFn = function x() {} } = {});
+({ fn = function() {} } = {});
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-gen.js b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..9ae0f31a76467917a4c79b1879618f0976d65f4d
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-id-init-fn-name-gen.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression)
+es6id: 12.14.5.2
+info: >
+    AssignmentProperty : IdentifierReference Initializeropt
+
+    [...]
+    6. If Initializeropt is present and v is undefined, then
+       [...]
+       d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+          i. Let hasNameProperty be HasOwnProperty(v, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(v, P).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+var xGen, gen;
+
+({ xGen = function* x() {} } = {});
+({ gen = function*() {} } = {});
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-arrow.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..a089de2b73c70282a6b2eecbe60f19dfda8f2cb5
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-arrow.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (ArrowFunction)
+es6id: 12.14.5.4
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and v is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var arrow;
+
+({ x: arrow = () => {} } = {});
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-class.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..43b0ddafb74fe79a7be5a01040de6f092b60176f
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-class.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (ClassExpression)
+es6id: 12.14.5.4
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and v is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+var xCls, cls;
+
+({ x: xCls = class x {} } = {});
+({ x: cls = class {} } = {});
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-cover.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e4f473426eeae541918b4575edfd15a15666b7c
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-cover.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+es6id: 12.14.5.4
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and v is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var xCover, cover;
+
+({ x: xCover = (0, function() {}) } = {});
+({ x: cover = (function() {}) } = {});
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-fn.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..79111de8caad845dfb22609cfe7b1a747abe59d4
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-fn.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (FunctionExpression)
+es6id: 12.14.5.4
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and v is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var xFn, fn;
+
+({ x: xFn = function x() {} } = {});
+({ x: fn = function() {} } = {});
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-gen.js b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..c65a81683c8014e224fe538f13327b72ab0dfea3
--- /dev/null
+++ b/test/language/expressions/assignment/destructuring/obj-prop-elem-init-fn-name-gen.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression)
+es6id: 12.14.5.4
+info: >
+    AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+
+    [...]
+    7. If Initializer is present and v is undefined and
+       IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+       DestructuringAssignmentTarget are both true, then
+       a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+          GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+var xGen, gen;
+
+({ x: xGen = function* x() {} } = {});
+({ x: gen = function*() {} } = {});
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');
diff --git a/test/language/expressions/assignment/fn-name-arrow.js b/test/language/expressions/assignment/fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..31e3f9fc738c66811f0bb20b133e47250ef8ae1f
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-arrow.js
@@ -0,0 +1,31 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: Assignment of function `name` attribute (ArrowFunction)
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var arrow;
+
+arrow = () => {};
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/expressions/assignment/fn-name-class.js b/test/language/expressions/assignment/fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..5295daf260f4294ffe49b66055825089a15983af
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-class.js
@@ -0,0 +1,35 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: Assignment of function `name` attribute (ClassExpression)
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+var xCls, cls;
+
+xCls = class x {};
+cls = class {};
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/expressions/assignment/fn-name-cover.js b/test/language/expressions/assignment/fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c71bbe2e70a2a89a4a4c28627f96b5d9e2732c2
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-cover.js
@@ -0,0 +1,35 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var xCover, cover;
+
+xCover = (0, function() {});
+cover = (function() {});
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/expressions/assignment/fn-name-fn.js b/test/language/expressions/assignment/fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..10b81cda4fd10000851b498c9bc035e0dfabf829
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-fn.js
@@ -0,0 +1,34 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: Assignment of function `name` attribute (FunctionExpression)
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+includes: [propertyHelper.js]
+---*/
+
+var xFn, fn;
+
+xFn = function x() {};
+fn = function() {};
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/expressions/assignment/fn-name-gen.js b/test/language/expressions/assignment/fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..e549f07e71a22fa1d211364ca04edde87e514e75
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-gen.js
@@ -0,0 +1,35 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: Assignment of function `name` attribute (GeneratorExpression)
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+var xGen, gen;
+
+xGen = function* x() {};
+gen = function*() {};
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');
diff --git a/test/language/expressions/assignment/fn-name-lhs-cover.js b/test/language/expressions/assignment/fn-name-lhs-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..08db5d36840a390129b8a129e99f831987298b77
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-lhs-cover.js
@@ -0,0 +1,27 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: Left-hand side as a CoverParenthesizedExpression
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+---*/
+
+var fn;
+
+(fn) = function() {};
+
+assert.sameValue(Object.hasOwnProperty.call(fn, 'name'), false);
diff --git a/test/language/expressions/assignment/fn-name-lhs-member.js b/test/language/expressions/assignment/fn-name-lhs-member.js
new file mode 100644
index 0000000000000000000000000000000000000000..c76fbd932038715d5a47209e8568319ae737ba92
--- /dev/null
+++ b/test/language/expressions/assignment/fn-name-lhs-member.js
@@ -0,0 +1,27 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.14.4
+description: Left-hand side as a MemberExpression
+info: >
+    AssignmentExpression[In, Yield] :
+        LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
+
+    1. If LeftHandSideExpression is neither an ObjectLiteral nor an
+       ArrayLiteral, then
+       [...]
+       e. If IsAnonymousFunctionDefinition(AssignmentExpression) and
+          IsIdentifierRef of LeftHandSideExpression are both true, then
+
+          i. Let hasNameProperty be HasOwnProperty(rval, "name").
+          ii. ReturnIfAbrupt(hasNameProperty).
+          iii. If hasNameProperty is false, perform SetFunctionName(rval,
+               GetReferencedName(lref)).
+---*/
+
+var o = {};
+
+o.attr = function() {};
+
+assert.sameValue(Object.hasOwnProperty.call(o.attr, 'name'), false);
diff --git a/test/language/expressions/class/name.js b/test/language/expressions/class/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..70a1995301fad8741e34a8dd1c908474db689da7
--- /dev/null
+++ b/test/language/expressions/class/name.js
@@ -0,0 +1,32 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.5.16
+description: Assignment of function `name` attribute
+info: >
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+    5. If className is not undefined, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, then
+          i. Perform SetFunctionName(value, className).
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Object.hasOwnProperty.call(class {}, 'name'), false);
+
+assert.sameValue(class cls {}.name, 'cls');
+verifyNotEnumerable(class cls {}, 'name');
+verifyNotWritable(class cls {}, 'name');
+verifyConfigurable(class cls {}, 'name');
+
+assert.sameValue(
+  Object.hasOwnProperty.call(class { constructor() {} }, 'name'), false
+);
+
+assert.sameValue(class cls { constructor() {} }.name, 'cls');
+verifyNotEnumerable(class cls { constructor() {} }, 'name');
+verifyNotWritable(class cls { constructor() {} }, 'name');
+verifyConfigurable(class cls { constructor() {} }, 'name');
diff --git a/test/language/expressions/function/name.js b/test/language/expressions/function/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..543cc28d6eb215e4396344c119732060d2df53cf
--- /dev/null
+++ b/test/language/expressions/function/name.js
@@ -0,0 +1,33 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.1.20
+description: Assignment of function `name` attribute
+info: >
+    FunctionExpression : function ( FormalParameters ) { FunctionBody }
+
+    1. If the function code for FunctionExpression is strict mode code, let
+       strict be true. Otherwise let strict be false.
+    2. Let scope be the LexicalEnvironment of the running execution context.
+    3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody,
+       scope, strict).
+    4. Perform MakeConstructor(closure).
+    5. Return closure.
+
+    FunctionExpression :
+        function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+    [...]
+    5. Let name be StringValue of BindingIdentifier.
+    [...]
+    9. Perform SetFunctionName(closure, name).
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Object.hasOwnProperty.call(function() {}, 'name'), false);
+
+assert.sameValue(function func() {}.name, 'func');
+verifyNotEnumerable(function func() {}, 'name');
+verifyNotWritable(function func() {}, 'name');
+verifyConfigurable(function func() {}, 'name');
diff --git a/test/language/expressions/generators/name.js b/test/language/expressions/generators/name.js
index b732a6f5dd5d214b5b440dc867e94dcba00b1580..ec43d6342bed3dbdf644de3c434e959498e7a72d 100644
--- a/test/language/expressions/generators/name.js
+++ b/test/language/expressions/generators/name.js
@@ -1,19 +1,31 @@
-// Copyright 2015 Cubane Canada, Inc.  All rights reserved.
-// See LICENSE for details.
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
 
 /*---
+es6id: 14.4.1
+description: Assignment of function `name` attribute
 info: >
-    Generator can be declared with GeneratorExpression syntax
-es6id: 14.4
-author: Sam Mikes
-description: can create generator function expressions (with name)
----*/
+    GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
+
+    1. If the function code for this GeneratorExpression is strict mode code,
+       let strict be true. Otherwise let strict be false.
+    2. Let scope be the LexicalEnvironment of the running execution context.
+    3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters,
+       GeneratorBody, scope, strict).
+    4. Let prototype be ObjectCreate(%GeneratorPrototype%).
+    5. Perform MakeConstructor(closure, true, prototype).
+    6. Return closure.
 
-var f = function *foo(a) { yield a+1; return; };
+    GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 
-assert.sameValue(f.name, 'foo');
+    [...]
+    10. Perform SetFunctionName(closure, name).
+includes: [propertyHelper.js]
+---*/
 
-var g = f(3);
+assert.sameValue(Object.hasOwnProperty.call(function*() {}, 'name'), false);
 
-assert.sameValue(g.next().value, 4);
-assert.sameValue(g.next().done, true);
+assert.sameValue(function* func() {}.name, 'func');
+verifyNotEnumerable(function* func() {}, 'name');
+verifyNotWritable(function* func() {}, 'name');
+verifyConfigurable(function* func() {}, 'name');
diff --git a/test/language/expressions/object/fn-name-accessor-get.js b/test/language/expressions/object/fn-name-accessor-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..10cca6931f29f1fe87f4e120f0af321f695dd7da
--- /dev/null
+++ b/test/language/expressions/object/fn-name-accessor-get.js
@@ -0,0 +1,42 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.3.9
+description: Assignment of function `name` attribute ("get" accessor)
+info: >
+    MethodDefinition : get PropertyName ( ) { FunctionBody }
+
+    [...]
+    8. Perform SetFunctionName(closure, propKey, "get").
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o, getter;
+
+o = {
+  get id() {},
+  get [anonSym]() {},
+  get [namedSym]() {}
+};
+
+getter = Object.getOwnPropertyDescriptor(o, 'id').get;
+assert.sameValue(getter.name, 'get id');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(o, anonSym).get;
+assert.sameValue(getter.name, 'get ');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(o, namedSym).get;
+assert.sameValue(getter.name, 'get [test262]');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
diff --git a/test/language/expressions/object/fn-name-accessor-set.js b/test/language/expressions/object/fn-name-accessor-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ba36462281e451dbf2e22091ab86e2a57273691
--- /dev/null
+++ b/test/language/expressions/object/fn-name-accessor-set.js
@@ -0,0 +1,43 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.3.9
+description: Assignment of function `name` attribute ("set" accessor)
+info: >
+    MethodDefinition :
+        set PropertyName ( PropertySetParameterList ) { FunctionBody }
+
+    [...]
+    7. Perform SetFunctionName(closure, propKey, "set").
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o, setter;
+
+o = {
+  set id(_) {},
+  set [anonSym](_) {},
+  set [namedSym](_) {}
+};
+
+setter = Object.getOwnPropertyDescriptor(o, 'id').set;
+assert.sameValue(setter.name, 'set id');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(o, anonSym).set;
+assert.sameValue(setter.name, 'set ');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(o, namedSym).set;
+assert.sameValue(setter.name, 'set [test262]');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
diff --git a/test/language/expressions/object/fn-name-arrow.js b/test/language/expressions/object/fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..134fdb9586a362c0e8ebbbd01e7c6d5fc0ef6028
--- /dev/null
+++ b/test/language/expressions/object/fn-name-arrow.js
@@ -0,0 +1,40 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: Assignment of function `name` attribute (ArrowFunction)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  id: () => {},
+  [anonSym]: () => {},
+  [namedSym]: () => {}
+};
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/expressions/object/fn-name-class.js b/test/language/expressions/object/fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8ee409b6420f610942e6ae925e40bf1aa526464
--- /dev/null
+++ b/test/language/expressions/object/fn-name-class.js
@@ -0,0 +1,43 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: Assignment of function `name` attribute (ClassExpression)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [class, Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  xId: class x {},
+  id: class {},
+  [anonSym]: class {},
+  [namedSym]: class {}
+};
+
+assert(o.xId.name !== 'xId');
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/expressions/object/fn-name-cover.js b/test/language/expressions/object/fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..e3068f9424ea507527d8f640ef922031e79f248c
--- /dev/null
+++ b/test/language/expressions/object/fn-name-cover.js
@@ -0,0 +1,44 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  xId: (0, function() {}),
+  id: (function() {}),
+  [anonSym]: (function() {}),
+  [namedSym]: (function() {})
+};
+
+assert(o.xId.name !== 'xId');
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/expressions/object/fn-name-fn.js b/test/language/expressions/object/fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..84a5635caa9659d75bcc8b28d49490e4b4f5f033
--- /dev/null
+++ b/test/language/expressions/object/fn-name-fn.js
@@ -0,0 +1,43 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: Assignment of function `name` attribute (FunctionExpression)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  xId: function x() {},
+  id: function() {},
+  [anonSym]: function() {},
+  [namedSym]: function() {}
+};
+
+assert(o.xId.name !== 'xId');
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/expressions/object/fn-name-gen.js b/test/language/expressions/object/fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..d35e730532a6453af55bb3f218c1a68e24570e4a
--- /dev/null
+++ b/test/language/expressions/object/fn-name-gen.js
@@ -0,0 +1,44 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: >
+    Assignment of function `name` attribute (GeneratorExpression)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [generators, Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  xId: function* x() {},
+  id: function*() {},
+  [anonSym]: function*() {},
+  [namedSym]: function*() {}
+};
+
+assert(o.xId.name !== 'xId');
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/expressions/object/method-definition/fn-name-fn.js b/test/language/expressions/object/method-definition/fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f323f50a19445bcc2a684c261f03488a37b5892
--- /dev/null
+++ b/test/language/expressions/object/method-definition/fn-name-fn.js
@@ -0,0 +1,40 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: Assignment of function `name` attribute (MethodDefinition)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  id() {},
+  [anonSym]() {},
+  [namedSym]() {}
+};
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/expressions/object/method-definition/fn-name-gen.js b/test/language/expressions/object/method-definition/fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..448fa6b99be7d6fba248135599eb8373eae3cbce
--- /dev/null
+++ b/test/language/expressions/object/method-definition/fn-name-gen.js
@@ -0,0 +1,41 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.4.13
+description: >
+    Assignment of function `name` attribute (GeneratorMethod)
+info: >
+    GeneratorMethod :
+        * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+    [...]
+    9. Perform SetFunctionName(closure, propKey).
+includes: [propertyHelper.js]
+features: [generators, Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var o;
+
+o = {
+  *id() {},
+  *[anonSym]() {},
+  *[namedSym]() {}
+};
+
+assert.sameValue(o.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(o.id, 'name');
+verifyNotWritable(o.id, 'name');
+verifyConfigurable(o.id, 'name');
+
+assert.sameValue(o[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(o[anonSym], 'name');
+verifyNotWritable(o[anonSym], 'name');
+verifyConfigurable(o[anonSym], 'name');
+
+assert.sameValue(o[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(o[namedSym], 'name');
+verifyNotWritable(o[namedSym], 'name');
+verifyConfigurable(o[namedSym], 'name');
diff --git a/test/language/statements/class/definition/fn-name-accessor-get.js b/test/language/statements/class/definition/fn-name-accessor-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..5dfd13915f8bb7d01cf53cf25562955657268997
--- /dev/null
+++ b/test/language/statements/class/definition/fn-name-accessor-get.js
@@ -0,0 +1,63 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.3.9
+description: Assignment of function `name` attribute ("get" accessor)
+info: >
+    MethodDefinition : get PropertyName ( ) { FunctionBody }
+
+    [...]
+    8. Perform SetFunctionName(closure, propKey, "get").
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var getter;
+
+class A {
+  get id() {}
+  get [anonSym]() {}
+  get [namedSym]() {}
+  static get id() {}
+  static get [anonSym]() {}
+  static get [namedSym]() {}
+}
+
+getter = Object.getOwnPropertyDescriptor(A.prototype, 'id').get;
+assert.sameValue(getter.name, 'get id');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(A.prototype, anonSym).get;
+assert.sameValue(getter.name, 'get ');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(A.prototype, namedSym).get;
+assert.sameValue(getter.name, 'get [test262]');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(A, 'id').get;
+assert.sameValue(getter.name, 'get id');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(A, anonSym).get;
+assert.sameValue(getter.name, 'get ');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
+
+getter = Object.getOwnPropertyDescriptor(A, namedSym).get;
+assert.sameValue(getter.name, 'get [test262]');
+verifyNotEnumerable(getter, 'name');
+verifyNotWritable(getter, 'name');
+verifyConfigurable(getter, 'name');
diff --git a/test/language/statements/class/definition/fn-name-accessor-set.js b/test/language/statements/class/definition/fn-name-accessor-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..f5c329625f2b599bff5e2d15d6bb6dd3edde8bd2
--- /dev/null
+++ b/test/language/statements/class/definition/fn-name-accessor-set.js
@@ -0,0 +1,64 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.3.9
+description: Assignment of function `name` attribute ("set" accessor)
+info: >
+    MethodDefinition :
+        set PropertyName ( PropertySetParameterList ) { FunctionBody }
+
+    [...]
+    7. Perform SetFunctionName(closure, propKey, "set").
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+var setter;
+
+class A {
+  set id(_) {}
+  set [anonSym](_) {}
+  set [namedSym](_) {}
+  static set id(_) {}
+  static set [anonSym](_) {}
+  static set [namedSym](_) {}
+}
+
+setter = Object.getOwnPropertyDescriptor(A.prototype, 'id').set;
+assert.sameValue(setter.name, 'set id');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(A.prototype, anonSym).set;
+assert.sameValue(setter.name, 'set ');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(A.prototype, namedSym).set;
+assert.sameValue(setter.name, 'set [test262]');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(A, 'id').set;
+assert.sameValue(setter.name, 'set id');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(A, anonSym).set;
+assert.sameValue(setter.name, 'set ');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
+
+setter = Object.getOwnPropertyDescriptor(A, namedSym).set;
+assert.sameValue(setter.name, 'set [test262]');
+verifyNotEnumerable(setter, 'name');
+verifyNotWritable(setter, 'name');
+verifyConfigurable(setter, 'name');
diff --git a/test/language/statements/class/definition/fn-name-gen-method.js b/test/language/statements/class/definition/fn-name-gen-method.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed09ddf3e66f01170ab7b5e44b897db72a8d23a8
--- /dev/null
+++ b/test/language/statements/class/definition/fn-name-gen-method.js
@@ -0,0 +1,58 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.4.13
+description: >
+    Assignment of function `name` attribute (GeneratorMethod)
+info: >
+    GeneratorMethod :
+        * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+    [...]
+    9. Perform SetFunctionName(closure, propKey).
+includes: [propertyHelper.js]
+features: [generators, Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+
+class A {
+  *id() {}
+  *[anonSym]() {}
+  *[namedSym]() {}
+  static *id() {}
+  static *[anonSym]() {}
+  static *[namedSym]() {}
+}
+
+assert.sameValue(A.prototype.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(A.prototype.id, 'name');
+verifyNotWritable(A.prototype.id, 'name');
+verifyConfigurable(A.prototype.id, 'name');
+
+assert.sameValue(A.prototype[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(A.prototype[anonSym], 'name');
+verifyNotWritable(A.prototype[anonSym], 'name');
+verifyConfigurable(A.prototype[anonSym], 'name');
+
+assert.sameValue(A.prototype[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(A.prototype[namedSym], 'name');
+verifyNotWritable(A.prototype[namedSym], 'name');
+verifyConfigurable(A.prototype[namedSym], 'name');
+
+assert.sameValue(A.id.name, 'id', 'static via IdentifierName');
+verifyNotEnumerable(A.id, 'name');
+verifyNotWritable(A.id, 'name');
+verifyConfigurable(A.id, 'name');
+
+assert.sameValue(A[anonSym].name, '', 'static via anonymous Symbol');
+verifyNotEnumerable(A[anonSym], 'name');
+verifyNotWritable(A[anonSym], 'name');
+verifyConfigurable(A[anonSym], 'name');
+
+assert.sameValue(A[namedSym].name, '[test262]', 'static via Symbol');
+verifyNotEnumerable(A[namedSym], 'name');
+verifyNotWritable(A[namedSym], 'name');
+verifyConfigurable(A[namedSym], 'name');
diff --git a/test/language/statements/class/definition/fn-name-method.js b/test/language/statements/class/definition/fn-name-method.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6842abc22757d5b875e4e582842a8ea5c17bdb2
--- /dev/null
+++ b/test/language/statements/class/definition/fn-name-method.js
@@ -0,0 +1,57 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 12.2.6.9
+description: Assignment of function `name` attribute (MethodDefinition)
+info: >
+    6. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+       a. Let hasNameProperty be HasOwnProperty(propValue, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(propValue,
+          propKey).
+includes: [propertyHelper.js]
+features: [Symbol]
+---*/
+
+var namedSym = Symbol('test262');
+var anonSym = Symbol();
+
+class A {
+  id() {}
+  [anonSym]() {}
+  [namedSym]() {}
+  static id() {}
+  static [anonSym]() {}
+  static [namedSym]() {}
+}
+
+assert.sameValue(A.prototype.id.name, 'id', 'via IdentifierName');
+verifyNotEnumerable(A.prototype.id, 'name');
+verifyNotWritable(A.prototype.id, 'name');
+verifyConfigurable(A.prototype.id, 'name');
+
+assert.sameValue(A.prototype[anonSym].name, '', 'via anonymous Symbol');
+verifyNotEnumerable(A.prototype[anonSym], 'name');
+verifyNotWritable(A.prototype[anonSym], 'name');
+verifyConfigurable(A.prototype[anonSym], 'name');
+
+assert.sameValue(A.prototype[namedSym].name, '[test262]', 'via Symbol');
+verifyNotEnumerable(A.prototype[namedSym], 'name');
+verifyNotWritable(A.prototype[namedSym], 'name');
+verifyConfigurable(A.prototype[namedSym], 'name');
+
+assert.sameValue(A.id.name, 'id', 'static via IdentifierName');
+verifyNotEnumerable(A.id, 'name');
+verifyNotWritable(A.id, 'name');
+verifyConfigurable(A.id, 'name');
+
+assert.sameValue(A[anonSym].name, '', 'static via anonymous Symbol');
+verifyNotEnumerable(A[anonSym], 'name');
+verifyNotWritable(A[anonSym], 'name');
+verifyConfigurable(A[anonSym], 'name');
+
+assert.sameValue(A[namedSym].name, '[test262]', 'static via Symbol');
+verifyNotEnumerable(A[namedSym], 'name');
+verifyNotWritable(A[namedSym], 'name');
+verifyConfigurable(A[namedSym], 'name');
diff --git a/test/language/statements/class/definition/fn-name-static-precedence.js b/test/language/statements/class/definition/fn-name-static-precedence.js
new file mode 100644
index 0000000000000000000000000000000000000000..7afcda8870697235e3c105887b64ea669e7d9270
--- /dev/null
+++ b/test/language/statements/class/definition/fn-name-static-precedence.js
@@ -0,0 +1,63 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.5.15
+description: >
+    Function `name` attribute not inferred in presence of static `name` method
+info: >
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+    [...]
+    4. Let hasNameProperty be HasOwnProperty(value, "name").
+    5. ReturnIfAbrupt(hasNameProperty).
+    6. If hasNameProperty is false, then perform SetFunctionName(value,
+       className).
+includes: [propertyHelper.js]
+---*/
+
+class A {
+  static name() {
+    $ERROR('Static method should not be executed during definition');
+  }
+}
+
+assert.sameValue(typeof A.name, 'function');
+
+var attr = 'name';
+class B {
+  static [attr]() {
+    $ERROR(
+      'Static method defined via computed property should not be executed ' +
+      'during definition'
+    );
+  }
+}
+
+assert.sameValue(typeof B.name, 'function');
+
+class C {
+  static get name() {
+    $ERROR('Static `get` accessor should not be executed during definition');
+  }
+}
+
+assert.throws(Test262Error, function() {
+  C.name;
+});
+
+class D {
+  static set name(_) {
+    $ERROR('Static `set` accessor should not be executed during definition');
+  }
+}
+
+assert.sameValue(D.name, undefined);
+
+class E {
+  static *name() {
+    $ERROR('Static GeneratorMethod should not be executed during definition');
+  }
+}
+
+assert.sameValue(typeof E.name, 'function');
diff --git a/test/language/statements/class/name.js b/test/language/statements/class/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..b74ede216141cbf48e7c45fac59fa2da31ddd363
--- /dev/null
+++ b/test/language/statements/class/name.js
@@ -0,0 +1,21 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.5.15
+description: Assignment of function `name` attribute
+info: >
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+    [...]
+    6. If hasNameProperty is false, then perform SetFunctionName(value,
+       className).
+includes: [propertyHelper.js]
+---*/
+
+class Test262 {}
+
+assert.sameValue(Test262.name, 'Test262');
+verifyNotEnumerable(Test262, 'name');
+verifyNotWritable(Test262, 'name');
+verifyConfigurable(Test262, 'name');
diff --git a/test/language/statements/const/fn-name-arrow.js b/test/language/statements/const/fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..d68cbc4bc578aa838f334bbb404df692d9bd0dd5
--- /dev/null
+++ b/test/language/statements/const/fn-name-arrow.js
@@ -0,0 +1,24 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (ArrowFunction)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+const arrow = () => {};
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/statements/const/fn-name-class.js b/test/language/statements/const/fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..f48a7aa2de89b7e0c2753ede824b71dac6217a90
--- /dev/null
+++ b/test/language/statements/const/fn-name-class.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (ClassExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+const xCls = class x {};
+const cls = class {};
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/statements/const/fn-name-cover.js b/test/language/statements/const/fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..822b543daf2acc8a0df9e4df07d8f2b9900d3b8c
--- /dev/null
+++ b/test/language/statements/const/fn-name-cover.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+const xCover = (0, function() {});
+const cover = (function() {});
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/statements/const/fn-name-fn.js b/test/language/statements/const/fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..03f9ce73ec91b3ff70d54584aa9871453ca13f92
--- /dev/null
+++ b/test/language/statements/const/fn-name-fn.js
@@ -0,0 +1,27 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (FunctionExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+const xFn = function x() {};
+const fn = function() {};
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/statements/const/fn-name-gen.js b/test/language/statements/const/fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..227615cd3942b5773208909ba6d7d0dafefdf221
--- /dev/null
+++ b/test/language/statements/const/fn-name-gen.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (GeneratorExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+const xGen = function* x() {};
+const gen = function*() {};
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');
diff --git a/test/language/statements/function/name.js b/test/language/statements/function/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..b9a81426711483b0c851eb1266dba4cbe9b93d41
--- /dev/null
+++ b/test/language/statements/function/name.js
@@ -0,0 +1,24 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 14.1.19
+description: Assignment of function `name` attribute
+info: >
+    FunctionDeclaration :
+        function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+    1. Let name be StringValue of BindingIdentifier.
+    2. Let F be FunctionCreate(Normal, FormalParameters, FunctionBody, scope, strict).
+    3. Perform MakeConstructor(F).
+    4. Perform SetFunctionName(F, name).
+    5. Return F.
+includes: [propertyHelper.js]
+---*/
+
+function func() {}
+
+assert.sameValue(func.name, 'func');
+verifyNotEnumerable(func, 'name');
+verifyNotWritable(func, 'name');
+verifyConfigurable(func, 'name');
diff --git a/test/language/statements/generators/name-property-descriptor.js b/test/language/statements/generators/name-property-descriptor.js
deleted file mode 100644
index f3e8007c8f3a114375f669f3ea9b751b44281287..0000000000000000000000000000000000000000
--- a/test/language/statements/generators/name-property-descriptor.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (C) 2013 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
-description: >
-    Generator functions should define a `name` property.
-includes: [propertyHelper.js]
-es6id: 25.2.4
----*/
-
-function* g() {}
-
-assert.sameValue(g.name, 'g');
-verifyNotEnumerable(g, 'name');
-verifyNotWritable(g, 'name');
-verifyConfigurable(g, 'name');
diff --git a/test/language/expressions/generators/name-property-descriptor.js b/test/language/statements/generators/name.js
similarity index 55%
rename from test/language/expressions/generators/name-property-descriptor.js
rename to test/language/statements/generators/name.js
index 02828c7b639c2553b645e20b93960a8fa2e63557..c6b931652f7fd3b67a011a2e53a35cf8b9184e5c 100644
--- a/test/language/expressions/generators/name-property-descriptor.js
+++ b/test/language/statements/generators/name.js
@@ -2,13 +2,18 @@
 // This code is governed by the BSD license found in the LICENSE file.
 
 /*---
-description: >
-    Generator functions should define a `name` property.
+description: Assignment of function `name` attribute
+es6id: 14.4.12
+info: >
+    GeneratorDeclaration :
+        function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
+
+    [...]
+    6. Perform SetFunctionName(F, name).
 includes: [propertyHelper.js]
-es6id: 25.2.4
 ---*/
 
-var g = function*() {};
+function* g() {}
 
 assert.sameValue(g.name, 'g');
 verifyNotEnumerable(g, 'name');
diff --git a/test/language/statements/let/fn-name-arrow.js b/test/language/statements/let/fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a82ece3f29fc5342269e6f9610cd4d5e1ec4878
--- /dev/null
+++ b/test/language/statements/let/fn-name-arrow.js
@@ -0,0 +1,24 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (ArrowFunction)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+let arrow = () => {};
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/statements/let/fn-name-class.js b/test/language/statements/let/fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..85be2ac4292c3557b9e902b67a2da529b1794d4f
--- /dev/null
+++ b/test/language/statements/let/fn-name-class.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (ClassExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+let xCls = class x {};
+let cls = class {};
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/statements/let/fn-name-cover.js b/test/language/statements/let/fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..49de023520d41bb640e06e0c85bbdec0451dcccd
--- /dev/null
+++ b/test/language/statements/let/fn-name-cover.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+let xCover = (0, function() {});
+let cover = (function() {});
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/statements/let/fn-name-fn.js b/test/language/statements/let/fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..749a9519f29b5f8af680e742176aaa54a6379ef0
--- /dev/null
+++ b/test/language/statements/let/fn-name-fn.js
@@ -0,0 +1,27 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (FunctionExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+let xFn = function x() {};
+let fn = function() {};
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/statements/let/fn-name-gen.js b/test/language/statements/let/fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..857e19943ce1986fc3b39be0b4a03d49d640b028
--- /dev/null
+++ b/test/language/statements/let/fn-name-gen.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.1.4
+description: Assignment of function `name` attribute (GeneratorExpression)
+info: >
+    LexicalBinding : BindingIdentifier Initializer
+
+    [...]
+    6. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+let xGen = function* x() {};
+let gen = function*() {};
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');
diff --git a/test/language/statements/variable/fn-name-arrow.js b/test/language/statements/variable/fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..885c848c04a65c4cd148c5d00105335ee98a0022
--- /dev/null
+++ b/test/language/statements/variable/fn-name-arrow.js
@@ -0,0 +1,24 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.2.4
+description: Assignment of function `name` attribute (ArrowFunction)
+info: >
+    VariableDeclaration : BindingIdentifier Initializer
+
+    [...]
+    7. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+var arrow = () => {};
+
+assert.sameValue(arrow.name, 'arrow');
+verifyNotEnumerable(arrow, 'name');
+verifyNotWritable(arrow, 'name');
+verifyConfigurable(arrow, 'name');
diff --git a/test/language/statements/variable/fn-name-class.js b/test/language/statements/variable/fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d095fc922f3eed3e71987b4fd7c64ffc5a89881
--- /dev/null
+++ b/test/language/statements/variable/fn-name-class.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.2.4
+description: Assignment of function `name` attribute (ClassExpression)
+info: >
+    VariableDeclaration : BindingIdentifier Initializer
+
+    [...]
+    7. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+features: [class]
+---*/
+
+var xCls = class x {};
+var cls = class {};
+
+assert(xCls.name !== 'xCls');
+
+assert.sameValue(cls.name, 'cls');
+verifyNotEnumerable(cls, 'name');
+verifyNotWritable(cls, 'name');
+verifyConfigurable(cls, 'name');
diff --git a/test/language/statements/variable/fn-name-cover.js b/test/language/statements/variable/fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..875726ed7e550774d1106d3eff2ada9123899c04
--- /dev/null
+++ b/test/language/statements/variable/fn-name-cover.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.2.4
+description: >
+    Assignment of function `name` attribute (CoverParenthesizedExpression)
+info: >
+    VariableDeclaration : BindingIdentifier Initializer
+
+    [...]
+    7. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+var xCover = (0, function() {});
+var cover = (function() {});
+
+assert(xCover.name !== 'xCover');
+
+assert.sameValue(cover.name, 'cover');
+verifyNotEnumerable(cover, 'name');
+verifyNotWritable(cover, 'name');
+verifyConfigurable(cover, 'name');
diff --git a/test/language/statements/variable/fn-name-fn.js b/test/language/statements/variable/fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f0211573753af8241a13feeae0db93c112efa31
--- /dev/null
+++ b/test/language/statements/variable/fn-name-fn.js
@@ -0,0 +1,27 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.2.4
+description: Assignment of function `name` attribute (FunctionExpression)
+info: >
+    VariableDeclaration : BindingIdentifier Initializer
+
+    [...]
+    7. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+---*/
+
+var xFn = function x() {};
+var fn = function() {};
+
+assert(xFn.name !== 'xFn');
+
+assert.sameValue(fn.name, 'fn');
+verifyNotEnumerable(fn, 'name');
+verifyNotWritable(fn, 'name');
+verifyConfigurable(fn, 'name');
diff --git a/test/language/statements/variable/fn-name-gen.js b/test/language/statements/variable/fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..73dee4795b3e283158ab4a1348d06588ee46d68c
--- /dev/null
+++ b/test/language/statements/variable/fn-name-gen.js
@@ -0,0 +1,28 @@
+// Copyright (C) Copyright 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+es6id: 13.3.2.4
+description: Assignment of function `name` attribute (GeneratorExpression)
+info: >
+    VariableDeclaration : BindingIdentifier Initializer
+
+    [...]
+    7. If IsAnonymousFunctionDefinition(Initializer) is true, then
+       a. Let hasNameProperty be HasOwnProperty(value, "name").
+       b. ReturnIfAbrupt(hasNameProperty).
+       c. If hasNameProperty is false, perform SetFunctionName(value,
+          bindingId).
+includes: [propertyHelper.js]
+features: [generators]
+---*/
+
+var xGen = function* x() {};
+var gen = function*() {};
+
+assert(xGen.name !== 'xGen');
+
+assert.sameValue(gen.name, 'gen');
+verifyNotEnumerable(gen, 'name');
+verifyNotWritable(gen, 'name');
+verifyConfigurable(gen, 'name');