← Back to branch summary

~webapps/unity-js-scopes/node.js

« back to all changes in this revision

Viewing changes to deps/v8/test/cctest/test-func-name-inference.cc

  • Committer: Marcus Tomlinson
  • Date: 2015-11-13 07:59:04 UTC
  • Revision ID: marcus.tomlinson@canonical.com-20151113075904-h0swczmoq1rvstfc
Node v4 (stable)

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/v8/test/cctest/test-func-name-inference.cc
 
1
// Copyright 2011 the V8 project authors. All rights reserved.
 
2
// Redistribution and use in source and binary forms, with or without
 
3
// modification, are permitted provided that the following conditions are
 
4
// met:
 
5
//
 
6
//     * Redistributions of source code must retain the above copyright
 
7
//       notice, this list of conditions and the following disclaimer.
 
8
//     * Redistributions in binary form must reproduce the above
 
9
//       copyright notice, this list of conditions and the following
 
10
//       disclaimer in the documentation and/or other materials provided
 
11
//       with the distribution.
 
12
//     * Neither the name of Google Inc. nor the names of its
 
13
//       contributors may be used to endorse or promote products derived
 
14
//       from this software without specific prior written permission.
 
15
//
 
16
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
17
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
18
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
19
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
20
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
21
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
22
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
23
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
24
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
25
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
26
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
 
 
28
 
 
29
#include "src/v8.h"
 
30
 
 
31
#include "src/api.h"
 
32
#include "src/debug.h"
 
33
#include "src/string-search.h"
 
34
#include "test/cctest/cctest.h"
 
35
 
 
36
 
 
37
using ::v8::internal::CStrVector;
 
38
using ::v8::internal::Factory;
 
39
using ::v8::internal::Handle;
 
40
using ::v8::internal::Heap;
 
41
using ::v8::internal::Isolate;
 
42
using ::v8::internal::JSFunction;
 
43
using ::v8::internal::Object;
 
44
using ::v8::internal::Runtime;
 
45
using ::v8::internal::Script;
 
46
using ::v8::internal::SmartArrayPointer;
 
47
using ::v8::internal::SharedFunctionInfo;
 
48
using ::v8::internal::String;
 
49
using ::v8::internal::Vector;
 
50
 
 
51
 
 
52
static void CheckFunctionName(v8::Handle<v8::Script> script,
 
53
                              const char* func_pos_src,
 
54
                              const char* ref_inferred_name) {
 
55
  Isolate* isolate = CcTest::i_isolate();
 
56
 
 
57
  // Get script source.
 
58
  Handle<Object> obj = v8::Utils::OpenHandle(*script);
 
59
  Handle<SharedFunctionInfo> shared_function;
 
60
  if (obj->IsSharedFunctionInfo()) {
 
61
    shared_function =
 
62
        Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(*obj));
 
63
  } else {
 
64
    shared_function =
 
65
        Handle<SharedFunctionInfo>(JSFunction::cast(*obj)->shared());
 
66
  }
 
67
  Handle<Script> i_script(Script::cast(shared_function->script()));
 
68
  CHECK(i_script->source()->IsString());
 
69
  Handle<String> script_src(String::cast(i_script->source()));
 
70
 
 
71
  // Find the position of a given func source substring in the source.
 
72
  int func_pos;
 
73
  {
 
74
    i::DisallowHeapAllocation no_gc;
 
75
    Vector<const uint8_t> func_pos_str = i::OneByteVector(func_pos_src);
 
76
    String::FlatContent script_content = script_src->GetFlatContent();
 
77
    func_pos = SearchString(isolate, script_content.ToOneByteVector(),
 
78
                            func_pos_str, 0);
 
79
  }
 
80
  CHECK_NE(0, func_pos);
 
81
 
 
82
  // Obtain SharedFunctionInfo for the function.
 
83
  isolate->debug()->PrepareForBreakPoints();
 
84
  Handle<SharedFunctionInfo> shared_func_info =
 
85
      Handle<SharedFunctionInfo>::cast(
 
86
          isolate->debug()->FindSharedFunctionInfoInScript(i_script, func_pos));
 
87
 
 
88
  // Verify inferred function name.
 
89
  SmartArrayPointer<char> inferred_name =
 
90
      shared_func_info->inferred_name()->ToCString();
 
91
  CHECK_EQ(0, strcmp(ref_inferred_name, inferred_name.get()));
 
92
}
 
93
 
 
94
 
 
95
static v8::Handle<v8::Script> Compile(v8::Isolate* isolate, const char* src) {
 
96
  return v8::Script::Compile(v8::String::NewFromUtf8(isolate, src));
 
97
}
 
98
 
 
99
 
 
100
TEST(GlobalProperty) {
 
101
  CcTest::InitializeVM();
 
102
  v8::HandleScope scope(CcTest::isolate());
 
103
 
 
104
  v8::Handle<v8::Script> script = Compile(
 
105
      CcTest::isolate(),
 
106
      "fun1 = function() { return 1; }\n"
 
107
      "fun2 = function() { return 2; }\n");
 
108
  CheckFunctionName(script, "return 1", "fun1");
 
109
  CheckFunctionName(script, "return 2", "fun2");
 
110
}
 
111
 
 
112
 
 
113
TEST(GlobalVar) {
 
114
  CcTest::InitializeVM();
 
115
  v8::HandleScope scope(CcTest::isolate());
 
116
 
 
117
  v8::Handle<v8::Script> script = Compile(
 
118
      CcTest::isolate(),
 
119
      "var fun1 = function() { return 1; }\n"
 
120
      "var fun2 = function() { return 2; }\n");
 
121
  CheckFunctionName(script, "return 1", "fun1");
 
122
  CheckFunctionName(script, "return 2", "fun2");
 
123
}
 
124
 
 
125
 
 
126
TEST(LocalVar) {
 
127
  CcTest::InitializeVM();
 
128
  v8::HandleScope scope(CcTest::isolate());
 
129
 
 
130
  v8::Handle<v8::Script> script = Compile(
 
131
      CcTest::isolate(),
 
132
      "function outer() {\n"
 
133
      "  var fun1 = function() { return 1; }\n"
 
134
      "  var fun2 = function() { return 2; }\n"
 
135
      "}");
 
136
  CheckFunctionName(script, "return 1", "fun1");
 
137
  CheckFunctionName(script, "return 2", "fun2");
 
138
}
 
139
 
 
140
 
 
141
TEST(InConstructor) {
 
142
  CcTest::InitializeVM();
 
143
  v8::HandleScope scope(CcTest::isolate());
 
144
 
 
145
  v8::Handle<v8::Script> script = Compile(
 
146
      CcTest::isolate(),
 
147
      "function MyClass() {\n"
 
148
      "  this.method1 = function() { return 1; }\n"
 
149
      "  this.method2 = function() { return 2; }\n"
 
150
      "}");
 
151
  CheckFunctionName(script, "return 1", "MyClass.method1");
 
152
  CheckFunctionName(script, "return 2", "MyClass.method2");
 
153
}
 
154
 
 
155
 
 
156
TEST(Factory) {
 
157
  CcTest::InitializeVM();
 
158
  v8::HandleScope scope(CcTest::isolate());
 
159
 
 
160
  v8::Handle<v8::Script> script = Compile(
 
161
      CcTest::isolate(),
 
162
      "function createMyObj() {\n"
 
163
      "  var obj = {};\n"
 
164
      "  obj.method1 = function() { return 1; }\n"
 
165
      "  obj.method2 = function() { return 2; }\n"
 
166
      "  return obj;\n"
 
167
      "}");
 
168
  CheckFunctionName(script, "return 1", "obj.method1");
 
169
  CheckFunctionName(script, "return 2", "obj.method2");
 
170
}
 
171
 
 
172
 
 
173
TEST(Static) {
 
174
  CcTest::InitializeVM();
 
175
  v8::HandleScope scope(CcTest::isolate());
 
176
 
 
177
  v8::Handle<v8::Script> script = Compile(
 
178
      CcTest::isolate(),
 
179
      "function MyClass() {}\n"
 
180
      "MyClass.static1 = function() { return 1; }\n"
 
181
      "MyClass.static2 = function() { return 2; }\n"
 
182
      "MyClass.MyInnerClass = {}\n"
 
183
      "MyClass.MyInnerClass.static3 = function() { return 3; }\n"
 
184
      "MyClass.MyInnerClass.static4 = function() { return 4; }");
 
185
  CheckFunctionName(script, "return 1", "MyClass.static1");
 
186
  CheckFunctionName(script, "return 2", "MyClass.static2");
 
187
  CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.static3");
 
188
  CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.static4");
 
189
}
 
