Fix test-parsing/InnerAssignment to test what it intended

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 3263 matching lines @@
 
 
 TEST(InnerAssignment) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
   i::HandleScope scope(isolate);
   LocalContext env;
 
   const char* prefix = "function f() {";
   const char* midfix = " function g() {";
-  const char* suffix = "}}";
+  const char* suffix = "}}; f";
   struct { const char* source; bool assigned; bool strict; } outers[] = {
     // Actual assignments.
     { "var x; var x = 5;", true, false },
     { "var x; { var x = 5; }", true, false },
     { "'use strict'; let x; x = 6;", true, true },
     { "var x = 5; function x() {}", true, false },
     // Actual non-assignments.
     { "var x;", false, false },
     { "var x = 5;", false, false },
     { "'use strict'; let x;", false, true },
@@ skipping 59 matching lines @@
     { "function h() { eval(''); }", true, false },
     { "(function() { eval(''); })", true, false },
     // Shadowing not recognized because of eval approximation.
     { "var x; eval('');", true, false },
     { "'use strict'; let x; eval('');", true, false },
     { "try {} catch(x) { eval(''); }", true, false },
     { "function x() { eval(''); }", true, false },
     { "(function(x) { eval(''); })", true, false },
   };
 
-  // Used to trigger lazy parsing of the outer function.
-  int comment_len = 2048;
-  i::ScopedVector<char> comment(comment_len + 1);
-  i::SNPrintF(comment, "/*%0*d*/", comment_len - 4, 0);
   int prefix_len = Utf8LengthHelper(prefix);
   int midfix_len = Utf8LengthHelper(midfix);
   int suffix_len = Utf8LengthHelper(suffix);
   for (unsigned i = 0; i < arraysize(outers); ++i) {
     const char* outer = outers[i].source;
     int outer_len = Utf8LengthHelper(outer);
     for (unsigned j = 0; j < arraysize(inners); ++j) {
       for (unsigned lazy = 0; lazy < 2; ++lazy) {
         if (outers[i].strict && inners[j].with) continue;
         const char* inner = inners[j].source;
         int inner_len = Utf8LengthHelper(inner);
 
-        const char* comment_chars = lazy ? comment.start() : "";
-        int len = prefix_len + (lazy ? comment_len : 0) + outer_len +
-                  midfix_len + inner_len + suffix_len;
+        int len = prefix_len + outer_len + midfix_len + inner_len + suffix_len;
         i::ScopedVector<char> program(len + 1);
 
-        i::SNPrintF(program, "%s%s%s%s%s%s", comment_chars, prefix, outer,
-                    midfix, inner, suffix);
-        i::Handle<i::String> source =
-            factory->InternalizeUtf8String(program.start());
-        source->PrintOn(stdout);
-        printf("\n");
+        i::SNPrintF(program, "%s%s%s%s%s", prefix, outer, midfix, inner,
+                    suffix);
 
-        i::Handle<i::Script> script = factory->NewScript(source);
         i::Zone zone(CcTest::i_isolate()->allocator());
-        i::ParseInfo info(&zone, script);
-        i::Parser parser(&info);
-        CHECK(parser.Parse(&info));
-        CHECK(i::Compiler::Analyze(&info));
-        CHECK(info.literal() != NULL);
+        std::unique_ptr<i::ParseInfo> info;
+        if (lazy) {
+          printf("%s\n", program.start());
+          v8::Local<v8::Value> v = CompileRun(program.start());
+          i::Handle<i::Object> o = v8::Utils::OpenHandle(*v);
+          i::Handle<i::JSFunction> f = i::Handle<i::JSFunction>::cast(o);
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, f));
+        } else {
+          i::Handle<i::String> source =
+              factory->InternalizeUtf8String(program.start());
+          source->PrintOn(stdout);
+          printf("\n");
+          i::Handle<i::Script> script = factory->NewScript(source);
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, script));
+        }
+        i::Parser parser(info.get());
+        CHECK(parser.Parse(info.get()));
+        CHECK(i::Compiler::Analyze(info.get()));
+        CHECK(info->literal() != NULL);
 
-        i::Scope* scope = info.literal()->scope();
-        i::Scope* inner_scope = scope->inner_scope();
-        DCHECK_NOT_NULL(inner_scope);
-        DCHECK_NULL(inner_scope->sibling());
+        i::Scope* scope = info->literal()->scope();
+        if (!lazy) {
+          scope = scope->inner_scope();
+        }
+        DCHECK_NOT_NULL(scope);
+        DCHECK_NULL(scope->sibling());
+        DCHECK(scope->is_function_scope());
         const i::AstRawString* var_name =
-            info.ast_value_factory()->GetOneByteString("x");
-        i::Variable* var = inner_scope->Lookup(var_name);
+            info->ast_value_factory()->GetOneByteString("x");
+        i::Variable* var = scope->Lookup(var_name);
         bool expected = outers[i].assigned || inners[j].assigned;
         CHECK(var != NULL);
         CHECK(var->is_used() || !expected);
         bool is_maybe_assigned = var->maybe_assigned() == i::kMaybeAssigned;
         if (i::FLAG_lazy_inner_functions) {
           // If we parse inner functions lazily, allow being pessimistic about
           // maybe_assigned.
           CHECK(is_maybe_assigned || (is_maybe_assigned == expected));
         } else {
           CHECK(is_maybe_assigned == expected);
@@ skipping 4909 matching lines @@
     const char* data[] = {
       "const arguments = 1",
       "let arguments",
       "var arguments",
       NULL
     };
     // clang-format on
     RunParserSyncTest(context_data, data, kSuccess);
   }
 }