[ignition] desugar async functions/generators/modules in BytecodeGenerator

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 2579 matching lines @@
   enum IdType { kIdTypeInvalid = -1, kIdTypeTopLevel = 0 };
 
   enum ParameterFlag { kNoDuplicateParameters, kHasDuplicateParameters };
 
   enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
 
   Handle<String> name() const { return raw_name_->string(); }
   const AstString* raw_name() const { return raw_name_; }
   void set_raw_name(const AstString* name) { raw_name_ = name; }
   DeclarationScope* scope() const { return scope_; }
+
+  // AST desugaring of initialization of non-simple parameters. If non-null,
+  // forces Ignition/TF pipeline.
+  Block* parameter_init_block() const { return parameter_init_block_; }
+  void set_parameter_init_block(Block* block) { parameter_init_block_ = block; }
+
   ZoneList<Statement*>* body() const { return body_; }
   void set_function_token_position(int pos) { function_token_position_ = pos; }
   int function_token_position() const { return function_token_position_; }
   int start_position() const;
   int end_position() const;
   int SourceSize() const { return end_position() - start_position(); }
   bool is_declaration() const { return function_type() == kDeclaration; }
   bool is_named_expression() const {
     return function_type() == kNamedExpression;
   }
@@ skipping 130 matching lines @@
       : Expression(position, kFunctionLiteral),
         materialized_literal_count_(materialized_literal_count),
         expected_property_count_(expected_property_count),
         parameter_count_(parameter_count),
         function_length_(function_length),
         function_token_position_(kNoSourcePosition),
         yield_count_(0),
         has_braces_(has_braces),
         raw_name_(name),
         scope_(scope),
+        parameter_init_block_(nullptr),
         body_(body),
         raw_inferred_name_(ast_value_factory->empty_string()),
         ast_properties_(zone),
         function_literal_id_(function_literal_id) {
     bit_field_ |= FunctionTypeBits::encode(function_type) |
                   Pretenure::encode(false) |
                   HasDuplicateParameters::encode(has_duplicate_parameters ==
                                                  kHasDuplicateParameters) |
                   ShouldNotBeUsedOnceHintField::encode(false) |
                   DontOptimizeReasonField::encode(kNoReason);
@@ skipping 13 matching lines @@
   int materialized_literal_count_;
   int expected_property_count_;
   int parameter_count_;
   int function_length_;
   int function_token_position_;
   int yield_count_;
   bool has_braces_;
 
   const AstString* raw_name_;
   DeclarationScope* scope_;
+  Block* parameter_init_block_;
   ZoneList<Statement*>* body_;
   const AstString* raw_inferred_name_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
   int function_literal_id_;
   FeedbackVectorSlot literal_feedback_slot_;
 };
 
 // Property is used for passing information
 // about a class literal's properties from the parser to the code generator.
@@ skipping 862 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_