Support lazy parsing of inner functions

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 139 matching lines @@
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; tests[i]; i++) {
     const i::byte* source =
         reinterpret_cast<const i::byte*>(tests[i]);
     i::Utf8ToUtf16CharacterStream stream(source, i::StrLength(tests[i]));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::Zone zone(CcTest::i_isolate());
+    i::AstValueFactory ast_value_factory(
+        &zone, CcTest::i_isolate()->heap()->HashSeed());
+    ast_value_factory.Internalize(CcTest::i_isolate());
+    i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                           stack_limit);
     preparser.set_allow_lazy(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     CHECK(!log.HasError());
   }
 
   for (int i = 0; fail_tests[i]; i++) {
     const i::byte* source =
         reinterpret_cast<const i::byte*>(fail_tests[i]);
     i::Utf8ToUtf16CharacterStream stream(source, i::StrLength(fail_tests[i]));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::Zone zone(CcTest::i_isolate());
+    i::AstValueFactory ast_value_factory(
+        &zone, CcTest::i_isolate()->heap()->HashSeed());
+    ast_value_factory.Internalize(CcTest::i_isolate());
+    i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                           stack_limit);
     preparser.set_allow_lazy(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     // Even in the case of a syntax error, kPreParseSuccess is returned.
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     CHECK(log.HasError());
   }
 }
 
 
 class ScriptResource : public v8::String::ExternalOneByteStringResource {
@@ skipping 101 matching lines @@
     v8::Local<v8::Value> result =
         v8::ScriptCompiler::Compile(isolate, &bad_source)->Run();
     CHECK(result->IsInt32());
     CHECK_EQ(25, result->Int32Value());
   }
 }
 
 
 TEST(StandAlonePreParser) {
   v8::V8::Initialize();
+  v8::HandleScope handles(CcTest::isolate());
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
   const char* programs[] = {
       "{label: 42}",
       "var x = 42;",
       "function foo(x, y) { return x + y; }",
       "%ArgleBargle(glop);",
       "var x = new new Function('this.x = 42');",
       "var f = (x, y) => x + y;",
       NULL
   };
 
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; programs[i]; i++) {
     const char* program = programs[i];
     i::Utf8ToUtf16CharacterStream stream(
         reinterpret_cast<const i::byte*>(program),
         static_cast<unsigned>(strlen(program)));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::Zone zone(CcTest::i_isolate());
+    i::AstValueFactory ast_value_factory(
+        &zone, CcTest::i_isolate()->heap()->HashSeed());
+    ast_value_factory.Internalize(CcTest::i_isolate());
+    i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                           stack_limit);
     preparser.set_allow_lazy(true);
     preparser.set_allow_natives_syntax(true);
     preparser.set_allow_arrow_functions(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     CHECK(!log.HasError());
   }
 }
 
 
 TEST(StandAlonePreParserNoNatives) {
   v8::V8::Initialize();
+  v8::HandleScope handles(CcTest::isolate());
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
   const char* programs[] = {
       "%ArgleBargle(glop);",
       "var x = %_IsSmi(42);",
       NULL
   };
 
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; programs[i]; i++) {
     const char* program = programs[i];
     i::Utf8ToUtf16CharacterStream stream(
         reinterpret_cast<const i::byte*>(program),
         static_cast<unsigned>(strlen(program)));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
     // Preparser defaults to disallowing natives syntax.
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::Zone zone(CcTest::i_isolate());
+    i::AstValueFactory ast_value_factory(
+        &zone, CcTest::i_isolate()->heap()->HashSeed());
+    ast_value_factory.Internalize(CcTest::i_isolate());
+    i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                           stack_limit);
     preparser.set_allow_lazy(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     CHECK(log.HasError());
   }
 }
 
 
 TEST(PreparsingObjectLiterals) {
   // Regression test for a bug where the symbol stream produced by PreParser
@@ skipping 26 matching lines @@
     v8::Local<v8::Value> result = ParserCacheCompileRun(source);
     CHECK(result->IsString());
     v8::String::Utf8Value utf8(result);
     CHECK_EQ("foo", *utf8);
   }
 }
 
 
 TEST(RegressChromium62639) {
   v8::V8::Initialize();
+  v8::HandleScope handles(CcTest::isolate());
   i::Isolate* isolate = CcTest::i_isolate();
 
   isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
                                         128 * 1024);
 
   const char* program = "var x = 'something';\n"
                         "escape: function() {}";
   // Fails parsing expecting an identifier after "function".
   // Before fix, didn't check *ok after Expect(Token::Identifier, ok),
   // and then used the invalid currently scanned literal. This always
   // failed in debug mode, and sometimes crashed in release mode.
 
   i::Utf8ToUtf16CharacterStream stream(
       reinterpret_cast<const i::byte*>(program),
       static_cast<unsigned>(strlen(program)));
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
-  i::PreParser preparser(&scanner, &log,
+  i::Zone zone(CcTest::i_isolate());
+  i::AstValueFactory ast_value_factory(&zone,
+                                       CcTest::i_isolate()->heap()->HashSeed());
+  ast_value_factory.Internalize(CcTest::i_isolate());
+  i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
                          CcTest::i_isolate()->stack_guard()->real_climit());
   preparser.set_allow_lazy(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   // Even in the case of a syntax error, kPreParseSuccess is returned.
   CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   CHECK(log.HasError());
 }
 
 
 TEST(Regress928) {
@@ skipping 11 matching lines @@
   const char* program =
       "try { } catch (e) { var foo = function () { /* first */ } }"
       "var bar = function () { /* second */ }";
 
   v8::HandleScope handles(CcTest::isolate());
   i::Handle<i::String> source = factory->NewStringFromAsciiChecked(program);
   i::GenericStringUtf16CharacterStream stream(source, 0, source->length());
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
-  i::PreParser preparser(&scanner, &log,
+  i::Zone zone(CcTest::i_isolate());
+  i::AstValueFactory ast_value_factory(&zone,
+                                       CcTest::i_isolate()->heap()->HashSeed());
+  ast_value_factory.Internalize(CcTest::i_isolate());
+  i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
                          CcTest::i_isolate()->stack_guard()->real_climit());
   preparser.set_allow_lazy(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   i::ScriptData* sd = log.GetScriptData();
   i::ParseData pd(sd);
   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);
   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);
   CHECK(entry2.is_valid());
   CHECK_EQ('}', program[entry2.end_pos() - 1]);
   delete sd;
 }
 
 
 TEST(PreParseOverflow) {
   v8::V8::Initialize();
+  v8::HandleScope handles(CcTest::isolate());
 
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       i::GetCurrentStackPosition() - 128 * 1024);
 
   size_t kProgramSize = 1024 * 1024;
   i::SmartArrayPointer<char> program(i::NewArray<char>(kProgramSize + 1));
   memset(program.get(), '(', kProgramSize);
   program[kProgramSize] = '\0';
 
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
 
   i::Utf8ToUtf16CharacterStream stream(
       reinterpret_cast<const i::byte*>(program.get()),
       static_cast<unsigned>(kProgramSize));
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
 
