Fix calculation of 'scope_calls_eval' when 'eval' is within a nested catch.

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 2138 matching lines @@
           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);
           top_scope_ = saved_scope;
+          if(catch_scope->calls_eval()) top_scope_->RecordEvalCall();

[Kevin Millikin (Chromium), 2011/07/28 08:53:40]

Style nit: there should be a space after the keyword if (also for, while, etc.)
to visually distinguish it from a function call.

[Steven, 2011/07/28 11:12:12]

Removed.
On 2011/07/28 08:53:40, Kevin Millikin wrote:

         }
       }
 
       // Create exit block.
       Block* inner_finally = new(zone()) Block(isolate(), NULL, 1, false);
       inner_finally->AddStatement(new(zone()) ExitContextStatement());
 
       // Create a try/finally statement.
       TryFinallyStatement* inner_try_finally =
           new(zone()) TryFinallyStatement(inner_body, inner_finally);
@@ skipping 579 matching lines @@
         // TODO(994): In ES5, it doesn't matter if the "eval" var is declared
         // in the local scope chain. It only matters that it's called "eval",
         // is called without a receiver and it refers to the original eval
         // function.
         VariableProxy* callee = result->AsVariableProxy();
         if (callee != NULL &&
             callee->IsVariable(isolate()->factory()->eval_symbol())) {
           Handle<String> name = callee->name();
           Variable* var = top_scope_->Lookup(name);
           if (var == NULL) {
             top_scope_->RecordEvalCall();

[Kevin Millikin (Chromium), 2011/07/28 08:53:40]

I think it's more straightforward to do, instead,

top_scope_->DeclarationScope()->RecordEvalCall()

here.  That avoids recording eval call for the potential try scope and we have
only one call to Scope::RecordEvalCall exactly where needed.  What do you think?

[Steven, 2011/07/28 11:12:12]

Done.

           }
         }
         result = NewCall(result, args, pos);
         break;
       }
 
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         int pos = scanner().location().beg_pos;
         Handle<String> name = ParseIdentifierName(CHECK_OK);
@@ skipping 2342 matching lines @@
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
 
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal