PreParser: track variable declarations and parameters

src/parsing/preparser.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSING_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
 #include "src/parsing/preparse-data.h"
@@ skipping 131 matching lines @@
     expression.AddIdentifier(id.string_, zone);
     return expression;
   }
 
   static PreParserExpression BinaryOperation(PreParserExpression left,
                                              Token::Value op,
                                              PreParserExpression right) {
     return PreParserExpression(TypeField::encode(kExpression));
   }
 
-  static PreParserExpression Assignment() {
+  static PreParserExpression Assignment(
+      ZoneList<const AstRawString*>* identifiers = nullptr) {
     return PreParserExpression(TypeField::encode(kExpression) |
-                               ExpressionTypeField::encode(kAssignment));
+                                   ExpressionTypeField::encode(kAssignment),
+                               identifiers);
   }
 
   static PreParserExpression ObjectLiteral(
       ZoneList<const AstRawString*>* identifiers = nullptr) {
     return PreParserExpression(TypeField::encode(kObjectLiteralExpression),
                                identifiers);
   }
 
   static PreParserExpression ArrayLiteral(
       ZoneList<const AstRawString*>* identifiers = nullptr) {
@@ skipping 432 matching lines @@
                                           PreParserExpression right, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewRewritableExpression(PreParserExpression expression) {
     return expression;
   }
   PreParserExpression NewAssignment(Token::Value op,
                                     PreParserExpression left,
                                     PreParserExpression right,
                                     int pos) {
-    return PreParserExpression::Assignment();
+    // For tracking identifiers for parameters with a default value.
+    return PreParserExpression::Assignment(left.identifiers_);
   }
   PreParserExpression NewYield(PreParserExpression generator_object,
                                PreParserExpression expression, int pos,
                                Yield::OnException on_exception) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewConditional(PreParserExpression condition,
                                      PreParserExpression then_expression,
                                      PreParserExpression else_expression,
                                      int pos) {
@@ skipping 121 matching lines @@
     static int dummy = 42;
     return &dummy;
   }
 
  private:
   Zone* zone_;
 };
 
 
 struct PreParserFormalParameters : FormalParametersBase {
+  struct Parameter : public ZoneObject {
+    explicit Parameter(PreParserExpression pattern) : pattern(pattern) {}
+    Parameter** next() { return &next_parameter; }
+    Parameter* const* next() const { return &next_parameter; }
+    PreParserExpression pattern;
+    Parameter* next_parameter = nullptr;
+  };
   explicit PreParserFormalParameters(DeclarationScope* scope)
       : FormalParametersBase(scope) {}
 
-  void* params = nullptr;  // Dummy
+  ThreadedList<Parameter> params;
 };
 
 
 class PreParser;
 
 class PreParserTarget {
  public:
   PreParserTarget(ParserBase<PreParser>* preparser,
                   PreParserStatement statement) {}
 };
@@ skipping 670 matching lines @@
 
   V8_INLINE void AddParameterInitializationBlock(
       const PreParserFormalParameters& parameters, PreParserStatementList body,
       bool is_async, bool* ok) {}
 
   V8_INLINE void AddFormalParameter(PreParserFormalParameters* parameters,
                                     PreParserExpression pattern,
                                     PreParserExpression initializer,
                                     int initializer_end_position,
                                     bool is_rest) {
+    if (track_unresolved_variables_) {
+      DCHECK(FLAG_lazy_inner_functions);
+      parameters->params.Add(new (zone())
+                                 PreParserFormalParameters::Parameter(pattern));
+    }
     parameters->UpdateArityAndFunctionLength(!initializer.IsEmpty(), is_rest);
   }
 
-  V8_INLINE void DeclareFormalParameters(DeclarationScope* scope,
-                                         void* parameters) {
+  V8_INLINE void DeclareFormalParameters(
+      DeclarationScope* scope,
+      const ThreadedList<PreParserFormalParameters::Parameter>& parameters) {
     if (!classifier()->is_simple_parameter_list()) {
       scope->SetHasNonSimpleParameters();
     }
+    if (track_unresolved_variables_) {
+      DCHECK(FLAG_lazy_inner_functions);
+      for (auto parameter : parameters) {
+        if (parameter->pattern.identifiers_ != nullptr) {
+          for (auto i : *parameter->pattern.identifiers_) {
+            scope->DeclareVariableName(i, VAR);
+          }
+        }
+      }
+    }
   }
 
   V8_INLINE void DeclareArrowFunctionFormalParameters(
       PreParserFormalParameters* parameters, PreParserExpression params,
       const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
       bool* ok) {
     // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect
     // parameter lists that are too long.
+    // FIXME(marja): Add code to declare arrow function parameters to allocate
+    // less pessimistically.
   }
 
   V8_INLINE void ReindexLiterals(const PreParserFormalParameters& parameters) {}
 
   V8_INLINE PreParserExpression NoTemplateTag() {
     return PreParserExpression::NoTemplateTag();
   }
 
   V8_INLINE static bool IsTaggedTemplate(const PreParserExpression tag) {
     return !tag.IsNoTemplateTag();
@@ skipping 79 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H