Support lazy parsing of inner functions

src/preparser.cc

 // Copyright 2011 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 <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
 #include "src/globals.h"
 #include "src/hashmap.h"
 #include "src/list.h"
+#include "src/parser.h"
 #include "src/preparse-data.h"
 #include "src/preparse-data-format.h"
 #include "src/preparser.h"
 #include "src/unicode.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
+PreParserScope::~PreParserScope() {
+  if (unbound_variables_ && outer_scope_) {
+    PreParserScope* scope = outer_scope_->DeclarationScope();
+    for (ZoneHashMap::Entry* p = unbound_variables_->Start(); p != NULL;
+         p = unbound_variables_->Next(p)) {
+      AstRawString* identifier = static_cast<AstRawString*>(p->key);
+      if (!declared_variables_->Lookup(identifier, identifier->hash(), false,
+                                       ZoneAllocationPolicy(zone_))) {
+        scope->RecordVariableUsage(identifier);
+      }
+    }
+  }
+}
+
+
+PreParserScope* PreParserScope::DeclarationScope() {
+  PreParserScope* scope = this;
+  while (!scope->is_declaration_scope()) {
+    scope = scope->outer_scope();
+  }
+  return scope;
+}
+
+
+void PreParserScope::RecordVariableUsage(const AstRawString* identifier) {
+  if (is_declaration_scope()) {
+    ZoneAllocationPolicy allocator(zone_);
+    if (!declared_variables_->Lookup(const_cast<AstRawString*>(identifier),
+                                     identifier->hash(), false, allocator)) {
+      unbound_variables_->Lookup(const_cast<AstRawString*>(identifier),
+                                 identifier->hash(), true, allocator);
+    }
+  } else {
+    DeclarationScope()->Declare(identifier);

[rossberg, 2014/11/06 11:55:46]

Why Declare here?

+  }
+}
+
+
+void PreParserScope::LogUnboundVariables(ParserRecorder* recorder) {
+  for (ZoneHashMap::Entry* p = unbound_variables_->Start(); p != NULL;
+       p = unbound_variables_->Next(p)) {
+    AstRawString* identifier = static_cast<AstRawString*>(p->key);
+    if (!declared_variables_->Lookup(identifier, identifier->hash(), false,
+                                     ZoneAllocationPolicy(zone_))) {
+      recorder->LogIdentifier(identifier);
+    }
+  }
+  unbound_variables_->Clear();
+}
+
+
+void PreParserScope::Declare(const AstRawString* identifier) {
+  if (is_declaration_scope()) {
+    DCHECK(declared_variables_);
+    declared_variables_->Lookup(const_cast<AstRawString*>(identifier),
+                                identifier->hash(), true,
+                                ZoneAllocationPolicy(zone_));
+  } else {
+    DeclarationScope()->Declare(identifier);
+  }
+}
+
+
+void PreParserTraits::RecordCurrentSymbolAsIdentifierExpression() {
+  if (pre_parser_->log_ != NULL && pre_parser_->log_identifiers_) {
+    DCHECK(pre_parser_->ast_value_factory_ != NULL);
+    const AstRawString* identifier =
+        pre_parser_->scanner()->CurrentSymbol(pre_parser_->ast_value_factory_);
+    pre_parser_->scope_->RecordVariableUsage(identifier);
+  }
+}
+
+
 void PreParserTraits::ReportMessageAt(Scanner::Location location,
                                       const char* message,
                                       const char* arg,
                                       bool is_reference_error) {
   ReportMessageAt(location.beg_pos,
                   location.end_pos,
                   message,
                   arg,
                   is_reference_error);
 }
 
 
 void PreParserTraits::ReportMessageAt(int start_pos,
                                       int end_pos,
                                       const char* message,
                                       const char* arg,
                                       bool is_reference_error) {
   pre_parser_->log_->LogMessage(start_pos, end_pos, message, arg,
                                 is_reference_error);
 }
 
 
