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_) {
+    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_))) {
+        outer_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) {
+  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);
+  }
+}
+
+
+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, bool lexical) {
+  if (lexical || is_declaration_scope()) {
+    DCHECK(declared_variables_);
+    declared_variables_->Lookup(const_cast<AstRawString*>(identifier),
+                                identifier->hash(), true,
+                                ZoneAllocationPolicy(zone_));
+  } else {
+    DeclarationScope()->Declare(identifier, lexical);
+  }
+}
+
+
+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 201 matching lines @@
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = Check(Token::MUL);
   bool is_strict_reserved = false;
   Identifier name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
+  if (log_identifiers_) {
+    DCHECK(ast_value_factory_);
+    const AstRawString* identifier =
+        scanner()->CurrentSymbol(ast_value_factory_);
+    scope_->Declare(identifier);
+  }
   ParseFunctionLiteral(name, scanner()->location(), is_strict_reserved,
                        is_generator ? FunctionKind::kGeneratorFunction
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
 PreParser::Statement PreParser::ParseClassDeclaration(bool* ok) {
   Expect(Token::CLASS, CHECK_OK);
   int pos = position();
   bool is_strict_reserved = false;
   Identifier name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+  if (log_identifiers_) {
+    DCHECK(ast_value_factory_);
+    const AstRawString* identifier =
+        scanner()->CurrentSymbol(ast_value_factory_);
+    scope_->Declare(identifier);
+  }
   ParseClassLiteral(name, scanner()->location(), is_strict_reserved, pos,
                     CHECK_OK);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' Statement* '}'
 
   // Note that a Block does not introduce a new execution scope!
   // (ECMA-262, 3rd, 12.2)
   //
   Expect(Token::LBRACE, CHECK_OK);
-  while (peek() != Token::RBRACE) {
-    if (allow_harmony_scoping() && strict_mode() == STRICT) {
+  if (allow_harmony_scoping() && strict_mode() == STRICT) {
+    PreParserScope block_scope = NewScope(scope_, BLOCK_SCOPE);
+    BlockState block_state(&scope_, &block_scope);
+    while (peek() != Token::RBRACE) {
       ParseSourceElement(CHECK_OK);
-    } else {
+    }
+  } else {
+    while (peek() != Token::RBRACE) {
       ParseStatement(CHECK_OK);
     }
   }
   Expect(Token::RBRACE, ok);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseVariableStatement(
     VariableDeclarationContext var_context,
@@ skipping 27 matching lines @@
   //
   // ConstDeclaration ::
   //   const ConstBinding (',' ConstBinding)* ';'
   // ConstBinding ::
   //   Identifier '=' AssignmentExpression
   //
   // TODO(ES6):
   // ConstBinding ::
   //   BindingPattern '=' AssignmentExpression
   bool require_initializer = false;
+  bool lexical = false;
   if (peek() == Token::VAR) {
     Consume(Token::VAR);
   } else if (peek() == Token::CONST) {
     // TODO(ES6): The ES6 Draft Rev4 section 12.2.2 reads:
     //
     // ConstDeclaration : const ConstBinding (',' ConstBinding)* ';'
     //
     // * It is a Syntax Error if the code that matches this production is not
     //   contained in extended code.
     //
     // However disallowing const in sloppy mode will break compatibility with
     // existing pages. Therefore we keep allowing const with the old
     // non-harmony semantics in sloppy mode.
     Consume(Token::CONST);
     if (strict_mode() == STRICT) {
       if (allow_harmony_scoping()) {
         if (var_context != kSourceElement && var_context != kForStatement) {
           ReportMessageAt(scanner()->peek_location(), "unprotected_const");
           *ok = false;
           return Statement::Default();
         }
         require_initializer = true;
+        lexical = true;
       } else {
         Scanner::Location location = scanner()->peek_location();
         ReportMessageAt(location, "strict_const");
         *ok = false;
         return Statement::Default();
       }
     }
   } else if (peek() == Token::LET && strict_mode() == STRICT) {
     Consume(Token::LET);
     if (var_context != kSourceElement && var_context != kForStatement) {
       ReportMessageAt(scanner()->peek_location(), "unprotected_let");
       *ok = false;
       return Statement::Default();
     }
+    lexical = true;
   } else {
     *ok = false;
     return Statement::Default();
   }
 
   // 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, lexical);
+    }
     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 59 matching lines @@
     return true;
   }
   return false;
 }
 
 
 PreParser::Statement PreParser::ParseForStatement(bool* ok) {
   // ForStatement ::
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
 
+  // Create an in-between scope for let-bound iteration variables.
+  PreParserScope* saved_scope = scope_;
+  PreParserScope for_scope = NewScope(scope_, BLOCK_SCOPE);
+  scope_ = &for_scope;
+
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || peek() == Token::CONST ||
         (peek() == Token::LET && strict_mode() == STRICT)) {
       bool is_let = peek() == Token::LET;
       int decl_count;
       VariableDeclarationProperties decl_props = kHasNoInitializers;
       ParseVariableDeclarations(
           kForStatement, &decl_props, &decl_count, CHECK_OK);
       bool has_initializers = decl_props == kHasInitializers;
       bool accept_IN = decl_count == 1 && !(is_let && has_initializers);
       bool accept_OF = !has_initializers;
       if (accept_IN && CheckInOrOf(accept_OF)) {
+        // The expression does not see the loop variable.
+        scope_ = saved_scope;
         ParseExpression(true, CHECK_OK);
+        scope_ = &for_scope;
         Expect(Token::RPAREN, CHECK_OK);
 
         ParseStatement(CHECK_OK);
+        scope_ = saved_scope;
         return Statement::Default();
       }
     } else {
       Expression lhs = ParseExpression(false, CHECK_OK);
       if (CheckInOrOf(lhs.IsIdentifier())) {
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
 
         ParseStatement(CHECK_OK);
+        scope_ = saved_scope;
         return Statement::Default();
       }
     }
   }
 
   // Parsed initializer at this point.
   Expect(Token::SEMICOLON, CHECK_OK);
 
   if (peek() != Token::SEMICOLON) {
     ParseExpression(true, CHECK_OK);
   }
   Expect(Token::SEMICOLON, CHECK_OK);
 
   if (peek() != Token::RPAREN) {
     ParseExpression(true, CHECK_OK);
   }
   Expect(Token::RPAREN, CHECK_OK);
 
   ParseStatement(ok);
