Stack allocate lexical locals + hoist stack slots

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 501 matching lines @@
   }
 }
 
 
 void ParserTraits::CheckPossibleEvalCall(Expression* expression,
                                          Scope* scope) {
   VariableProxy* callee = expression->AsVariableProxy();
   if (callee != NULL &&
       callee->raw_name() == parser_->ast_value_factory()->eval_string()) {
     scope->DeclarationScope()->RecordEvalCall();
+    scope->RecordEvalCall();

[rossberg, 2015/04/17 15:16:27]

Hm, why is this needed?

[Dmitry Lomov (no reviews), 2015/04/17 15:21:54]

I need to record eval inside block scopes.

[rossberg, 2015/04/17 15:26:07]

Right, I keep forgetting that "declaration scope" = "_var_ declaration scope" :)

   }
 }
 
 
 Expression* ParserTraits::MarkExpressionAsAssigned(Expression* expression) {
   VariableProxy* proxy =
       expression != NULL ? expression->AsVariableProxy() : NULL;
   if (proxy != NULL) proxy->set_is_assigned();
   return expression;
 }
@@ skipping 2760 matching lines @@
     Statement* clear_first = NULL;
     // Make statement: first = 0.
     {
       VariableProxy* first_proxy = factory()->NewVariableProxy(first);
       Expression* const0 = factory()->NewSmiLiteral(0, RelocInfo::kNoPosition);
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, first_proxy, const0, RelocInfo::kNoPosition);
       clear_first =
           factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition);
     }
-    Statement* clear_first_or_next =
-        factory()->NewIfStatement(compare, clear_first, next, next->position());
+    Statement* clear_first_or_next = factory()->NewIfStatement(
+        compare, clear_first, next, RelocInfo::kNoPosition);
     inner_block->AddStatement(clear_first_or_next, zone());
   }
 
   Variable* flag = scope_->DeclarationScope()->NewTemporary(temp_name);
   // Make statement: flag = 1.
   {
     VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
     Expression* const1 = factory()->NewSmiLiteral(1, RelocInfo::kNoPosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, flag_proxy, const1, RelocInfo::kNoPosition);
@@ skipping 734 matching lines @@
     // that it will be compiled lazily.
 
     // To make this additional case work, both Parser and PreParser implement a
     // logic where only top-level functions will be parsed lazily.
     bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
                              scope_->AllowsLazyCompilation() &&
                              !parenthesized_function_);
     parenthesized_function_ = false;  // The bit was set for this function only.
 
     if (is_lazily_parsed) {
+      for (Scope* s = scope_->outer_scope();
+           s != nullptr && s->is_block_scope(); s = s->outer_scope()) {

[rossberg, 2015/04/17 15:16:27]

I think you have to walk up all the way to the next surrounding
function/global/script/eval context. Otherwise I assume you'll crash on cases
like

  function() {
    for (;;) {
      let x = 9
      try {} catch (y) {
        return function() { return x + y }
      }
    }
  }

[Dmitry Lomov (no reviews), 2015/04/20 11:53:20]

Done.

+        s->ForceContextAllocation();
+      }
       SkipLazyFunctionBody(function_name, &materialized_literal_count,
                            &expected_property_count, CHECK_OK);
     } else {
       body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
                                     kind, CHECK_OK);
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
     }
 
@@ skipping 1727 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 } }  // namespace v8::internal