Preliminary code for block scopes and block contexts.

src/parser.cc

 // 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
@@ skipping 1192 matching lines @@
   // iterations or 'switch' statements (i.e., BreakableStatements),
   // labels can be simply ignored in all other cases; except for
   // trivial labeled break statements 'label: break label' which is
   // parsed into an empty statement.
 
   // Keep the source position of the statement
   int statement_pos = scanner().peek_location().beg_pos;
   Statement* stmt = NULL;
   switch (peek()) {
     case Token::LBRACE:
-      return ParseBlock(labels, ok);
+      return ParseScopedBlock(labels, ok);
 
     case Token::CONST:  // fall through
     case Token::VAR:
       stmt = ParseVariableStatement(ok);
       break;
 
     case Token::SEMICOLON:
       Next();
       return EmptyStatement();
 
@@ skipping 279 matching lines @@
     if (stat && !stat->IsEmpty()) {
       result->AddStatement(stat);
       block_finder.Update(stat);
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
   return result;
 }
 
 
+Statement* Parser::ParseScopedBlock(ZoneStringList* labels, bool* ok) {
+  if (!FLAG_harmony_block_scoping) return ParseBlock(labels, ok);

[Kevin Millikin (Chromium), 2011/08/10 11:19:27]

This is OK for now, but you should try to think of a way to ultimately turn this
code into:

if (FLAG_harmony_block_scoping) {
  // Preparation.
}
Block* body = ParseBlock(labels, ok);
if (FLAG_harmony_block_scoping) {
  // Cleanup.
}

With the idea of just inlining the code for ParseBlock (provided this is the
only call site) and getting rid of that function.  I can see that's hard to do
right now because of the scoped Target, but once we stop using try/finally here,
I think you could do it.

[Steven, 2011/08/10 12:21:00]

Yes sure. But indeed I think this should be done when getting rid of
try-finally.

I changed the definition of ParseBlock/ParseScopedBlock slightly to use
ParseScopedBlock at all call sites.

On 2011/08/10 11:19:27, Kevin Millikin wrote:

+
+  // Construct block expecting 16 statements.
+  Block* body = new(zone()) Block(isolate(), labels, 16, false);
+  Scope* saved_scope = top_scope_;
+  Scope* block_scope = NewScope(top_scope_,
+                                Scope::BLOCK_SCOPE,
+                                inside_with());
+  body->set_block_scope(block_scope);
+  block_scope->DeclareLocal(isolate()->factory()->block_scope_symbol(),
+                            Variable::VAR);
+  if (top_scope_->is_strict_mode()) {
+    block_scope->EnableStrictMode();
+  }
+  top_scope_ = block_scope;
+
+  // Parse the statements and collect escaping labels.
+  TargetCollector collector;
+  Target target(&this->target_stack_, &collector);
+  Expect(Token::LBRACE, CHECK_OK);
+  {
+    Target target_body(&this->target_stack_, body);
+    InitializationBlockFinder block_finder(top_scope_, target_stack_);
+
+    while (peek() != Token::RBRACE) {
+      Statement* stat = ParseStatement(NULL, CHECK_OK);
+      if (stat && !stat->IsEmpty()) {
+        body->AddStatement(stat);
+        block_finder.Update(stat);
+      }
+    }
+  }
+  Expect(Token::RBRACE, CHECK_OK);
+
+  // Create exit block.
+  Block* exit = new(zone()) Block(isolate(), NULL, 1, false);
+  exit->AddStatement(new(zone()) ExitContextStatement());
+
+  // Return a try-finally statement.
+  TryFinallyStatement* result = new(zone()) TryFinallyStatement(body, exit);
+  result->set_escaping_targets(collector.targets());
+  top_scope_ = saved_scope;
+  return result;
+}
+
+
 Block* Parser::ParseVariableStatement(bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
   Handle<String> ignore;
   Block* result = ParseVariableDeclarations(true, &ignore, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return result;
 }
 
@@ skipping 3573 matching lines @@
     result->capture_count = capture_count;
   }
   return !parser.failed();
 }
 
 
 bool ParserApi::Parse(CompilationInfo* info) {
   ASSERT(info->function() == NULL);
   FunctionLiteral* result = NULL;
   Handle<Script> script = info->script();
+  bool save_block_scoping = FLAG_harmony_block_scoping;
+  FLAG_harmony_block_scoping = !info->is_native() && FLAG_harmony_block_scoping;

[Kevin Millikin (Chromium), 2011/08/10 11:19:27]

I'm always nervous about assigning to the flags.  Since they're global, this
prevents other unrelated code from being able to tell the original value of the
flag.

Can you make this a member variable of the parser, and avoid mutating the flag?

[Steven, 2011/08/10 12:21:00]

Done.

   if (info->is_lazy()) {
     Parser parser(script, true, NULL, NULL);
     result = parser.ParseLazy(info);
   } else {
     // Whether we allow %identifier(..) syntax.
     bool allow_natives_syntax =
         info->allows_natives_syntax() || FLAG_allow_natives_syntax;
     ScriptDataImpl* pre_data = info->pre_parse_data();
     Parser parser(script, allow_natives_syntax, info->extension(), pre_data);
     if (pre_data != NULL && pre_data->has_error()) {
       Scanner::Location loc = pre_data->MessageLocation();
       const char* message = pre_data->BuildMessage();
       Vector<const char*> args = pre_data->BuildArgs();
       parser.ReportMessageAt(loc, message, args);
       DeleteArray(message);
       for (int i = 0; i < args.length(); i++) {
         DeleteArray(args[i]);
       }
       DeleteArray(args.start());
       ASSERT(info->isolate()->has_pending_exception());
     } else {
       Handle<String> source = Handle<String>(String::cast(script->source()));
       result = parser.ParseProgram(source,
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
-
+  FLAG_harmony_block_scoping = save_block_scoping;
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal