Preparse lazy function 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 269 matching lines @@
   i::FLAG_min_preparse_length = 0;
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handles(isolate);
   v8::Local<v8::Context> context = v8::Context::New(isolate);
   v8::Context::Scope context_scope(context);
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
   const char* good_code[] = {
-      "function this_is_lazy() { var a; } function foo() { return 25; } foo();",
-      "var this_is_lazy = () => { var a; }; var foo = () => 25; foo();",
+      "function z() { var a; } function f() { return 25; } f();",
+      "var z = function () { var a; }; function f() { return 25; } f();",
+      "function *z() { var a; } function f() { return 25; } f();",
+      "var z = function *() { var a; }; function f() { return 25; } f();",
+      "function z(p1, p2) { var a; } function f() { return 25; } f();",
+      "var z = function (p1, p2) { var a; }; function f() { return 25; } f();",
+      "function *z(p1, p2) { var a; } function f() { return 25; } f();",
+      "var z = function *(p1, p2) { var a; }; function f() { return 25; } f();",
+      "var z = () => { var a; }; function f() { return 25; } f();",
+      "var z = (p1, p2) => { var a; }; function f() { return 25; } f();",
   };
 
   // Insert a syntax error inside the lazy function.
   const char* bad_code[] = {
-      "function this_is_lazy() { if (   } function foo() { return 25; } foo();",
-      "var this_is_lazy = () => { if (   }; var foo = () => 25; foo();",
+      "function z() { if (   } function f() { return 25; } f();",
+      "var z = function () { if (   }; function f() { return 25; } f();",
+      "function *z() { if (   } function f() { return 25; } f();",
+      "var z = function *() { if (   }; function f() { return 25; } f();",
+      "function z(p1, p2) { if (   } function f() { return 25; } f();",
+      "var z = function (p1, p2) { if (   }; function f() { return 25; } f();",
+      "function *z(p1, p2) { if (   } function f() { return 25; } f();",
+      "var z = function *(p1, p2) { if (   }; function f() { return 25; } f();",
+      "var z = () => { if (   }; function f() { return 25; } f();",
+      "var z = (p1, p2) => { if (   }; function f() { return 25; } f();",
   };
 
   for (unsigned i = 0; i < arraysize(good_code); i++) {
     v8::ScriptCompiler::Source good_source(v8_str(good_code[i]));
     v8::ScriptCompiler::Compile(isolate->GetCurrentContext(), &good_source,
                                 v8::ScriptCompiler::kProduceParserCache)
         .ToLocalChecked();
 
     const v8::ScriptCompiler::CachedData* cached_data =
         good_source.GetCachedData();
@@ skipping 173 matching lines @@
       .ToLocalChecked();
 
   const v8::ScriptCompiler::CachedData* cached_data =
       script_source.GetCachedData();
   i::ScriptData script_data(cached_data->data, cached_data->length);
   std::unique_ptr<i::ParseData> pd(i::ParseData::FromCachedData(&script_data));
   pd->Initialize();
 
   int first_function =
       static_cast<int>(strstr(program, "function") - program);
-  int first_lbrace = first_function + i::StrLength("function () ");
-  CHECK_EQ('{', program[first_lbrace]);
-  i::FunctionEntry entry1 = pd->GetFunctionEntry(first_lbrace);
+  int first_lparen = first_function + i::StrLength("function ");
+  CHECK_EQ('(', program[first_lparen]);
+  i::FunctionEntry entry1 = pd->GetFunctionEntry(first_lparen);
   CHECK(!entry1.is_valid());
 
   int second_function =
-      static_cast<int>(strstr(program + first_lbrace, "function") - program);
-  int second_lbrace =
-      second_function + i::StrLength("function () ");
-  CHECK_EQ('{', program[second_lbrace]);
-  i::FunctionEntry entry2 = pd->GetFunctionEntry(second_lbrace);
+      static_cast<int>(strstr(program + first_lparen, "function") - program);
+  int second_lparen = second_function + i::StrLength("function ");
+  CHECK_EQ('(', program[second_lparen]);
+  i::FunctionEntry entry2 = pd->GetFunctionEntry(second_lparen);
   CHECK(entry2.is_valid());
   CHECK_EQ('}', program[entry2.end_pos() - 1]);
 }
 
 
 TEST(PreParseOverflow) {
   v8::V8::Initialize();
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
@@ skipping 7813 matching lines @@
     const char* data[] = {
       "const arguments = 1",
       "let arguments",
       "var arguments",
       NULL
     };
     // clang-format on
     RunParserSyncTest(context_data, data, kSuccess);
   }
 }