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"
 
@@ skipping 135 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_);

[Toon Verwaest, 2016/12/01 13:33:27]

Mmh, actually this isn't correct is it?

var {a:b}={a} just creates an assigned var b on the left side, and a reference
to a on the right side. This would wrongly assume that the a reference on the
right resolves to the "local a"; but there is no local "a". It need to be
context allocated in the outer scope (if this is a nested function with no other
"a" declaration).

[marja, 2016/12/05 16:05:19]

Tracking unresolved variables doesn't go via this code path.

Added tests to demonstrate that this works:

      {"function inner() { var {my_var : a} = {my_var}; }", true},
      {"function inner() { let {my_var : a} = {my_var}; }", true},
      {"function inner() { const {my_var : a} = {my_var}; }", true},

and

(function TestLazyInnerFunctionDestructuring() {
  var i = (function eager_outer() {
    var outer_var = 41; // Should be context-allocated
    function lazy_inner() {
      // This introduces b and refers to outer_var.
      var {outer_var : b} = {outer_var};
      return b;
    }
    return lazy_inner;
  })();
  assertEquals(41, i());
})();

   }
   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 {
+    Parameter(const AstRawString* name, bool is_optional, bool is_rest)
+        : name(name),
+          pattern(PreParserExpression::Default()),
+          is_optional(is_optional),
+          is_rest(is_rest) {}
+    Parameter(PreParserExpression pattern, bool is_optional, bool is_rest)
+        : name(nullptr),
+          pattern(pattern),
+          is_optional(is_optional),
+          is_rest(is_rest) {}
+    Parameter()
+        : name(nullptr),
+          pattern(PreParserExpression::Default()),
+          is_optional(false),
+          is_rest(false) {}
+    Parameter** next() { return &next_parameter; }
+    Parameter* const* next() const { return &next_parameter; }
+    const AstRawString* name;
+    PreParserExpression pattern;
+    bool is_optional;
+    bool is_rest;
+    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 680 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);
+      bool is_simple = pattern.IsIdentifier() && IsEmptyExpression(initializer);
+      if (is_simple) {
+        DCHECK_EQ(1, pattern.identifiers_->length());
+        parameters->params.Add(
+            new (zone()) PreParserFormalParameters::Parameter(
+                (*pattern.identifiers_)[0], !IsEmptyExpression(initializer),
+                is_rest));
+      } else {
+        parameters->params.Add(
+            new (zone()) PreParserFormalParameters::Parameter(
+                pattern, !IsEmptyExpression(initializer), is_rest));
+      }
+    }
     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->name != nullptr) {
+          DCHECK(FLAG_lazy_inner_functions);
+          bool is_duplicate = false;
+          scope->DeclareParameterName(parameter->name, parameter->is_optional,
+                                      parameter->is_rest, &is_duplicate,
+                                      ast_value_factory());
+        }
+        if (parameter->pattern.identifiers_ != nullptr) {
+          DCHECK(FLAG_lazy_inner_functions);
+          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 (once we add
+    // lazy inner arrow functions - at the moment inner arrow functions are
+    // parsed eagerly).
   }
 
   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