Provisional implementation of stack allocated catch variables.

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 1473 matching lines @@
 Block* Parser::ParseBlock(ZoneStringList* labels, bool* ok) {
   // Block ::
   //   '{' Statement* '}'
 
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   // Construct block expecting 16 statements.
   Block* result = new(zone()) Block(isolate(), labels, 16, false);
   Target target(&this->target_stack_, result);
+  result->SetSourceBegStatementPos(scanner().location().beg_pos);
   Expect(Token::LBRACE, CHECK_OK);
   InitializationBlockFinder block_finder(top_scope_, target_stack_);
   while (peek() != Token::RBRACE) {
     Statement* stat = ParseStatement(NULL, CHECK_OK);
     if (stat && !stat->IsEmpty()) {
       result->AddStatement(stat);
       block_finder.Update(stat);
     }
   }
+  result->SetSourceEndStatementPos(scanner().location().end_pos);
   Expect(Token::RBRACE, CHECK_OK);
   return result;
 }
 
 
 Block* Parser::ParseVariableStatement(bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
   Handle<String> ignore;
@@ skipping 437 matching lines @@
   return new(zone()) ReturnStatement(expr);
 }
 
 
 Block* Parser::WithHelper(Expression* obj, ZoneStringList* labels, bool* ok) {
   // Parse the statement and collect escaping labels.
   TargetCollector collector;
   Statement* stat;
   { Target target(&this->target_stack_, &collector);
     with_nesting_level_++;
+    Scope* saved_scope = top_scope_;
+    Scope* with_scope = NewScope(top_scope_, Scope::WITH_SCOPE, true);
+    if (top_scope_->is_strict_mode()) {
+      with_scope->EnableStrictMode();
+    }
     top_scope_->DeclarationScope()->RecordWithStatement();
+    top_scope_ = with_scope;
+    with_scope->SetSourceBegStatementPos(scanner().location().beg_pos);
     stat = ParseStatement(labels, CHECK_OK);
+    with_scope->SetSourceEndStatementPos(scanner().location().end_pos);
+    top_scope_ = saved_scope;
+    if (with_scope->calls_eval()) top_scope_->RecordEvalCall();
     with_nesting_level_--;
   }
   // Create resulting block with two statements.
   // 1: Evaluate the with expression.
   // 2: The try-finally block evaluating the body.
   Block* result = new(zone()) Block(isolate(), NULL, 2, false);
 
   if (result != NULL) {
     result->AddStatement(new(zone()) EnterWithContextStatement(obj));
 
@@ skipping 176 matching lines @@
         { Target target(&this->target_stack_, &inner_collector);
           catch_scope = NewScope(top_scope_, Scope::CATCH_SCOPE, inside_with());
           if (top_scope_->is_strict_mode()) {
             catch_scope->EnableStrictMode();
           }
           catch_variable = catch_scope->DeclareLocal(name, Variable::VAR);
 
           Scope* saved_scope = top_scope_;
           top_scope_ = catch_scope;
           inner_body = ParseBlock(NULL, CHECK_OK);
+          catch_scope->SetSourceBegStatementPos(
+              inner_body->SourceBegStatementPos());
+          catch_scope->SetSourceEndStatementPos(
+              inner_body->SourceEndStatementPos());
           top_scope_ = saved_scope;
+          if (catch_scope->calls_eval()) top_scope_->RecordEvalCall();
         }
       }
 
       // Create exit block.
       Block* inner_finally = new(zone()) Block(isolate(), NULL, 1, false);
-      inner_finally->AddStatement(new(zone()) ExitContextStatement());
+      inner_finally->AddStatement(new(zone())
+                                  ExitScopedBlockStatement(catch_scope));
 
       // Create a try/finally statement.
       TryFinallyStatement* inner_try_finally =
           new(zone()) TryFinallyStatement(inner_body, inner_finally);
       inner_try_finally->set_escaping_targets(inner_collector.targets());
 
       catch_block = new(zone()) Block(isolate(), NULL, 1, false);
       catch_block->AddStatement(inner_try_finally);
     } else {
       Expect(Token::LBRACE, CHECK_OK);
@@ skipping 2936 matching lines @@
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
 
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal