OLD | NEW |
| (Empty) |
1 // Copyright 2015 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 // | |
5 // Flags: --harmony-function-name | |
6 | |
7 (function testVariableDeclarationsFunction() { | |
8 'use strict'; | |
9 var a = function(){}; | |
10 assertEquals('a', a.name); | |
11 let b = () => {}; | |
12 assertEquals('b', b.name); | |
13 const c = ((function(){})); | |
14 assertEquals('c', c.name); | |
15 | |
16 var x = function(){}, y = () => {}, z = function withName() {}; | |
17 assertEquals('x', x.name); | |
18 assertEquals('y', y.name); | |
19 assertEquals('withName', z.name); | |
20 })(); | |
21 | |
22 (function testVariableDeclarationsClass() { | |
23 'use strict'; | |
24 var a = class {}; | |
25 assertEquals('a', a.name); | |
26 let b = ((class {})); | |
27 assertEquals('b', b.name); | |
28 // Should not overwrite name property. | |
29 const c = class { static name() { } } | |
30 assertEquals('function', typeof c.name); | |
31 | |
32 var x = class {}, y = class NamedClass {}; | |
33 assertEquals('x', x.name); | |
34 assertEquals('NamedClass', y.name); | |
35 })(); | |
36 | |
37 (function testObjectProperties() { | |
38 'use strict'; | |
39 var obj = { | |
40 a: function() {}, | |
41 b: () => {}, | |
42 c() { }, | |
43 get d() { }, | |
44 set d(val) { }, | |
45 x: function withName() { }, | |
46 y: class { }, | |
47 z: class ClassName { }, | |
48 42: function() {}, | |
49 4.2: function() {}, | |
50 __proto__: function() {}, | |
51 }; | |
52 | |
53 assertEquals('a', obj.a.name); | |
54 assertEquals('b', obj.b.name); | |
55 assertEquals('c', obj.c.name); | |
56 var dDescriptor = Object.getOwnPropertyDescriptor(obj, 'd'); | |
57 assertEquals('get d', dDescriptor.get.name); | |
58 assertEquals('set d', dDescriptor.set.name); | |
59 assertEquals('withName', obj.x.name); | |
60 assertEquals('y', obj.y.name); | |
61 assertEquals('ClassName', obj.z.name); | |
62 assertEquals('42', obj[42].name); | |
63 assertEquals('4.2', obj[4.2].name); | |
64 assertEquals('', obj.__proto__.name); | |
65 })(); | |
66 | |
67 (function testClassProperties() { | |
68 'use strict'; | |
69 class C { | |
70 a() { } | |
71 static b() { } | |
72 get c() { } | |
73 set c(val) { } | |
74 42() { } | |
75 static 43() { } | |
76 get 44() { } | |
77 set 44(val) { } | |
78 }; | |
79 | |
80 assertEquals('a', C.prototype.a.name); | |
81 assertEquals('b', C.b.name); | |
82 var descriptor = Object.getOwnPropertyDescriptor(C.prototype, 'c'); | |
83 assertEquals('get c', descriptor.get.name); | |
84 assertEquals('set c', descriptor.set.name); | |
85 assertEquals('42', C.prototype[42].name); | |
86 assertEquals('43', C[43].name); | |
87 var descriptor = Object.getOwnPropertyDescriptor(C.prototype, '44'); | |
88 assertEquals('get 44', descriptor.get.name); | |
89 assertEquals('set 44', descriptor.set.name); | |
90 })(); | |
91 | |
92 (function testComputedProperties() { | |
93 'use strict'; | |
94 var a = 'a'; | |
95 var b = 'b'; | |
96 var sym1 = Symbol('1'); | |
97 var sym2 = Symbol('2'); | |
98 var sym3 = Symbol('3'); | |
99 var symNoDescription = Symbol(); | |
100 var obj = { | |
101 [a]: function() {}, | |
102 [sym1]: function() {}, | |
103 [sym2]: function withName() {}, | |
104 [symNoDescription]: function() {}, | |
105 | |
106 get [sym3]() {}, | |
107 set [b](val) {}, | |
108 }; | |
109 | |
110 assertEquals('a', obj[a].name); | |
111 assertEquals('[1]', obj[sym1].name); | |
112 assertEquals('withName', obj[sym2].name); | |
113 assertEquals('', obj[symNoDescription].name); | |
114 | |
115 assertEquals('get [3]', Object.getOwnPropertyDescriptor(obj, sym3).get.name); | |
116 assertEquals('set b', Object.getOwnPropertyDescriptor(obj, 'b').set.name); | |
117 | |
118 var objMethods = { | |
119 [a]() {}, | |
120 [sym1]() {}, | |
121 [symNoDescription]: function() {}, | |
122 }; | |
123 | |
124 assertEquals('a', objMethods[a].name); | |
125 assertEquals('[1]', objMethods[sym1].name); | |
126 assertEquals('', objMethods[symNoDescription].name); | |
127 | |
128 class C { | |
129 [a]() { } | |
130 [sym1]() { } | |
131 static [sym2]() { } | |
132 [symNoDescription]() { } | |
133 | |
134 get [sym3]() { } | |
135 static set [b](val) { } | |
136 } | |
137 | |
138 assertEquals('a', C.prototype[a].name); | |
139 assertEquals('[1]', C.prototype[sym1].name); | |
140 assertEquals('[2]', C[sym2].name); | |
141 assertEquals('', C.prototype[symNoDescription].name); | |
142 | |
143 assertEquals('get [3]', Object.getOwnPropertyDescriptor(C.prototype, sym3).get
.name); | |
144 assertEquals('set b', Object.getOwnPropertyDescriptor(C, 'b').set.name); | |
145 })(); | |
146 | |
147 | |
148 (function testAssignment() { | |
149 var basicFn, arrowFn, generatorFn, classLit; | |
150 | |
151 basicFn = function() { return true; }; | |
152 assertEquals('basicFn', basicFn.name); | |
153 var basicFn2 = basicFn; | |
154 assertEquals('basicFn', basicFn2.name); | |
155 basicFn = function functionWithName() { }; | |
156 assertEquals("functionWithName", basicFn.name); | |
157 | |
158 arrowFn = x => x; | |
159 assertEquals('arrowFn', arrowFn.name); | |
160 var arrowFn2 = arrowFn; | |
161 assertEquals('arrowFn', arrowFn2.name); | |
162 | |
163 generatorFn = function*() { yield true; }; | |
164 assertEquals('generatorFn', generatorFn.name); | |
165 var generatorFn2 = generatorFn; | |
166 assertEquals('generatorFn', generatorFn2.name); | |
167 generatorFn = function* generatorWithName() { }; | |
168 assertEquals("generatorWithName", generatorFn.name); | |
169 | |
170 classLit = class { constructor() {} }; | |
171 assertEquals('classLit', classLit.name); | |
172 var classLit2 = classLit; | |
173 assertEquals('classLit', classLit2.name); | |
174 classLit = class classWithName { constructor() {} }; | |
175 assertEquals('classWithName', classLit.name); | |
176 classLit = class { constructor() {} static name() {} }; | |
177 assertEquals('function', typeof classLit.name); | |
178 classLit = class { constructor() {} static get name() { return true; } }; | |
179 assertTrue(classLit.name); | |
180 classLit = class { constructor() {} static ['name']() {} }; | |
181 assertEquals('function', typeof classLit.name); | |
182 classLit = class { constructor() {} static get ['name']() { return true; } }; | |
183 assertTrue(classLit.name); | |
184 })(); | |
185 | |
186 (function testObjectBindingPattern() { | |
187 var { | |
188 a = function() {}, | |
189 b = () => {}, | |
190 x = function withName() { }, | |
191 y = class { }, | |
192 z = class ClassName { }, | |
193 q = class { static name() { return 42 } }, | |
194 foo: bar = function() {}, | |
195 inParens = (() => {}), | |
196 inManyParens = ((((() => {})))), | |
197 } = {}; | |
198 assertEquals('a', a.name); | |
199 assertEquals('b', b.name); | |
200 assertEquals('withName', x.name); | |
201 assertEquals('y', y.name); | |
202 assertEquals('ClassName', z.name); | |
203 assertEquals('function', typeof q.name); | |
204 assertEquals('bar', bar.name); | |
205 assertEquals('inParens', inParens.name) | |
206 assertEquals('inManyParens', inManyParens.name) | |
207 })(); | |
208 | |
209 (function testArrayBindingPattern() { | |
210 var [ | |
211 a = function() {}, | |
212 b = () => {}, | |
213 x = function withName() { }, | |
214 y = class { }, | |
215 z = class ClassName { }, | |
216 q = class { static name() { return 42 } }, | |
217 inParens = (() => {}), | |
218 inManyParens = ((((() => {})))), | |
219 ] = []; | |
220 assertEquals('a', a.name); | |
221 assertEquals('b', b.name); | |
222 assertEquals('withName', x.name); | |
223 assertEquals('y', y.name); | |
224 assertEquals('ClassName', z.name); | |
225 assertEquals('function', typeof q.name); | |
226 assertEquals('inParens', inParens.name) | |
227 assertEquals('inManyParens', inManyParens.name) | |
228 })(); | |
229 | |
230 (function testObjectAssignmentPattern() { | |
231 var a, b, x, y, z, q; | |
232 ({ | |
233 a = function() {}, | |
234 b = () => {}, | |
235 x = function withName() { }, | |
236 y = class { }, | |
237 z = class ClassName { }, | |
238 q = class { static name() { return 42 } }, | |
239 foo: bar = function() {}, | |
240 inParens = (() => {}), | |
241 inManyParens = ((((() => {})))), | |
242 } = {}); | |
243 assertEquals('a', a.name); | |
244 assertEquals('b', b.name); | |
245 assertEquals('withName', x.name); | |
246 assertEquals('y', y.name); | |
247 assertEquals('ClassName', z.name); | |
248 assertEquals('function', typeof q.name); | |
249 assertEquals('bar', bar.name); | |
250 assertEquals('inParens', inParens.name) | |
251 assertEquals('inManyParens', inManyParens.name) | |
252 })(); | |
253 | |
254 (function testArrayAssignmentPattern() { | |
255 var a, b, x, y, z, q; | |
256 [ | |
257 a = function() {}, | |
258 b = () => {}, | |
259 x = function withName() { }, | |
260 y = class { }, | |
261 z = class ClassName { }, | |
262 q = class { static name() { return 42 } }, | |
263 inParens = (() => {}), | |
264 inManyParens = ((((() => {})))), | |
265 ] = []; | |
266 assertEquals('a', a.name); | |
267 assertEquals('b', b.name); | |
268 assertEquals('withName', x.name); | |
269 assertEquals('y', y.name); | |
270 assertEquals('ClassName', z.name); | |
271 assertEquals('function', typeof q.name); | |
272 assertEquals('inParens', inParens.name) | |
273 assertEquals('inManyParens', inManyParens.name) | |
274 })(); | |
275 | |
276 (function testParameterDestructuring() { | |
277 (function({ a = function() {}, | |
278 b = () => {}, | |
279 x = function withName() { }, | |
280 y = class { }, | |
281 z = class ClassName { }, | |
282 q = class { static name() { return 42 } }, | |
283 foo: bar = function() {}, | |
284 inParens = (() => {}), | |
285 inManyParens = ((((() => {})))) }) { | |
286 assertEquals('a', a.name); | |
287 assertEquals('b', b.name); | |
288 assertEquals('withName', x.name); | |
289 assertEquals('y', y.name); | |
290 assertEquals('ClassName', z.name); | |
291 assertEquals('function', typeof q.name); | |
292 assertEquals('bar', bar.name); | |
293 assertEquals('inParens', inParens.name) | |
294 assertEquals('inManyParens', inManyParens.name) | |
295 })({}); | |
296 | |
297 (function([ a = function() {}, | |
298 b = () => {}, | |
299 x = function withName() { }, | |
300 y = class { }, | |
301 z = class ClassName { }, | |
302 q = class { static name() { return 42 } }, | |
303 inParens = (() => {}), | |
304 inManyParens = ((((() => {})))) ]) { | |
305 assertEquals('a', a.name); | |
306 assertEquals('b', b.name); | |
307 assertEquals('withName', x.name); | |
308 assertEquals('y', y.name); | |
309 assertEquals('ClassName', z.name); | |
310 assertEquals('function', typeof q.name); | |
311 assertEquals('inParens', inParens.name) | |
312 assertEquals('inManyParens', inManyParens.name) | |
313 })([]); | |
314 })(); | |
315 | |
316 (function testDefaultParameters() { | |
317 (function(a = function() {}, | |
318 b = () => {}, | |
319 x = function withName() { }, | |
320 y = class { }, | |
321 z = class ClassName { }, | |
322 q = class { static name() { return 42 } }, | |
323 inParens = (() => {}), | |
324 inManyParens = ((((() => {}))))) { | |
325 assertEquals('a', a.name); | |
326 assertEquals('b', b.name); | |
327 assertEquals('withName', x.name); | |
328 assertEquals('y', y.name); | |
329 assertEquals('ClassName', z.name); | |
330 assertEquals('function', typeof q.name); | |
331 assertEquals('inParens', inParens.name) | |
332 assertEquals('inManyParens', inManyParens.name) | |
333 })(); | |
334 })(); | |
335 | |
336 (function testComputedNameNotShared() { | |
337 function makeClass(propName) { | |
338 return class { | |
339 static [propName]() {} | |
340 } | |
341 } | |
342 | |
343 var sym1 = Symbol('1'); | |
344 var sym2 = Symbol('2'); | |
345 var class1 = makeClass(sym1); | |
346 assertEquals('[1]', class1[sym1].name); | |
347 var class2 = makeClass(sym2); | |
348 assertEquals('[2]', class2[sym2].name); | |
349 assertEquals('[1]', class1[sym1].name); | |
350 })(); | |
351 | |
352 | |
353 (function testComputedNamesOnlyAppliedSyntactically() { | |
354 function factory() { return () => {}; } | |
355 | |
356 var obj = { ['foo']: factory() }; | |
357 assertEquals('', obj.foo.name); | |
358 })(); | |
359 | |
360 | |
361 (function testNameNotReflectedInToString() { | |
362 var f = function() {}; | |
363 var g = function*() {}; | |
364 var obj = { | |
365 ['h']: function() {}, | |
366 i: () => {} | |
367 }; | |
368 assertEquals('function () {}', f.toString()); | |
369 assertEquals('function* () {}', g.toString()); | |
370 assertEquals('function () {}', obj.h.toString()); | |
371 assertEquals('() => {}', obj.i.toString()); | |
372 })(); | |
OLD | NEW |