-  i::PreParser preparser(&scanner, &log, stack_limit);
+  i::Zone zone(CcTest::i_isolate());
+  i::AstValueFactory ast_value_factory(&zone,
+                                       CcTest::i_isolate()->heap()->HashSeed());
+  ast_value_factory.Internalize(CcTest::i_isolate());
+  i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                         stack_limit);
   preparser.set_allow_lazy(true);
   preparser.set_allow_arrow_functions(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   CHECK_EQ(i::PreParser::kPreParseStackOverflow, result);
 }
 
 
 class TestExternalResource: public v8::String::ExternalStringResource {
  public:
   explicit TestExternalResource(uint16_t* data, int length)
@@ skipping 856 matching lines @@
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
   uintptr_t stack_limit = isolate->stack_guard()->real_climit();
 
   // Preparse the data.
   i::CompleteParserRecorder log;
   {
     i::Scanner scanner(isolate->unicode_cache());
     i::GenericStringUtf16CharacterStream stream(source, 0, source->length());
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::Zone zone(CcTest::i_isolate());
+    i::AstValueFactory ast_value_factory(
+        &zone, CcTest::i_isolate()->heap()->HashSeed());
+    v8::HandleScope handles(CcTest::isolate());
+    ast_value_factory.Internalize(CcTest::i_isolate());
+    i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                           stack_limit);
     SetParserFlags(&preparser, flags);
     scanner.Initialize(&stream);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   }
 
   bool preparse_error = log.HasError();
 
   // Parse the data
   i::FunctionLiteral* function;
