1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
Debug = debug.Debug;
// StaCurrentContextSlot
success(10, `(function(){
const x = 10;
function f1() {return x;}
return x;
})()`);
// StaNamedProperty
var a = {name: 'foo'};
function set_name(a) {
a.name = 'bar';
return a.name;
}
fail(`set_name(a)`);
success('bar', `set_name({name: 'foo'})`);
// StaNamedOwnProperty
var name_value = 'value';
function create_object_literal() {
var obj = {name: name_value};
return obj.name;
};
success('value', `create_object_literal()`);
// StaKeyedProperty
var arrayValue = 1;
function create_array_literal() {
return [arrayValue];
}
var b = { 1: 2 };
success([arrayValue], `create_array_literal()`)
fail(`b[1] ^= 2`);
// StaInArrayLiteral
function return_array_use_spread(a) {
return [...a];
}
success([1], `return_array_use_spread([1])`);
// CallAccessorSetter
var array = [1,2,3];
fail(`array.length = 2`);
// TODO(7515): this one should be side effect free
fail(`[1,2,3].length = 2`);
// StaDataPropertyInLiteral
function return_literal_with_data_property(a) {
return {[a] : 1};
}
success({foo: 1}, `return_literal_with_data_property('foo')`);
// Set builtins with temporary objects
var set = new Set([1,2]);
fail(`set.add(3).size`);
success(1, `new Set().add(1).size`);
success(0, `(() => { const s = new Set([1]); s.delete(1); return s.size; })()`);
fail(`set.delete(1)`);
success(0, `(() => { const s = new Set([1]); s.clear(); return s.size; })()`);
fail(`set.clear()`);
// new set
success(3, `(() => {
let s = 0;
for (const a of new Set([1,2]))
s += a;
return s;
})()`);
// existing set
success(3, `(() => {
let s = 0;
for (const a of set)
s += a;
return s;
})()`);
// existing iterator
var setIterator = set.entries();
fail(`(() => {
let s = 0;
for (const a of setIterator)
s += a;
return s;
})()`);
// Array builtins with temporary objects
success([1,1,1], '[1,2,3].fill(1)');
fail(`array.fill(1)`);
success([1], `(() => { const a = []; a.push(1); return a; })()`);
fail(`array.push(1)`);
success([1], `(() => { const a = [1,2]; a.pop(); return a; })()`);
fail(`array.pop()`);
success([3,2,1], `[1,2,3].reverse()`);
fail(`array.reverse()`);
success([1,2,3], `[2,1,3].sort()`);
fail(`array.sort()`);
success([2,3], `[1,2,3].splice(1,2)`);
fail(`array.splice(1,2)`);
success([1,2], `(() => { const a = [2]; a.unshift(1); return a; })()`);
fail(`array.unshift(1)`);
success(1, `[1,2].shift()`);
fail(`array.shift()`);
// new array
success(6, `(() => {
let s = 0;
for (const a of [1,2,3])
s += a;
return s;
})()`);
// existing array
success(6, `(() => {
let s = 0;
for (const a of array)
s += a;
return s;
})()`);
// existing iterator
var arrayIterator = array.entries();
fail(`(() => {
let s = 0;
for (const a of arrayIterator)
s += a;
return s;
})()`);
success(6, `array.reduce((a,b) => a + b, 0)`);
// Map builtins with temporary objects
var map = new Map([[1,2]]);
fail(`map.set(3, 4).size`);
success(1, `new Map().set(1, 2).size`);
success(0, `(() => {
const m = new Map([[1, 2]]);
m.delete(1);
return m.size;
})()`);
fail(`map.delete(1)`);
success(0, `(() => {
const m = new Map([[1, 2]]);
m.clear();
return m.size;
})()`);
fail(`map.clear()`);
// new set
success(2, `(() => {
let s = 0;
for (const [a, b] of new Map([[1,2]]))
s += b;
return s;
})()`);
// existing set
success(2, `(() => {
let s = 0;
for (const [a,b] of map)
s += b;
return s;
})()`);
// existing iterator
var mapIterator = map.entries();
fail(`(() => {
let s = 0;
for (const [a,b] of mapIterator)
s += a;
return s;
})()`);
// Regexps
var regExp = /a/;
success(true, `/a/.test('a')`);
fail(`/a/.test({toString: () => {map.clear(); return 'a';}})`)
fail(`regExp.test('a')`);
function success(expectation, source) {
const result = Debug.evaluateGlobal(source, true).value();
if (expectation !== undefined) assertEquals(expectation, result);
}
function fail(source) {
assertThrows(() => Debug.evaluateGlobal(source, true),
EvalError);
}
|
