[test] Add more maybe-assigned tests for parameters.

test/cctest/test-parsing.cc

 // Copyright 2012 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
@@ skipping 3421 matching lines @@
   }
 }
 
 TEST(MaybeAssignedParameters) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::HandleScope scope(isolate);
   LocalContext env;
 
   struct {
     bool arg_assigned;
+    bool imprecise_when_lazy;
     const char* source;
   } tests[] = {
-      {false, "function f(arg) {}"},
-      {false, "function f(arg) {g(arg)}"},
-      {false, "function f(arg) {function h() { g(arg) }; h()}"},
-      {false, "function f(arg) {function h() { g(arg) }; return h}"},
-      {false, "function f(arg=1) {}"},
-      {false, "function f(arg=1) {g(arg)}"},
-      {false, "function f(arg, arguments) {g(arg); arguments[0] = 42; g(arg)}"},
-      {false,
+      {false, false, "function f(arg) {}"},
+      {false, false, "function f(arg) {g(arg)}"},
+      {false, false, "function f(arg) {function h() { g(arg) }; h()}"},
+      {false, false, "function f(arg) {function h() { g(arg) }; return h}"},
+      {false, false, "function f(arg=1) {}"},
+      {false, false, "function f(arg=1) {g(arg)}"},
+      {false, false,
+       "function f(arg, arguments) {g(arg); arguments[0] = 42; g(arg)}"},
+      {false, false,
        "function f(arg, ...arguments) {g(arg); arguments[0] = 42; g(arg)}"},
-      {false,
+      {false, false,
        "function f(arg, arguments=[]) {g(arg); arguments[0] = 42; g(arg)}"},
-      {false, "function f(...arg) {g(arg); arguments[0] = 42; g(arg)}"},
+      {false, false, "function f(...arg) {g(arg); arguments[0] = 42; g(arg)}"},
+      {false, true,
+       "function f(arg) {g(arg); g(function() {arguments[0] = 42}); g(arg)}"},

[neis, 2016/12/16 10:12:54]

This test is the reason for adding the imprecise_when_lazy flag.

 
       // strict arguments object
-      {false, "function f(arg, x=1) {g(arg); arguments[0] = 42; g(arg)}"},
-      {false, "function f(arg, ...x) {g(arg); arguments[0] = 42; g(arg)}"},
-      {false, "function f(arg=1) {g(arg); arguments[0] = 42; g(arg)}"},
-      {false,
+      {false, false,
+       "function f(arg, x=1) {g(arg); arguments[0] = 42; g(arg)}"},
+      {false, false,
+       "function f(arg, ...x) {g(arg); arguments[0] = 42; g(arg)}"},
+      {false, false, "function f(arg=1) {g(arg); arguments[0] = 42; g(arg)}"},
+      {false, false,
        "function f(arg) {'use strict'; g(arg); arguments[0] = 42; g(arg)}"},
-      {false, "function f(arg) {g(arg); f.arguments[0] = 42; g(arg)}"},
-      {false, "function f(arg, args=arguments) {g(arg); args[0] = 42; g(arg)}"},
+      {false, false, "function f(arg) {g(arg); f.arguments[0] = 42; g(arg)}"},
+      {false, false,
+       "function f(arg, args=arguments) {g(arg); args[0] = 42; g(arg)}"},
 
-      {true, "function f(arg) {g(arg); arg = 42; g(arg)}"},
-      {true, "function f(arg) {g(arg); eval('arg = 42'); g(arg)}"},
-      {true, "function f(arg) {g(arg); var arg = 42; g(arg)}"},
-      {true, "function f(arg, x=1) {g(arg); arg = 42; g(arg)}"},
-      {true, "function f(arg, ...x) {g(arg); arg = 42; g(arg)}"},
-      {true, "function f(arg=1) {g(arg); arg = 42; g(arg)}"},
-      {true, "function f(arg) {'use strict'; g(arg); arg = 42; g(arg)}"},
-      {true, "function f(arg, {a=(g(arg), arg=42)}) {g(arg)}"},
-      {true, "function f(arg) {g(arg); g(() => arg = 42); g(arg)}"},
-      {true, "function f(arg) {g(arg); g(() => eval('arg = 42')); g(arg)}"},
-      {true, "function f(arg) {g(arg); g(() => arguments[0] = 42); g(arg)}"},
-      {true, "function f(...arg) {g(arg); eval('arg = 42'); g(arg)}"},
+      {true, false, "function f(arg) {g(arg); arg = 42; g(arg)}"},
+      {true, false, "function f(arg) {g(arg); eval('arg = 42'); g(arg)}"},
+      {true, false, "function f(arg) {g(arg); var arg = 42; g(arg)}"},
+      {true, false, "function f(arg, x=1) {g(arg); arg = 42; g(arg)}"},
+      {true, false, "function f(arg, ...x) {g(arg); arg = 42; g(arg)}"},
+      {true, false, "function f(arg=1) {g(arg); arg = 42; g(arg)}"},
+      {true, false, "function f(arg) {'use strict'; g(arg); arg = 42; g(arg)}"},
+      {true, false, "function f(arg, {a=(g(arg), arg=42)}) {g(arg)}"},
+      {true, false,
+       "function f(arg) {g(arg); g(function() {arg = 42}); g(arg)}"},
+      {true, false,
+       "function f(arg) {g(arg); g(function() {eval('arg = 42')}); g(arg)}"},
+      {true, false, "function f(arg) {g(arg); g(() => arg = 42); g(arg)}"},
+      {true, false,
+       "function f(arg) {g(arg); g(() => eval('arg = 42')); g(arg)}"},
+      {true, false, "function f(...arg) {g(arg); eval('arg = 42'); g(arg)}"},
 
       // sloppy arguments object
-      {true, "function f(arg) {g(arg); arguments[0] = 42; g(arg)}"},
-      {true, "function f(arg) {g(arg); h(arguments); g(arg)}"},
-      {true,
+      {true, false, "function f(arg) {g(arg); arguments[0] = 42; g(arg)}"},
+      {true, false, "function f(arg) {g(arg); h(arguments); g(arg)}"},
+      {true, false,
        "function f(arg) {((args) => {arguments[0] = 42})(arguments); "
        "g(arg)}"},
-      {true, "function f(arg) {g(arg); eval('arguments[0] = 42'); g(arg)}"},
+      {true, false,
+       "function f(arg) {g(arg); eval('arguments[0] = 42'); g(arg)}"},
+      {true, false,
+       "function f(arg) {g(arg); g(() => arguments[0] = 42); g(arg)}"},
   };
 
   const char* suffix = "; f";
 
   for (unsigned i = 0; i < arraysize(tests); ++i) {
     bool assigned = tests[i].arg_assigned;
     const char* source = tests[i].source;
     for (unsigned allow_lazy = 0; allow_lazy < 2; ++allow_lazy) {
       i::ScopedVector<char> program(Utf8LengthHelper(source) +
                                     Utf8LengthHelper(suffix) + 1);
@@ skipping 13 matching lines @@
 
       i::Scope* scope = info->literal()->scope();
       CHECK(!scope->AsDeclarationScope()->was_lazily_parsed());
       CHECK_NULL(scope->sibling());
       CHECK(scope->is_function_scope());
       const i::AstRawString* var_name =
           info->ast_value_factory()->GetOneByteString("arg");
       i::Variable* var = scope->Lookup(var_name);
       CHECK(var->is_used() || !assigned);
       bool is_maybe_assigned = var->maybe_assigned() == i::kMaybeAssigned;
-      CHECK_EQ(is_maybe_assigned, assigned);
+      if (allow_lazy && tests[i].imprecise_when_lazy) {
+        CHECK_IMPLIES(assigned, is_maybe_assigned);
+      } else {
+        CHECK_EQ(assigned, is_maybe_assigned);
+      }
     }
   }
 }
 
 namespace {
 
 i::Scope* DeserializeFunctionScope(i::Isolate* isolate, i::Zone* zone,
                                    i::Handle<i::JSObject> m, const char* name) {
   i::AstValueFactory avf(zone, isolate->heap()->HashSeed());
   i::Handle<i::JSFunction> f = i::Handle<i::JSFunction>::cast(
@@ skipping 5165 matching lines @@
     DCHECK_NOT_NULL(scope);
     DCHECK_NULL(scope->sibling());
     DCHECK(scope->is_function_scope());
     const i::AstRawString* var_name =
         info.ast_value_factory()->GetOneByteString("my_var");
     i::Variable* var = scope->Lookup(var_name);
     CHECK_EQ(inners[i].ctxt_allocate,
              i::ScopeTestHelper::MustAllocateInContext(var));
   }
 }