Assign unique IDs to FunctionLiterals

src/parsing/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"
@@ skipping 177 matching lines @@
       runtime_call_stats_,
       counters[track_unresolved_variables_][parsing_on_main_thread_]);
 
   // Parse function body.
   PreParserStatementList body;
   DeclarationScope* function_scope = NewFunctionScope(kind);
   function_scope->SetLanguageMode(language_mode);
   FunctionState function_state(&function_state_, &scope_state_, function_scope);
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   ExpressionClassifier formals_classifier(this, &duplicate_finder);
+  GetNextFunctionLiteralNum();
 
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = scanner()->location().beg_pos;
   function_scope->set_start_position(start_position);
   PreParserFormalParameters formals(function_scope);
   ParseFormalParameterList(&formals, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   int formals_end_position = scanner()->location().end_pos;
 
   CheckArityRestrictions(formals.arity, kind, formals.has_rest, start_position,
@@ skipping 27 matching lines @@
                                        : "Preparse no-resolution",
            function_scope->start_position(), function_scope->end_position());
   }
 
   return Expression::Default();
 }
 
 PreParser::LazyParsingResult PreParser::ParseStatementListAndLogFunction(
     PreParserFormalParameters* formals, bool has_duplicate_parameters,
     bool may_abort, bool* ok) {
+  ResetFunctionLiteralNum();
+
   PreParserStatementList body;
   LazyParsingResult result = ParseStatementList(
       body, Token::RBRACE, may_abort, CHECK_OK_VALUE(kLazyParsingComplete));
   if (result == kLazyParsingAborted) return result;
 
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
   DCHECK(this->scope()->is_function_scope());
   log_.LogFunction(body_end, formals->num_parameters(),
                    formals->function_length, has_duplicate_parameters,
                    function_state_->materialized_literal_count(),
-                   function_state_->expected_property_count());
+                   function_state_->expected_property_count(),
+                   GetNextFunctionLiteralNum() - 1);
   return kLazyParsingComplete;
 }
 
 PreParserExpression PreParser::ExpressionFromIdentifier(
     PreParserIdentifier name, int start_position, InferName infer) {
   if (track_unresolved_variables_) {
     AstNodeFactory factory(ast_value_factory());
     // Setting the Zone is necessary because zone_ might be the temp Zone, and
     // AstValueFactory doesn't know about it.
     factory.set_zone(zone());
@@ skipping 29 matching lines @@
     }
   }
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 
 }  // namespace internal
 }  // namespace v8