| 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 |
|---|
Chromium Code Reviews
Issue 2096933002:
Remove all harmony runtime flags which shipped in M51 (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master