190
 
 
191
 
 
192
TEST(Prototype) {
 
193
  CcTest::InitializeVM();
 
194
  v8::HandleScope scope(CcTest::isolate());
 
195
 
 
196
  v8::Handle<v8::Script> script = Compile(
 
197
      CcTest::isolate(),
 
198
      "function MyClass() {}\n"
 
199
      "MyClass.prototype.method1 = function() { return 1; }\n"
 
200
      "MyClass.prototype.method2 = function() { return 2; }\n"
 
201
      "MyClass.MyInnerClass = function() {}\n"
 
202
      "MyClass.MyInnerClass.prototype.method3 = function() { return 3; }\n"
 
203
      "MyClass.MyInnerClass.prototype.method4 = function() { return 4; }");
 
204
  CheckFunctionName(script, "return 1", "MyClass.method1");
 
205
  CheckFunctionName(script, "return 2", "MyClass.method2");
 
206
  CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.method3");
 
207
  CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.method4");
 
208
}
 
209
 
 
210
 
 
211
TEST(ObjectLiteral) {
 
212
  CcTest::InitializeVM();
 
213
  v8::HandleScope scope(CcTest::isolate());
 
214
 
 
215
  v8::Handle<v8::Script> script = Compile(
 
216
      CcTest::isolate(),
 
217
      "function MyClass() {}\n"
 
218
      "MyClass.prototype = {\n"
 
219
      "  method1: function() { return 1; },\n"
 
220
      "  method2: function() { return 2; } }");
 
221
  CheckFunctionName(script, "return 1", "MyClass.method1");
 
222
  CheckFunctionName(script, "return 2", "MyClass.method2");
 
223
}
 
224
 
 
225
 
 
226
TEST(AsParameter) {
 
227
  CcTest::InitializeVM();
 
228
  v8::HandleScope scope(CcTest::isolate());
 
229
 
 
230
  v8::Handle<v8::Script> script = Compile(
 
231
      CcTest::isolate(),
 
232
      "function f1(a) { return a(); }\n"
 
233
      "function f2(a, b) { return a() + b(); }\n"
 
234
      "var result1 = f1(function() { return 1; })\n"
 
235
      "var result2 = f2(function() { return 2; }, function() { return 3; })");
 
236
  // Can't infer names here.
 
237
  CheckFunctionName(script, "return 1", "");
 
238
  CheckFunctionName(script, "return 2", "");
 
239
  CheckFunctionName(script, "return 3", "");
 
240
}
 
241
 
 
242
 
 
243
TEST(MultipleFuncsConditional) {
 
244
  CcTest::InitializeVM();
 
245
  v8::HandleScope scope(CcTest::isolate());
 
246
 
 
247
  v8::Handle<v8::Script> script = Compile(
 
248
      CcTest::isolate(),
 
249
      "fun1 = 0 ?\n"
 
250
      "    function() { return 1; } :\n"
 
251
      "    function() { return 2; }");
 
252
  CheckFunctionName(script, "return 1", "fun1");
 
253
  CheckFunctionName(script, "return 2", "fun1");
 
254
}
 
255
 
 
256
 
 
257
TEST(MultipleFuncsInLiteral) {
 
258
  CcTest::InitializeVM();
 
259
  v8::HandleScope scope(CcTest::isolate());
 
260
 
 
261
  v8::Handle<v8::Script> script = Compile(
 
262
      CcTest::isolate(),
 
263
      "function MyClass() {}\n"
 
264
      "MyClass.prototype = {\n"
 
265
      "  method1: 0 ? function() { return 1; } :\n"
 
266
      "               function() { return 2; } }");
 
267
  CheckFunctionName(script, "return 1", "MyClass.method1");
 
268
  CheckFunctionName(script, "return 2", "MyClass.method1");
 
269
}
 
270
 
 
271
 
 
272
TEST(AnonymousInAnonymousClosure1) {
 
273
  CcTest::InitializeVM();
 
274
  v8::HandleScope scope(CcTest::isolate());
 
275
 
 
276
  v8::Handle<v8::Script> script = Compile(
 
277
      CcTest::isolate(),
 
278
      "(function() {\n"
 
279
      "  (function() {\n"
 
280
      "      var a = 1;\n"
 
281
      "      return;\n"
 
282
      "  })();\n"
 
283
      "  var b = function() {\n"
 
284
      "      var c = 1;\n"
 
285
      "      return;\n"
 
286
      "  };\n"
 
287
      "})();");
 
288
  CheckFunctionName(script, "return", "");
 
289
}
 
290
 
 
291
 
 
292
TEST(AnonymousInAnonymousClosure2) {
 
293
  CcTest::InitializeVM();
 
294
  v8::HandleScope scope(CcTest::isolate());
 
295
 
 
296
  v8::Handle<v8::Script> script = Compile(
 
297
      CcTest::isolate(),
 
298
      "(function() {\n"
 
299
      "  (function() {\n"
 
300
      "      var a = 1;\n"
 
301
      "      return;\n"
 
302
      "  })();\n"
 
303
      "  var c = 1;\n"
 
304
      "})();");
 
305
  CheckFunctionName(script, "return", "");
 
306
}
 
