• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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# Templatated tests with eval/arguments/future reserved words.
29
30# ----------------------------------------------------------------------
31# Constants and utility functions
32
33reserved_words = [
34  'class',
35  'const', # Has other error message than other reserved words.
36  'enum',
37  'export',
38  'extends',
39  'import',
40  'super'
41  ]
42
43strict_reserved_words = [
44  'implements',
45  'interface',
46  'let',
47  'package',
48  'private',
49  'protected',
50  'public',
51  'static',
52  'yield'
53  ]
54
55assign_ops = {
56  "=": "assign",
57  "+=": "addeq",
58  "-=": "subeq",
59  "*=": "muleq",
60  "/=": "diveq",
61  "%=": "modeq",
62  "&=": "andeq",
63  "|=": "oreq",
64  "^=": "xoreq",
65  "<<=": "shleq",
66  ">>=": "asreq",
67  ">>>=": "lsreq"
68  }
69
70
71# A template that performs the same strict-mode test in different
72# scopes (global scope, function scope, and nested function scope).
73def StrictTemplate(name, source):
74  def MakeTests(replacement, expectation):
75    Template(name, '"use strict";\n' + source)(replacement, expectation)
76    Template(name + '-infunc',
77             'function foo() {\n "use strict";\n' + source +'\n}\n')(
78              replacement, expectation)
79    Template(name + '-infunc2',
80             'function foo() {\n "use strict";\n  function bar() {\n' +
81             source +'\n }\n}\n')(replacement, expectation)
82  return MakeTests
83
84# ----------------------------------------------------------------------
85# Test templates
86
87arg_name_own = Template("argument-name-own-$id", """
88  function foo($id) {
89    "use strict";
90  }
91""")
92
93arg_name_nested = Template("argument-name-nested-$id", """
94  function foo() {
95    "use strict";
96    function bar($id) { }
97  }
98""")
99
100func_name_own = Template("function-name-own-$id", """
101  function $id(foo) {
102    "use strict";
103  }
104""")
105
106func_name_nested = Template("function-name-nested-$id", """
107  function foo() {
108    "use strict";
109    function $id(bar) { }
110  }
111""")
112
113catch_var = StrictTemplate("catch-$id", """
114    try { } catch ($id) { }
115""")
116
117declare_var = StrictTemplate("var-$id", """
118  var $id = 42;
119""")
120
121assign_var = StrictTemplate("assign-$id-$opname", """
122  var x = $id $op 42;
123""")
124
125prefix_var = StrictTemplate("prefix-$opname-$id", """
126  var x = $op$id;
127""")
128
129postfix_var = StrictTemplate("postfix-$opname-$id", """
130  var x = $id$op;
131""")
132
133read_var = StrictTemplate("read-reserved-$id", """
134  var x = $id;
135""")
136
137setter_arg = StrictTemplate("setter-param-$id", """
138  var x = {set foo($id) { }};
139""")
140
141label_normal = Template("label-normal-$id", """
142  $id: '';
143""")
144
145label_strict = StrictTemplate("label-strict-$id", """
146  $id: '';
147""")
148
149break_normal = Template("break-normal-$id", """
150  $id: for (;false;) {
151    break $id;
152  }
153""")
154
155break_strict = StrictTemplate("break-strict-$id", """
156  $id: for (;false;) {
157    break $id;
158  }
159""")
160
161continue_normal = Template("continue-normal-$id", """
162  $id: for (;false;) {
163    continue $id;
164  }
165""")
166
167continue_strict = StrictTemplate("continue-strict-$id", """
168  $id: for (;false;) {
169    continue $id;
170  }
171""")
172
173non_strict_use = Template("nonstrict-$id", """
174  var $id = 42;
175  $id++;
176  $id--;
177  ++$id;
178  --$id;
179  $id += 10;
180  $id -= 10;
181  try {} catch ($id) { }
182  function $id($id) { }
183  var x = {$id: 42};
184  x = {get $id() {}, set $id(value) {}};
185  function foo() { "use strict;" }
186  var $id = 42;
187  $id++;
188  $id--;
189  ++$id;
190  --$id;
191  $id += 10;
192  $id -= 10;
193  try {} catch ($id) { }
194  function $id($id) { }
195  x = {$id: 42};
196  x = {get $id() {}, set $id(value) {}};
197  $id: '';
198""")
199
200identifier_name_source = """
201  var x = {$id: 42};
202  x = {get $id() {}, set $id(value) {}};
203  x.$id = 42;
204  function foo() { "use strict;" }
205  x = {$id: 42};
206  x = {get $id() {}, set $id(value) {}};
207  x.$id = 42;
208"""
209
210identifier_name = Template("identifier_name-$id", identifier_name_source)
211identifier_name_strict = StrictTemplate("identifier_name_strict-$id",
212                                        identifier_name_source)
213
214# ----------------------------------------------------------------------
215# Run tests
216
217# eval and arguments have specific exceptions for different uses.
218for id in ["eval", "arguments"]:
219  arg_name_own({"id": id}, "strict_param_name")
220  arg_name_nested({"id": id}, "strict_param_name")
221  func_name_own({"id": id}, "strict_function_name")
222  func_name_nested({"id": id}, "strict_function_name")
223  setter_arg({"id": id}, "strict_param_name")
224  for op in assign_ops.keys():
225    assign_var({"id": id, "op":op, "opname": assign_ops[op]},
226               "strict_lhs_assignment")
227  catch_var({"id": id}, "strict_catch_variable")
228  declare_var({"id": id}, "strict_var_name")
229  prefix_var({"id": id, "op":"++", "opname":"inc"}, "strict_lhs_prefix")
230  prefix_var({"id": id, "op":"--", "opname":"dec"}, "strict_lhs_prefix")
231  postfix_var({"id": id, "op":"++", "opname":"inc"}, "strict_lhs_postfix")
232  postfix_var({"id": id, "op":"--", "opname":"dec"}, "strict_lhs_postfix")
233  label_normal({"id": id}, None)
234  label_strict({"id": id}, None)
235  break_normal({"id": id}, None)
236  break_strict({"id": id}, None)
237  continue_normal({"id": id}, None)
238  continue_strict({"id": id}, None)
239  non_strict_use({"id": id}, None)
240
241
242# Reserved words just throw the same exception in all cases
243# (with "const" being special, as usual).
244for reserved_word in reserved_words + strict_reserved_words:
245  if (reserved_word in strict_reserved_words):
246    message = "strict_reserved_word"
247    label_message = None
248  elif (reserved_word == "const"):
249    message = "unexpected_token"
250    label_message = message
251  else:
252    message = "reserved_word"
253    label_message = message
254  arg_name_own({"id":reserved_word}, message)
255  arg_name_nested({"id":reserved_word}, message)
256  setter_arg({"id": reserved_word}, message)
257  func_name_own({"id":reserved_word}, message)
258  func_name_nested({"id":reserved_word}, message)
259  for op in assign_ops.keys():
260    assign_var({"id":reserved_word, "op":op, "opname": assign_ops[op]}, message)
261  catch_var({"id":reserved_word}, message)
262  declare_var({"id":reserved_word}, message)
263  prefix_var({"id":reserved_word, "op":"++", "opname":"inc"}, message)
264  prefix_var({"id":reserved_word, "op":"--", "opname":"dec"}, message)
265  postfix_var({"id":reserved_word, "op":"++", "opname":"inc"}, message)
266  postfix_var({"id":reserved_word, "op":"--", "opname":"dec"}, message)
267  read_var({"id": reserved_word}, message)
268  identifier_name({"id": reserved_word}, None);
269  identifier_name_strict({"id": reserved_word}, None);
270  label_normal({"id": reserved_word}, label_message)
271  break_normal({"id": reserved_word}, label_message)
272  continue_normal({"id": reserved_word}, label_message)
273  if (reserved_word == "const"):
274    # The error message for this case is different because
275    # ParseLabelledStatementOrExpression will try to parse this as an expression
276    # first, effectively disallowing the use in ParseVariableDeclarations, i.e.
277    # the preparser never sees that 'const' was intended to be a label.
278    label_strict({"id": reserved_word}, "strict_const")
279  else:
280    label_strict({"id": reserved_word}, message)
281  break_strict({"id": reserved_word}, message)
282  continue_strict({"id": reserved_word}, message)
283
284
285# Future reserved words in strict mode behave like normal identifiers
286# in a non strict context.
287for reserved_word in strict_reserved_words:
288  non_strict_use({"id": reserved_word}, None)
289