Preparsing inner funcs: be less pessimistic about maybe_assigned.

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 248 matching lines @@
   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(), GetLastFunctionLiteralId());
   return kLazyParsingComplete;
 }
 
 PreParserExpression PreParser::ExpressionFromIdentifier(
     PreParserIdentifier name, int start_position, InferName infer) {
+  VariableProxy* proxy = nullptr;
   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());
     DCHECK_NOT_NULL(name.string_);
-    VariableProxy* proxy = scope()->NewUnresolved(
-        &factory, name.string_, start_position, NORMAL_VARIABLE);
-    // We don't know whether the preparsed function assigns or not, so we set
-    // is_assigned pessimistically.
-    proxy->set_is_assigned();
+    proxy = scope()->NewUnresolved(&factory, name.string_, start_position,
+                                   NORMAL_VARIABLE);
   }
-  return PreParserExpression::FromIdentifier(name, zone());
+  return PreParserExpression::FromIdentifier(name, proxy, zone());
 }
 
 void PreParser::DeclareAndInitializeVariables(
     PreParserStatement block,
     const DeclarationDescriptor* declaration_descriptor,
     const DeclarationParsingResult::Declaration* declaration,
     ZoneList<const AstRawString*>* names, bool* ok) {
-  if (declaration->pattern.identifiers_ != nullptr) {
+  if (declaration->pattern.variables_ != nullptr) {
     DCHECK(FLAG_lazy_inner_functions);
     /* Mimic what Parser does when declaring variables (see
        Parser::PatternRewriter::VisitVariableProxy).
 
        var + no initializer -> RemoveUnresolved
        let / const + no initializer -> RemoveUnresolved
        var + initializer -> RemoveUnresolved followed by NewUnresolved
        let / const + initializer -> RemoveUnresolved
     */
     Scope* scope = declaration_descriptor->hoist_scope;
     if (scope == nullptr) {
       scope = this->scope();
     }
     if (declaration->initializer.IsEmpty() ||
         (declaration_descriptor->mode == VariableMode::LET ||
          declaration_descriptor->mode == VariableMode::CONST)) {
-      for (auto identifier : *(declaration->pattern.identifiers_)) {
-        declaration_descriptor->scope->RemoveUnresolved(identifier);
+      for (auto variable : *(declaration->pattern.variables_)) {
+        declaration_descriptor->scope->RemoveUnresolved(variable);
       }
     }
-    for (auto identifier : *(declaration->pattern.identifiers_)) {
-      scope->DeclareVariableName(identifier, declaration_descriptor->mode);
+    for (auto variable : *(declaration->pattern.variables_)) {
+      scope->DeclareVariableName(variable->raw_name(),
+                                 declaration_descriptor->mode);
     }
   }
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 
 }  // namespace internal
 }  // namespace v8