307
 
 
308
 
 
309
TEST(NamedInAnonymousClosure) {
 
310
  CcTest::InitializeVM();
 
311
  v8::HandleScope scope(CcTest::isolate());
 
312
 
 
313
  v8::Handle<v8::Script> script = Compile(
 
314
      CcTest::isolate(),
 
315
      "var foo = function() {\n"
 
316
      "  (function named() {\n"
 
317
      "      var a = 1;\n"
 
318
      "  })();\n"
 
319
      "  var c = 1;\n"
 
320
      "  return;\n"
 
321
      "};");
 
322
  CheckFunctionName(script, "return", "foo");
 
323
}
 
324
 
 
325
 
 
326
// See http://code.google.com/p/v8/issues/detail?id=380
 
327
TEST(Issue380) {
 
328
  CcTest::InitializeVM();
 
329
  v8::HandleScope scope(CcTest::isolate());
 
330
 
 
331
  v8::Handle<v8::Script> script = Compile(
 
332
      CcTest::isolate(),
 
333
      "function a() {\n"
 
334
      "var result = function(p,a,c,k,e,d)"
 
335
      "{return p}(\"if blah blah\",62,1976,\'a|b\'.split(\'|\'),0,{})\n"
 
336
      "}");
 
337
  CheckFunctionName(script, "return p", "");
 
338
}
 
339
 
 
340
 
 
341
TEST(MultipleAssignments) {
 
342
  CcTest::InitializeVM();
 
343
  v8::HandleScope scope(CcTest::isolate());
 
344
 
 
345
  v8::Handle<v8::Script> script = Compile(
 
346
      CcTest::isolate(),
 
347
      "var fun1 = fun2 = function () { return 1; }\n"
 
348
      "var bar1 = bar2 = bar3 = function () { return 2; }\n"
 
349
      "foo1 = foo2 = function () { return 3; }\n"
 
350
      "baz1 = baz2 = baz3 = function () { return 4; }");
 
351
  CheckFunctionName(script, "return 1", "fun2");
 
352
  CheckFunctionName(script, "return 2", "bar3");
 
353
  CheckFunctionName(script, "return 3", "foo2");
 
354
  CheckFunctionName(script, "return 4", "baz3");
 
355
}
 
356
 
 
357
 
 
358
TEST(AsConstructorParameter) {
 
359
  CcTest::InitializeVM();
 
360
  v8::HandleScope scope(CcTest::isolate());
 
361
 
 
362
  v8::Handle<v8::Script> script = Compile(
 
363
      CcTest::isolate(),
 
364
      "function Foo() {}\n"
 
365
      "var foo = new Foo(function() { return 1; })\n"
 
366
      "var bar = new Foo(function() { return 2; }, function() { return 3; })");
 
367
  CheckFunctionName(script, "return 1", "");
 
368
  CheckFunctionName(script, "return 2", "");
 
369
  CheckFunctionName(script, "return 3", "");
 
370
}
 
371
 
 
372
 
 
373
TEST(FactoryHashmap) {
 
374
  CcTest::InitializeVM();
 
375
  v8::HandleScope scope(CcTest::isolate());
 
376
 
 
377
  v8::Handle<v8::Script> script = Compile(
 
378
      CcTest::isolate(),
 
379
      "function createMyObj() {\n"
 
380
      "  var obj = {};\n"
 
381
      "  obj[\"method1\"] = function() { return 1; }\n"
 
382
      "  obj[\"method2\"] = function() { return 2; }\n"
 
383
      "  return obj;\n"
 
384
      "}");
 
385
  CheckFunctionName(script, "return 1", "obj.method1");
 
386
  CheckFunctionName(script, "return 2", "obj.method2");
 
387
}
 
388
 
 
389
 
 
390
TEST(FactoryHashmapVariable) {
 
391
  CcTest::InitializeVM();
 
392
  v8::HandleScope scope(CcTest::isolate());
 
393
 
 
394
  v8::Handle<v8::Script> script = Compile(
 
395
      CcTest::isolate(),
 
396
      "function createMyObj() {\n"
 
397
      "  var obj = {};\n"
 
398
      "  var methodName = \"method1\";\n"
 
399
      "  obj[methodName] = function() { return 1; }\n"
 
400
      "  methodName = \"method2\";\n"
 
401
      "  obj[methodName] = function() { return 2; }\n"
 
402
      "  return obj;\n"
 
403
      "}");
 
404
  // Can't infer function names statically.
 
405
  CheckFunctionName(script, "return 1", "obj.(anonymous function)");
 
406
  CheckFunctionName(script, "return 2", "obj.(anonymous function)");
 
407
}
 
408
 
 
409
 
 
410
TEST(FactoryHashmapConditional) {
 
411
  CcTest::InitializeVM();
 
412
  v8::HandleScope scope(CcTest::isolate());
 
413
 
 
414
  v8::Handle<v8::Script> script = Compile(
 
415
      CcTest::isolate(),
 
416
      "function createMyObj() {\n"
 
417
      "  var obj = {};\n"
 
418
      "  obj[0 ? \"method1\" : \"method2\"] = function() { return 1; }\n"
 
419
      "  return obj;\n"
 
420
      "}");
 
421
  // Can't infer the function name statically.
 
422
  CheckFunctionName(script, "return 1", "obj.(anonymous function)");
 
423
}
 
424
 
 
425
 
 
426
TEST(GlobalAssignmentAndCall) {
 
427
  CcTest::InitializeVM();
 
428
  v8::HandleScope scope(CcTest::isolate());
 
429
 
 
430
  v8::Handle<v8::Script> script = Compile(
 
431
      CcTest::isolate(),
 
432
      "var Foo = function() {\n"
 
433
      "  return 1;\n"
 
434
      "}();\n"
 
435
      "var Baz = Bar = function() {\n"
 
436
      "  return 2;\n"
 
437
      "}");
 
438
  // The inferred name is empty, because this is an assignment of a result.
 
439
  CheckFunctionName(script, "return 1", "");
 
440
  // See MultipleAssignments test.
 
441
  CheckFunctionName(script, "return 2", "Bar");
 
442
}
 
443
 
 
444
 
 
445
TEST(AssignmentAndCall) {
 
446
  CcTest::InitializeVM();
 
447
  v8::HandleScope scope(CcTest::isolate());
 
448
 
 
449
  v8::Handle<v8::Script> script = Compile(
 
450
      CcTest::isolate(),
 
451
      "(function Enclosing() {\n"
 
452
      "  var Foo;\n"
 
453
      "  Foo = function() {\n"
 
454
      "    return 1;\n"
 
455
      "  }();\n"
 
456
      "  var Baz = Bar = function() {\n"
 
457
      "    return 2;\n"
 
458
      "  }\n"
 
459
      "})();");
 
460
  // The inferred name is empty, because this is an assignment of a result.
 
461
  CheckFunctionName(script, "return 1", "");
 
462
  // See MultipleAssignments test.
 
463
  // TODO(2276): Lazy compiling the enclosing outer closure would yield
 
464
  // in "Enclosing.Bar" being the inferred name here.
 
465
  CheckFunctionName(script, "return 2", "Bar");
 
466
}
 
467
 
 
468
 
 
469
TEST(MethodAssignmentInAnonymousFunctionCall) {
 
470
  CcTest::InitializeVM();
 
471
  v8::HandleScope scope(CcTest::isolate());
 
472
 
 
473
  v8::Handle<v8::Script> script = Compile(
 
474
      CcTest::isolate(),
 
475
      "(function () {\n"
 
476
      "    var EventSource = function () { };\n"
 
477
      "    EventSource.prototype.addListener = function () {\n"
 
478
      "        return 2012;\n"
 
479
      "    };\n"
 
480
      "    this.PublicEventSource = EventSource;\n"
 
481
      "})();");
 
482
  CheckFunctionName(script, "return 2012", "EventSource.addListener");
 
483
}
 
484
 
 
485
 
 
486
TEST(ReturnAnonymousFunction) {
 
487
  CcTest::InitializeVM();
 
488
  v8::HandleScope scope(CcTest::isolate());
 
489
 
 
490
  v8::Handle<v8::Script> script = Compile(
 
491
      CcTest::isolate(),
 
492
      "(function() {\n"
 
493
      "  function wrapCode() {\n"
 
494
      "    return function () {\n"
 
495
      "      return 2012;\n"
 
496
      "    };\n"
 
497
      "  };\n"
 
498
      "  var foo = 10;\n"
 
499
      "  function f() {\n"
 
500
      "    return wrapCode();\n"
 
501
      "  }\n"
 
502
      "  this.ref = f;\n"
 
503
      "})()");
 
504
  script->Run();
 
505
  CheckFunctionName(script, "return 2012", "");
 
506
}