OLD | NEW |
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 29 matching lines...) Expand all Loading... |
40 for (var j = 0; j < 5; ++j) f1(); | 40 for (var j = 0; j < 5; ++j) f1(); |
41 %OptimizeFunctionOnNextCall(f1); | 41 %OptimizeFunctionOnNextCall(f1); |
42 f1(); | 42 f1(); |
43 assertTrue(%GetOptimizationStatus(f1) != 2); | 43 assertTrue(%GetOptimizationStatus(f1) != 2); |
44 | 44 |
45 // Dynamic lookup in and through block contexts. | 45 // Dynamic lookup in and through block contexts. |
46 function f2(one) { | 46 function f2(one) { |
47 var x = one + 1; | 47 var x = one + 1; |
48 let y = one + 2; | 48 let y = one + 2; |
49 const u = one + 4; | 49 const u = one + 4; |
| 50 class a { static foo() { return one + 6; } } |
50 { | 51 { |
51 let z = one + 3; | 52 let z = one + 3; |
52 const v = one + 5; | 53 const v = one + 5; |
| 54 class b { static foo() { return one + 7; } } |
53 assertEquals(1, eval('one')); | 55 assertEquals(1, eval('one')); |
54 assertEquals(2, eval('x')); | 56 assertEquals(2, eval('x')); |
55 assertEquals(3, eval('y')); | 57 assertEquals(3, eval('y')); |
56 assertEquals(4, eval('z')); | 58 assertEquals(4, eval('z')); |
57 assertEquals(5, eval('u')); | 59 assertEquals(5, eval('u')); |
58 assertEquals(6, eval('v')); | 60 assertEquals(6, eval('v')); |
| 61 assertEquals(7, eval('a.foo()')); |
| 62 assertEquals(8, eval('b.foo()')); |
59 } | 63 } |
60 } | 64 } |
61 | 65 |
62 f2(1); | 66 f2(1); |
63 | 67 |
64 // Lookup in and through block contexts. | 68 // Lookup in and through block contexts. |
65 function f3(one) { | 69 function f3(one) { |
66 var x = one + 1; | 70 var x = one + 1; |
67 let y = one + 2; | 71 let y = one + 2; |
68 const u = one + 4; | 72 const u = one + 4; |
| 73 class a { static foo() { return one + 6; } } |
69 { | 74 { |
70 let z = one + 3; | 75 let z = one + 3; |
71 const v = one + 5; | 76 const v = one + 5; |
| 77 class b { static foo() { return one + 7; } } |
72 assertEquals(1, one); | 78 assertEquals(1, one); |
73 assertEquals(2, x); | 79 assertEquals(2, x); |
74 assertEquals(3, y); | 80 assertEquals(3, y); |
75 assertEquals(4, z); | 81 assertEquals(4, z); |
76 assertEquals(5, u); | 82 assertEquals(5, u); |
77 assertEquals(6, v); | 83 assertEquals(6, v); |
| 84 assertEquals(7, a.foo()); |
| 85 assertEquals(8, b.foo()); |
78 } | 86 } |
79 } | 87 } |
80 for (var j = 0; j < 5; ++j) f3(1); | 88 for (var j = 0; j < 5; ++j) f3(1); |
81 %OptimizeFunctionOnNextCall(f3); | 89 %OptimizeFunctionOnNextCall(f3); |
82 f3(1); | 90 f3(1); |
83 assertTrue(%GetOptimizationStatus(f3) != 2); | 91 assertTrue(%GetOptimizationStatus(f3) != 2); |
84 | 92 |
85 | 93 |
86 | 94 |
87 // Dynamic lookup from closure. | 95 // Dynamic lookup from closure. |
88 function f4(one) { | 96 function f4(one) { |
89 var x = one + 1; | 97 var x = one + 1; |
90 let y = one + 2; | 98 let y = one + 2; |
91 const u = one + 4; | 99 const u = one + 4; |
| 100 class a { static foo() { return one + 6; } } |
92 { | 101 { |
93 let z = one + 3; | 102 let z = one + 3; |
94 const v = one + 5; | 103 const v = one + 5; |
| 104 class b { static foo() { return one + 7; } } |
95 function f() { | 105 function f() { |
96 assertEquals(1, eval('one')); | 106 assertEquals(1, eval('one')); |
97 assertEquals(2, eval('x')); | 107 assertEquals(2, eval('x')); |
98 assertEquals(3, eval('y')); | 108 assertEquals(3, eval('y')); |
99 assertEquals(4, eval('z')); | 109 assertEquals(4, eval('z')); |
100 assertEquals(5, eval('u')); | 110 assertEquals(5, eval('u')); |
101 assertEquals(6, eval('v')); | 111 assertEquals(6, eval('v')); |
| 112 assertEquals(7, eval('a.foo()')); |
| 113 assertEquals(8, eval('b.foo()')); |
102 } | 114 } |
103 f(); | 115 f(); |
104 } | 116 } |
105 } | 117 } |
106 f4(1); | 118 f4(1); |
107 | 119 |
108 | 120 |
109 // Lookup from closure. | 121 // Lookup from closure. |
110 function f5(one) { | 122 function f5(one) { |
111 var x = one + 1; | 123 var x = one + 1; |
112 let y = one + 2; | 124 let y = one + 2; |
113 const u = one + 4; | 125 const u = one + 4; |
| 126 class a { static foo() { return one + 6; } } |
114 { | 127 { |
115 let z = one + 3; | 128 let z = one + 3; |
116 const v = one + 5; | 129 const v = one + 5; |
| 130 class b { static foo() { return one + 7; } } |
117 function f() { | 131 function f() { |
118 assertEquals(1, one); | 132 assertEquals(1, one); |
119 assertEquals(2, x); | 133 assertEquals(2, x); |
120 assertEquals(3, y); | 134 assertEquals(3, y); |
121 assertEquals(4, z); | 135 assertEquals(4, z); |
122 assertEquals(5, u); | 136 assertEquals(5, u); |
123 assertEquals(6, v); | 137 assertEquals(6, v); |
| 138 assertEquals(7, a.foo()); |
| 139 assertEquals(8, b.foo()); |
124 } | 140 } |
125 f(); | 141 f(); |
126 } | 142 } |
127 } | 143 } |
128 f5(1); | 144 f5(1); |
129 | 145 |
130 | 146 |
131 // Return from block. | 147 // Return from block. |
132 function f6() { | 148 function f6() { |
133 let x = 1; | 149 let x = 1; |
134 const u = 3; | 150 const u = 3; |
135 { | 151 { |
136 let y = 2; | 152 let y = 2; |
137 const v = 4; | 153 const v = 4; |
138 return x + y; | 154 return x + y; |
139 } | 155 } |
140 } | 156 } |
141 assertEquals(3, f6(6)); | 157 assertEquals(3, f6(6)); |
142 | 158 |
143 | 159 |
144 // Variable shadowing and lookup. | 160 // Variable shadowing and lookup. |
145 function f7(a) { | 161 function f7(a) { |
146 let b = 1; | 162 let b = 1; |
147 var c = 1; | 163 var c = 1; |
148 var d = 1; | 164 var d = 1; |
149 const e = 1; | 165 const e = 1; |
150 { // let variables shadowing argument, let, const and var variables | 166 class f { static foo() { return 1; } } |
| 167 { // let variables shadowing argument, let, const, class and var variables |
151 let a = 2; | 168 let a = 2; |
152 let b = 2; | 169 let b = 2; |
153 let c = 2; | 170 let c = 2; |
154 let e = 2; | 171 let e = 2; |
| 172 let f = 2; |
155 assertEquals(2,a); | 173 assertEquals(2,a); |
156 assertEquals(2,b); | 174 assertEquals(2,b); |
157 assertEquals(2,c); | 175 assertEquals(2,c); |
158 assertEquals(2,e); | 176 assertEquals(2,e); |
| 177 assertEquals(2,f); |
159 } | 178 } |
160 { // const variables shadowing argument, let, const and var variables | 179 { // const variables shadowing argument, let, const and var variables |
161 const a = 2; | 180 const a = 2; |
162 const b = 2; | 181 const b = 2; |
163 const c = 2; | 182 const c = 2; |
164 const e = 2; | 183 const e = 2; |
| 184 const f = 2; |
165 assertEquals(2,a); | 185 assertEquals(2,a); |
166 assertEquals(2,b); | 186 assertEquals(2,b); |
167 assertEquals(2,c); | 187 assertEquals(2,c); |
168 assertEquals(2,e); | 188 assertEquals(2,e); |
| 189 assertEquals(2,f); |
| 190 } |
| 191 { // class variables shadowing argument, let, const and var variables |
| 192 class a { static foo() { return 2; } } |
| 193 class b { static foo() { return 2; } } |
| 194 class c { static foo() { return 2; } } |
| 195 class d { static foo() { return 2; } } |
| 196 class e { static foo() { return 2; } } |
| 197 class f { static foo() { return 2; } } |
| 198 assertEquals(2,a.foo()); |
| 199 assertEquals(2,b.foo()); |
| 200 assertEquals(2,c.foo()); |
| 201 assertEquals(2,e.foo()); |
| 202 assertEquals(2,f.foo()); |
169 } | 203 } |
170 try { | 204 try { |
171 throw 'stuff1'; | 205 throw 'stuff1'; |
172 } catch (a) { | 206 } catch (a) { |
173 assertEquals('stuff1',a); | 207 assertEquals('stuff1',a); |
174 // catch variable shadowing argument | 208 // catch variable shadowing argument |
175 a = 2; | 209 a = 2; |
176 assertEquals(2,a); | 210 assertEquals(2,a); |
177 { | 211 { |
178 // let variable shadowing catch variable | 212 // let variable shadowing catch variable |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
216 })(); | 250 })(); |
217 assertEquals('stuff3', c); | 251 assertEquals('stuff3', c); |
218 (function() { | 252 (function() { |
219 // var variable shadowing catch variable | 253 // var variable shadowing catch variable |
220 var c = 3; | 254 var c = 3; |
221 })(); | 255 })(); |
222 assertEquals('stuff3', c); | 256 assertEquals('stuff3', c); |
223 c = 2; | 257 c = 2; |
224 } | 258 } |
225 assertEquals(1,c); | 259 assertEquals(1,c); |
226 (function(a,b,c,e) { | 260 (function(a,b,c,e,f) { |
227 // arguments shadowing argument, let, const and var variable | 261 // arguments shadowing argument, let, const, class and var variable |
228 a = 2; | 262 a = 2; |
229 b = 2; | 263 b = 2; |
230 c = 2; | 264 c = 2; |
231 e = 2; | 265 e = 2; |
| 266 f = 2; |
232 assertEquals(2,a); | 267 assertEquals(2,a); |
233 assertEquals(2,b); | 268 assertEquals(2,b); |
234 assertEquals(2,c); | 269 assertEquals(2,c); |
235 assertEquals(2,e); | 270 assertEquals(2,e); |
| 271 assertEquals(2,f); |
236 // var variable shadowing var variable | 272 // var variable shadowing var variable |
237 var d = 2; | 273 var d = 2; |
238 })(1,1); | 274 })(1,1); |
239 assertEquals(1,a); | 275 assertEquals(1,a); |
240 assertEquals(1,b); | 276 assertEquals(1,b); |
241 assertEquals(1,c); | 277 assertEquals(1,c); |
242 assertEquals(1,d); | 278 assertEquals(1,d); |
243 assertEquals(1,e); | 279 assertEquals(1,e); |
| 280 assertEquals(1,f.foo()); |
244 } | 281 } |
245 f7(1); | 282 f7(1); |
246 | 283 |
247 | 284 |
248 // Ensure let and const variables are block local | 285 // Ensure let and const variables are block local |
249 // and var variables function local. | 286 // and var variables function local. |
250 function f8() { | 287 function f8() { |
251 var let_accessors = []; | 288 var let_accessors = []; |
252 var var_accessors = []; | 289 var var_accessors = []; |
253 var const_accessors = []; | 290 var const_accessors = []; |
| 291 var class_accessors = []; |
254 for (var i = 0; i < 10; i++) { | 292 for (var i = 0; i < 10; i++) { |
255 let x = i; | 293 let x = i; |
256 var y = i; | 294 var y = i; |
257 const z = i; | 295 const z = i; |
| 296 class a { static foo() { return x; } } |
258 let_accessors[i] = function() { return x; } | 297 let_accessors[i] = function() { return x; } |
259 var_accessors[i] = function() { return y; } | 298 var_accessors[i] = function() { return y; } |
260 const_accessors[i] = function() { return z; } | 299 const_accessors[i] = function() { return z; } |
| 300 class_accessors[i] = function() { return a; } |
261 } | 301 } |
262 for (var j = 0; j < 10; j++) { | 302 for (var j = 0; j < 10; j++) { |
263 y = j + 10; | 303 y = j + 10; |
264 assertEquals(j, let_accessors[j]()); | 304 assertEquals(j, let_accessors[j]()); |
265 assertEquals(y, var_accessors[j]()); | 305 assertEquals(y, var_accessors[j]()); |
266 assertEquals(j, const_accessors[j]()); | 306 assertEquals(j, const_accessors[j]()); |
| 307 assertEquals(j, class_accessors[j]().foo()); |
267 } | 308 } |
268 } | 309 } |
269 f8(); | 310 f8(); |
OLD | NEW |