+void PreParserTraits::CheckPossibleEvalCall(PreParserExpression expression,
+                                            PreParserScope* scope) {
+  if (pre_parser_->log_ != NULL && pre_parser_->log_identifiers_ &&
+      expression.IsIdentifier() && expression.AsIdentifier().IsEval()) {
+    pre_parser_->log_->LogEvalCall();
+  }
+}
+
+
 PreParserIdentifier PreParserTraits::GetSymbol(Scanner* scanner) {
   if (scanner->current_token() == Token::FUTURE_RESERVED_WORD) {
     return PreParserIdentifier::FutureReserved();
   } else if (scanner->current_token() ==
              Token::FUTURE_STRICT_RESERVED_WORD) {
     return PreParserIdentifier::FutureStrictReserved();
   } else if (scanner->current_token() == Token::LET) {
     return PreParserIdentifier::Let();
   } else if (scanner->current_token() == Token::YIELD) {
     return PreParserIdentifier::Yield();
@@ skipping 38 matching lines @@
     bool name_is_strict_reserved, FunctionKind kind,
     int function_token_position, FunctionLiteral::FunctionType type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   return pre_parser_->ParseFunctionLiteral(
       name, function_name_location, name_is_strict_reserved, kind,
       function_token_position, type, arity_restriction, ok);
 }
 
 
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
-    StrictMode strict_mode, bool is_generator, ParserRecorder* log) {
+    StrictMode strict_mode, bool is_generator, bool log_identifiers,
+    ParserRecorder* log) {
+  log_identifiers_ = log_identifiers;
   log_ = log;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
-  PreParserScope top_scope(scope_, GLOBAL_SCOPE);
+  PreParserScope top_scope = NewScope(NULL, GLOBAL_SCOPE);
   PreParserFactory top_factory(NULL);
   FunctionState top_state(&function_state_, &scope_, &top_scope, &top_factory);
   scope_->SetStrictMode(strict_mode);
-  PreParserScope function_scope(scope_, FUNCTION_SCOPE);
+  PreParserScope function_scope = NewScope(scope_, FUNCTION_SCOPE);
   PreParserFactory function_factory(NULL);
   FunctionState function_state(&function_state_, &scope_, &function_scope,
                                &function_factory);
   function_state.set_is_generator(is_generator);
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
   bool ok = true;
   int start_position = peek_position();
   ParseLazyFunctionLiteralBody(&ok);
   if (stack_overflow()) return kPreParseStackOverflow;
   if (!ok) {
@@ skipping 331 matching lines @@
 
   // The scope of a var/const declared variable anywhere inside a function
   // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). The scope
   // of a let declared variable is the scope of the immediately enclosing
   // block.
   int nvars = 0;  // the number of variables declared
   do {
     // Parse variable name.
     if (nvars > 0) Consume(Token::COMMA);
     ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
+    if (log_identifiers_) {
+      DCHECK(ast_value_factory_);
+      const AstRawString* identifier =
+          scanner()->CurrentSymbol(ast_value_factory_);
+      scope_->Declare(identifier);
+    }
     nvars++;
     if (peek() == Token::ASSIGN || require_initializer) {
       Expect(Token::ASSIGN, CHECK_OK);
       ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);
       if (decl_props != NULL) *decl_props = kHasInitializers;
     }
   } while (peek() == Token::COMMA);
 
   if (num_decl != NULL) *num_decl = nvars;
   return Statement::Default();
@@ skipping 114 matching lines @@
   Expect(Token::WITH, CHECK_OK);
   if (strict_mode() == STRICT) {
     ReportMessageAt(scanner()->location(), "strict_mode_with");
     *ok = false;
     return Statement::Default();
   }
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
-  PreParserScope with_scope(scope_, WITH_SCOPE);
+  PreParserScope with_scope = NewScope(scope_, WITH_SCOPE);
   BlockState block_state(&scope_, &with_scope);
   ParseStatement(CHECK_OK);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseSwitchStatement(bool* ok) {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
 
@@ skipping 153 matching lines @@
     ReportMessageAt(scanner()->location(), "no_catch_or_finally");
     *ok = false;
     return Statement::Default();
   }
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
     Expect(Token::LPAREN, CHECK_OK);
     ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     {
-      PreParserScope with_scope(scope_, WITH_SCOPE);
+      PreParserScope with_scope = NewScope(scope_, WITH_SCOPE);
       BlockState block_state(&scope_, &with_scope);
       ParseBlock(CHECK_OK);
     }
     tok = peek();
   }
   if (tok == Token::FINALLY) {
     Consume(Token::FINALLY);
     ParseBlock(CHECK_OK);
   }
   return Statement::Default();
@@ skipping 24 matching lines @@
 PreParser::Expression PreParser::ParseFunctionLiteral(
     Identifier function_name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind, int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
 
   // Parse function body.
   ScopeType outer_scope_type = scope_->type();
-  PreParserScope function_scope(scope_, FUNCTION_SCOPE);
+  PreParserScope function_scope = NewScope(scope_, FUNCTION_SCOPE);
   PreParserFactory factory(NULL);
   FunctionState function_state(&function_state_, &scope_, &function_scope,
                                &factory);
   function_state.set_is_generator(IsGeneratorFunction(kind));
   //  FormalParameterList ::
   //    '(' (Identifier)*[','] ')'
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = position();
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   // We don't yet know if the function will be strict, so we cannot yet produce
@@ skipping 82 matching lines @@
 
 
 void PreParser::ParseLazyFunctionLiteralBody(bool* ok) {
   int body_start = position();
   ParseSourceElements(Token::RBRACE, ok);
   if (!*ok) return;
 
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
+  if (log_identifiers_) {
+    scope_->LogUnboundVariables(log_);
+  }
   log_->LogFunction(body_start, body_end,
                     function_state_->materialized_literal_count(),
                     function_state_->expected_property_count(),
                     strict_mode());
 }
 
 
 PreParser::Expression PreParser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
   Expect(Token::MOD, CHECK_OK);
   if (!allow_natives_syntax()) {
     *ok = false;
     return Expression::Default();
   }
   // Allow "eval" or "arguments" for backward compatibility.
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal