[ast/parsing] Pessimistically assume all top-level variables will be assigned.

src/parsing/pattern-rewriter.cc

 // Copyright 2015 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/ast/ast.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
 #include "src/parsing/parameter-initializer-rewriter.h"
 #include "src/parsing/parser.h"
 
@@ skipping 144 matching lines @@
                                  : descriptor_->scope->GetDeclarationScope();
   if (declaration_scope->num_var() > kMaxNumFunctionLocals) {
     parser_->ReportMessage(MessageTemplate::kTooManyVariables);
     *ok_ = false;
     return;
   }
   if (names_) {
     names_->Add(name, zone());
   }
 
+  Scope* var_init_scope = descriptor_->scope;
+  MarkTopLevelVariableAsAssigned(var_init_scope, proxy);
+
   // If there's no initializer, we're done.
   if (value == nullptr) return;
 
   // A declaration of the form:
   //
   //    var v = x;
   //
   // is syntactic sugar for:
   //
   //    var v; v = x;
   //
   // In particular, we need to re-lookup 'v' as it may be a different
   // 'v' than the 'v' in the declaration (e.g., if we are inside a
   // 'with' statement or 'catch' block). Global var declarations
   // also need special treatment.
-  Scope* var_init_scope = descriptor_->scope;
 
   if (descriptor_->mode == VAR && var_init_scope->is_script_scope()) {
     // Global variable declarations must be compiled in a specific
     // way. When the script containing the global variable declaration
     // is entered, the global variable must be declared, so that if it
     // doesn't exist (on the global object itself, see ES5 errata) it
     // gets created with an initial undefined value. This is handled
     // by the declarations part of the function representing the
     // top-level global code; see Runtime::DeclareGlobalVariable. If
     // it already exists (in the object or in a prototype), it is
@@ skipping 22 matching lines @@
         Runtime::kInitializeVarGlobal, arguments, value->position());
     block_->statements()->Add(
         factory()->NewExpressionStatement(initialize, initialize->position()),
         zone());
   } else {
     // For 'let' and 'const' declared variables the initialization always
     // assigns to the declared variable.
     // But for var declarations we need to do a new lookup.
     if (descriptor_->mode == VAR) {
       proxy = var_init_scope->NewUnresolved(factory(), name);
-      // TODO(neis): Set is_assigned on proxy.
     } else {
       DCHECK_NOT_NULL(proxy);
       DCHECK_NOT_NULL(proxy->var());
-      if (var_init_scope->is_script_scope() ||
-          var_init_scope->is_module_scope()) {
-        // We have to pessimistically assume that top-level variables will be
-        // assigned.  This is because they might be accessed by a lazily parsed
-        // top-level function, which, for efficiency, we preparse without
-        // variable tracking.  In the case of a script (not a module), they
-        // might also get accessed by another script.
-        proxy->set_is_assigned();
-      }
     }
     // Add break location for destructured sub-pattern.
     int pos = IsSubPattern() ? pattern->position() : value->position();
     Assignment* assignment =
         factory()->NewAssignment(Token::INIT, proxy, value, pos);
     block_->statements()->Add(
         factory()->NewExpressionStatement(assignment, pos), zone());
   }
 }
 
@@ skipping 500 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }  // namespace internal
 }  // namespace v8