+  scope_ = saved_scope;
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseThrowStatement(bool* ok) {
   // ThrowStatement ::
   //   'throw' [no line terminator] Expression ';'
 
   Expect(Token::THROW, CHECK_OK);
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
@@ skipping 26 matching lines @@
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     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);
+    if (log_identifiers_) {
+      DCHECK(ast_value_factory_);
+      const AstRawString* identifier =
+          scanner()->CurrentSymbol(ast_value_factory_);
+      scope_->Declare(identifier);
+    }
     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
   // errors for parameter names or duplicates. However, we remember the
   // locations of these errors if they occur and produce the errors later.
   Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
   Scanner::Location dupe_error_loc = Scanner::Location::invalid();
   Scanner::Location reserved_error_loc = Scanner::Location::invalid();
 
   bool done = arity_restriction == FunctionLiteral::GETTER_ARITY ||
       (peek() == Token::RPAREN &&
        arity_restriction != FunctionLiteral::SETTER_ARITY);
   while (!done) {
     bool is_strict_reserved = false;
     Identifier param_name =
         ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
+    if (log_identifiers_) {
+      DCHECK(ast_value_factory_);
+      const AstRawString* identifier =
+          scanner()->CurrentSymbol(ast_value_factory_);
+      scope_->Declare(identifier);
+    }
     if (!eval_args_error_loc.IsValid() && param_name.IsEvalOrArguments()) {
       eval_args_error_loc = scanner()->location();
     }
     if (!reserved_error_loc.IsValid() && is_strict_reserved) {
       reserved_error_loc = scanner()->location();
     }
 
     int prev_value = scanner()->FindSymbol(&duplicate_finder, 1);
 
     if (!dupe_error_loc.IsValid() && prev_value != 0) {
@@ skipping 59 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