@@ skipping 995 matching lines @@
     // No functions.
     {"var x = 42;", 0},
     // Functions.
     {"function foo() {}", 1}, {"function foo() {} function bar() {}", 2},
     // Getter / setter functions are recorded as functions if they're on the top
     // level.
     {"var x = {get foo(){} };", 1},
     // Functions insize lazy functions are not recorded.
     {"function lazy() { function a() {} function b() {} function c() {} }", 1},
     {"function lazy() { var x = {get foo(){} } }", 1},
+    // Functions inside eager functions are recorded.
+    {"(function() { function lazy() {} })()", 1},
+    {"(function() { var lazy = function() {} })()", 1},
     {NULL, 0}
   };
 
   for (int i = 0; test_cases[i].program; i++) {
     const char* program = test_cases[i].program;
     i::Factory* factory = CcTest::i_isolate()->factory();
     i::Handle<i::String> source =
         factory->NewStringFromUtf8(i::CStrVector(program)).ToHandleChecked();
     i::Handle<i::Script> script = factory->NewScript(source);
     i::CompilationInfoWithZone info(script);
     i::ScriptData* sd = NULL;
     info.SetCachedData(&sd, v8::ScriptCompiler::kProduceParserCache);
     i::Parser::Parse(&info, true);
     i::ParseData pd(sd);
 
     if (pd.FunctionCount() != test_cases[i].functions) {
       v8::base::OS::Print(
           "Expected preparse data for program:\n"
           "\t%s\n"
           "to contain %d functions, however, received %d functions.\n",
           program, test_cases[i].functions, pd.FunctionCount());
       CHECK(false);
     }
     delete sd;
   }
 }
 
 
