| # Copyright 2011 the V8 project authors. All rights reserved. | |
| # Redistribution and use in source and binary forms, with or without | |
| # modification, are permitted provided that the following conditions are | |
| # met: | |
| # | |
| # * Redistributions of source code must retain the above copyright | |
| # notice, this list of conditions and the following disclaimer. | |
| # * Redistributions in binary form must reproduce the above | |
| # copyright notice, this list of conditions and the following | |
| # disclaimer in the documentation and/or other materials provided | |
| # with the distribution. | |
| # * Neither the name of Google Inc. nor the names of its | |
| # contributors may be used to endorse or promote products derived | |
| # from this software without specific prior written permission. | |
| # | |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| # Templatated tests with eval/arguments/future reserved words. | |
| # ---------------------------------------------------------------------- | |
| # Constants and utility functions | |
| reserved_words = [ | |
| 'class', | |
| 'const', # Has other error message than other reserved words. | |
| 'enum', | |
| 'export', | |
| 'extends', | |
| 'import', | |
| 'super' | |
| ] | |
| strict_reserved_words = [ | |
| 'implements', | |
| 'interface', | |
| 'let', | |
| 'package', | |
| 'private', | |
| 'protected', | |
| 'public', | |
| 'static', | |
| 'yield' | |
| ] | |
| assign_ops = { | |
| "=": "assign", | |
| "+=": "addeq", | |
| "-=": "subeq", | |
| "*=": "muleq", | |
| "/=": "diveq", | |
| "%=": "modeq", | |
| "&=": "andeq", | |
| "|=": "oreq", | |
| "^=": "xoreq", | |
| "<<=": "shleq", | |
| ">>=": "asreq", | |
| ">>>=": "lsreq" | |
| } | |
| # A template that performs the same strict-mode test in different | |
| # scopes (global scope, function scope, and nested function scope). | |
| def StrictTemplate(name, source): | |
| def MakeTests(replacement, expectation): | |
| Template(name, '"use strict";\n' + source)(replacement, expectation) | |
| Template(name + '-infunc', | |
| 'function foo() {\n "use strict";\n' + source +'\n}\n')( | |
| replacement, expectation) | |
| Template(name + '-infunc2', | |
| 'function foo() {\n "use strict";\n function bar() {\n' + | |
| source +'\n }\n}\n')(replacement, expectation) | |
| return MakeTests | |
| # ---------------------------------------------------------------------- | |
| # Test templates | |
| arg_name_own = Template("argument-name-own-$id", """ | |
| function foo($id) { | |
| "use strict"; | |
| } | |
| """) | |
| arg_name_nested = Template("argument-name-nested-$id", """ | |
| function foo() { | |
| "use strict"; | |
| function bar($id) { } | |
| } | |
| """) | |
| func_name_own = Template("function-name-own-$id", """ | |
| function $id(foo) { | |
| "use strict"; | |
| } | |
| """) | |
| func_name_nested = Template("function-name-nested-$id", """ | |
| function foo() { | |
| "use strict"; | |
| function $id(bar) { } | |
| } | |
| """) | |
| catch_var = StrictTemplate("catch-$id", """ | |
| try { } catch ($id) { } | |
| """) | |
| declare_var = StrictTemplate("var-$id", """ | |
| var $id = 42; | |
| """) | |
| assign_var = StrictTemplate("assign-$id-$opname", """ | |
| var x = $id $op 42; | |
| """) | |
| prefix_var = StrictTemplate("prefix-$opname-$id", """ | |
| var x = $op$id; | |
| """) | |
| postfix_var = StrictTemplate("postfix-$opname-$id", """ | |
| var x = $id$op; | |
| """) | |
| read_var = StrictTemplate("read-reserved-$id", """ | |
| var x = $id; | |
| """) | |
| setter_arg = StrictTemplate("setter-param-$id", """ | |
| var x = {set foo($id) { }}; | |
| """) | |
| label_normal = Template("label-normal-$id", """ | |
| $id: ''; | |
| """) | |
| label_strict = StrictTemplate("label-strict-$id", """ | |
| $id: ''; | |
| """) | |
| break_normal = Template("break-normal-$id", """ | |
| $id: for (;false;) { | |
| break $id; | |
| } | |
| """) | |
| break_strict = StrictTemplate("break-strict-$id", """ | |
| $id: for (;false;) { | |
| break $id; | |
| } | |
| """) | |
| continue_normal = Template("continue-normal-$id", """ | |
| $id: for (;false;) { | |
| continue $id; | |
| } | |
| """) | |
| continue_strict = StrictTemplate("continue-strict-$id", """ | |
| $id: for (;false;) { | |
| continue $id; | |
| } | |
| """) | |
| non_strict_use = Template("nonstrict-$id", """ | |
| var $id = 42; | |
| $id++; | |
| $id--; | |
| ++$id; | |
| --$id; | |
| $id += 10; | |
| $id -= 10; | |
| try {} catch ($id) { } | |
| function $id($id) { } | |
| var x = {$id: 42}; | |
| x = {get $id() {}, set $id(value) {}}; | |
| function foo() { "use strict;" } | |
| var $id = 42; | |
| $id++; | |
| $id--; | |
| ++$id; | |
| --$id; | |
| $id += 10; | |
| $id -= 10; | |
| try {} catch ($id) { } | |
| function $id($id) { } | |
| x = {$id: 42}; | |
| x = {get $id() {}, set $id(value) {}}; | |
| $id: ''; | |
| """) | |
| identifier_name_source = """ | |
| var x = {$id: 42}; | |
| x = {get $id() {}, set $id(value) {}}; | |
| x.$id = 42; | |
| function foo() { "use strict;" } | |
| x = {$id: 42}; | |
| x = {get $id() {}, set $id(value) {}}; | |
| x.$id = 42; | |
| """ | |
| identifier_name = Template("identifier_name-$id", identifier_name_source) | |
| identifier_name_strict = StrictTemplate("identifier_name_strict-$id", | |
| identifier_name_source) | |
| # ---------------------------------------------------------------------- | |
| # Run tests | |
| # eval and arguments have specific exceptions for different uses. | |
| for id in ["eval", "arguments"]: | |
| arg_name_own({"id": id}, "strict_param_name") | |
| arg_name_nested({"id": id}, "strict_param_name") | |
| func_name_own({"id": id}, "strict_function_name") | |
| func_name_nested({"id": id}, "strict_function_name") | |
| setter_arg({"id": id}, "strict_param_name") | |
| for op in assign_ops.keys(): | |
| assign_var({"id": id, "op":op, "opname": assign_ops[op]}, | |
| "strict_lhs_assignment") | |
| catch_var({"id": id}, "strict_catch_variable") | |
| declare_var({"id": id}, "strict_var_name") | |
| prefix_var({"id": id, "op":"++", "opname":"inc"}, "strict_lhs_prefix") | |
| prefix_var({"id": id, "op":"--", "opname":"dec"}, "strict_lhs_prefix") | |
| postfix_var({"id": id, "op":"++", "opname":"inc"}, "strict_lhs_postfix") | |
| postfix_var({"id": id, "op":"--", "opname":"dec"}, "strict_lhs_postfix") | |
| label_normal({"id": id}, None) | |
| label_strict({"id": id}, None) | |
| break_normal({"id": id}, None) | |
| break_strict({"id": id}, None) | |
| continue_normal({"id": id}, None) | |
| continue_strict({"id": id}, None) | |
| non_strict_use({"id": id}, None) | |
| # Reserved words just throw the same exception in all cases | |
| # (with "const" being special, as usual). | |
| for reserved_word in reserved_words + strict_reserved_words: | |
| if (reserved_word in strict_reserved_words): | |
| message = "strict_reserved_word" | |
| label_message = None | |
| elif (reserved_word == "const"): | |
| message = "unexpected_token" | |
| label_message = message | |
| else: | |
| message = "reserved_word" | |
| label_message = message | |
| arg_name_own({"id":reserved_word}, message) | |
| arg_name_nested({"id":reserved_word}, message) | |
| setter_arg({"id": reserved_word}, message) | |
| func_name_own({"id":reserved_word}, message) | |
| func_name_nested({"id":reserved_word}, message) | |
| for op in assign_ops.keys(): | |
| assign_var({"id":reserved_word, "op":op, "opname": assign_ops[op]}, message) | |
| catch_var({"id":reserved_word}, message) | |
| declare_var({"id":reserved_word}, message) | |
| prefix_var({"id":reserved_word, "op":"++", "opname":"inc"}, message) | |
| prefix_var({"id":reserved_word, "op":"--", "opname":"dec"}, message) | |
| postfix_var({"id":reserved_word, "op":"++", "opname":"inc"}, message) | |
| postfix_var({"id":reserved_word, "op":"--", "opname":"dec"}, message) | |
| read_var({"id": reserved_word}, message) | |
| identifier_name({"id": reserved_word}, None); | |
| identifier_name_strict({"id": reserved_word}, None); | |
| label_normal({"id": reserved_word}, label_message) | |
| break_normal({"id": reserved_word}, label_message) | |
| continue_normal({"id": reserved_word}, label_message) | |
| if (reserved_word == "const"): | |
| # The error message for this case is different because | |
| # ParseLabelledStatementOrExpression will try to parse this as an expression | |
| # first, effectively disallowing the use in ParseVariableDeclarations, i.e. | |
| # the preparser never sees that 'const' was intended to be a label. | |
| label_strict({"id": reserved_word}, "strict_const") | |
| else: | |
| label_strict({"id": reserved_word}, message) | |
| break_strict({"id": reserved_word}, message) | |
| continue_strict({"id": reserved_word}, message) | |
| # Future reserved words in strict mode behave like normal identifiers | |
| # in a non strict context. | |
| for reserved_word in strict_reserved_words: | |
| non_strict_use({"id": reserved_word}, None) |