diff options
Diffstat (limited to 'deps/v8/src/parsing/preparser.h')
| -rw-r--r-- | deps/v8/src/parsing/preparser.h | 298 |
1 files changed, 198 insertions, 100 deletions
diff --git a/deps/v8/src/parsing/preparser.h b/deps/v8/src/parsing/preparser.h index f4687eb3f7..77fe061f42 100644 --- a/deps/v8/src/parsing/preparser.h +++ b/deps/v8/src/parsing/preparser.h @@ -5,8 +5,10 @@ #ifndef V8_PARSING_PREPARSER_H #define V8_PARSING_PREPARSER_H +#include "src/ast/ast.h" #include "src/ast/scopes.h" #include "src/parsing/parser-base.h" +#include "src/parsing/preparse-data.h" namespace v8 { namespace internal { @@ -67,6 +69,9 @@ class PreParserIdentifier { static PreParserIdentifier Async() { return PreParserIdentifier(kAsyncIdentifier); } + static PreParserIdentifier Name() { + return PreParserIdentifier(kNameIdentifier); + } bool IsEmpty() const { return type_ == kEmptyIdentifier; } bool IsEval() const { return type_ == kEvalIdentifier; } bool IsArguments() const { return type_ == kArgumentsIdentifier; } @@ -79,11 +84,7 @@ class PreParserIdentifier { bool IsConstructor() const { return type_ == kConstructorIdentifier; } bool IsEnum() const { return type_ == kEnumIdentifier; } bool IsAwait() const { return type_ == kAwaitIdentifier; } - bool IsFutureStrictReserved() const { - return type_ == kFutureStrictReservedIdentifier || - type_ == kLetIdentifier || type_ == kStaticIdentifier || - type_ == kYieldIdentifier; - } + bool IsName() const { return type_ == kNameIdentifier; } // Allow identifier->name()[->length()] to work. The preparser // does not need the actual positions/lengths of the identifiers. @@ -109,7 +110,8 @@ class PreParserIdentifier { kConstructorIdentifier, kEnumIdentifier, kAwaitIdentifier, - kAsyncIdentifier + kAsyncIdentifier, + kNameIdentifier }; explicit PreParserIdentifier(Type type) : type_(type), string_(nullptr) {} @@ -125,49 +127,65 @@ class PreParserIdentifier { class PreParserExpression { public: PreParserExpression() - : code_(TypeField::encode(kEmpty)), identifiers_(nullptr) {} + : code_(TypeField::encode(kEmpty)), variables_(nullptr) {} static PreParserExpression Empty() { return PreParserExpression(); } static PreParserExpression Default( - ZoneList<const AstRawString*>* identifiers = nullptr) { - return PreParserExpression(TypeField::encode(kExpression), identifiers); + ZoneList<VariableProxy*>* variables = nullptr) { + return PreParserExpression(TypeField::encode(kExpression), variables); } static PreParserExpression Spread(PreParserExpression expression) { return PreParserExpression(TypeField::encode(kSpreadExpression), - expression.identifiers_); + expression.variables_); } static PreParserExpression FromIdentifier(PreParserIdentifier id, + VariableProxy* variable, Zone* zone) { PreParserExpression expression(TypeField::encode(kIdentifierExpression) | IdentifierTypeField::encode(id.type_)); - expression.AddIdentifier(id.string_, zone); + expression.AddVariable(variable, zone); return expression; } static PreParserExpression BinaryOperation(PreParserExpression left, Token::Value op, - PreParserExpression right) { - return PreParserExpression(TypeField::encode(kBinaryOperationExpression)); + PreParserExpression right, + Zone* zone) { + if (op == Token::COMMA) { + // Possibly an arrow function parameter list. + if (left.variables_ == nullptr) { + return PreParserExpression(TypeField::encode(kExpression), + right.variables_); + } + if (right.variables_ != nullptr) { + for (auto variable : *right.variables_) { + left.variables_->Add(variable, zone); + } + } + return PreParserExpression(TypeField::encode(kExpression), + left.variables_); + } + return PreParserExpression(TypeField::encode(kExpression)); } - static PreParserExpression Assignment() { + static PreParserExpression Assignment(ZoneList<VariableProxy*>* variables) { return PreParserExpression(TypeField::encode(kExpression) | - ExpressionTypeField::encode(kAssignment)); + ExpressionTypeField::encode(kAssignment), + variables); } static PreParserExpression ObjectLiteral( - ZoneList<const AstRawString*>* identifiers = nullptr) { + ZoneList<VariableProxy*>* variables) { return PreParserExpression(TypeField::encode(kObjectLiteralExpression), - identifiers); + variables); } - static PreParserExpression ArrayLiteral( - ZoneList<const AstRawString*>* identifiers = nullptr) { + static PreParserExpression ArrayLiteral(ZoneList<VariableProxy*>* variables) { return PreParserExpression(TypeField::encode(kArrayLiteralExpression), - identifiers); + variables); } static PreParserExpression StringLiteral() { @@ -284,11 +302,6 @@ class PreParserExpression { ExpressionTypeField::decode(code_) == kCallEvalExpression); } - bool IsDirectEvalCall() const { - return TypeField::decode(code_) == kExpression && - ExpressionTypeField::decode(code_) == kCallEvalExpression; - } - bool IsSuperCallReference() const { return TypeField::decode(code_) == kExpression && ExpressionTypeField::decode(code_) == kSuperCallReference; @@ -313,10 +326,6 @@ class PreParserExpression { PreParserExpression AsFunctionLiteral() { return *this; } - bool IsBinaryOperation() const { - return TypeField::decode(code_) == kBinaryOperationExpression; - } - // Dummy implementation for making expression->somefunc() work in both Parser // and PreParser. PreParserExpression* operator->() { return this; } @@ -329,15 +338,12 @@ class PreParserExpression { int position() const { return kNoSourcePosition; } void set_function_token_position(int position) {} - void set_is_class_field_initializer(bool is_class_field_initializer) {} - private: enum Type { kEmpty, kExpression, kIdentifierExpression, kStringLiteralExpression, - kBinaryOperationExpression, kSpreadExpression, kObjectLiteralExpression, kArrayLiteralExpression @@ -354,19 +360,18 @@ class PreParserExpression { kAssignment }; - explicit PreParserExpression( - uint32_t expression_code, - ZoneList<const AstRawString*>* identifiers = nullptr) - : code_(expression_code), identifiers_(identifiers) {} + explicit PreParserExpression(uint32_t expression_code, + ZoneList<VariableProxy*>* variables = nullptr) + : code_(expression_code), variables_(variables) {} - void AddIdentifier(const AstRawString* identifier, Zone* zone) { - if (identifier == nullptr) { + void AddVariable(VariableProxy* variable, Zone* zone) { + if (variable == nullptr) { return; } - if (identifiers_ == nullptr) { - identifiers_ = new (zone) ZoneList<const AstRawString*>(1, zone); + if (variables_ == nullptr) { + variables_ = new (zone) ZoneList<VariableProxy*>(1, zone); } - identifiers_->Add(identifier, zone); + variables_->Add(variable, zone); } // The first three bits are for the Type. @@ -389,9 +394,9 @@ class PreParserExpression { typedef BitField<bool, TypeField::kNext, 1> HasCoverInitializedNameField; uint32_t code_; - // If the PreParser is used in the identifier tracking mode, - // PreParserExpression accumulates identifiers in that expression. - ZoneList<const AstRawString*>* identifiers_; + // If the PreParser is used in the variable tracking mode, PreParserExpression + // accumulates variables in that expression. + ZoneList<VariableProxy*>* variables_; friend class PreParser; friend class PreParserFactory; @@ -401,13 +406,13 @@ class PreParserExpression { // The pre-parser doesn't need to build lists of expressions, identifiers, or -// the like. If the PreParser is used in identifier tracking mode, it needs to -// build lists of identifiers though. +// the like. If the PreParser is used in variable tracking mode, it needs to +// build lists of variables though. template <typename T> class PreParserList { public: // These functions make list->Add(some_expression) work (and do nothing). - PreParserList() : length_(0), identifiers_(nullptr) {} + PreParserList() : length_(0), variables_(nullptr) {} PreParserList* operator->() { return this; } void Add(T, Zone* zone); int length() const { return length_; } @@ -415,9 +420,9 @@ class PreParserList { bool IsNull() const { return length_ == -1; } private: - explicit PreParserList(int n) : length_(n), identifiers_(nullptr) {} + explicit PreParserList(int n) : length_(n), variables_(nullptr) {} int length_; - ZoneList<const AstRawString*>* identifiers_; + ZoneList<VariableProxy*>* variables_; friend class PreParser; friend class PreParserFactory; @@ -426,14 +431,14 @@ class PreParserList { template <> inline void PreParserList<PreParserExpression>::Add( PreParserExpression expression, Zone* zone) { - if (expression.identifiers_ != nullptr) { + if (expression.variables_ != nullptr) { DCHECK(FLAG_lazy_inner_functions); DCHECK(zone != nullptr); - if (identifiers_ == nullptr) { - identifiers_ = new (zone) ZoneList<const AstRawString*>(1, zone); + if (variables_ == nullptr) { + variables_ = new (zone) ZoneList<VariableProxy*>(1, zone); } - for (auto identifier : (*expression.identifiers_)) { - identifiers_->Add(identifier, zone); + for (auto identifier : (*expression.variables_)) { + variables_->Add(identifier, zone); } } ++length_; @@ -532,7 +537,8 @@ class PreParserStatement { class PreParserFactory { public: explicit PreParserFactory(AstValueFactory* ast_value_factory) - : zone_(ast_value_factory->zone()) {} + : ast_value_factory_(ast_value_factory), + zone_(ast_value_factory->zone()) {} void set_zone(Zone* zone) { zone_ = zone; } @@ -541,7 +547,14 @@ class PreParserFactory { // This is needed for object literal property names. Property names are // normalized to string literals during object literal parsing. PreParserExpression expression = PreParserExpression::Default(); - expression.AddIdentifier(identifier.string_, zone_); + if (identifier.string_ != nullptr) { + DCHECK(FLAG_lazy_inner_functions); + AstNodeFactory factory(ast_value_factory_); + factory.set_zone(zone_); + VariableProxy* variable = + factory.NewVariableProxy(identifier.string_, NORMAL_VARIABLE); + expression.AddVariable(variable, zone_); + } return expression; } PreParserExpression NewNumberLiteral(double number, @@ -559,7 +572,7 @@ class PreParserFactory { PreParserExpression NewArrayLiteral(PreParserExpressionList values, int first_spread_index, int literal_index, int pos) { - return PreParserExpression::ArrayLiteral(values.identifiers_); + return PreParserExpression::ArrayLiteral(values.variables_); } PreParserExpression NewClassLiteralProperty(PreParserExpression key, PreParserExpression value, @@ -572,18 +585,18 @@ class PreParserFactory { PreParserExpression value, ObjectLiteralProperty::Kind kind, bool is_computed_name) { - return PreParserExpression::Default(value.identifiers_); + return PreParserExpression::Default(value.variables_); } PreParserExpression NewObjectLiteralProperty(PreParserExpression key, PreParserExpression value, bool is_computed_name) { - return PreParserExpression::Default(value.identifiers_); + return PreParserExpression::Default(value.variables_); } PreParserExpression NewObjectLiteral(PreParserExpressionList properties, int literal_index, int boilerplate_properties, int pos) { - return PreParserExpression::ObjectLiteral(properties.identifiers_); + return PreParserExpression::ObjectLiteral(properties.variables_); } PreParserExpression NewVariableProxy(void* variable) { return PreParserExpression::Default(); @@ -604,7 +617,7 @@ class PreParserFactory { PreParserExpression NewBinaryOperation(Token::Value op, PreParserExpression left, PreParserExpression right, int pos) { - return PreParserExpression::BinaryOperation(left, op, right); + return PreParserExpression::BinaryOperation(left, op, right, zone_); } PreParserExpression NewCompareOperation(Token::Value op, PreParserExpression left, @@ -618,7 +631,9 @@ class PreParserFactory { PreParserExpression left, PreParserExpression right, int pos) { - return PreParserExpression::Assignment(); + // Identifiers need to be tracked since this might be a parameter with a + // default value inside an arrow function parameter list. + return PreParserExpression::Assignment(left.variables_); } PreParserExpression NewYield(PreParserExpression generator_object, PreParserExpression expression, int pos, @@ -662,7 +677,7 @@ class PreParserFactory { FunctionLiteral::ParameterFlag has_duplicate_parameters, FunctionLiteral::FunctionType function_type, FunctionLiteral::EagerCompileHint eager_compile_hint, int position, - bool has_braces) { + bool has_braces, int function_literal_id) { return PreParserExpression::Default(); } @@ -755,14 +770,23 @@ class PreParserFactory { } private: + AstValueFactory* ast_value_factory_; 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) {} - PreParserIdentifier at(int i) { return PreParserIdentifier(); } // Dummy + + ThreadedList<Parameter> params; }; @@ -838,11 +862,14 @@ class PreParser : public ParserBase<PreParser> { kPreParseSuccess }; - PreParser(Zone* zone, Scanner* scanner, AstValueFactory* ast_value_factory, + PreParser(Zone* zone, Scanner* scanner, uintptr_t stack_limit, + AstValueFactory* ast_value_factory, PendingCompilationErrorHandler* pending_error_handler, - RuntimeCallStats* runtime_call_stats, uintptr_t stack_limit) + RuntimeCallStats* runtime_call_stats, + bool parsing_on_main_thread = true) : ParserBase<PreParser>(zone, scanner, stack_limit, nullptr, - ast_value_factory, runtime_call_stats), + ast_value_factory, runtime_call_stats, + parsing_on_main_thread), use_counts_(nullptr), track_unresolved_variables_(false), pending_error_handler_(pending_error_handler) {} @@ -859,6 +886,9 @@ class PreParser : public ParserBase<PreParser> { bool is_module = false) { DCHECK_NULL(scope_state_); DeclarationScope* scope = NewScriptScope(); +#ifdef DEBUG + scope->set_is_being_lazily_parsed(true); +#endif // ModuleDeclarationInstantiation for Source Text Module Records creates a // new Module Environment Record whose outer lexical environment record is @@ -877,8 +907,6 @@ class PreParser : public ParserBase<PreParser> { } else if (is_strict(this->scope()->language_mode())) { CheckStrictOctalLiteral(start_position, scanner()->location().end_pos, &ok); - CheckDecimalLiteralWithLeadingZero(start_position, - scanner()->location().end_pos); } if (materialized_literals) { *materialized_literals = function_state_->materialized_literal_count(); @@ -958,11 +986,6 @@ class PreParser : public ParserBase<PreParser> { V8_INLINE void MarkCollectedTailCallExpressions() {} V8_INLINE void MarkTailPosition(PreParserExpression expression) {} - V8_INLINE PreParserExpressionList - PrepareSpreadArguments(PreParserExpressionList list) { - return list; - } - V8_INLINE PreParserExpression SpreadCall(PreParserExpression function, PreParserExpressionList args, int pos); @@ -970,11 +993,6 @@ class PreParser : public ParserBase<PreParser> { PreParserExpressionList args, int pos); - V8_INLINE PreParserExpression - RewriteSuperCall(PreParserExpression call_expression) { - return call_expression; - } - V8_INLINE void RewriteDestructuringAssignments() {} V8_INLINE PreParserExpression RewriteExponentiation(PreParserExpression left, @@ -1015,8 +1033,7 @@ class PreParser : public ParserBase<PreParser> { bool* ok) { DCHECK(!expr.AsIdentifier().IsEnum()); DCHECK(!parsing_module_ || !expr.AsIdentifier().IsAwait()); - DCHECK(is_sloppy(language_mode()) || - !IsFutureStrictReserved(expr.AsIdentifier())); + DCHECK(IsIdentifier(expr)); return labels; } @@ -1035,7 +1052,22 @@ class PreParser : public ParserBase<PreParser> { PreParserStatementList cases, Scope* scope) { return PreParserStatement::Default(); } - V8_INLINE void RewriteCatchPattern(CatchInfo* catch_info, bool* ok) {} + + V8_INLINE void RewriteCatchPattern(CatchInfo* catch_info, bool* ok) { + if (track_unresolved_variables_) { + if (catch_info->name.string_ != nullptr) { + // Unlike in the parser, we need to declare the catch variable as LET + // variable, so that it won't get hoisted out of the scope. + catch_info->scope->DeclareVariableName(catch_info->name.string_, LET); + } + if (catch_info->pattern.variables_ != nullptr) { + for (auto variable : *catch_info->pattern.variables_) { + scope()->DeclareVariableName(variable->raw_name(), LET); + } + } + } + } + V8_INLINE void ValidateCatchBlock(const CatchInfo& catch_info, bool* ok) {} V8_INLINE PreParserStatement RewriteTryStatement( PreParserStatement try_block, PreParserStatement catch_block, @@ -1060,9 +1092,19 @@ class PreParser : public ParserBase<PreParser> { } V8_INLINE PreParserStatement DeclareFunction( - PreParserIdentifier variable_name, PreParserExpression function, int pos, - bool is_generator, bool is_async, ZoneList<const AstRawString*>* names, + PreParserIdentifier variable_name, PreParserExpression function, + VariableMode mode, int pos, bool is_generator, bool is_async, + bool is_sloppy_block_function, ZoneList<const AstRawString*>* names, bool* ok) { + DCHECK_NULL(names); + if (variable_name.string_ != nullptr) { + DCHECK(track_unresolved_variables_); + scope()->DeclareVariableName(variable_name.string_, mode); + if (is_sloppy_block_function) { + GetDeclarationScope()->DeclareSloppyBlockFunction(variable_name.string_, + scope()); + } + } return Statement::Default(); } @@ -1070,6 +1112,12 @@ class PreParser : public ParserBase<PreParser> { DeclareClass(PreParserIdentifier variable_name, PreParserExpression value, ZoneList<const AstRawString*>* names, int class_token_pos, int end_pos, bool* ok) { + // Preparser shouldn't be used in contexts where we need to track the names. + DCHECK_NULL(names); + if (variable_name.string_ != nullptr) { + DCHECK(track_unresolved_variables_); + scope()->DeclareVariableName(variable_name.string_, LET); + } return PreParserStatement::Default(); } V8_INLINE void DeclareClassVariable(PreParserIdentifier name, @@ -1077,10 +1125,16 @@ class PreParser : public ParserBase<PreParser> { int class_token_pos, bool* ok) {} V8_INLINE void DeclareClassProperty(PreParserIdentifier class_name, PreParserExpression property, - ClassInfo* class_info, bool* ok) {} + ClassLiteralProperty::Kind kind, + bool is_static, bool is_constructor, + ClassInfo* class_info, bool* ok) { + } V8_INLINE PreParserExpression RewriteClassLiteral(PreParserIdentifier name, ClassInfo* class_info, int pos, bool* ok) { + bool has_default_constructor = !class_info->has_seen_constructor; + // Account for the default constructor. + if (has_default_constructor) GetNextFunctionLiteralId(); return PreParserExpression::Default(); } @@ -1115,10 +1169,6 @@ class PreParser : public ParserBase<PreParser> { return identifier.IsAwait(); } - V8_INLINE bool IsFutureStrictReserved(PreParserIdentifier identifier) const { - return identifier.IsFutureStrictReserved(); - } - // Returns true if the expression is of type "this.foo". V8_INLINE static bool IsThisProperty(PreParserExpression expression) { return expression.IsThisProperty(); @@ -1146,8 +1196,8 @@ class PreParser : public ParserBase<PreParser> { return identifier.IsConstructor(); } - V8_INLINE bool IsDirectEvalCall(PreParserExpression expression) const { - return expression.IsDirectEvalCall(); + V8_INLINE bool IsName(PreParserIdentifier identifier) const { + return identifier.IsName(); } V8_INLINE static bool IsBoilerplateProperty(PreParserExpression property) { @@ -1202,11 +1252,16 @@ class PreParser : public ParserBase<PreParser> { V8_INLINE static void CheckAssigningFunctionLiteralToProperty( PreParserExpression left, PreParserExpression right) {} - V8_INLINE static PreParserExpression MarkExpressionAsAssigned( - PreParserExpression expression) { + V8_INLINE void MarkExpressionAsAssigned(PreParserExpression expression) { // TODO(marja): To be able to produce the same errors, the preparser needs // to start tracking which expressions are variables and which are assigned. - return expression; + if (expression.variables_ != nullptr) { + DCHECK(FLAG_lazy_inner_functions); + DCHECK(track_unresolved_variables_); + for (auto variable : *expression.variables_) { + variable->set_is_assigned(); + } + } } V8_INLINE bool ShortcutNumericLiteralBinaryExpression(PreParserExpression* x, @@ -1229,6 +1284,11 @@ class PreParser : public ParserBase<PreParser> { V8_INLINE PreParserStatement BuildInitializationBlock(DeclarationParsingResult* parsing_result, ZoneList<const AstRawString*>* names, bool* ok) { + for (auto declaration : parsing_result->declarations) { + DeclareAndInitializeVariables(PreParserStatement::Default(), + &(parsing_result->descriptor), &declaration, + names, ok); + } return PreParserStatement::Default(); } @@ -1236,15 +1296,25 @@ class PreParser : public ParserBase<PreParser> { InitializeForEachStatement(PreParserStatement stmt, PreParserExpression each, PreParserExpression subject, PreParserStatement body, int each_keyword_pos) { + MarkExpressionAsAssigned(each); return stmt; } V8_INLINE PreParserStatement RewriteForVarInLegacy(const ForInfo& for_info) { return PreParserStatement::Null(); } + V8_INLINE void DesugarBindingInForEachStatement( ForInfo* for_info, PreParserStatement* body_block, - PreParserExpression* each_variable, bool* ok) {} + PreParserExpression* each_variable, bool* ok) { + if (track_unresolved_variables_) { + DCHECK(for_info->parsing_result.declarations.length() == 1); + DeclareAndInitializeVariables( + PreParserStatement::Default(), &for_info->parsing_result.descriptor, + &for_info->parsing_result.declarations[0], nullptr, ok); + } + } + V8_INLINE PreParserStatement CreateForEachStatementTDZ( PreParserStatement init_block, const ForInfo& for_info, bool* ok) { return init_block; @@ -1449,14 +1519,30 @@ class PreParser : public ParserBase<PreParser> { 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 DeclareFormalParameter(DeclarationScope* scope, - PreParserIdentifier parameter) { + 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.variables_ != nullptr) { + for (auto variable : *parameter->pattern.variables_) { + scope->DeclareVariableName(variable->raw_name(), VAR); + } + } + } + } } V8_INLINE void DeclareArrowFunctionFormalParameters( @@ -1465,6 +1551,14 @@ class PreParser : public ParserBase<PreParser> { bool* ok) { // TODO(wingo): Detect duplicated identifiers in paramlists. Detect // parameter lists that are too long. + if (track_unresolved_variables_) { + DCHECK(FLAG_lazy_inner_functions); + if (params.variables_ != nullptr) { + for (auto variable : *params.variables_) { + parameters->scope->DeclareVariableName(variable->raw_name(), VAR); + } + } + } } V8_INLINE void ReindexLiterals(const PreParserFormalParameters& parameters) {} @@ -1485,7 +1579,7 @@ class PreParser : public ParserBase<PreParser> { V8_INLINE PreParserExpression ExpressionListToExpression(PreParserExpressionList args) { - return PreParserExpression::Default(args.identifiers_); + return PreParserExpression::Default(args.variables_); } V8_INLINE void AddAccessorPrefixToFunctionName(bool is_get, @@ -1535,8 +1629,8 @@ PreParserStatementList PreParser::ParseEagerFunctionBody( FunctionLiteral::FunctionType function_type, bool* ok) { PreParserStatementList result; - Scope* inner_scope = scope(); - if (!parameters.is_simple) inner_scope = NewScope(BLOCK_SCOPE); + DeclarationScope* inner_scope = scope()->AsDeclarationScope(); + if (!parameters.is_simple) inner_scope = NewVarblockScope(); { BlockState block_state(&scope_state_, inner_scope); @@ -1545,6 +1639,10 @@ PreParserStatementList PreParser::ParseEagerFunctionBody( } Expect(Token::RBRACE, ok); + + if (is_sloppy(inner_scope->language_mode())) { + inner_scope->HoistSloppyBlockFunctions(nullptr); + } return result; } |