+TEST(PreParserReportsUnboundIdentifiers) {
+  v8::V8::Initialize();
+  v8::Isolate* isolate = CcTest::isolate();
+  i::Factory* factory = CcTest::i_isolate()->factory();
+  v8::HandleScope handles(isolate);
+
+  CcTest::i_isolate()->stack_guard()->SetStackLimit(
+      i::GetCurrentStackPosition() - 128 * 1024);
+
+  struct TestCase {
+    const char* function;
+    i::StrictMode strict_mode;
+    const char* identifier;
+  } test_cases[] = {
+    {"{ a = 0; }", i::SLOPPY, "a"},
+    {"{ var a = 0; }", i::SLOPPY, NULL},
+    {"{ a(); }", i::SLOPPY, "a"},
+    {"{ function a(){} a(); }", i::SLOPPY, NULL},
+    {"{ function a(){ b = 0; } }", i::SLOPPY, "b"},
+    {"{ function a(b){ b = 0; } }", i::SLOPPY, NULL},
+    {"{ try { a = 0; } catch (e) {} }", i::SLOPPY, "a"},
+    {"{ a = 0; try { var a = 1; } catch (e) { a = e; } }", i::SLOPPY, NULL},
+    {"{ var a = {}; with (a) { b = 0; } }", i::SLOPPY, "b"},
+    {"{ var a = {}; with (a) { var b = 0; } b = 1; }", i::SLOPPY, NULL},
+    {"{ for (var i = 0; i < 2; i++) { a = i; } }", i::STRICT, "a"},
+    {"{ for (let i = 0; i < 2; i++) { a = i; } }", i::STRICT, "a"},
+    {"{ for (let i = 0; i < 2; i++) {} i++; }", i::STRICT, "i"},
+    {"{ for (let a in a) {} }", i::STRICT, "a"},
+    {"{ for (let a of a) {} }", i::STRICT, "a"},
+    {"{ var o = {}; for (let a of o;;) { a(); } }", i::STRICT, NULL},
+    {"{ var o = {}; for (let a of o;;) { a(); } }", i::STRICT, NULL},
+    {"{ class C {} return C; }", i::SLOPPY, NULL},
+    {"{ function a(){ class C {} } return C; }", i::SLOPPY, "C"},
+    {"{ function a(){ let b = 0; } b = 1; }", i::STRICT, "b"},
+    {"{ if (1) { let b = 0; } b = 1; }", i::STRICT, "b"},
+    {"{ let a = 0; a = 1; }", i::STRICT, NULL},
+    {"{ if (1) { const b = 0; } b = 1; }", i::STRICT, "b"},
+    {NULL, i::STRICT, 0}
+  };
+
+  for (int i = 0; test_cases[i].function; i++) {
+    const char* function = test_cases[i].function;
+    const i::StrictMode strict_mode = test_cases[i].strict_mode;
+    i::Handle<i::String> source = factory->NewStringFromAsciiChecked(function);
+    i::GenericStringUtf16CharacterStream stream(source, 0, source->length());
+    i::SingletonLogger log;
+    i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
+    scanner.Initialize(&stream);
+    i::Zone zone(CcTest::i_isolate());
+    i::AstValueFactory ast_value_factory(
+        &zone, CcTest::i_isolate()->heap()->HashSeed());
+    ast_value_factory.Internalize(CcTest::i_isolate());
+    i::PreParser preparser(&scanner, &log, &ast_value_factory, &zone,
+                           CcTest::i_isolate()->stack_guard()->real_climit());
+    preparser.set_allow_classes(true);
+    preparser.set_allow_harmony_scoping(true);
+
+    scanner.Next();  // Kick-start the scanner so we have a current_token
+    CHECK_EQ(preparser.PreParseLazyFunction(strict_mode, false, true, &log),
+             i::PreParser::kPreParseSuccess);
+
+    const char* expected_identifier = test_cases[i].identifier;
+    i::SingletonLogger::IdentifierIterator it = log.IdentifiersStart();
+    if (expected_identifier) {
+      const i::AstRawString* reported_identifier = it.Next();
+      if (!(reported_identifier &&
+            reported_identifier->IsOneByteEqualTo(expected_identifier))) {
+        v8::base::OS::Print(
+            "Expected lazy preparse of function:\n"
+            "\t%s\n"
+            "to report identifier %s.\n",
+            function, expected_identifier);
+        if (reported_identifier) {
+          v8::base::OS::Print("(Actually reported %.*s)\n",
+                              reported_identifier->length(),
+                              reported_identifier->raw_data());
+        }
+        CHECK(false);
+      }
+    }
+    CHECK_EQ(it.Next(), NULL);
+  }
+}
+
+
 TEST(FunctionDeclaresItselfStrict) {
   // Tests that we produce the right kinds of errors when a function declares
   // itself strict (we cannot produce there errors as soon as we see the
   // offending identifiers, because we don't know at that point whether the
   // function is strict or not).
   const char* context_data[][2] = {
     {"function eval() {", "}"},
     {"function arguments() {", "}"},
     {"function yield() {", "}"},
     {"function interface() {", "}"},
@@ skipping 1768 matching lines @@
 
   const char* name_data[] = {
     "function* g() { ({yield}); }",
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
   RunParserSyncTest(context_data, name_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }