Line data Source code
1 : // Copyright 2012 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/parsing/parser.h"
6 :
7 : #include <algorithm>
8 : #include <memory>
9 :
10 : #include "src/ast/ast-function-literal-id-reindexer.h"
11 : #include "src/ast/ast-traversal-visitor.h"
12 : #include "src/ast/ast.h"
13 : #include "src/ast/source-range-ast-visitor.h"
14 : #include "src/bailout-reason.h"
15 : #include "src/base/ieee754.h"
16 : #include "src/base/overflowing-math.h"
17 : #include "src/base/platform/platform.h"
18 : #include "src/char-predicates-inl.h"
19 : #include "src/compiler-dispatcher/compiler-dispatcher.h"
20 : #include "src/conversions-inl.h"
21 : #include "src/log.h"
22 : #include "src/message-template.h"
23 : #include "src/objects/scope-info.h"
24 : #include "src/parsing/expression-scope-reparenter.h"
25 : #include "src/parsing/parse-info.h"
26 : #include "src/parsing/rewriter.h"
27 : #include "src/runtime/runtime.h"
28 : #include "src/string-stream.h"
29 : #include "src/tracing/trace-event.h"
30 : #include "src/zone/zone-list-inl.h"
31 :
32 : namespace v8 {
33 : namespace internal {
34 :
35 97850 : FunctionLiteral* Parser::DefaultConstructor(const AstRawString* name,
36 : bool call_super, int pos,
37 : int end_pos) {
38 : int expected_property_count = -1;
39 : const int parameter_count = 0;
40 :
41 : FunctionKind kind = call_super ? FunctionKind::kDefaultDerivedConstructor
42 97850 : : FunctionKind::kDefaultBaseConstructor;
43 97850 : DeclarationScope* function_scope = NewFunctionScope(kind);
44 : SetLanguageMode(function_scope, LanguageMode::kStrict);
45 : // Set start and end position to the same value
46 : function_scope->set_start_position(pos);
47 : function_scope->set_end_position(pos);
48 : ScopedPtrList<Statement> body(pointer_buffer());
49 :
50 : {
51 97851 : FunctionState function_state(&function_state_, &scope_, function_scope);
52 :
53 97851 : if (call_super) {
54 : // Create a SuperCallReference and handle in BytecodeGenerator.
55 : auto constructor_args_name = ast_value_factory()->empty_string();
56 : bool is_rest = true;
57 : bool is_optional = false;
58 : Variable* constructor_args = function_scope->DeclareParameter(
59 : constructor_args_name, VariableMode::kTemporary, is_optional, is_rest,
60 25302 : ast_value_factory(), pos);
61 :
62 : Expression* call;
63 : {
64 : ScopedPtrList<Expression> args(pointer_buffer());
65 : Spread* spread_args = factory()->NewSpread(
66 : factory()->NewVariableProxy(constructor_args), pos, pos);
67 :
68 : args.Add(spread_args);
69 25302 : Expression* super_call_ref = NewSuperCallReference(pos);
70 25303 : call = factory()->NewCall(super_call_ref, args, pos);
71 : }
72 : body.Add(factory()->NewReturnStatement(call, pos));
73 : }
74 :
75 : expected_property_count = function_state.expected_property_count();
76 : }
77 :
78 97852 : FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
79 : name, function_scope, body, expected_property_count, parameter_count,
80 : parameter_count, FunctionLiteral::kNoDuplicateParameters,
81 : FunctionLiteral::kAnonymousExpression, default_eager_compile_hint(), pos,
82 97852 : true, GetNextFunctionLiteralId());
83 97851 : return function_literal;
84 : }
85 :
86 1899082 : void Parser::ReportUnexpectedTokenAt(Scanner::Location location,
87 : Token::Value token,
88 : MessageTemplate message) {
89 : const char* arg = nullptr;
90 1899082 : switch (token) {
91 : case Token::EOS:
92 : message = MessageTemplate::kUnexpectedEOS;
93 : break;
94 : case Token::SMI:
95 : case Token::NUMBER:
96 : case Token::BIGINT:
97 : message = MessageTemplate::kUnexpectedTokenNumber;
98 426 : break;
99 : case Token::STRING:
100 : message = MessageTemplate::kUnexpectedTokenString;
101 348 : break;
102 : case Token::PRIVATE_NAME:
103 : case Token::IDENTIFIER:
104 : message = MessageTemplate::kUnexpectedTokenIdentifier;
105 9661 : break;
106 : case Token::AWAIT:
107 : case Token::ENUM:
108 : message = MessageTemplate::kUnexpectedReserved;
109 3400 : break;
110 : case Token::LET:
111 : case Token::STATIC:
112 : case Token::YIELD:
113 : case Token::FUTURE_STRICT_RESERVED_WORD:
114 : message = is_strict(language_mode())
115 : ? MessageTemplate::kUnexpectedStrictReserved
116 16207 : : MessageTemplate::kUnexpectedTokenIdentifier;
117 : break;
118 : case Token::TEMPLATE_SPAN:
119 : case Token::TEMPLATE_TAIL:
120 : message = MessageTemplate::kUnexpectedTemplateString;
121 200 : break;
122 : case Token::ESCAPED_STRICT_RESERVED_WORD:
123 : case Token::ESCAPED_KEYWORD:
124 : message = MessageTemplate::kInvalidEscapedReservedWord;
125 4580 : break;
126 : case Token::ILLEGAL:
127 1780802 : if (scanner()->has_error()) {
128 : message = scanner()->error();
129 232955 : location = scanner()->error_location();
130 : } else {
131 : message = MessageTemplate::kInvalidOrUnexpectedToken;
132 : }
133 : break;
134 : case Token::REGEXP_LITERAL:
135 : message = MessageTemplate::kUnexpectedTokenRegExp;
136 0 : break;
137 : default:
138 : const char* name = Token::String(token);
139 : DCHECK_NOT_NULL(name);
140 : arg = name;
141 78890 : break;
142 : }
143 1899082 : ReportMessageAt(location, message, arg);
144 1899082 : }
145 :
146 : // ----------------------------------------------------------------------------
147 : // Implementation of Parser
148 :
149 1713133 : bool Parser::ShortcutNumericLiteralBinaryExpression(Expression** x,
150 : Expression* y,
151 : Token::Value op, int pos) {
152 1713133 : if ((*x)->IsNumberLiteral() && y->IsNumberLiteral()) {
153 1259732 : double x_val = (*x)->AsLiteral()->AsNumber();
154 1259730 : double y_val = y->AsLiteral()->AsNumber();
155 629863 : switch (op) {
156 : case Token::ADD:
157 31278 : *x = factory()->NewNumberLiteral(x_val + y_val, pos);
158 15639 : return true;
159 : case Token::SUB:
160 3380 : *x = factory()->NewNumberLiteral(x_val - y_val, pos);
161 1690 : return true;
162 : case Token::MUL:
163 429280 : *x = factory()->NewNumberLiteral(x_val * y_val, pos);
164 214640 : return true;
165 : case Token::DIV:
166 6468 : *x = factory()->NewNumberLiteral(base::Divide(x_val, y_val), pos);
167 3234 : return true;
168 : case Token::BIT_OR: {
169 10511 : int value = DoubleToInt32(x_val) | DoubleToInt32(y_val);
170 21022 : *x = factory()->NewNumberLiteral(value, pos);
171 10511 : return true;
172 : }
173 : case Token::BIT_AND: {
174 369 : int value = DoubleToInt32(x_val) & DoubleToInt32(y_val);
175 738 : *x = factory()->NewNumberLiteral(value, pos);
176 369 : return true;
177 : }
178 : case Token::BIT_XOR: {
179 201 : int value = DoubleToInt32(x_val) ^ DoubleToInt32(y_val);
180 402 : *x = factory()->NewNumberLiteral(value, pos);
181 201 : return true;
182 : }
183 : case Token::SHL: {
184 : int value =
185 381051 : base::ShlWithWraparound(DoubleToInt32(x_val), DoubleToInt32(y_val));
186 762104 : *x = factory()->NewNumberLiteral(value, pos);
187 381051 : return true;
188 : }
189 : case Token::SHR: {
190 416 : uint32_t shift = DoubleToInt32(y_val) & 0x1F;
191 416 : uint32_t value = DoubleToUint32(x_val) >> shift;
192 832 : *x = factory()->NewNumberLiteral(value, pos);
193 416 : return true;
194 : }
195 : case Token::SAR: {
196 372 : uint32_t shift = DoubleToInt32(y_val) & 0x1F;
197 372 : int value = ArithmeticShiftRight(DoubleToInt32(x_val), shift);
198 744 : *x = factory()->NewNumberLiteral(value, pos);
199 372 : return true;
200 : }
201 : case Token::EXP:
202 2516 : *x = factory()->NewNumberLiteral(base::ieee754::pow(x_val, y_val), pos);
203 1258 : return true;
204 : default:
205 : break;
206 : }
207 : }
208 : return false;
209 : }
210 :
211 1083747 : bool Parser::CollapseNaryExpression(Expression** x, Expression* y,
212 : Token::Value op, int pos,
213 : const SourceRange& range) {
214 : // Filter out unsupported ops.
215 1083747 : if (!Token::IsBinaryOp(op) || op == Token::EXP) return false;
216 :
217 : // Convert *x into an nary operation with the given op, returning false if
218 : // this is not possible.
219 : NaryOperation* nary = nullptr;
220 2162908 : if ((*x)->IsBinaryOperation()) {
221 198829 : BinaryOperation* binop = (*x)->AsBinaryOperation();
222 198829 : if (binop->op() != op) return false;
223 :
224 256312 : nary = factory()->NewNaryOperation(op, binop->left(), 2);
225 : nary->AddSubsequent(binop->right(), binop->position());
226 : ConvertBinaryToNaryOperationSourceRange(binop, nary);
227 128154 : *x = nary;
228 882625 : } else if ((*x)->IsNaryOperation()) {
229 218799 : nary = (*x)->AsNaryOperation();
230 218799 : if (nary->op() != op) return false;
231 : } else {
232 : return false;
233 : }
234 :
235 : // Append our current expression to the nary operation.
236 : // TODO(leszeks): Do some literal collapsing here if we're appending Smi or
237 : // String literals.
238 : nary->AddSubsequent(y, pos);
239 : nary->clear_parenthesized();
240 : AppendNaryOperationSourceRange(nary, range);
241 :
242 : return true;
243 : }
244 :
245 684573 : Expression* Parser::BuildUnaryExpression(Expression* expression,
246 : Token::Value op, int pos) {
247 : DCHECK_NOT_NULL(expression);
248 684573 : const Literal* literal = expression->AsLiteral();
249 684573 : if (literal != nullptr) {
250 365082 : if (op == Token::NOT) {
251 : // Convert the literal to a boolean condition and negate it.
252 275 : return factory()->NewBooleanLiteral(literal->ToBooleanIsFalse(), pos);
253 364807 : } else if (literal->IsNumberLiteral()) {
254 : // Compute some expressions involving only number literals.
255 360391 : double value = literal->AsNumber();
256 360392 : switch (op) {
257 : case Token::ADD:
258 : return expression;
259 : case Token::SUB:
260 703474 : return factory()->NewNumberLiteral(-value, pos);
261 : case Token::BIT_NOT:
262 3026 : return factory()->NewNumberLiteral(~DoubleToInt32(value), pos);
263 : default:
264 : break;
265 : }
266 : }
267 : }
268 329666 : return factory()->NewUnaryOperation(op, expression, pos);
269 : }
270 :
271 1230 : Expression* Parser::NewThrowError(Runtime::FunctionId id,
272 : MessageTemplate message,
273 : const AstRawString* arg, int pos) {
274 : ScopedPtrList<Expression> args(pointer_buffer());
275 : args.Add(factory()->NewSmiLiteral(static_cast<int>(message), pos));
276 : args.Add(factory()->NewStringLiteral(arg, pos));
277 1230 : CallRuntime* call_constructor = factory()->NewCallRuntime(id, args, pos);
278 1230 : return factory()->NewThrow(call_constructor, pos);
279 : }
280 :
281 2758 : Expression* Parser::NewSuperPropertyReference(int pos) {
282 : // this_function[home_object_symbol]
283 : VariableProxy* this_function_proxy =
284 : NewUnresolved(ast_value_factory()->this_function_string(), pos);
285 : Expression* home_object_symbol_literal = factory()->NewSymbolLiteral(
286 : AstSymbol::kHomeObjectSymbol, kNoSourcePosition);
287 : Expression* home_object = factory()->NewProperty(
288 : this_function_proxy, home_object_symbol_literal, pos);
289 2758 : return factory()->NewSuperPropertyReference(home_object, pos);
290 : }
291 :
292 28192 : Expression* Parser::NewSuperCallReference(int pos) {
293 : VariableProxy* new_target_proxy =
294 : NewUnresolved(ast_value_factory()->new_target_string(), pos);
295 : VariableProxy* this_function_proxy =
296 : NewUnresolved(ast_value_factory()->this_function_string(), pos);
297 : return factory()->NewSuperCallReference(new_target_proxy, this_function_proxy,
298 28193 : pos);
299 : }
300 :
301 2113 : Expression* Parser::NewTargetExpression(int pos) {
302 : auto proxy = NewUnresolved(ast_value_factory()->new_target_string(), pos);
303 : proxy->set_is_new_target();
304 2113 : return proxy;
305 : }
306 :
307 3210 : Expression* Parser::ImportMetaExpression(int pos) {
308 : ScopedPtrList<Expression> args(pointer_buffer());
309 : return factory()->NewCallRuntime(Runtime::kInlineGetImportMetaObject, args,
310 6420 : pos);
311 : }
312 :
313 24947450 : Expression* Parser::ExpressionFromLiteral(Token::Value token, int pos) {
314 24947450 : switch (token) {
315 : case Token::NULL_LITERAL:
316 77258 : return factory()->NewNullLiteral(pos);
317 : case Token::TRUE_LITERAL:
318 163205 : return factory()->NewBooleanLiteral(true, pos);
319 : case Token::FALSE_LITERAL:
320 247271 : return factory()->NewBooleanLiteral(false, pos);
321 : case Token::SMI: {
322 : uint32_t value = scanner()->smi_value();
323 37412515 : return factory()->NewSmiLiteral(value, pos);
324 : }
325 : case Token::NUMBER: {
326 1318209 : double value = scanner()->DoubleValue();
327 1318262 : return factory()->NewNumberLiteral(value, pos);
328 : }
329 : case Token::BIGINT:
330 12293 : return factory()->NewBigIntLiteral(
331 : AstBigInt(scanner()->CurrentLiteralAsCString(zone())), pos);
332 : case Token::STRING: {
333 4423033 : return factory()->NewStringLiteral(GetSymbol(), pos);
334 : }
335 : default:
336 : DCHECK(false);
337 : }
338 0 : return FailureExpression();
339 : }
340 :
341 62632 : Expression* Parser::NewV8Intrinsic(const AstRawString* name,
342 : const ScopedPtrList<Expression>& args,
343 : int pos) {
344 62632 : if (extension_ != nullptr) {
345 : // The extension structures are only accessible while parsing the
346 : // very first time, not when reparsing because of lazy compilation.
347 : GetClosureScope()->ForceEagerCompilation();
348 : }
349 :
350 : DCHECK(name->is_one_byte());
351 : const Runtime::Function* function =
352 62632 : Runtime::FunctionForName(name->raw_data(), name->length());
353 :
354 62635 : if (function != nullptr) {
355 : // Check for possible name clash.
356 : DCHECK_EQ(Context::kNotFound,
357 : Context::IntrinsicIndexForName(name->raw_data(), name->length()));
358 :
359 : // Check that the expected number of arguments are being passed.
360 100054 : if (function->nargs != -1 && function->nargs != args.length()) {
361 9 : ReportMessage(MessageTemplate::kRuntimeWrongNumArgs);
362 9 : return FailureExpression();
363 : }
364 :
365 62581 : return factory()->NewCallRuntime(function, args, pos);
366 : }
367 :
368 : int context_index =
369 45 : Context::IntrinsicIndexForName(name->raw_data(), name->length());
370 :
371 : // Check that the function is defined.
372 45 : if (context_index == Context::kNotFound) {
373 45 : ReportMessage(MessageTemplate::kNotDefined, name);
374 45 : return FailureExpression();
375 : }
376 :
377 0 : return factory()->NewCallRuntime(context_index, args, pos);
378 : }
379 :
380 2451301 : Parser::Parser(ParseInfo* info)
381 : : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
382 : info->extension(), info->GetOrCreateAstValueFactory(),
383 : info->pending_error_handler(),
384 : info->runtime_call_stats(), info->logger(),
385 : info->script().is_null() ? -1 : info->script()->id(),
386 : info->is_module(), true),
387 : info_(info),
388 : scanner_(info->character_stream(), info->is_module()),
389 : preparser_zone_(info->zone()->allocator(), ZONE_NAME),
390 : reusable_preparser_(nullptr),
391 : mode_(PARSE_EAGERLY), // Lazy mode must be set explicitly.
392 : source_range_map_(info->source_range_map()),
393 : target_stack_(nullptr),
394 : total_preparse_skipped_(0),
395 : consumed_preparse_data_(info->consumed_preparse_data()),
396 : preparse_data_buffer_(),
397 19610420 : parameters_end_pos_(info->parameters_end_pos()) {
398 : // Even though we were passed ParseInfo, we should not store it in
399 : // Parser - this makes sure that Isolate is not accidentally accessed via
400 : // ParseInfo during background parsing.
401 : DCHECK_NOT_NULL(info->character_stream());
402 : // Determine if functions can be lazily compiled. This is necessary to
403 : // allow some of our builtin JS files to be lazily compiled. These
404 : // builtins cannot be handled lazily by the parser, since we have to know
405 : // if a function uses the special natives syntax, which is something the
406 : // parser records.
407 : // If the debugger requests compilation for break points, we cannot be
408 : // aggressive about lazy compilation, because it might trigger compilation
409 : // of functions without an outer context when setting a breakpoint through
410 : // Debug::FindSharedFunctionInfoInScript
411 : // We also compile eagerly for kProduceExhaustiveCodeCache.
412 4902290 : bool can_compile_lazily = info->allow_lazy_compile() && !info->is_eager();
413 :
414 2451302 : set_default_eager_compile_hint(can_compile_lazily
415 : ? FunctionLiteral::kShouldLazyCompile
416 : : FunctionLiteral::kShouldEagerCompile);
417 4621318 : allow_lazy_ = info->allow_lazy_compile() && info->allow_lazy_parsing() &&
418 4621632 : !info->is_native() && info->extension() == nullptr &&
419 2451302 : can_compile_lazily;
420 4149457 : set_allow_natives(info->allow_natives_syntax() || info->is_native());
421 : set_allow_harmony_public_fields(info->allow_harmony_public_fields());
422 : set_allow_harmony_static_fields(info->allow_harmony_static_fields());
423 : set_allow_harmony_dynamic_import(info->allow_harmony_dynamic_import());
424 : set_allow_harmony_import_meta(info->allow_harmony_import_meta());
425 : set_allow_harmony_numeric_separator(info->allow_harmony_numeric_separator());
426 : set_allow_harmony_private_fields(info->allow_harmony_private_fields());
427 : set_allow_harmony_private_methods(info->allow_harmony_private_methods());
428 375048142 : for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
429 : ++feature) {
430 186298420 : use_counts_[feature] = 0;
431 : }
432 2451302 : }
433 :
434 13308 : void Parser::InitializeEmptyScopeChain(ParseInfo* info) {
435 : DCHECK_NULL(original_scope_);
436 : DCHECK_NULL(info->script_scope());
437 2451303 : DeclarationScope* script_scope = NewScriptScope();
438 : info->set_script_scope(script_scope);
439 2451302 : original_scope_ = script_scope;
440 13308 : }
441 :
442 2437995 : void Parser::DeserializeScopeChain(
443 : Isolate* isolate, ParseInfo* info,
444 : MaybeHandle<ScopeInfo> maybe_outer_scope_info,
445 : Scope::DeserializationMode mode) {
446 : InitializeEmptyScopeChain(info);
447 : Handle<ScopeInfo> outer_scope_info;
448 2437996 : if (maybe_outer_scope_info.ToHandle(&outer_scope_info)) {
449 : DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
450 1014532 : original_scope_ = Scope::DeserializeScopeChain(
451 : isolate, zone(), *outer_scope_info, info->script_scope(),
452 1014533 : ast_value_factory(), mode);
453 1413622 : if (info->is_eval() || IsArrowFunction(info->function_kind())) {
454 779616 : original_scope_->GetReceiverScope()->DeserializeReceiver(
455 779616 : ast_value_factory());
456 : }
457 : }
458 2437997 : }
459 :
460 : namespace {
461 :
462 2451290 : void MaybeResetCharacterStream(ParseInfo* info, FunctionLiteral* literal) {
463 : // Don't reset the character stream if there is an asm.js module since it will
464 : // be used again by the asm-parser.
465 2451290 : if (info->contains_asm_module()) {
466 4227 : if (FLAG_stress_validate_asm) return;
467 4227 : if (literal != nullptr && literal->scope()->ContainsAsmModule()) return;
468 : }
469 2447084 : info->ResetCharacterStream();
470 : }
471 :
472 2437996 : void MaybeProcessSourceRanges(ParseInfo* parse_info, Expression* root,
473 : uintptr_t stack_limit_) {
474 2437996 : if (root != nullptr && parse_info->source_range_map() != nullptr) {
475 : SourceRangeAstVisitor visitor(stack_limit_, root,
476 676 : parse_info->source_range_map());
477 : visitor.Run();
478 : }
479 2437996 : }
480 :
481 : } // namespace
482 :
483 1721140 : FunctionLiteral* Parser::ParseProgram(Isolate* isolate, ParseInfo* info) {
484 : // TODO(bmeurer): We temporarily need to pass allow_nesting = true here,
485 : // see comment for HistogramTimerScope class.
486 :
487 : // It's OK to use the Isolate & counters here, since this function is only
488 : // called in the main thread.
489 : DCHECK(parsing_on_main_thread_);
490 : RuntimeCallTimerScope runtime_timer(
491 : runtime_call_stats_, info->is_eval()
492 : ? RuntimeCallCounterId::kParseEval
493 1721140 : : RuntimeCallCounterId::kParseProgram);
494 5163416 : TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseProgram");
495 : base::ElapsedTimer timer;
496 1721140 : if (V8_UNLIKELY(FLAG_log_function_events)) timer.Start();
497 :
498 : // Initialize parser state.
499 : DeserializeScopeChain(isolate, info, info->maybe_outer_scope_info(),
500 1721140 : Scope::DeserializationMode::kIncludingVariables);
501 :
502 1721139 : scanner_.Initialize();
503 1721138 : if (FLAG_harmony_hashbang) {
504 1711418 : scanner_.SkipHashBang();
505 : }
506 1721137 : FunctionLiteral* result = DoParseProgram(isolate, info);
507 1721137 : MaybeResetCharacterStream(info, result);
508 1721140 : MaybeProcessSourceRanges(info, result, stack_limit_);
509 :
510 1721140 : HandleSourceURLComments(isolate, info->script());
511 :
512 1721136 : if (V8_UNLIKELY(FLAG_log_function_events) && result != nullptr) {
513 11 : double ms = timer.Elapsed().InMillisecondsF();
514 : const char* event_name = "parse-eval";
515 : Script script = *info->script();
516 : int start = -1;
517 : int end = -1;
518 11 : if (!info->is_eval()) {
519 : event_name = "parse-script";
520 : start = 0;
521 : end = String::cast(script->source())->length();
522 : }
523 22 : LOG(isolate,
524 : FunctionEvent(event_name, script->id(), ms, start, end, "", 0));
525 : }
526 1721136 : return result;
527 : }
528 :
529 1734364 : FunctionLiteral* Parser::DoParseProgram(Isolate* isolate, ParseInfo* info) {
530 : // Note that this function can be called from the main thread or from a
531 : // background thread. We should not access anything Isolate / heap dependent
532 : // via ParseInfo, and also not pass it forward. If not on the main thread
533 : // isolate will be nullptr.
534 : DCHECK_EQ(parsing_on_main_thread_, isolate != nullptr);
535 : DCHECK_NULL(scope_);
536 : DCHECK_NULL(target_stack_);
537 :
538 1734364 : ParsingModeScope mode(this, allow_lazy_ ? PARSE_LAZILY : PARSE_EAGERLY);
539 : ResetFunctionLiteralId();
540 : DCHECK(info->function_literal_id() == kFunctionLiteralIdTopLevel ||
541 : info->function_literal_id() == kFunctionLiteralIdInvalid);
542 :
543 : FunctionLiteral* result = nullptr;
544 : {
545 1734364 : Scope* outer = original_scope_;
546 : DCHECK_NOT_NULL(outer);
547 1734364 : if (info->is_eval()) {
548 960347 : outer = NewEvalScope(outer);
549 774017 : } else if (parsing_module_) {
550 : DCHECK_EQ(outer, info->script_scope());
551 40820 : outer = NewModuleScope(info->script_scope());
552 : }
553 :
554 1734364 : DeclarationScope* scope = outer->AsDeclarationScope();
555 : scope->set_start_position(0);
556 :
557 1734364 : FunctionState function_state(&function_state_, &scope_, scope);
558 : ScopedPtrList<Statement> body(pointer_buffer());
559 1734364 : int beg_pos = scanner()->location().beg_pos;
560 1734364 : if (parsing_module_) {
561 : DCHECK(info->is_module());
562 : // Declare the special module parameter.
563 : auto name = ast_value_factory()->empty_string();
564 : bool is_rest = false;
565 : bool is_optional = false;
566 : VariableMode mode = VariableMode::kVar;
567 : bool was_added;
568 40820 : scope->DeclareLocal(name, mode, PARAMETER_VARIABLE, &was_added,
569 40820 : Variable::DefaultInitializationFlag(mode));
570 : DCHECK(was_added);
571 : auto var = scope->DeclareParameter(name, VariableMode::kVar, is_optional,
572 40820 : is_rest, ast_value_factory(), beg_pos);
573 : var->AllocateTo(VariableLocation::PARAMETER, 0);
574 :
575 40820 : PrepareGeneratorVariables();
576 : Expression* initial_yield =
577 40820 : BuildInitialYield(kNoSourcePosition, kGeneratorFunction);
578 : body.Add(
579 : factory()->NewExpressionStatement(initial_yield, kNoSourcePosition));
580 :
581 40820 : ParseModuleItemList(&body);
582 56192 : if (!has_error() &&
583 30744 : !module()->Validate(this->scope()->AsModuleScope(),
584 : pending_error_handler(), zone())) {
585 : scanner()->set_parser_error();
586 : }
587 1693544 : } else if (info->is_wrapped_as_function()) {
588 74 : ParseWrapped(isolate, info, &body, scope, zone());
589 : } else {
590 : // Don't count the mode in the use counters--give the program a chance
591 : // to enable script-wide strict mode below.
592 : this->scope()->SetLanguageMode(info->language_mode());
593 1693470 : ParseStatementList(&body, Token::EOS);
594 : }
595 :
596 : // The parser will peek but not consume EOS. Our scope logically goes all
597 : // the way to the EOS, though.
598 : scope->set_end_position(peek_position());
599 :
600 1734343 : if (is_strict(language_mode())) {
601 328764 : CheckStrictOctalLiteral(beg_pos, end_position());
602 : }
603 1734343 : if (is_sloppy(language_mode())) {
604 : // TODO(littledan): Function bindings on the global object that modify
605 : // pre-existing bindings should be made writable, enumerable and
606 : // nonconfigurable if possible, whereas this code will leave attributes
607 : // unchanged if the property already exists.
608 1405578 : InsertSloppyBlockFunctionVarBindings(scope);
609 : }
610 : // Internalize the ast strings in the case of eval so we can check for
611 : // conflicting var declarations with outer scope-info-backed scopes.
612 1734358 : if (info->is_eval()) {
613 : DCHECK(parsing_on_main_thread_);
614 960347 : info->ast_value_factory()->Internalize(isolate);
615 : }
616 1734358 : CheckConflictingVarDeclarations(scope);
617 :
618 1734341 : if (info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
619 1010831 : if (body.length() != 1 || !body.at(0)->IsExpressionStatement() ||
620 : !body.at(0)
621 : ->AsExpressionStatement()
622 336478 : ->expression()
623 : ->IsFunctionLiteral()) {
624 1406 : ReportMessage(MessageTemplate::kSingleFunctionLiteral);
625 : }
626 : }
627 :
628 1734334 : int parameter_count = parsing_module_ ? 1 : 0;
629 : result = factory()->NewScriptOrEvalFunctionLiteral(
630 1734334 : scope, body, function_state.expected_property_count(), parameter_count);
631 : result->set_suspend_count(function_state.suspend_count());
632 : }
633 :
634 : info->set_max_function_literal_id(GetLastFunctionLiteralId());
635 :
636 : // Make sure the target stack is empty.
637 : DCHECK_NULL(target_stack_);
638 :
639 1734359 : if (has_error()) return nullptr;
640 1348849 : return result;
641 : }
642 :
643 84 : ZonePtrList<const AstRawString>* Parser::PrepareWrappedArguments(
644 : Isolate* isolate, ParseInfo* info, Zone* zone) {
645 : DCHECK(parsing_on_main_thread_);
646 : DCHECK_NOT_NULL(isolate);
647 : Handle<FixedArray> arguments(info->script()->wrapped_arguments(), isolate);
648 : int arguments_length = arguments->length();
649 : ZonePtrList<const AstRawString>* arguments_for_wrapped_function =
650 : new (zone) ZonePtrList<const AstRawString>(arguments_length, zone);
651 124 : for (int i = 0; i < arguments_length; i++) {
652 40 : const AstRawString* argument_string = ast_value_factory()->GetString(
653 20 : Handle<String>(String::cast(arguments->get(i)), isolate));
654 20 : arguments_for_wrapped_function->Add(argument_string, zone);
655 : }
656 84 : return arguments_for_wrapped_function;
657 : }
658 :
659 74 : void Parser::ParseWrapped(Isolate* isolate, ParseInfo* info,
660 : ScopedPtrList<Statement>* body,
661 : DeclarationScope* outer_scope, Zone* zone) {
662 : DCHECK_EQ(parsing_on_main_thread_, isolate != nullptr);
663 : DCHECK(info->is_wrapped_as_function());
664 : ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
665 :
666 : // Set function and block state for the outer eval scope.
667 : DCHECK(outer_scope->is_eval_scope());
668 74 : FunctionState function_state(&function_state_, &scope_, outer_scope);
669 :
670 : const AstRawString* function_name = nullptr;
671 : Scanner::Location location(0, 0);
672 :
673 : ZonePtrList<const AstRawString>* arguments_for_wrapped_function =
674 74 : PrepareWrappedArguments(isolate, info, zone);
675 :
676 : FunctionLiteral* function_literal = ParseFunctionLiteral(
677 : function_name, location, kSkipFunctionNameCheck, kNormalFunction,
678 : kNoSourcePosition, FunctionLiteral::kWrapped, LanguageMode::kSloppy,
679 74 : arguments_for_wrapped_function);
680 :
681 : Statement* return_statement = factory()->NewReturnStatement(
682 : function_literal, kNoSourcePosition, kNoSourcePosition);
683 : body->Add(return_statement);
684 74 : }
685 :
686 716857 : FunctionLiteral* Parser::ParseFunction(Isolate* isolate, ParseInfo* info,
687 : Handle<SharedFunctionInfo> shared_info) {
688 : // It's OK to use the Isolate & counters here, since this function is only
689 : // called in the main thread.
690 : DCHECK(parsing_on_main_thread_);
691 : RuntimeCallTimerScope runtime_timer(runtime_call_stats_,
692 716857 : RuntimeCallCounterId::kParseFunction);
693 2150570 : TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseFunction");
694 : base::ElapsedTimer timer;
695 716856 : if (V8_UNLIKELY(FLAG_log_function_events)) timer.Start();
696 :
697 : DeserializeScopeChain(isolate, info, info->maybe_outer_scope_info(),
698 716856 : Scope::DeserializationMode::kIncludingVariables);
699 : DCHECK_EQ(factory()->zone(), info->zone());
700 :
701 : // Initialize parser state.
702 1433714 : Handle<String> name(shared_info->Name(), isolate);
703 716857 : info->set_function_name(ast_value_factory()->GetString(name));
704 716857 : scanner_.Initialize();
705 :
706 : FunctionLiteral* result =
707 716859 : DoParseFunction(isolate, info, info->function_name());
708 716858 : MaybeResetCharacterStream(info, result);
709 716859 : MaybeProcessSourceRanges(info, result, stack_limit_);
710 716858 : if (result != nullptr) {
711 1423168 : Handle<String> inferred_name(shared_info->inferred_name(), isolate);
712 711584 : result->set_inferred_name(inferred_name);
713 : }
714 :
715 716858 : if (V8_UNLIKELY(FLAG_log_function_events) && result != nullptr) {
716 23 : double ms = timer.Elapsed().InMillisecondsF();
717 : // We need to make sure that the debug-name is available.
718 23 : ast_value_factory()->Internalize(isolate);
719 : DeclarationScope* function_scope = result->scope();
720 23 : std::unique_ptr<char[]> function_name = result->GetDebugName();
721 69 : LOG(isolate,
722 : FunctionEvent("parse-function", info->script()->id(), ms,
723 : function_scope->start_position(),
724 : function_scope->end_position(), function_name.get(),
725 : strlen(function_name.get())));
726 : }
727 716858 : return result;
728 : }
729 :
730 716936 : static FunctionLiteral::FunctionType ComputeFunctionType(ParseInfo* info) {
731 716936 : if (info->is_wrapped_as_function()) {
732 : return FunctionLiteral::kWrapped;
733 716926 : } else if (info->is_declaration()) {
734 : return FunctionLiteral::kDeclaration;
735 451652 : } else if (info->is_named_expression()) {
736 : return FunctionLiteral::kNamedExpression;
737 635245 : } else if (IsConciseMethod(info->function_kind()) ||
738 : IsAccessorFunction(info->function_kind())) {
739 : return FunctionLiteral::kAccessorOrMethod;
740 : }
741 258134 : return FunctionLiteral::kAnonymousExpression;
742 : }
743 :
744 716935 : FunctionLiteral* Parser::DoParseFunction(Isolate* isolate, ParseInfo* info,
745 : const AstRawString* raw_name) {
746 : DCHECK_EQ(parsing_on_main_thread_, isolate != nullptr);
747 : DCHECK_NOT_NULL(raw_name);
748 : DCHECK_NULL(scope_);
749 : DCHECK_NULL(target_stack_);
750 :
751 : DCHECK(ast_value_factory());
752 716935 : fni_.PushEnclosingName(raw_name);
753 :
754 : ResetFunctionLiteralId();
755 : DCHECK_LT(0, info->function_literal_id());
756 716936 : SkipFunctionLiterals(info->function_literal_id() - 1);
757 :
758 : ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
759 :
760 : // Place holder for the result.
761 : FunctionLiteral* result = nullptr;
762 :
763 : {
764 : // Parse the function literal.
765 716936 : Scope* outer = original_scope_;
766 716936 : DeclarationScope* outer_function = outer->GetClosureScope();
767 : DCHECK(outer);
768 716936 : FunctionState function_state(&function_state_, &scope_, outer_function);
769 : BlockState block_state(&scope_, outer);
770 : DCHECK(is_sloppy(outer->language_mode()) ||
771 : is_strict(info->language_mode()));
772 716936 : FunctionLiteral::FunctionType function_type = ComputeFunctionType(info);
773 : FunctionKind kind = info->function_kind();
774 :
775 716936 : if (IsArrowFunction(kind)) {
776 178218 : if (IsAsyncFunction(kind)) {
777 : DCHECK(!scanner()->HasLineTerminatorAfterNext());
778 1076 : if (!Check(Token::ASYNC)) {
779 0 : CHECK(stack_overflow());
780 20 : return nullptr;
781 : }
782 1076 : if (!(peek_any_identifier() || peek() == Token::LPAREN)) {
783 0 : CHECK(stack_overflow());
784 : return nullptr;
785 : }
786 : }
787 :
788 : // TODO(adamk): We should construct this scope from the ScopeInfo.
789 178218 : DeclarationScope* scope = NewFunctionScope(kind);
790 : scope->set_has_checked_syntax(true);
791 :
792 : // This bit only needs to be explicitly set because we're
793 : // not passing the ScopeInfo to the Scope constructor.
794 178218 : SetLanguageMode(scope, info->language_mode());
795 :
796 : scope->set_start_position(info->start_position());
797 : ParserFormalParameters formals(scope);
798 : {
799 : ParameterDeclarationParsingScope formals_scope(this);
800 : // Parsing patterns as variable reference expression creates
801 : // NewUnresolved references in current scope. Enter arrow function
802 : // scope for formal parameter parsing.
803 : BlockState block_state(&scope_, scope);
804 178218 : if (Check(Token::LPAREN)) {
805 : // '(' StrictFormalParameters ')'
806 159433 : ParseFormalParameterList(&formals);
807 159433 : Expect(Token::RPAREN);
808 : } else {
809 : // BindingIdentifier
810 : ParameterParsingScope scope(impl(), &formals);
811 : ParseFormalParameter(&formals);
812 : DeclareFormalParameters(&formals);
813 : }
814 178218 : formals.duplicate_loc = formals_scope.duplicate_location();
815 : }
816 :
817 178218 : if (GetLastFunctionLiteralId() != info->function_literal_id() - 1) {
818 304 : if (has_error()) return nullptr;
819 : // If there were FunctionLiterals in the parameters, we need to
820 : // renumber them to shift down so the next function literal id for
821 : // the arrow function is the one requested.
822 : AstFunctionLiteralIdReindexer reindexer(
823 : stack_limit_,
824 568 : (info->function_literal_id() - 1) - GetLastFunctionLiteralId());
825 663 : for (auto p : formals.params) {
826 379 : if (p->pattern != nullptr) reindexer.Reindex(p->pattern);
827 379 : if (p->initializer() != nullptr) {
828 254 : reindexer.Reindex(p->initializer());
829 : }
830 : }
831 : ResetFunctionLiteralId();
832 284 : SkipFunctionLiterals(info->function_literal_id() - 1);
833 : }
834 :
835 178198 : Expression* expression = ParseArrowFunctionLiteral(formals);
836 : // Scanning must end at the same position that was recorded
837 : // previously. If not, parsing has been interrupted due to a stack
838 : // overflow, at which point the partially parsed arrow function
839 : // concise body happens to be a valid expression. This is a problem
840 : // only for arrow functions with single expression bodies, since there
841 : // is no end token such as "}" for normal functions.
842 178198 : if (scanner()->location().end_pos == info->end_position()) {
843 : // The pre-parser saw an arrow function here, so the full parser
844 : // must produce a FunctionLiteral.
845 : DCHECK(expression->IsFunctionLiteral());
846 178116 : result = expression->AsFunctionLiteral();
847 : }
848 538718 : } else if (IsDefaultConstructor(kind)) {
849 : DCHECK_EQ(scope(), outer);
850 8528 : result = DefaultConstructor(raw_name, IsDerivedConstructor(kind),
851 8528 : info->start_position(), info->end_position());
852 : } else {
853 : ZonePtrList<const AstRawString>* arguments_for_wrapped_function =
854 : info->is_wrapped_as_function()
855 : ? PrepareWrappedArguments(isolate, info, zone())
856 530190 : : nullptr;
857 530190 : result = ParseFunctionLiteral(
858 : raw_name, Scanner::Location::invalid(), kSkipFunctionNameCheck, kind,
859 : kNoSourcePosition, function_type, info->language_mode(),
860 530190 : arguments_for_wrapped_function);
861 : }
862 :
863 716915 : if (has_error()) return nullptr;
864 : result->set_requires_instance_members_initializer(
865 : info->requires_instance_members_initializer());
866 711660 : if (info->is_oneshot_iife()) {
867 : result->mark_as_oneshot_iife();
868 : }
869 : }
870 :
871 : // Make sure the target stack is empty.
872 : DCHECK_NULL(target_stack_);
873 : DCHECK_IMPLIES(result,
874 : info->function_literal_id() == result->function_literal_id());
875 711660 : return result;
876 : }
877 :
878 140944 : Statement* Parser::ParseModuleItem() {
879 : // ecma262/#prod-ModuleItem
880 : // ModuleItem :
881 : // ImportDeclaration
882 : // ExportDeclaration
883 : // StatementListItem
884 :
885 : Token::Value next = peek();
886 :
887 140944 : if (next == Token::EXPORT) {
888 19524 : return ParseExportDeclaration();
889 : }
890 :
891 121420 : if (next == Token::IMPORT) {
892 : // We must be careful not to parse a dynamic import expression as an import
893 : // declaration. Same for import.meta expressions.
894 : Token::Value peek_ahead = PeekAhead();
895 5968 : if ((!allow_harmony_dynamic_import() || peek_ahead != Token::LPAREN) &&
896 1694 : (!allow_harmony_import_meta() || peek_ahead != Token::PERIOD)) {
897 2484 : ParseImportDeclaration();
898 2484 : return factory()->EmptyStatement();
899 : }
900 : }
901 :
902 118936 : return ParseStatementListItem();
903 : }
904 :
905 40820 : void Parser::ParseModuleItemList(ScopedPtrList<Statement>* body) {
906 : // ecma262/#prod-Module
907 : // Module :
908 : // ModuleBody?
909 : //
910 : // ecma262/#prod-ModuleItemList
911 : // ModuleBody :
912 : // ModuleItem*
913 :
914 : DCHECK(scope()->is_module_scope());
915 156316 : while (peek() != Token::EOS) {
916 140944 : Statement* stat = ParseModuleItem();
917 140944 : if (stat == nullptr) return;
918 115496 : if (stat->IsEmptyStatement()) continue;
919 : body->Add(stat);
920 : }
921 : }
922 :
923 2919 : const AstRawString* Parser::ParseModuleSpecifier() {
924 : // ModuleSpecifier :
925 : // StringLiteral
926 :
927 2919 : Expect(Token::STRING);
928 2919 : return GetSymbol();
929 : }
930 :
931 635 : ZoneChunkList<Parser::ExportClauseData>* Parser::ParseExportClause(
932 : Scanner::Location* reserved_loc) {
933 : // ExportClause :
934 : // '{' '}'
935 : // '{' ExportsList '}'
936 : // '{' ExportsList ',' '}'
937 : //
938 : // ExportsList :
939 : // ExportSpecifier
940 : // ExportsList ',' ExportSpecifier
941 : //
942 : // ExportSpecifier :
943 : // IdentifierName
944 : // IdentifierName 'as' IdentifierName
945 : ZoneChunkList<ExportClauseData>* export_data =
946 : new (zone()) ZoneChunkList<ExportClauseData>(zone());
947 :
948 635 : Expect(Token::LBRACE);
949 :
950 : Token::Value name_tok;
951 755 : while ((name_tok = peek()) != Token::RBRACE) {
952 : // Keep track of the first reserved word encountered in case our
953 : // caller needs to report an error.
954 1410 : if (!reserved_loc->IsValid() &&
955 : !Token::IsValidIdentifier(name_tok, LanguageMode::kStrict, false,
956 705 : parsing_module_)) {
957 65 : *reserved_loc = scanner()->location();
958 : }
959 : const AstRawString* local_name = ParsePropertyName();
960 : const AstRawString* export_name = nullptr;
961 705 : Scanner::Location location = scanner()->location();
962 705 : if (CheckContextualKeyword(ast_value_factory()->as_string())) {
963 : export_name = ParsePropertyName();
964 : // Set the location to the whole "a as b" string, so that it makes sense
965 : // both for errors due to "a" and for errors due to "b".
966 340 : location.end_pos = scanner()->location().end_pos;
967 : }
968 705 : if (export_name == nullptr) {
969 : export_name = local_name;
970 : }
971 705 : export_data->push_back({export_name, local_name, location});
972 705 : if (peek() == Token::RBRACE) break;
973 160 : if (V8_UNLIKELY(!Check(Token::COMMA))) {
974 40 : ReportUnexpectedToken(Next());
975 40 : break;
976 : }
977 : }
978 :
979 635 : Expect(Token::RBRACE);
980 635 : return export_data;
981 : }
982 :
983 1269 : ZonePtrList<const Parser::NamedImport>* Parser::ParseNamedImports(int pos) {
984 : // NamedImports :
985 : // '{' '}'
986 : // '{' ImportsList '}'
987 : // '{' ImportsList ',' '}'
988 : //
989 : // ImportsList :
990 : // ImportSpecifier
991 : // ImportsList ',' ImportSpecifier
992 : //
993 : // ImportSpecifier :
994 : // BindingIdentifier
995 : // IdentifierName 'as' BindingIdentifier
996 :
997 1269 : Expect(Token::LBRACE);
998 :
999 : auto result = new (zone()) ZonePtrList<const NamedImport>(1, zone());
1000 1629 : while (peek() != Token::RBRACE) {
1001 : const AstRawString* import_name = ParsePropertyName();
1002 : const AstRawString* local_name = import_name;
1003 1424 : Scanner::Location location = scanner()->location();
1004 : // In the presence of 'as', the left-side of the 'as' can
1005 : // be any IdentifierName. But without 'as', it must be a valid
1006 : // BindingIdentifier.
1007 1424 : if (CheckContextualKeyword(ast_value_factory()->as_string())) {
1008 : local_name = ParsePropertyName();
1009 : }
1010 1424 : if (!Token::IsValidIdentifier(scanner()->current_token(),
1011 : LanguageMode::kStrict, false,
1012 1424 : parsing_module_)) {
1013 155 : ReportMessage(MessageTemplate::kUnexpectedReserved);
1014 155 : return nullptr;
1015 1269 : } else if (IsEvalOrArguments(local_name)) {
1016 25 : ReportMessage(MessageTemplate::kStrictEvalArguments);
1017 25 : return nullptr;
1018 : }
1019 :
1020 : DeclareUnboundVariable(local_name, VariableMode::kConst,
1021 : kNeedsInitialization, position());
1022 :
1023 : NamedImport* import =
1024 : new (zone()) NamedImport(import_name, local_name, location);
1025 1244 : result->Add(import, zone());
1026 :
1027 1244 : if (peek() == Token::RBRACE) break;
1028 180 : Expect(Token::COMMA);
1029 : }
1030 :
1031 1089 : Expect(Token::RBRACE);
1032 1089 : return result;
1033 : }
1034 :
1035 2484 : void Parser::ParseImportDeclaration() {
1036 : // ImportDeclaration :
1037 : // 'import' ImportClause 'from' ModuleSpecifier ';'
1038 : // 'import' ModuleSpecifier ';'
1039 : //
1040 : // ImportClause :
1041 : // ImportedDefaultBinding
1042 : // NameSpaceImport
1043 : // NamedImports
1044 : // ImportedDefaultBinding ',' NameSpaceImport
1045 : // ImportedDefaultBinding ',' NamedImports
1046 : //
1047 : // NameSpaceImport :
1048 : // '*' 'as' ImportedBinding
1049 :
1050 : int pos = peek_position();
1051 2484 : Expect(Token::IMPORT);
1052 :
1053 : Token::Value tok = peek();
1054 :
1055 : // 'import' ModuleSpecifier ';'
1056 2484 : if (tok == Token::STRING) {
1057 95 : Scanner::Location specifier_loc = scanner()->peek_location();
1058 95 : const AstRawString* module_specifier = ParseModuleSpecifier();
1059 95 : ExpectSemicolon();
1060 95 : module()->AddEmptyImport(module_specifier, specifier_loc);
1061 : return;
1062 : }
1063 :
1064 : // Parse ImportedDefaultBinding if present.
1065 : const AstRawString* import_default_binding = nullptr;
1066 : Scanner::Location import_default_binding_loc;
1067 2389 : if (tok != Token::MUL && tok != Token::LBRACE) {
1068 985 : import_default_binding = ParseNonRestrictedIdentifier();
1069 985 : import_default_binding_loc = scanner()->location();
1070 : DeclareUnboundVariable(import_default_binding, VariableMode::kConst,
1071 : kNeedsInitialization, pos);
1072 : }
1073 :
1074 : // Parse NameSpaceImport or NamedImports if present.
1075 : const AstRawString* module_namespace_binding = nullptr;
1076 : Scanner::Location module_namespace_binding_loc;
1077 : const ZonePtrList<const NamedImport>* named_imports = nullptr;
1078 3374 : if (import_default_binding == nullptr || Check(Token::COMMA)) {
1079 1429 : switch (peek()) {
1080 : case Token::MUL: {
1081 : Consume(Token::MUL);
1082 150 : ExpectContextualKeyword(ast_value_factory()->as_string());
1083 150 : module_namespace_binding = ParseNonRestrictedIdentifier();
1084 150 : module_namespace_binding_loc = scanner()->location();
1085 : DeclareUnboundVariable(module_namespace_binding, VariableMode::kConst,
1086 : kCreatedInitialized, pos);
1087 : break;
1088 : }
1089 :
1090 : case Token::LBRACE:
1091 1269 : named_imports = ParseNamedImports(pos);
1092 1269 : break;
1093 :
1094 : default:
1095 10 : ReportUnexpectedToken(scanner()->current_token());
1096 10 : return;
1097 : }
1098 : }
1099 :
1100 2379 : ExpectContextualKeyword(ast_value_factory()->from_string());
1101 2379 : Scanner::Location specifier_loc = scanner()->peek_location();
1102 2379 : const AstRawString* module_specifier = ParseModuleSpecifier();
1103 2379 : ExpectSemicolon();
1104 :
1105 : // Now that we have all the information, we can make the appropriate
1106 : // declarations.
1107 :
1108 : // TODO(neis): Would prefer to call DeclareVariable for each case below rather
1109 : // than above and in ParseNamedImports, but then a possible error message
1110 : // would point to the wrong location. Maybe have a DeclareAt version of
1111 : // Declare that takes a location?
1112 :
1113 2379 : if (module_namespace_binding != nullptr) {
1114 : module()->AddStarImport(module_namespace_binding, module_specifier,
1115 : module_namespace_binding_loc, specifier_loc,
1116 150 : zone());
1117 : }
1118 :
1119 2379 : if (import_default_binding != nullptr) {
1120 : module()->AddImport(ast_value_factory()->default_string(),
1121 : import_default_binding, module_specifier,
1122 975 : import_default_binding_loc, specifier_loc, zone());
1123 : }
1124 :
1125 2379 : if (named_imports != nullptr) {
1126 1089 : if (named_imports->length() == 0) {
1127 20 : module()->AddEmptyImport(module_specifier, specifier_loc);
1128 : } else {
1129 3427 : for (int i = 0; i < named_imports->length(); ++i) {
1130 1179 : const NamedImport* import = named_imports->at(i);
1131 1179 : module()->AddImport(import->import_name, import->local_name,
1132 : module_specifier, import->location, specifier_loc,
1133 1179 : zone());
1134 : }
1135 : }
1136 : }
1137 : }
1138 :
1139 461 : Statement* Parser::ParseExportDefault() {
1140 : // Supports the following productions, starting after the 'default' token:
1141 : // 'export' 'default' HoistableDeclaration
1142 : // 'export' 'default' ClassDeclaration
1143 : // 'export' 'default' AssignmentExpression[In] ';'
1144 :
1145 461 : Expect(Token::DEFAULT);
1146 461 : Scanner::Location default_loc = scanner()->location();
1147 :
1148 : ZonePtrList<const AstRawString> local_names(1, zone());
1149 : Statement* result = nullptr;
1150 461 : switch (peek()) {
1151 : case Token::FUNCTION:
1152 65 : result = ParseHoistableDeclaration(&local_names, true);
1153 65 : break;
1154 :
1155 : case Token::CLASS:
1156 : Consume(Token::CLASS);
1157 45 : result = ParseClassDeclaration(&local_names, true);
1158 45 : break;
1159 :
1160 : case Token::ASYNC:
1161 120 : if (PeekAhead() == Token::FUNCTION &&
1162 : !scanner()->HasLineTerminatorAfterNext()) {
1163 : Consume(Token::ASYNC);
1164 60 : result = ParseAsyncFunctionDeclaration(&local_names, true);
1165 60 : break;
1166 : }
1167 : V8_FALLTHROUGH;
1168 :
1169 : default: {
1170 : int pos = position();
1171 : AcceptINScope scope(this, true);
1172 : Expression* value = ParseAssignmentExpression();
1173 291 : SetFunctionName(value, ast_value_factory()->default_string());
1174 :
1175 : const AstRawString* local_name =
1176 291 : ast_value_factory()->dot_default_string();
1177 291 : local_names.Add(local_name, zone());
1178 :
1179 : // It's fine to declare this as VariableMode::kConst because the user has
1180 : // no way of writing to it.
1181 : VariableProxy* proxy =
1182 291 : DeclareBoundVariable(local_name, VariableMode::kConst, pos);
1183 : proxy->var()->set_initializer_position(position());
1184 :
1185 : Assignment* assignment = factory()->NewAssignment(
1186 291 : Token::INIT, proxy, value, kNoSourcePosition);
1187 : result = IgnoreCompletion(
1188 291 : factory()->NewExpressionStatement(assignment, kNoSourcePosition));
1189 :
1190 291 : ExpectSemicolon();
1191 : break;
1192 : }
1193 : }
1194 :
1195 461 : if (result != nullptr) {
1196 : DCHECK_EQ(local_names.length(), 1);
1197 461 : module()->AddExport(local_names.first(),
1198 : ast_value_factory()->default_string(), default_loc,
1199 461 : zone());
1200 : }
1201 :
1202 461 : return result;
1203 : }
1204 :
1205 110 : const AstRawString* Parser::NextInternalNamespaceExportName() {
1206 : const char* prefix = ".ns-export";
1207 110 : std::string s(prefix);
1208 220 : s.append(std::to_string(number_of_named_namespace_exports_++));
1209 220 : return ast_value_factory()->GetOneByteString(s.c_str());
1210 : }
1211 :
1212 260 : void Parser::ParseExportStar() {
1213 : int pos = position();
1214 : Consume(Token::MUL);
1215 :
1216 520 : if (!FLAG_harmony_namespace_exports ||
1217 260 : !PeekContextualKeyword(ast_value_factory()->as_string())) {
1218 : // 'export' '*' 'from' ModuleSpecifier ';'
1219 150 : Scanner::Location loc = scanner()->location();
1220 150 : ExpectContextualKeyword(ast_value_factory()->from_string());
1221 150 : Scanner::Location specifier_loc = scanner()->peek_location();
1222 150 : const AstRawString* module_specifier = ParseModuleSpecifier();
1223 150 : ExpectSemicolon();
1224 150 : module()->AddStarExport(module_specifier, loc, specifier_loc, zone());
1225 : return;
1226 : }
1227 110 : if (!FLAG_harmony_namespace_exports) return;
1228 :
1229 : // 'export' '*' 'as' IdentifierName 'from' ModuleSpecifier ';'
1230 : //
1231 : // Desugaring:
1232 : // export * as x from "...";
1233 : // ~>
1234 : // import * as .x from "..."; export {.x as x};
1235 :
1236 110 : ExpectContextualKeyword(ast_value_factory()->as_string());
1237 : const AstRawString* export_name = ParsePropertyName();
1238 110 : Scanner::Location export_name_loc = scanner()->location();
1239 110 : const AstRawString* local_name = NextInternalNamespaceExportName();
1240 110 : Scanner::Location local_name_loc = Scanner::Location::invalid();
1241 : DeclareUnboundVariable(local_name, VariableMode::kConst, kCreatedInitialized,
1242 : pos);
1243 :
1244 110 : ExpectContextualKeyword(ast_value_factory()->from_string());
1245 110 : Scanner::Location specifier_loc = scanner()->peek_location();
1246 110 : const AstRawString* module_specifier = ParseModuleSpecifier();
1247 110 : ExpectSemicolon();
1248 :
1249 : module()->AddStarImport(local_name, module_specifier, local_name_loc,
1250 110 : specifier_loc, zone());
1251 110 : module()->AddExport(local_name, export_name, export_name_loc, zone());
1252 : }
1253 :
1254 19524 : Statement* Parser::ParseExportDeclaration() {
1255 : // ExportDeclaration:
1256 : // 'export' '*' 'from' ModuleSpecifier ';'
1257 : // 'export' '*' 'as' IdentifierName 'from' ModuleSpecifier ';'
1258 : // 'export' ExportClause ('from' ModuleSpecifier)? ';'
1259 : // 'export' VariableStatement
1260 : // 'export' Declaration
1261 : // 'export' 'default' ... (handled in ParseExportDefault)
1262 :
1263 19524 : Expect(Token::EXPORT);
1264 : Statement* result = nullptr;
1265 : ZonePtrList<const AstRawString> names(1, zone());
1266 19524 : Scanner::Location loc = scanner()->peek_location();
1267 19524 : switch (peek()) {
1268 : case Token::DEFAULT:
1269 461 : return ParseExportDefault();
1270 :
1271 : case Token::MUL:
1272 260 : ParseExportStar();
1273 260 : return factory()->EmptyStatement();
1274 :
1275 : case Token::LBRACE: {
1276 : // There are two cases here:
1277 : //
1278 : // 'export' ExportClause ';'
1279 : // and
1280 : // 'export' ExportClause FromClause ';'
1281 : //
1282 : // In the first case, the exported identifiers in ExportClause must
1283 : // not be reserved words, while in the latter they may be. We
1284 : // pass in a location that gets filled with the first reserved word
1285 : // encountered, and then throw a SyntaxError if we are in the
1286 : // non-FromClause case.
1287 635 : Scanner::Location reserved_loc = Scanner::Location::invalid();
1288 : ZoneChunkList<ExportClauseData>* export_data =
1289 635 : ParseExportClause(&reserved_loc);
1290 : const AstRawString* module_specifier = nullptr;
1291 : Scanner::Location specifier_loc;
1292 635 : if (CheckContextualKeyword(ast_value_factory()->from_string())) {
1293 185 : specifier_loc = scanner()->peek_location();
1294 185 : module_specifier = ParseModuleSpecifier();
1295 450 : } else if (reserved_loc.IsValid()) {
1296 : // No FromClause, so reserved words are invalid in ExportClause.
1297 30 : ReportMessageAt(reserved_loc, MessageTemplate::kUnexpectedReserved);
1298 30 : return nullptr;
1299 : }
1300 605 : ExpectSemicolon();
1301 605 : if (module_specifier == nullptr) {
1302 910 : for (const ExportClauseData& data : *export_data) {
1303 490 : module()->AddExport(data.local_name, data.export_name, data.location,
1304 490 : zone());
1305 : }
1306 185 : } else if (export_data->is_empty()) {
1307 30 : module()->AddEmptyImport(module_specifier, specifier_loc);
1308 : } else {
1309 330 : for (const ExportClauseData& data : *export_data) {
1310 175 : module()->AddExport(data.local_name, data.export_name,
1311 : module_specifier, data.location, specifier_loc,
1312 175 : zone());
1313 : }
1314 : }
1315 605 : return factory()->EmptyStatement();
1316 : }
1317 :
1318 : case Token::FUNCTION:
1319 350 : result = ParseHoistableDeclaration(&names, false);
1320 350 : break;
1321 :
1322 : case Token::CLASS:
1323 : Consume(Token::CLASS);
1324 35 : result = ParseClassDeclaration(&names, false);
1325 35 : break;
1326 :
1327 : case Token::VAR:
1328 : case Token::LET:
1329 : case Token::CONST:
1330 17673 : result = ParseVariableStatement(kStatementListItem, &names);
1331 17673 : break;
1332 :
1333 : case Token::ASYNC:
1334 : Consume(Token::ASYNC);
1335 190 : if (peek() == Token::FUNCTION &&
1336 : !scanner()->HasLineTerminatorBeforeNext()) {
1337 65 : result = ParseAsyncFunctionDeclaration(&names, false);
1338 65 : break;
1339 : }
1340 : V8_FALLTHROUGH;
1341 :
1342 : default:
1343 45 : ReportUnexpectedToken(scanner()->current_token());
1344 45 : return nullptr;
1345 : }
1346 18123 : loc.end_pos = scanner()->location().end_pos;
1347 :
1348 : ModuleDescriptor* descriptor = module();
1349 54309 : for (int i = 0; i < names.length(); ++i) {
1350 18093 : descriptor->AddExport(names[i], names[i], loc, zone());
1351 : }
1352 :
1353 : return result;
1354 : }
1355 :
1356 0 : void Parser::DeclareUnboundVariable(const AstRawString* name, VariableMode mode,
1357 : InitializationFlag init, int pos) {
1358 : bool was_added;
1359 2489 : Variable* var = DeclareVariable(name, NORMAL_VARIABLE, mode, init, scope(),
1360 : &was_added, pos, end_position());
1361 : // The variable will be added to the declarations list, but since we are not
1362 : // binding it to anything, we can simply ignore it here.
1363 : USE(var);
1364 0 : }
1365 :
1366 365205 : VariableProxy* Parser::DeclareBoundVariable(const AstRawString* name,
1367 : VariableMode mode, int pos) {
1368 : DCHECK_NOT_NULL(name);
1369 : VariableProxy* proxy =
1370 : factory()->NewVariableProxy(name, NORMAL_VARIABLE, position());
1371 : bool was_added;
1372 365205 : Variable* var = DeclareVariable(name, NORMAL_VARIABLE, mode,
1373 : Variable::DefaultInitializationFlag(mode),
1374 365205 : scope(), &was_added, pos, end_position());
1375 365208 : proxy->BindTo(var);
1376 365206 : return proxy;
1377 : }
1378 :
1379 143196 : void Parser::DeclareAndBindVariable(VariableProxy* proxy, VariableKind kind,
1380 : VariableMode mode, InitializationFlag init,
1381 : Scope* scope, bool* was_added, int begin,
1382 : int end) {
1383 143196 : Variable* var = DeclareVariable(proxy->raw_name(), kind, mode, init, scope,
1384 143196 : was_added, begin, end);
1385 143195 : proxy->BindTo(var);
1386 143195 : }
1387 :
1388 14387908 : Variable* Parser::DeclareVariable(const AstRawString* name, VariableKind kind,
1389 : VariableMode mode, InitializationFlag init,
1390 : Scope* scope, bool* was_added, int begin,
1391 : int end) {
1392 : Declaration* declaration;
1393 27055205 : if (mode == VariableMode::kVar && !scope->is_declaration_scope()) {
1394 : DCHECK(scope->is_block_scope() || scope->is_with_scope());
1395 : declaration = factory()->NewNestedVariableDeclaration(scope, begin);
1396 : } else {
1397 : declaration = factory()->NewVariableDeclaration(begin);
1398 : }
1399 14387894 : Declare(declaration, name, kind, mode, init, scope, was_added, begin, end);
1400 14387818 : return declaration->var();
1401 : }
1402 :
1403 15370552 : void Parser::Declare(Declaration* declaration, const AstRawString* name,
1404 : VariableKind variable_kind, VariableMode mode,
1405 : InitializationFlag init, Scope* scope, bool* was_added,
1406 : int var_begin_pos, int var_end_pos) {
1407 15370552 : bool local_ok = true;
1408 15370552 : bool sloppy_mode_block_scope_function_redefinition = false;
1409 15370552 : scope->DeclareVariable(
1410 : declaration, name, var_begin_pos, mode, variable_kind, init, was_added,
1411 15370552 : &sloppy_mode_block_scope_function_redefinition, &local_ok);
1412 15370353 : if (!local_ok) {
1413 : // If we only have the start position of a proxy, we can't highlight the
1414 : // whole variable name. Pretend its length is 1 so that we highlight at
1415 : // least the first character.
1416 : Scanner::Location loc(var_begin_pos, var_end_pos != kNoSourcePosition
1417 : ? var_end_pos
1418 64209 : : var_begin_pos + 1);
1419 64209 : if (variable_kind == PARAMETER_VARIABLE) {
1420 309 : ReportMessageAt(loc, MessageTemplate::kParamDupe);
1421 : } else {
1422 : ReportMessageAt(loc, MessageTemplate::kVarRedeclaration,
1423 63900 : declaration->var()->raw_name());
1424 : }
1425 15306144 : } else if (sloppy_mode_block_scope_function_redefinition) {
1426 229 : ++use_counts_[v8::Isolate::kSloppyModeBlockScopedFunctionRedefinition];
1427 : }
1428 15370353 : }
1429 :
1430 8895026 : Statement* Parser::BuildInitializationBlock(
1431 : DeclarationParsingResult* parsing_result) {
1432 : ScopedPtrList<Statement> statements(pointer_buffer());
1433 18031600 : for (const auto& declaration : parsing_result->declarations) {
1434 9136598 : if (!declaration.initializer) continue;
1435 7144046 : InitializeVariables(&statements, parsing_result->descriptor.kind,
1436 7144046 : &declaration);
1437 : }
1438 17790073 : return factory()->NewBlock(true, statements);
1439 : }
1440 :
1441 982584 : Statement* Parser::DeclareFunction(const AstRawString* variable_name,
1442 : FunctionLiteral* function, VariableMode mode,
1443 : VariableKind kind, int beg_pos, int end_pos,
1444 : ZonePtrList<const AstRawString>* names) {
1445 : Declaration* declaration =
1446 : factory()->NewFunctionDeclaration(function, beg_pos);
1447 : bool was_added;
1448 982590 : Declare(declaration, variable_name, kind, mode, kCreatedInitialized, scope(),
1449 982590 : &was_added, beg_pos);
1450 982593 : if (info()->coverage_enabled()) {
1451 : // Force the function to be allocated when collecting source coverage, so
1452 : // that even dead functions get source coverage data.
1453 : declaration->var()->set_is_used();
1454 : }
1455 982593 : if (names) names->Add(variable_name, zone());
1456 982581 : if (kind == SLOPPY_BLOCK_FUNCTION_VARIABLE) {
1457 9109 : Token::Value init = loop_nesting_depth() > 0 ? Token::ASSIGN : Token::INIT;
1458 : SloppyBlockFunctionStatement* statement =
1459 : factory()->NewSloppyBlockFunctionStatement(end_pos, declaration->var(),
1460 : init);
1461 9109 : GetDeclarationScope()->DeclareSloppyBlockFunction(statement);
1462 9108 : return statement;
1463 : }
1464 973472 : return factory()->EmptyStatement();
1465 : }
1466 :
1467 107578 : Statement* Parser::DeclareClass(const AstRawString* variable_name,
1468 : Expression* value,
1469 : ZonePtrList<const AstRawString>* names,
1470 : int class_token_pos, int end_pos) {
1471 : VariableProxy* proxy =
1472 107578 : DeclareBoundVariable(variable_name, VariableMode::kLet, class_token_pos);
1473 : proxy->var()->set_initializer_position(end_pos);
1474 107579 : if (names) names->Add(variable_name, zone());
1475 :
1476 : Assignment* assignment =
1477 107579 : factory()->NewAssignment(Token::INIT, proxy, value, class_token_pos);
1478 : return IgnoreCompletion(
1479 107578 : factory()->NewExpressionStatement(assignment, kNoSourcePosition));
1480 : }
1481 :
1482 1814 : Statement* Parser::DeclareNative(const AstRawString* name, int pos) {
1483 : // Make sure that the function containing the native declaration
1484 : // isn't lazily compiled. The extension structures are only
1485 : // accessible while parsing the first time not when reparsing
1486 : // because of lazy compilation.
1487 : GetClosureScope()->ForceEagerCompilation();
1488 :
1489 : // TODO(1240846): It's weird that native function declarations are
1490 : // introduced dynamically when we meet their declarations, whereas
1491 : // other functions are set up when entering the surrounding scope.
1492 1814 : VariableProxy* proxy = DeclareBoundVariable(name, VariableMode::kVar, pos);
1493 : NativeFunctionLiteral* lit =
1494 1814 : factory()->NewNativeFunctionLiteral(name, extension_, kNoSourcePosition);
1495 : return factory()->NewExpressionStatement(
1496 1814 : factory()->NewAssignment(Token::INIT, proxy, lit, kNoSourcePosition),
1497 1814 : pos);
1498 : }
1499 :
1500 15713 : void Parser::DeclareLabel(ZonePtrList<const AstRawString>** labels,
1501 : ZonePtrList<const AstRawString>** own_labels,
1502 : VariableProxy* var) {
1503 : DCHECK(IsIdentifier(var));
1504 15713 : const AstRawString* label = var->raw_name();
1505 :
1506 : // TODO(1240780): We don't check for redeclaration of labels
1507 : // during preparsing since keeping track of the set of active
1508 : // labels requires nontrivial changes to the way scopes are
1509 : // structured. However, these are probably changes we want to
1510 : // make later anyway so we should go back and fix this then.
1511 31426 : if (ContainsLabel(*labels, label) || TargetStackContainsLabel(label)) {
1512 0 : ReportMessage(MessageTemplate::kLabelRedeclaration, label);
1513 0 : return;
1514 : }
1515 :
1516 : // Add {label} to both {labels} and {own_labels}.
1517 15713 : if (*labels == nullptr) {
1518 : DCHECK_NULL(*own_labels);
1519 15069 : *labels = new (zone()) ZonePtrList<const AstRawString>(1, zone());
1520 15069 : *own_labels = new (zone()) ZonePtrList<const AstRawString>(1, zone());
1521 : } else {
1522 644 : if (*own_labels == nullptr) {
1523 12 : *own_labels = new (zone()) ZonePtrList<const AstRawString>(1, zone());
1524 : }
1525 : }
1526 15713 : (*labels)->Add(label, zone());
1527 15713 : (*own_labels)->Add(label, zone());
1528 :
1529 : // Remove the "ghost" variable that turned out to be a label
1530 : // from the top scope. This way, we don't try to resolve it
1531 : // during the scope processing.
1532 15713 : scope()->DeleteUnresolved(var);
1533 : }
1534 :
1535 0 : bool Parser::ContainsLabel(ZonePtrList<const AstRawString>* labels,
1536 : const AstRawString* label) {
1537 : DCHECK_NOT_NULL(label);
1538 51147 : if (labels != nullptr) {
1539 11510 : for (int i = labels->length(); i-- > 0;) {
1540 10359 : if (labels->at(i) == label) return true;
1541 : }
1542 : }
1543 : return false;
1544 : }
1545 :
1546 195759 : Block* Parser::IgnoreCompletion(Statement* statement) {
1547 195759 : Block* block = factory()->NewBlock(1, true);
1548 195759 : block->statements()->Add(statement, zone());
1549 195759 : return block;
1550 : }
1551 :
1552 987839 : Expression* Parser::RewriteReturn(Expression* return_value, int pos) {
1553 1975683 : if (IsDerivedConstructor(function_state_->kind())) {
1554 : // For subclass constructors we need to return this in case of undefined;
1555 : // other primitive values trigger an exception in the ConstructStub.
1556 : //
1557 : // return expr;
1558 : //
1559 : // Is rewritten as:
1560 : //
1561 : // return (temp = expr) === undefined ? this : temp;
1562 :
1563 : // temp = expr
1564 : Variable* temp = NewTemporary(ast_value_factory()->empty_string());
1565 : Assignment* assign = factory()->NewAssignment(
1566 332 : Token::ASSIGN, factory()->NewVariableProxy(temp), return_value, pos);
1567 :
1568 : // temp === undefined
1569 : Expression* is_undefined = factory()->NewCompareOperation(
1570 : Token::EQ_STRICT, assign,
1571 : factory()->NewUndefinedLiteral(kNoSourcePosition), pos);
1572 :
1573 : // is_undefined ? this : temp
1574 : // We don't need to call UseThis() since it's guaranteed to be called
1575 : // for derived constructors after parsing the constructor in
1576 : // ParseFunctionBody.
1577 : return_value =
1578 : factory()->NewConditional(is_undefined, factory()->ThisExpression(),
1579 : factory()->NewVariableProxy(temp), pos);
1580 : }
1581 987844 : return return_value;
1582 : }
1583 :
1584 922 : Statement* Parser::RewriteSwitchStatement(SwitchStatement* switch_statement,
1585 : Scope* scope) {
1586 : // In order to get the CaseClauses to execute in their own lexical scope,
1587 : // but without requiring downstream code to have special scope handling
1588 : // code for switch statements, desugar into blocks as follows:
1589 : // { // To group the statements--harmless to evaluate Expression in scope
1590 : // .tag_variable = Expression;
1591 : // { // To give CaseClauses a scope
1592 : // switch (.tag_variable) { CaseClause* }
1593 : // }
1594 : // }
1595 : DCHECK_NOT_NULL(scope);
1596 : DCHECK(scope->is_block_scope());
1597 : DCHECK_GE(switch_statement->position(), scope->start_position());
1598 : DCHECK_LT(switch_statement->position(), scope->end_position());
1599 :
1600 922 : Block* switch_block = factory()->NewBlock(2, false);
1601 :
1602 : Expression* tag = switch_statement->tag();
1603 : Variable* tag_variable =
1604 : NewTemporary(ast_value_factory()->dot_switch_tag_string());
1605 : Assignment* tag_assign = factory()->NewAssignment(
1606 : Token::ASSIGN, factory()->NewVariableProxy(tag_variable), tag,
1607 922 : tag->position());
1608 : // Wrap with IgnoreCompletion so the tag isn't returned as the completion
1609 : // value, in case the switch statements don't have a value.
1610 922 : Statement* tag_statement = IgnoreCompletion(
1611 922 : factory()->NewExpressionStatement(tag_assign, kNoSourcePosition));
1612 922 : switch_block->statements()->Add(tag_statement, zone());
1613 :
1614 : switch_statement->set_tag(factory()->NewVariableProxy(tag_variable));
1615 922 : Block* cases_block = factory()->NewBlock(1, false);
1616 1844 : cases_block->statements()->Add(switch_statement, zone());
1617 : cases_block->set_scope(scope);
1618 922 : switch_block->statements()->Add(cases_block, zone());
1619 922 : return switch_block;
1620 : }
1621 :
1622 7313987 : void Parser::InitializeVariables(
1623 : ScopedPtrList<Statement>* statements, VariableKind kind,
1624 : const DeclarationParsingResult::Declaration* declaration) {
1625 7313987 : if (has_error()) return;
1626 :
1627 : DCHECK_NOT_NULL(declaration->initializer);
1628 :
1629 7243800 : int pos = declaration->value_beg_pos;
1630 7243800 : if (pos == kNoSourcePosition) {
1631 341838 : pos = declaration->initializer->position();
1632 : }
1633 : Assignment* assignment = factory()->NewAssignment(
1634 14487600 : Token::INIT, declaration->pattern, declaration->initializer, pos);
1635 : statements->Add(factory()->NewExpressionStatement(assignment, pos));
1636 : }
1637 :
1638 3024 : Block* Parser::RewriteCatchPattern(CatchInfo* catch_info) {
1639 : DCHECK_NOT_NULL(catch_info->pattern);
1640 :
1641 : DeclarationParsingResult::Declaration decl(
1642 6048 : catch_info->pattern, factory()->NewVariableProxy(catch_info->variable));
1643 :
1644 : ScopedPtrList<Statement> init_statements(pointer_buffer());
1645 3024 : InitializeVariables(&init_statements, NORMAL_VARIABLE, &decl);
1646 6048 : return factory()->NewBlock(true, init_statements);
1647 : }
1648 :
1649 468 : void Parser::ReportVarRedeclarationIn(const AstRawString* name, Scope* scope) {
1650 648 : for (Declaration* decl : *scope->declarations()) {
1651 648 : if (decl->var()->raw_name() == name) {
1652 : int position = decl->position();
1653 : Scanner::Location location =
1654 : position == kNoSourcePosition
1655 : ? Scanner::Location::invalid()
1656 936 : : Scanner::Location(position, position + name->length());
1657 468 : ReportMessageAt(location, MessageTemplate::kVarRedeclaration, name);
1658 468 : return;
1659 : }
1660 : }
1661 0 : UNREACHABLE();
1662 : }
1663 :
1664 93169 : Statement* Parser::RewriteTryStatement(Block* try_block, Block* catch_block,
1665 : const SourceRange& catch_range,
1666 : Block* finally_block,
1667 : const SourceRange& finally_range,
1668 : const CatchInfo& catch_info, int pos) {
1669 : // Simplify the AST nodes by converting:
1670 : // 'try B0 catch B1 finally B2'
1671 : // to:
1672 : // 'try { try B0 catch B1 } finally B2'
1673 :
1674 93169 : if (catch_block != nullptr && finally_block != nullptr) {
1675 : // If we have both, create an inner try/catch.
1676 : TryCatchStatement* statement;
1677 1015 : statement = factory()->NewTryCatchStatement(try_block, catch_info.scope,
1678 : catch_block, kNoSourcePosition);
1679 : RecordTryCatchStatementSourceRange(statement, catch_range);
1680 :
1681 1015 : try_block = factory()->NewBlock(1, false);
1682 2030 : try_block->statements()->Add(statement, zone());
1683 : catch_block = nullptr; // Clear to indicate it's been handled.
1684 : }
1685 :
1686 93169 : if (catch_block != nullptr) {
1687 : DCHECK_NULL(finally_block);
1688 : TryCatchStatement* stmt = factory()->NewTryCatchStatement(
1689 87926 : try_block, catch_info.scope, catch_block, pos);
1690 : RecordTryCatchStatementSourceRange(stmt, catch_range);
1691 : return stmt;
1692 : } else {
1693 : DCHECK_NOT_NULL(finally_block);
1694 : TryFinallyStatement* stmt =
1695 : factory()->NewTryFinallyStatement(try_block, finally_block, pos);
1696 : RecordTryFinallyStatementSourceRange(stmt, finally_range);
1697 : return stmt;
1698 : }
1699 : }
1700 :
1701 25200 : void Parser::ParseAndRewriteGeneratorFunctionBody(
1702 : int pos, FunctionKind kind, ScopedPtrList<Statement>* body) {
1703 : // For ES6 Generators, we just prepend the initial yield.
1704 25200 : Expression* initial_yield = BuildInitialYield(pos, kind);
1705 : body->Add(
1706 : factory()->NewExpressionStatement(initial_yield, kNoSourcePosition));
1707 25200 : ParseStatementList(body, Token::RBRACE);
1708 25200 : }
1709 :
1710 24603 : void Parser::ParseAndRewriteAsyncGeneratorFunctionBody(
1711 : int pos, FunctionKind kind, ScopedPtrList<Statement>* body) {
1712 : // For ES2017 Async Generators, we produce:
1713 : //
1714 : // try {
1715 : // InitialYield;
1716 : // ...body...;
1717 : // return undefined; // See comment below
1718 : // } catch (.catch) {
1719 : // %AsyncGeneratorReject(generator, .catch);
1720 : // } finally {
1721 : // %_GeneratorClose(generator);
1722 : // }
1723 : //
1724 : // - InitialYield yields the actual generator object.
1725 : // - Any return statement inside the body will have its argument wrapped
1726 : // in an iterator result object with a "done" property set to `true`.
1727 : // - If the generator terminates for whatever reason, we must close it.
1728 : // Hence the finally clause.
1729 : // - BytecodeGenerator performs special handling for ReturnStatements in
1730 : // async generator functions, resolving the appropriate Promise with an
1731 : // "done" iterator result object containing a Promise-unwrapped value.
1732 : DCHECK(IsAsyncGeneratorFunction(kind));
1733 :
1734 : Block* try_block;
1735 : {
1736 : ScopedPtrList<Statement> statements(pointer_buffer());
1737 24603 : Expression* initial_yield = BuildInitialYield(pos, kind);
1738 : statements.Add(
1739 : factory()->NewExpressionStatement(initial_yield, kNoSourcePosition));
1740 24603 : ParseStatementList(&statements, Token::RBRACE);
1741 :
1742 : // Don't create iterator result for async generators, as the resume methods
1743 : // will create it.
1744 : // TODO(leszeks): This will create another suspend point, which is
1745 : // unnecessary if there is already an unconditional return in the body.
1746 : Statement* final_return = BuildReturnStatement(
1747 24603 : factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition);
1748 : statements.Add(final_return);
1749 :
1750 24603 : try_block = factory()->NewBlock(false, statements);
1751 : }
1752 :
1753 : // For AsyncGenerators, a top-level catch block will reject the Promise.
1754 24603 : Scope* catch_scope = NewHiddenCatchScope();
1755 :
1756 : Block* catch_block;
1757 : {
1758 : ScopedPtrList<Expression> reject_args(pointer_buffer());
1759 : reject_args.Add(factory()->NewVariableProxy(
1760 24603 : function_state_->scope()->generator_object_var()));
1761 : reject_args.Add(factory()->NewVariableProxy(catch_scope->catch_variable()));
1762 :
1763 : Expression* reject_call = factory()->NewCallRuntime(
1764 24603 : Runtime::kInlineAsyncGeneratorReject, reject_args, kNoSourcePosition);
1765 : catch_block = IgnoreCompletion(
1766 24603 : factory()->NewReturnStatement(reject_call, kNoSourcePosition));
1767 : }
1768 :
1769 : {
1770 : ScopedPtrList<Statement> statements(pointer_buffer());
1771 : TryStatement* try_catch = factory()->NewTryCatchStatementForAsyncAwait(
1772 : try_block, catch_scope, catch_block, kNoSourcePosition);
1773 : statements.Add(try_catch);
1774 24603 : try_block = factory()->NewBlock(false, statements);
1775 : }
1776 :
1777 : Expression* close_call;
1778 : {
1779 : ScopedPtrList<Expression> close_args(pointer_buffer());
1780 : VariableProxy* call_proxy = factory()->NewVariableProxy(
1781 24603 : function_state_->scope()->generator_object_var());
1782 : close_args.Add(call_proxy);
1783 : close_call = factory()->NewCallRuntime(Runtime::kInlineGeneratorClose,
1784 24603 : close_args, kNoSourcePosition);
1785 : }
1786 :
1787 : Block* finally_block;
1788 : {
1789 : ScopedPtrList<Statement> statements(pointer_buffer());
1790 : statements.Add(
1791 : factory()->NewExpressionStatement(close_call, kNoSourcePosition));
1792 24603 : finally_block = factory()->NewBlock(false, statements);
1793 : }
1794 :
1795 : body->Add(factory()->NewTryFinallyStatement(try_block, finally_block,
1796 : kNoSourcePosition));
1797 24603 : }
1798 :
1799 1788349 : void Parser::DeclareFunctionNameVar(const AstRawString* function_name,
1800 : FunctionLiteral::FunctionType function_type,
1801 : DeclarationScope* function_scope) {
1802 1917392 : if (function_type == FunctionLiteral::kNamedExpression &&
1803 : function_scope->LookupLocal(function_name) == nullptr) {
1804 : DCHECK_EQ(function_scope, scope());
1805 125362 : function_scope->DeclareFunctionVar(function_name);
1806 : }
1807 1788346 : }
1808 :
1809 : // Special case for legacy for
1810 : //
1811 : // for (var x = initializer in enumerable) body
1812 : //
1813 : // An initialization block of the form
1814 : //
1815 : // {
1816 : // x = initializer;
1817 : // }
1818 : //
1819 : // is returned in this case. It has reserved space for two statements,
1820 : // so that (later on during parsing), the equivalent of
1821 : //
1822 : // for (x in enumerable) body
1823 : //
1824 : // is added as a second statement to it.
1825 91408 : Block* Parser::RewriteForVarInLegacy(const ForInfo& for_info) {
1826 : const DeclarationParsingResult::Declaration& decl =
1827 : for_info.parsing_result.declarations[0];
1828 199528 : if (!IsLexicalVariableMode(for_info.parsing_result.descriptor.mode) &&
1829 91834 : decl.initializer != nullptr && decl.pattern->IsVariableProxy()) {
1830 213 : ++use_counts_[v8::Isolate::kForInInitializer];
1831 213 : const AstRawString* name = decl.pattern->AsVariableProxy()->raw_name();
1832 : VariableProxy* single_var = NewUnresolved(name);
1833 213 : Block* init_block = factory()->NewBlock(2, true);
1834 426 : init_block->statements()->Add(
1835 : factory()->NewExpressionStatement(
1836 213 : factory()->NewAssignment(Token::ASSIGN, single_var,
1837 213 : decl.initializer, decl.value_beg_pos),
1838 : kNoSourcePosition),
1839 213 : zone());
1840 213 : return init_block;
1841 : }
1842 : return nullptr;
1843 : }
1844 :
1845 : // Rewrite a for-in/of statement of the form
1846 : //
1847 : // for (let/const/var x in/of e) b
1848 : //
1849 : // into
1850 : //
1851 : // {
1852 : // var temp;
1853 : // for (temp in/of e) {
1854 : // let/const/var x = temp;
1855 : // b;
1856 : // }
1857 : // let x; // for TDZ
1858 : // }
1859 106148 : void Parser::DesugarBindingInForEachStatement(ForInfo* for_info,
1860 : Block** body_block,
1861 : Expression** each_variable) {
1862 : DCHECK_EQ(1, for_info->parsing_result.declarations.size());
1863 : DeclarationParsingResult::Declaration& decl =
1864 : for_info->parsing_result.declarations[0];
1865 : Variable* temp = NewTemporary(ast_value_factory()->dot_for_string());
1866 : ScopedPtrList<Statement> each_initialization_statements(pointer_buffer());
1867 : DCHECK_IMPLIES(!has_error(), decl.pattern != nullptr);
1868 212296 : decl.initializer = factory()->NewVariableProxy(temp, for_info->position);
1869 106148 : InitializeVariables(&each_initialization_statements, NORMAL_VARIABLE, &decl);
1870 :
1871 106148 : *body_block = factory()->NewBlock(3, false);
1872 : (*body_block)
1873 : ->statements()
1874 212296 : ->Add(factory()->NewBlock(true, each_initialization_statements), zone());
1875 212295 : *each_variable = factory()->NewVariableProxy(temp, for_info->position);
1876 106147 : }
1877 :
1878 : // Create a TDZ for any lexically-bound names in for in/of statements.
1879 106147 : Block* Parser::CreateForEachStatementTDZ(Block* init_block,
1880 : const ForInfo& for_info) {
1881 106147 : if (IsLexicalVariableMode(for_info.parsing_result.descriptor.mode)) {
1882 : DCHECK_NULL(init_block);
1883 :
1884 86423 : init_block = factory()->NewBlock(1, false);
1885 :
1886 273621 : for (int i = 0; i < for_info.bound_names.length(); ++i) {
1887 : // TODO(adamk): This needs to be some sort of special
1888 : // INTERNAL variable that's invisible to the debugger
1889 : // but visible to everything else.
1890 93599 : VariableProxy* tdz_proxy = DeclareBoundVariable(
1891 93599 : for_info.bound_names[i], VariableMode::kLet, kNoSourcePosition);
1892 : tdz_proxy->var()->set_initializer_position(position());
1893 : }
1894 : }
1895 106147 : return init_block;
1896 : }
1897 :
1898 17509 : Statement* Parser::DesugarLexicalBindingsInForStatement(
1899 : ForStatement* loop, Statement* init, Expression* cond, Statement* next,
1900 : Statement* body, Scope* inner_scope, const ForInfo& for_info) {
1901 : // ES6 13.7.4.8 specifies that on each loop iteration the let variables are
1902 : // copied into a new environment. Moreover, the "next" statement must be
1903 : // evaluated not in the environment of the just completed iteration but in
1904 : // that of the upcoming one. We achieve this with the following desugaring.
1905 : // Extra care is needed to preserve the completion value of the original loop.
1906 : //
1907 : // We are given a for statement of the form
1908 : //
1909 : // labels: for (let/const x = i; cond; next) body
1910 : //
1911 : // and rewrite it as follows. Here we write {{ ... }} for init-blocks, ie.,
1912 : // blocks whose ignore_completion_value_ flag is set.
1913 : //
1914 : // {
1915 : // let/const x = i;
1916 : // temp_x = x;
1917 : // first = 1;
1918 : // undefined;
1919 : // outer: for (;;) {
1920 : // let/const x = temp_x;
1921 : // {{ if (first == 1) {
1922 : // first = 0;
1923 : // } else {
1924 : // next;
1925 : // }
1926 : // flag = 1;
1927 : // if (!cond) break;
1928 : // }}
1929 : // labels: for (; flag == 1; flag = 0, temp_x = x) {
1930 : // body
1931 : // }
1932 : // {{ if (flag == 1) // Body used break.
1933 : // break;
1934 : // }}
1935 : // }
1936 : // }
1937 :
1938 : DCHECK_GT(for_info.bound_names.length(), 0);
1939 : ScopedPtrList<Variable> temps(pointer_buffer());
1940 :
1941 : Block* outer_block =
1942 35018 : factory()->NewBlock(for_info.bound_names.length() + 4, false);
1943 :
1944 : // Add statement: let/const x = i.
1945 17509 : outer_block->statements()->Add(init, zone());
1946 :
1947 : const AstRawString* temp_name = ast_value_factory()->dot_for_string();
1948 :
1949 : // For each lexical variable x:
1950 : // make statement: temp_x = x.
1951 64577 : for (int i = 0; i < for_info.bound_names.length(); i++) {
1952 23534 : VariableProxy* proxy = NewUnresolved(for_info.bound_names[i]);
1953 : Variable* temp = NewTemporary(temp_name);
1954 : VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
1955 : Assignment* assignment = factory()->NewAssignment(Token::ASSIGN, temp_proxy,
1956 23534 : proxy, kNoSourcePosition);
1957 : Statement* assignment_statement =
1958 23534 : factory()->NewExpressionStatement(assignment, kNoSourcePosition);
1959 23534 : outer_block->statements()->Add(assignment_statement, zone());
1960 : temps.Add(temp);
1961 : }
1962 :
1963 : Variable* first = nullptr;
1964 : // Make statement: first = 1.
1965 17509 : if (next) {
1966 : first = NewTemporary(temp_name);
1967 : VariableProxy* first_proxy = factory()->NewVariableProxy(first);
1968 : Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
1969 : Assignment* assignment = factory()->NewAssignment(
1970 2557 : Token::ASSIGN, first_proxy, const1, kNoSourcePosition);
1971 : Statement* assignment_statement =
1972 2557 : factory()->NewExpressionStatement(assignment, kNoSourcePosition);
1973 2557 : outer_block->statements()->Add(assignment_statement, zone());
1974 : }
1975 :
1976 : // make statement: undefined;
1977 35018 : outer_block->statements()->Add(
1978 : factory()->NewExpressionStatement(
1979 : factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition),
1980 17509 : zone());
1981 :
1982 : // Make statement: outer: for (;;)
1983 : // Note that we don't actually create the label, or set this loop up as an
1984 : // explicit break target, instead handing it directly to those nodes that
1985 : // need to know about it. This should be safe because we don't run any code
1986 : // in this function that looks up break targets.
1987 : ForStatement* outer_loop =
1988 : factory()->NewForStatement(nullptr, nullptr, kNoSourcePosition);
1989 17509 : outer_block->statements()->Add(outer_loop, zone());
1990 : outer_block->set_scope(scope());
1991 :
1992 17509 : Block* inner_block = factory()->NewBlock(3, false);
1993 : {
1994 17509 : BlockState block_state(&scope_, inner_scope);
1995 :
1996 : Block* ignore_completion_block =
1997 17509 : factory()->NewBlock(for_info.bound_names.length() + 3, true);
1998 : ScopedPtrList<Variable> inner_vars(pointer_buffer());
1999 : // For each let variable x:
2000 : // make statement: let/const x = temp_x.
2001 64577 : for (int i = 0; i < for_info.bound_names.length(); i++) {
2002 23534 : VariableProxy* proxy = DeclareBoundVariable(
2003 23534 : for_info.bound_names[i], for_info.parsing_result.descriptor.mode,
2004 23534 : kNoSourcePosition);
2005 : inner_vars.Add(proxy->var());
2006 : VariableProxy* temp_proxy = factory()->NewVariableProxy(temps.at(i));
2007 : Assignment* assignment = factory()->NewAssignment(
2008 23534 : Token::INIT, proxy, temp_proxy, kNoSourcePosition);
2009 : Statement* assignment_statement =
2010 23534 : factory()->NewExpressionStatement(assignment, kNoSourcePosition);
2011 23534 : int declaration_pos = for_info.parsing_result.descriptor.declaration_pos;
2012 : DCHECK_NE(declaration_pos, kNoSourcePosition);
2013 : proxy->var()->set_initializer_position(declaration_pos);
2014 23534 : ignore_completion_block->statements()->Add(assignment_statement, zone());
2015 : }
2016 :
2017 : // Make statement: if (first == 1) { first = 0; } else { next; }
2018 17509 : if (next) {
2019 : DCHECK(first);
2020 : Expression* compare = nullptr;
2021 : // Make compare expression: first == 1.
2022 : {
2023 : Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
2024 : VariableProxy* first_proxy = factory()->NewVariableProxy(first);
2025 : compare = factory()->NewCompareOperation(Token::EQ, first_proxy, const1,
2026 : kNoSourcePosition);
2027 : }
2028 : Statement* clear_first = nullptr;
2029 : // Make statement: first = 0.
2030 : {
2031 : VariableProxy* first_proxy = factory()->NewVariableProxy(first);
2032 : Expression* const0 = factory()->NewSmiLiteral(0, kNoSourcePosition);
2033 : Assignment* assignment = factory()->NewAssignment(
2034 2557 : Token::ASSIGN, first_proxy, const0, kNoSourcePosition);
2035 : clear_first =
2036 : factory()->NewExpressionStatement(assignment, kNoSourcePosition);
2037 : }
2038 : Statement* clear_first_or_next = factory()->NewIfStatement(
2039 2557 : compare, clear_first, next, kNoSourcePosition);
2040 2557 : ignore_completion_block->statements()->Add(clear_first_or_next, zone());
2041 : }
2042 :
2043 : Variable* flag = NewTemporary(temp_name);
2044 : // Make statement: flag = 1.
2045 : {
2046 : VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
2047 : Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
2048 : Assignment* assignment = factory()->NewAssignment(
2049 17509 : Token::ASSIGN, flag_proxy, const1, kNoSourcePosition);
2050 : Statement* assignment_statement =
2051 17509 : factory()->NewExpressionStatement(assignment, kNoSourcePosition);
2052 17509 : ignore_completion_block->statements()->Add(assignment_statement, zone());
2053 : }
2054 :
2055 : // Make statement: if (!cond) break.
2056 17509 : if (cond) {
2057 : Statement* stop =
2058 : factory()->NewBreakStatement(outer_loop, kNoSourcePosition);
2059 : Statement* noop = factory()->EmptyStatement();
2060 23486 : ignore_completion_block->statements()->Add(
2061 : factory()->NewIfStatement(cond, noop, stop, cond->position()),
2062 11743 : zone());
2063 : }
2064 :
2065 35018 : inner_block->statements()->Add(ignore_completion_block, zone());
2066 : // Make cond expression for main loop: flag == 1.
2067 : Expression* flag_cond = nullptr;
2068 : {
2069 : Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
2070 : VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
2071 : flag_cond = factory()->NewCompareOperation(Token::EQ, flag_proxy, const1,
2072 : kNoSourcePosition);
2073 : }
2074 :
2075 : // Create chain of expressions "flag = 0, temp_x = x, ..."
2076 : Statement* compound_next_statement = nullptr;
2077 : {
2078 : Expression* compound_next = nullptr;
2079 : // Make expression: flag = 0.
2080 : {
2081 : VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
2082 : Expression* const0 = factory()->NewSmiLiteral(0, kNoSourcePosition);
2083 : compound_next = factory()->NewAssignment(Token::ASSIGN, flag_proxy,
2084 17509 : const0, kNoSourcePosition);
2085 : }
2086 :
2087 : // Make the comma-separated list of temp_x = x assignments.
2088 17509 : int inner_var_proxy_pos = scanner()->location().beg_pos;
2089 64577 : for (int i = 0; i < for_info.bound_names.length(); i++) {
2090 : VariableProxy* temp_proxy = factory()->NewVariableProxy(temps.at(i));
2091 : VariableProxy* proxy =
2092 : factory()->NewVariableProxy(inner_vars.at(i), inner_var_proxy_pos);
2093 : Assignment* assignment = factory()->NewAssignment(
2094 23534 : Token::ASSIGN, temp_proxy, proxy, kNoSourcePosition);
2095 : compound_next = factory()->NewBinaryOperation(
2096 : Token::COMMA, compound_next, assignment, kNoSourcePosition);
2097 : }
2098 :
2099 : compound_next_statement =
2100 : factory()->NewExpressionStatement(compound_next, kNoSourcePosition);
2101 : }
2102 :
2103 : // Make statement: labels: for (; flag == 1; flag = 0, temp_x = x)
2104 : // Note that we re-use the original loop node, which retains its labels
2105 : // and ensures that any break or continue statements in body point to
2106 : // the right place.
2107 : loop->Initialize(nullptr, flag_cond, compound_next_statement, body);
2108 17509 : inner_block->statements()->Add(loop, zone());
2109 :
2110 : // Make statement: {{if (flag == 1) break;}}
2111 : {
2112 : Expression* compare = nullptr;
2113 : // Make compare expresion: flag == 1.
2114 : {
2115 : Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
2116 : VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
2117 : compare = factory()->NewCompareOperation(Token::EQ, flag_proxy, const1,
2118 : kNoSourcePosition);
2119 : }
2120 : Statement* stop =
2121 : factory()->NewBreakStatement(outer_loop, kNoSourcePosition);
2122 : Statement* empty = factory()->EmptyStatement();
2123 : Statement* if_flag_break =
2124 : factory()->NewIfStatement(compare, stop, empty, kNoSourcePosition);
2125 17509 : inner_block->statements()->Add(IgnoreCompletion(if_flag_break), zone());
2126 : }
2127 :
2128 : inner_block->set_scope(inner_scope);
2129 : }
2130 :
2131 : outer_loop->Initialize(nullptr, nullptr, nullptr, inner_block);
2132 :
2133 17509 : return outer_block;
2134 : }
2135 :
2136 0 : void ParserFormalParameters::ValidateDuplicate(Parser* parser) const {
2137 796665 : if (has_duplicate()) {
2138 2666 : parser->ReportMessageAt(duplicate_loc, MessageTemplate::kParamDupe);
2139 : }
2140 0 : }
2141 0 : void ParserFormalParameters::ValidateStrictMode(Parser* parser) const {
2142 744371 : if (strict_error_loc.IsValid()) {
2143 1910 : parser->ReportMessageAt(strict_error_loc, strict_error_message);
2144 : }
2145 0 : }
2146 :
2147 127516 : void Parser::AddArrowFunctionFormalParameters(
2148 : ParserFormalParameters* parameters, Expression* expr, int end_pos) {
2149 : // ArrowFunctionFormals ::
2150 : // Nary(Token::COMMA, VariableProxy*, Tail)
2151 : // Binary(Token::COMMA, NonTailArrowFunctionFormals, Tail)
2152 : // Tail
2153 : // NonTailArrowFunctionFormals ::
2154 : // Binary(Token::COMMA, NonTailArrowFunctionFormals, VariableProxy)
2155 : // VariableProxy
2156 : // Tail ::
2157 : // VariableProxy
2158 : // Spread(VariableProxy)
2159 : //
2160 : // We need to visit the parameters in left-to-right order
2161 : //
2162 :
2163 : // For the Nary case, we simply visit the parameters in a loop.
2164 132237 : if (expr->IsNaryOperation()) {
2165 4721 : NaryOperation* nary = expr->AsNaryOperation();
2166 : // The classifier has already run, so we know that the expression is a valid
2167 : // arrow function formals production.
2168 : DCHECK_EQ(nary->op(), Token::COMMA);
2169 : // Each op position is the end position of the *previous* expr, with the
2170 : // second (i.e. first "subsequent") op position being the end position of
2171 : // the first child expression.
2172 : Expression* next = nary->first();
2173 24943 : for (size_t i = 0; i < nary->subsequent_length(); ++i) {
2174 : AddArrowFunctionFormalParameters(parameters, next,
2175 10111 : nary->subsequent_op_position(i));
2176 : next = nary->subsequent(i);
2177 : }
2178 : AddArrowFunctionFormalParameters(parameters, next, end_pos);
2179 : return;
2180 : }
2181 :
2182 : // For the binary case, we recurse on the left-hand side of binary comma
2183 : // expressions.
2184 127516 : if (expr->IsBinaryOperation()) {
2185 14477 : BinaryOperation* binop = expr->AsBinaryOperation();
2186 : // The classifier has already run, so we know that the expression is a valid
2187 : // arrow function formals production.
2188 : DCHECK_EQ(binop->op(), Token::COMMA);
2189 : Expression* left = binop->left();
2190 : Expression* right = binop->right();
2191 : int comma_pos = binop->position();
2192 14477 : AddArrowFunctionFormalParameters(parameters, left, comma_pos);
2193 : // LHS of comma expression should be unparenthesized.
2194 : expr = right;
2195 : }
2196 :
2197 : // Only the right-most expression may be a rest parameter.
2198 : DCHECK(!parameters->has_rest);
2199 :
2200 : bool is_rest = expr->IsSpread();
2201 127516 : if (is_rest) {
2202 1534 : expr = expr->AsSpread()->expression();
2203 1534 : parameters->has_rest = true;
2204 : }
2205 : DCHECK_IMPLIES(parameters->is_simple, !is_rest);
2206 : DCHECK_IMPLIES(parameters->is_simple, expr->IsVariableProxy());
2207 :
2208 : Expression* initializer = nullptr;
2209 127516 : if (expr->IsAssignment()) {
2210 9939 : Assignment* assignment = expr->AsAssignment();
2211 : DCHECK(!assignment->IsCompoundAssignment());
2212 : initializer = assignment->value();
2213 : expr = assignment->target();
2214 : }
2215 :
2216 : AddFormalParameter(parameters, expr, initializer, end_pos, is_rest);
2217 : }
2218 :
2219 365994 : void Parser::DeclareArrowFunctionFormalParameters(
2220 : ParserFormalParameters* parameters, Expression* expr,
2221 : const Scanner::Location& params_loc) {
2222 468921 : if (expr->IsEmptyParentheses() || has_error()) return;
2223 :
2224 102927 : AddArrowFunctionFormalParameters(parameters, expr, params_loc.end_pos);
2225 :
2226 102928 : if (parameters->arity > Code::kMaxArguments) {
2227 0 : ReportMessageAt(params_loc, MessageTemplate::kMalformedArrowFunParamList);
2228 0 : return;
2229 : }
2230 :
2231 : DeclareFormalParameters(parameters);
2232 : DCHECK_IMPLIES(parameters->is_simple,
2233 : parameters->scope->has_simple_parameters());
2234 : }
2235 :
2236 142964 : void Parser::PrepareGeneratorVariables() {
2237 : // Calling a generator returns a generator object. That object is stored
2238 : // in a temporary variable, a definition that is used by "yield"
2239 : // expressions.
2240 142964 : function_state_->scope()->DeclareGeneratorObjectVar(
2241 142965 : ast_value_factory()->dot_generator_object_string());
2242 142965 : }
2243 :
2244 3842368 : FunctionLiteral* Parser::ParseFunctionLiteral(
2245 : const AstRawString* function_name, Scanner::Location function_name_location,
2246 : FunctionNameValidity function_name_validity, FunctionKind kind,
2247 : int function_token_pos, FunctionLiteral::FunctionType function_type,
2248 : LanguageMode language_mode,
2249 : ZonePtrList<const AstRawString>* arguments_for_wrapped_function) {
2250 : // Function ::
2251 : // '(' FormalParameterList? ')' '{' FunctionBody '}'
2252 : //
2253 : // Getter ::
2254 : // '(' ')' '{' FunctionBody '}'
2255 : //
2256 : // Setter ::
2257 : // '(' PropertySetParameterList ')' '{' FunctionBody '}'
2258 :
2259 : bool is_wrapped = function_type == FunctionLiteral::kWrapped;
2260 : DCHECK_EQ(is_wrapped, arguments_for_wrapped_function != nullptr);
2261 :
2262 : int pos = function_token_pos == kNoSourcePosition ? peek_position()
2263 3842368 : : function_token_pos;
2264 : DCHECK_NE(kNoSourcePosition, pos);
2265 :
2266 : // Anonymous functions were passed either the empty symbol or a null
2267 : // handle as the function name. Remember if we were passed a non-empty
2268 : // handle to decide whether to invoke function name inference.
2269 : bool should_infer_name = function_name == nullptr;
2270 :
2271 : // We want a non-null handle as the function name by default. We will handle
2272 : // the "function does not have a shared name" case later.
2273 3842368 : if (should_infer_name) {
2274 : function_name = ast_value_factory()->empty_string();
2275 : }
2276 :
2277 : FunctionLiteral::EagerCompileHint eager_compile_hint =
2278 7111461 : function_state_->next_function_is_likely_called() || is_wrapped
2279 : ? FunctionLiteral::kShouldEagerCompile
2280 7111375 : : default_eager_compile_hint();
2281 :
2282 : // Determine if the function can be parsed lazily. Lazy parsing is
2283 : // different from lazy compilation; we need to parse more eagerly than we
2284 : // compile.
2285 :
2286 : // We can only parse lazily if we also compile lazily. The heuristics for lazy
2287 : // compilation are:
2288 : // - It must not have been prohibited by the caller to Parse (some callers
2289 : // need a full AST).
2290 : // - The outer scope must allow lazy compilation of inner functions.
2291 : // - The function mustn't be a function expression with an open parenthesis
2292 : // before; we consider that a hint that the function will be called
2293 : // immediately, and it would be a waste of time to make it lazily
2294 : // compiled.
2295 : // These are all things we can know at this point, without looking at the
2296 : // function itself.
2297 :
2298 : // We separate between lazy parsing top level functions and lazy parsing inner
2299 : // functions, because the latter needs to do more work. In particular, we need
2300 : // to track unresolved variables to distinguish between these cases:
2301 : // (function foo() {
2302 : // bar = function() { return 1; }
2303 : // })();
2304 : // and
2305 : // (function foo() {
2306 : // var a = 1;
2307 : // bar = function() { return a; }
2308 : // })();
2309 :
2310 : // Now foo will be parsed eagerly and compiled eagerly (optimization: assume
2311 : // parenthesis before the function means that it will be called
2312 : // immediately). bar can be parsed lazily, but we need to parse it in a mode
2313 : // that tracks unresolved variables.
2314 : DCHECK_IMPLIES(parse_lazily(), info()->allow_lazy_compile());
2315 : DCHECK_IMPLIES(parse_lazily(), has_error() || allow_lazy_);
2316 : DCHECK_IMPLIES(parse_lazily(), extension_ == nullptr);
2317 :
2318 : const bool is_lazy =
2319 3842368 : eager_compile_hint == FunctionLiteral::kShouldLazyCompile;
2320 : const bool is_top_level = AllowsLazyParsingWithoutUnresolvedVariables();
2321 3842375 : const bool is_eager_top_level_function = !is_lazy && is_top_level;
2322 3842375 : const bool is_lazy_top_level_function = is_lazy && is_top_level;
2323 : const bool is_lazy_inner_function = is_lazy && !is_top_level;
2324 :
2325 : RuntimeCallTimerScope runtime_timer(
2326 : runtime_call_stats_,
2327 3842375 : parsing_on_main_thread_
2328 : ? RuntimeCallCounterId::kParseFunctionLiteral
2329 3842375 : : RuntimeCallCounterId::kParseBackgroundFunctionLiteral);
2330 : base::ElapsedTimer timer;
2331 3842389 : if (V8_UNLIKELY(FLAG_log_function_events)) timer.Start();
2332 :
2333 : // Determine whether we can still lazy parse the inner function.
2334 : // The preconditions are:
2335 : // - Lazy compilation has to be enabled.
2336 : // - Neither V8 natives nor native function declarations can be allowed,
2337 : // since parsing one would retroactively force the function to be
2338 : // eagerly compiled.
2339 : // - The invoker of this parser can't depend on the AST being eagerly
2340 : // built (either because the function is about to be compiled, or
2341 : // because the AST is going to be inspected for some reason).
2342 : // - Because of the above, we can't be attempting to parse a
2343 : // FunctionExpression; even without enclosing parentheses it might be
2344 : // immediately invoked.
2345 : // - The function literal shouldn't be hinted to eagerly compile.
2346 :
2347 : // Inner functions will be parsed using a temporary Zone. After parsing, we
2348 : // will migrate unresolved variable into a Scope in the main Zone.
2349 :
2350 3842389 : const bool should_preparse_inner = parse_lazily() && is_lazy_inner_function;
2351 :
2352 : // If parallel compile tasks are enabled, and the function is an eager
2353 : // top level function, then we can pre-parse the function and parse / compile
2354 : // in a parallel task on a worker thread.
2355 : bool should_post_parallel_task =
2356 3138403 : parse_lazily() && is_eager_top_level_function &&
2357 3842521 : FLAG_parallel_compile_tasks && info()->parallel_tasks() &&
2358 : scanner()->stream()->can_be_cloned_for_parallel_access();
2359 :
2360 : // This may be modified later to reflect preparsing decision taken
2361 3138399 : bool should_preparse = (parse_lazily() && is_lazy_top_level_function) ||
2362 6989554 : should_preparse_inner || should_post_parallel_task;
2363 :
2364 : ScopedPtrList<Statement> body(pointer_buffer());
2365 3842389 : int expected_property_count = -1;
2366 3842389 : int suspend_count = -1;
2367 3842389 : int num_parameters = -1;
2368 3842389 : int function_length = -1;
2369 3842389 : bool has_duplicate_parameters = false;
2370 : int function_literal_id = GetNextFunctionLiteralId();
2371 3842389 : ProducedPreparseData* produced_preparse_data = nullptr;
2372 :
2373 : // This Scope lives in the main zone. We'll migrate data into that zone later.
2374 3842389 : Zone* parse_zone = should_preparse ? &preparser_zone_ : zone();
2375 3842389 : DeclarationScope* scope = NewFunctionScope(kind, parse_zone);
2376 3842429 : SetLanguageMode(scope, language_mode);
2377 : #ifdef DEBUG
2378 : scope->SetScopeName(function_name);
2379 : #endif
2380 :
2381 7684745 : if (!is_wrapped && V8_UNLIKELY(!Check(Token::LPAREN))) {
2382 17679 : ReportUnexpectedToken(Next());
2383 17679 : return nullptr;
2384 : }
2385 : scope->set_start_position(position());
2386 :
2387 : // Eager or lazy parse? If is_lazy_top_level_function, we'll parse
2388 : // lazily. We'll call SkipFunction, which may decide to
2389 : // abort lazy parsing if it suspects that wasn't a good idea. If so (in
2390 : // which case the parser is expected to have backtracked), or if we didn't
2391 : // try to lazy parse in the first place, we'll have to parse eagerly.
2392 : bool did_preparse_successfully =
2393 3824728 : should_preparse && SkipFunction(function_name, kind, function_type, scope,
2394 : &num_parameters, &produced_preparse_data);
2395 :
2396 3824766 : if (!did_preparse_successfully) {
2397 : // If skipping aborted, it rewound the scanner until before the LPAREN.
2398 : // Consume it in that case.
2399 1294852 : if (should_preparse) Consume(Token::LPAREN);
2400 : should_post_parallel_task = false;
2401 : ParseFunction(&body, function_name, pos, kind, function_type, scope,
2402 : &num_parameters, &function_length, &has_duplicate_parameters,
2403 : &expected_property_count, &suspend_count,
2404 1294852 : arguments_for_wrapped_function);
2405 : }
2406 :
2407 3824739 : if (V8_UNLIKELY(FLAG_log_function_events)) {
2408 55 : double ms = timer.Elapsed().InMillisecondsF();
2409 : const char* event_name =
2410 : should_preparse
2411 : ? (is_top_level ? "preparse-no-resolution" : "preparse-resolution")
2412 55 : : "full-parse";
2413 55 : logger_->FunctionEvent(
2414 : event_name, script_id(), ms, scope->start_position(),
2415 : scope->end_position(),
2416 : reinterpret_cast<const char*>(function_name->raw_data()),
2417 55 : function_name->byte_length());
2418 : }
2419 3824739 : if (V8_UNLIKELY(TracingFlags::is_runtime_stats_enabled()) &&
2420 : did_preparse_successfully) {
2421 : const RuntimeCallCounterId counters[2] = {
2422 : RuntimeCallCounterId::kPreParseBackgroundWithVariableResolution,
2423 2 : RuntimeCallCounterId::kPreParseWithVariableResolution};
2424 2 : if (runtime_call_stats_) {
2425 2 : runtime_call_stats_->CorrectCurrentCounterId(
2426 4 : counters[parsing_on_main_thread_]);
2427 : }
2428 : }
2429 :
2430 : // Validate function name. We can do this only after parsing the function,
2431 : // since the function can declare itself strict.
2432 : language_mode = scope->language_mode();
2433 : CheckFunctionName(language_mode, function_name, function_name_validity,
2434 3824739 : function_name_location);
2435 :
2436 3824745 : if (is_strict(language_mode)) {
2437 872785 : CheckStrictOctalLiteral(scope->start_position(), scope->end_position());
2438 : }
2439 :
2440 : FunctionLiteral::ParameterFlag duplicate_parameters =
2441 : has_duplicate_parameters ? FunctionLiteral::kHasDuplicateParameters
2442 3824738 : : FunctionLiteral::kNoDuplicateParameters;
2443 :
2444 : // Note that the FunctionLiteral needs to be created in the main Zone again.
2445 3824738 : FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
2446 : function_name, scope, body, expected_property_count, num_parameters,
2447 : function_length, duplicate_parameters, function_type, eager_compile_hint,
2448 3824738 : pos, true, function_literal_id, produced_preparse_data);
2449 : function_literal->set_function_token_position(function_token_pos);
2450 3824693 : function_literal->set_suspend_count(suspend_count);
2451 :
2452 3824693 : if (should_post_parallel_task) {
2453 : // Start a parallel parse / compile task on the compiler dispatcher.
2454 55 : info()->parallel_tasks()->Enqueue(info(), function_name, function_literal);
2455 : }
2456 :
2457 3824708 : if (should_infer_name) {
2458 : fni_.AddFunction(function_literal);
2459 : }
2460 : return function_literal;
2461 : }
2462 :
2463 2603261 : bool Parser::SkipFunction(const AstRawString* function_name, FunctionKind kind,
2464 : FunctionLiteral::FunctionType function_type,
2465 : DeclarationScope* function_scope, int* num_parameters,
2466 : ProducedPreparseData** produced_preparse_data) {
2467 2603261 : FunctionState function_state(&function_state_, &scope_, function_scope);
2468 2603261 : function_scope->set_zone(&preparser_zone_);
2469 :
2470 : DCHECK_NE(kNoSourcePosition, function_scope->start_position());
2471 : DCHECK_EQ(kNoSourcePosition, parameters_end_pos_);
2472 :
2473 : DCHECK_IMPLIES(IsArrowFunction(kind),
2474 : scanner()->current_token() == Token::ARROW);
2475 :
2476 : // FIXME(marja): There are 2 ways to skip functions now. Unify them.
2477 2603261 : if (consumed_preparse_data_) {
2478 : int end_position;
2479 : LanguageMode language_mode;
2480 : int num_inner_functions;
2481 : bool uses_super_property;
2482 60666 : if (stack_overflow()) return true;
2483 : *produced_preparse_data =
2484 60666 : consumed_preparse_data_->GetDataForSkippableFunction(
2485 : main_zone(), function_scope->start_position(), &end_position,
2486 : num_parameters, &num_inner_functions, &uses_super_property,
2487 121332 : &language_mode);
2488 :
2489 : function_scope->outer_scope()->SetMustUsePreparseData();
2490 : function_scope->set_is_skipped_function(true);
2491 60666 : function_scope->set_end_position(end_position);
2492 60666 : scanner()->SeekForward(end_position - 1);
2493 60666 : Expect(Token::RBRACE);
2494 60666 : SetLanguageMode(function_scope, language_mode);
2495 60666 : if (uses_super_property) {
2496 : function_scope->RecordSuperPropertyUsage();
2497 : }
2498 60666 : SkipFunctionLiterals(num_inner_functions);
2499 60666 : function_scope->ResetAfterPreparsing(ast_value_factory_, false);
2500 60666 : return true;
2501 : }
2502 :
2503 : Scanner::BookmarkScope bookmark(scanner());
2504 2542595 : bookmark.Set(function_scope->start_position());
2505 :
2506 : // With no cached data, we partially parse the function, without building an
2507 : // AST. This gathers the data needed to build a lazy function.
2508 7627799 : TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.PreParse");
2509 :
2510 2542609 : PreParser::PreParseResult result = reusable_preparser()->PreParseFunction(
2511 : function_name, kind, function_type, function_scope, use_counts_,
2512 2542594 : produced_preparse_data, this->script_id());
2513 :
2514 2542555 : if (result == PreParser::kPreParseStackOverflow) {
2515 : // Propagate stack overflow.
2516 : set_stack_overflow();
2517 2542513 : } else if (pending_error_handler()->has_error_unidentifiable_by_preparser()) {
2518 : // Make sure we don't re-preparse inner functions of the aborted function.
2519 : // The error might be in an inner function.
2520 48875 : allow_lazy_ = false;
2521 48875 : mode_ = PARSE_EAGERLY;
2522 : DCHECK(!pending_error_handler()->stack_overflow());
2523 : // If we encounter an error that the preparser can not identify we reset to
2524 : // the state before preparsing. The caller may then fully parse the function
2525 : // to identify the actual error.
2526 48875 : bookmark.Apply();
2527 48875 : function_scope->ResetAfterPreparsing(ast_value_factory(), true);
2528 : pending_error_handler()->clear_unidentifiable_error();
2529 48875 : return false;
2530 2493638 : } else if (pending_error_handler()->has_pending_error()) {
2531 : DCHECK(!pending_error_handler()->stack_overflow());
2532 : DCHECK(has_error());
2533 : } else {
2534 : DCHECK(!pending_error_handler()->stack_overflow());
2535 2482563 : set_allow_eval_cache(reusable_preparser()->allow_eval_cache());
2536 :
2537 2482558 : PreParserLogger* logger = reusable_preparser()->logger();
2538 : function_scope->set_end_position(logger->end());
2539 2482578 : Expect(Token::RBRACE);
2540 : total_preparse_skipped_ +=
2541 2482592 : function_scope->end_position() - function_scope->start_position();
2542 2482592 : *num_parameters = logger->num_parameters();
2543 : SkipFunctionLiterals(logger->num_inner_functions());
2544 2482592 : function_scope->AnalyzePartially(this, factory());
2545 : }
2546 :
2547 : return true;
2548 : }
2549 :
2550 37897 : Block* Parser::BuildParameterInitializationBlock(
2551 : const ParserFormalParameters& parameters) {
2552 : DCHECK(!parameters.is_simple);
2553 : DCHECK(scope()->is_function_scope());
2554 : DCHECK_EQ(scope(), parameters.scope);
2555 : ScopedPtrList<Statement> init_statements(pointer_buffer());
2556 : int index = 0;
2557 98671 : for (auto parameter : parameters.params) {
2558 : Expression* initial_value =
2559 60774 : factory()->NewVariableProxy(parameters.scope->parameter(index));
2560 60774 : if (parameter->initializer() != nullptr) {
2561 : // IS_UNDEFINED($param) ? initializer : $param
2562 :
2563 : auto condition = factory()->NewCompareOperation(
2564 : Token::EQ_STRICT,
2565 21089 : factory()->NewVariableProxy(parameters.scope->parameter(index)),
2566 : factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition);
2567 : initial_value =
2568 : factory()->NewConditional(condition, parameter->initializer(),
2569 : initial_value, kNoSourcePosition);
2570 : }
2571 :
2572 : Scope* param_scope = scope();
2573 : ScopedPtrList<Statement>* param_init_statements = &init_statements;
2574 :
2575 60774 : base::Optional<ScopedPtrList<Statement>> non_simple_param_init_statements;
2576 101368 : if (!parameter->is_simple() &&
2577 40594 : scope()->AsDeclarationScope()->calls_sloppy_eval()) {
2578 1167 : param_scope = NewVarblockScope();
2579 1167 : param_scope->set_start_position(parameter->pattern->position());
2580 1167 : param_scope->set_end_position(parameter->initializer_end_position);
2581 : param_scope->RecordEvalCall();
2582 1167 : non_simple_param_init_statements.emplace(pointer_buffer());
2583 : param_init_statements = &non_simple_param_init_statements.value();
2584 : // Rewrite the outer initializer to point to param_scope
2585 1167 : ReparentExpressionScope(stack_limit(), parameter->pattern, param_scope);
2586 1167 : ReparentExpressionScope(stack_limit(), initial_value, param_scope);
2587 : }
2588 :
2589 60774 : BlockState block_state(&scope_, param_scope);
2590 60774 : DeclarationParsingResult::Declaration decl(parameter->pattern,
2591 : initial_value);
2592 :
2593 60774 : InitializeVariables(param_init_statements, PARAMETER_VARIABLE, &decl);
2594 :
2595 60774 : if (param_init_statements != &init_statements) {
2596 : DCHECK_EQ(param_init_statements,
2597 : &non_simple_param_init_statements.value());
2598 : Block* param_block =
2599 1167 : factory()->NewBlock(true, *non_simple_param_init_statements);
2600 : non_simple_param_init_statements.reset();
2601 : param_block->set_scope(param_scope);
2602 1167 : param_scope = param_scope->FinalizeBlockScope();
2603 : init_statements.Add(param_block);
2604 : }
2605 60774 : ++index;
2606 : }
2607 75794 : return factory()->NewBlock(true, init_statements);
2608 : }
2609 :
2610 69458 : Scope* Parser::NewHiddenCatchScope() {
2611 69458 : Scope* catch_scope = NewScopeWithParent(scope(), CATCH_SCOPE);
2612 : bool was_added;
2613 : catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(),
2614 69459 : VariableMode::kVar, NORMAL_VARIABLE, &was_added);
2615 : DCHECK(was_added);
2616 : catch_scope->set_is_hidden();
2617 69459 : return catch_scope;
2618 : }
2619 :
2620 44855 : Block* Parser::BuildRejectPromiseOnException(Block* inner_block) {
2621 : // try {
2622 : // <inner_block>
2623 : // } catch (.catch) {
2624 : // return %_AsyncFunctionReject(.generator_object, .catch, can_suspend);
2625 : // }
2626 44855 : Block* result = factory()->NewBlock(1, true);
2627 :
2628 : // catch (.catch) {
2629 : // return %_AsyncFunctionReject(.generator_object, .catch, can_suspend)
2630 : // }
2631 44856 : Scope* catch_scope = NewHiddenCatchScope();
2632 :
2633 : Expression* reject_promise;
2634 : {
2635 : ScopedPtrList<Expression> args(pointer_buffer());
2636 : args.Add(factory()->NewVariableProxy(
2637 44856 : function_state_->scope()->generator_object_var()));
2638 : args.Add(factory()->NewVariableProxy(catch_scope->catch_variable()));
2639 44856 : args.Add(factory()->NewBooleanLiteral(function_state_->CanSuspend(),
2640 : kNoSourcePosition));
2641 : reject_promise = factory()->NewCallRuntime(
2642 44856 : Runtime::kInlineAsyncFunctionReject, args, kNoSourcePosition);
2643 : }
2644 : Block* catch_block = IgnoreCompletion(
2645 44856 : factory()->NewReturnStatement(reject_promise, kNoSourcePosition));
2646 :
2647 : TryStatement* try_catch_statement =
2648 : factory()->NewTryCatchStatementForAsyncAwait(
2649 : inner_block, catch_scope, catch_block, kNoSourcePosition);
2650 89712 : result->statements()->Add(try_catch_statement, zone());
2651 44856 : return result;
2652 : }
2653 :
2654 90623 : Expression* Parser::BuildInitialYield(int pos, FunctionKind kind) {
2655 : Expression* yield_result = factory()->NewVariableProxy(
2656 90623 : function_state_->scope()->generator_object_var());
2657 : // The position of the yield is important for reporting the exception
2658 : // caused by calling the .throw method on a generator suspended at the
2659 : // initial yield (i.e. right after generator instantiation).
2660 90623 : function_state_->AddSuspend();
2661 : return factory()->NewYield(yield_result, scope()->start_position(),
2662 90623 : Suspend::kOnExceptionThrow);
2663 : }
2664 :
2665 1294850 : void Parser::ParseFunction(
2666 : ScopedPtrList<Statement>* body, const AstRawString* function_name, int pos,
2667 : FunctionKind kind, FunctionLiteral::FunctionType function_type,
2668 : DeclarationScope* function_scope, int* num_parameters, int* function_length,
2669 : bool* has_duplicate_parameters, int* expected_property_count,
2670 : int* suspend_count,
2671 : ZonePtrList<const AstRawString>* arguments_for_wrapped_function) {
2672 1294850 : ParsingModeScope mode(this, allow_lazy_ ? PARSE_LAZILY : PARSE_EAGERLY);
2673 :
2674 1294850 : FunctionState function_state(&function_state_, &scope_, function_scope);
2675 :
2676 : bool is_wrapped = function_type == FunctionLiteral::kWrapped;
2677 :
2678 1294850 : int expected_parameters_end_pos = parameters_end_pos_;
2679 1294850 : if (expected_parameters_end_pos != kNoSourcePosition) {
2680 : // This is the first function encountered in a CreateDynamicFunction eval.
2681 336487 : parameters_end_pos_ = kNoSourcePosition;
2682 : // The function name should have been ignored, giving us the empty string
2683 : // here.
2684 : DCHECK_EQ(function_name, ast_value_factory()->empty_string());
2685 : }
2686 :
2687 : ParserFormalParameters formals(function_scope);
2688 :
2689 : {
2690 : ParameterDeclarationParsingScope formals_scope(this);
2691 1294850 : if (is_wrapped) {
2692 : // For a function implicitly wrapped in function header and footer, the
2693 : // function arguments are provided separately to the source, and are
2694 : // declared directly here.
2695 : int arguments_length = arguments_for_wrapped_function->length();
2696 124 : for (int i = 0; i < arguments_length; i++) {
2697 : const bool is_rest = false;
2698 20 : Expression* argument = ExpressionFromIdentifier(
2699 : arguments_for_wrapped_function->at(i), kNoSourcePosition);
2700 : AddFormalParameter(&formals, argument, NullExpression(),
2701 : kNoSourcePosition, is_rest);
2702 : }
2703 : DCHECK_EQ(arguments_length, formals.num_parameters());
2704 : DeclareFormalParameters(&formals);
2705 : } else {
2706 : // For a regular function, the function arguments are parsed from source.
2707 : DCHECK_NULL(arguments_for_wrapped_function);
2708 1294766 : ParseFormalParameterList(&formals);
2709 1294761 : if (expected_parameters_end_pos != kNoSourcePosition) {
2710 : // Check for '(' or ')' shenanigans in the parameter string for dynamic
2711 : // functions.
2712 : int position = peek_position();
2713 336487 : if (position < expected_parameters_end_pos) {
2714 100 : ReportMessageAt(Scanner::Location(position, position + 1),
2715 50 : MessageTemplate::kArgStringTerminatesParametersEarly);
2716 50 : return;
2717 336437 : } else if (position > expected_parameters_end_pos) {
2718 36 : ReportMessageAt(Scanner::Location(expected_parameters_end_pos - 2,
2719 : expected_parameters_end_pos),
2720 18 : MessageTemplate::kUnexpectedEndOfArgString);
2721 18 : return;
2722 : }
2723 : }
2724 1294693 : Expect(Token::RPAREN);
2725 1294699 : int formals_end_position = scanner()->location().end_pos;
2726 :
2727 1294699 : CheckArityRestrictions(formals.arity, kind, formals.has_rest,
2728 : function_scope->start_position(),
2729 1294699 : formals_end_position);
2730 1294696 : Expect(Token::LBRACE);
2731 : }
2732 1294792 : formals.duplicate_loc = formals_scope.duplicate_location();
2733 : }
2734 :
2735 1294792 : *num_parameters = formals.num_parameters();
2736 1294792 : *function_length = formals.function_length;
2737 :
2738 1294792 : AcceptINScope scope(this, true);
2739 1294792 : ParseFunctionBody(body, function_name, pos, formals, kind, function_type,
2740 1294792 : FunctionBodyType::kBlock);
2741 :
2742 1294788 : *has_duplicate_parameters = formals.has_duplicate();
2743 :
2744 1294788 : *expected_property_count = function_state.expected_property_count();
2745 1294788 : *suspend_count = function_state.suspend_count();
2746 : }
2747 :
2748 0 : void Parser::DeclareClassVariable(const AstRawString* name,
2749 : ClassInfo* class_info, int class_token_pos) {
2750 : #ifdef DEBUG
2751 : scope()->SetScopeName(name);
2752 : #endif
2753 :
2754 184758 : if (name != nullptr) {
2755 : VariableProxy* proxy =
2756 123263 : DeclareBoundVariable(name, VariableMode::kConst, class_token_pos);
2757 123263 : class_info->variable = proxy->var();
2758 : }
2759 0 : }
2760 :
2761 : // TODO(gsathya): Ideally, this should just bypass scope analysis and
2762 : // allocate a slot directly on the context. We should just store this
2763 : // index in the AST, instead of storing the variable.
2764 15127 : Variable* Parser::CreateSyntheticContextVariable(const AstRawString* name) {
2765 : VariableProxy* proxy =
2766 15127 : DeclareBoundVariable(name, VariableMode::kConst, kNoSourcePosition);
2767 : proxy->var()->ForceContextAllocation();
2768 15127 : return proxy->var();
2769 : }
2770 :
2771 31884 : void Parser::DeclareClassField(ClassLiteralProperty* property,
2772 : const AstRawString* property_name,
2773 : bool is_static, bool is_computed_name,
2774 : bool is_private, ClassInfo* class_info) {
2775 : DCHECK(allow_harmony_public_fields() || allow_harmony_private_fields());
2776 :
2777 31884 : if (is_static) {
2778 8877 : class_info->static_fields->Add(property, zone());
2779 : } else {
2780 23007 : class_info->instance_fields->Add(property, zone());
2781 : }
2782 :
2783 : DCHECK_IMPLIES(is_computed_name, !is_private);
2784 31884 : if (is_computed_name) {
2785 : // We create a synthetic variable name here so that scope
2786 : // analysis doesn't dedupe the vars.
2787 : Variable* computed_name_var =
2788 5214 : CreateSyntheticContextVariable(ClassFieldVariableName(
2789 5214 : ast_value_factory(), class_info->computed_field_count));
2790 5214 : property->set_computed_name_var(computed_name_var);
2791 5214 : class_info->properties->Add(property, zone());
2792 26670 : } else if (is_private) {
2793 9913 : Variable* private_name_var = CreateSyntheticContextVariable(property_name);
2794 9913 : private_name_var->set_initializer_position(property->value()->position());
2795 : property->set_private_name_var(private_name_var);
2796 9913 : class_info->properties->Add(property, zone());
2797 : }
2798 31884 : }
2799 :
2800 : // This method declares a property of the given class. It updates the
2801 : // following fields of class_info, as appropriate:
2802 : // - constructor
2803 : // - properties
2804 378198 : void Parser::DeclareClassProperty(const AstRawString* class_name,
2805 : ClassLiteralProperty* property,
2806 : bool is_constructor, ClassInfo* class_info) {
2807 378198 : if (is_constructor) {
2808 : DCHECK(!class_info->constructor);
2809 42296 : class_info->constructor = property->value()->AsFunctionLiteral();
2810 : DCHECK_NOT_NULL(class_info->constructor);
2811 21148 : class_info->constructor->set_raw_name(
2812 : class_name != nullptr ? ast_value_factory()->NewConsString(class_name)
2813 : : nullptr);
2814 : return;
2815 : }
2816 :
2817 357050 : class_info->properties->Add(property, zone());
2818 : }
2819 :
2820 27005 : FunctionLiteral* Parser::CreateInitializerFunction(
2821 : const char* name, DeclarationScope* scope,
2822 : ZonePtrList<ClassLiteral::Property>* fields) {
2823 : DCHECK_EQ(scope->function_kind(),
2824 : FunctionKind::kClassMembersInitializerFunction);
2825 : // function() { .. class fields initializer .. }
2826 : ScopedPtrList<Statement> statements(pointer_buffer());
2827 : InitializeClassMembersStatement* static_fields =
2828 : factory()->NewInitializeClassMembersStatement(fields, kNoSourcePosition);
2829 : statements.Add(static_fields);
2830 27005 : return factory()->NewFunctionLiteral(
2831 : ast_value_factory()->GetOneByteString(name), scope, statements, 0, 0, 0,
2832 : FunctionLiteral::kNoDuplicateParameters,
2833 : FunctionLiteral::kAnonymousExpression,
2834 : FunctionLiteral::kShouldEagerCompile, scope->start_position(), false,
2835 54010 : GetNextFunctionLiteralId());
2836 : }
2837 :
2838 : // This method generates a ClassLiteral AST node.
2839 : // It uses the following fields of class_info:
2840 : // - constructor (if missing, it updates it with a default constructor)
2841 : // - proxy
2842 : // - extends
2843 : // - properties
2844 : // - has_name_static_property
2845 : // - has_static_computed_names
2846 110259 : Expression* Parser::RewriteClassLiteral(Scope* block_scope,
2847 : const AstRawString* name,
2848 : ClassInfo* class_info, int pos,
2849 : int end_pos) {
2850 : DCHECK_NOT_NULL(block_scope);
2851 : DCHECK_EQ(block_scope->scope_type(), BLOCK_SCOPE);
2852 : DCHECK_EQ(block_scope->language_mode(), LanguageMode::kStrict);
2853 :
2854 110259 : bool has_extends = class_info->extends != nullptr;
2855 110259 : bool has_default_constructor = class_info->constructor == nullptr;
2856 110259 : if (has_default_constructor) {
2857 : class_info->constructor =
2858 89322 : DefaultConstructor(name, has_extends, pos, end_pos);
2859 : }
2860 :
2861 110260 : if (name != nullptr) {
2862 : DCHECK_NOT_NULL(class_info->variable);
2863 82388 : class_info->variable->set_initializer_position(end_pos);
2864 : }
2865 :
2866 : FunctionLiteral* static_fields_initializer = nullptr;
2867 110260 : if (class_info->has_static_class_fields) {
2868 8435 : static_fields_initializer = CreateInitializerFunction(
2869 : "<static_fields_initializer>", class_info->static_fields_scope,
2870 8435 : class_info->static_fields);
2871 : }
2872 :
2873 : FunctionLiteral* instance_members_initializer_function = nullptr;
2874 110260 : if (class_info->has_instance_members) {
2875 18570 : instance_members_initializer_function = CreateInitializerFunction(
2876 : "<instance_members_initializer>", class_info->instance_members_scope,
2877 18570 : class_info->instance_fields);
2878 18570 : class_info->constructor->set_requires_instance_members_initializer(true);
2879 : }
2880 :
2881 110260 : ClassLiteral* class_literal = factory()->NewClassLiteral(
2882 : block_scope, class_info->variable, class_info->extends,
2883 : class_info->constructor, class_info->properties,
2884 : static_fields_initializer, instance_members_initializer_function, pos,
2885 110260 : end_pos, class_info->has_name_static_property,
2886 110260 : class_info->has_static_computed_names, class_info->is_anonymous);
2887 :
2888 110260 : AddFunctionForNameInference(class_info->constructor);
2889 110260 : return class_literal;
2890 : }
2891 :
2892 11856 : bool Parser::IsPropertyWithPrivateFieldKey(Expression* expression) {
2893 11856 : if (!expression->IsProperty()) return false;
2894 7235 : Property* property = expression->AsProperty();
2895 :
2896 7235 : if (!property->key()->IsVariableProxy()) return false;
2897 1510 : VariableProxy* key = property->key()->AsVariableProxy();
2898 :
2899 1510 : return key->IsPrivateName();
2900 : }
2901 :
2902 8933 : void Parser::InsertShadowingVarBindingInitializers(Block* inner_block) {
2903 : // For each var-binding that shadows a parameter, insert an assignment
2904 : // initializing the variable with the parameter.
2905 : Scope* inner_scope = inner_block->scope();
2906 : DCHECK(inner_scope->is_declaration_scope());
2907 : Scope* function_scope = inner_scope->outer_scope();
2908 : DCHECK(function_scope->is_function_scope());
2909 8933 : BlockState block_state(&scope_, inner_scope);
2910 28554 : for (Declaration* decl : *inner_scope->declarations()) {
2911 30117 : if (decl->var()->mode() != VariableMode::kVar ||
2912 : !decl->IsVariableDeclaration()) {
2913 18762 : continue;
2914 : }
2915 : const AstRawString* name = decl->var()->raw_name();
2916 : Variable* parameter = function_scope->LookupLocal(name);
2917 6980 : if (parameter == nullptr) continue;
2918 : VariableProxy* to = NewUnresolved(name);
2919 : VariableProxy* from = factory()->NewVariableProxy(parameter);
2920 : Expression* assignment =
2921 859 : factory()->NewAssignment(Token::ASSIGN, to, from, kNoSourcePosition);
2922 : Statement* statement =
2923 859 : factory()->NewExpressionStatement(assignment, kNoSourcePosition);
2924 859 : inner_block->statements()->InsertAt(0, statement, zone());
2925 : }
2926 8933 : }
2927 :
2928 2451262 : void Parser::InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope) {
2929 : // For the outermost eval scope, we cannot hoist during parsing: let
2930 : // declarations in the surrounding scope may prevent hoisting, but the
2931 : // information is unaccessible during parsing. In this case, we hoist later in
2932 : // DeclarationScope::Analyze.
2933 2451262 : if (scope->is_eval_scope() && scope->outer_scope() == original_scope_) {
2934 : return;
2935 : }
2936 1659994 : scope->HoistSloppyBlockFunctions(factory());
2937 : }
2938 :
2939 : // ----------------------------------------------------------------------------
2940 : // Parser support
2941 :
2942 15713 : bool Parser::TargetStackContainsLabel(const AstRawString* label) {
2943 24878 : for (ParserTarget* t = target_stack_; t != nullptr; t = t->previous()) {
2944 18330 : if (ContainsLabel(t->statement()->labels(), label)) return true;
2945 : }
2946 : return false;
2947 : }
2948 :
2949 43624 : BreakableStatement* Parser::LookupBreakTarget(const AstRawString* label) {
2950 : bool anonymous = label == nullptr;
2951 59697 : for (ParserTarget* t = target_stack_; t != nullptr; t = t->previous()) {
2952 : BreakableStatement* stat = t->statement();
2953 162934 : if ((anonymous && stat->is_target_for_anonymous()) ||
2954 30394 : (!anonymous && ContainsLabel(stat->labels(), label))) {
2955 : return stat;
2956 : }
2957 : }
2958 : return nullptr;
2959 : }
2960 :
2961 13655 : IterationStatement* Parser::LookupContinueTarget(const AstRawString* label) {
2962 : bool anonymous = label == nullptr;
2963 34680 : for (ParserTarget* t = target_stack_; t != nullptr; t = t->previous()) {
2964 34313 : IterationStatement* stat = t->statement()->AsIterationStatement();
2965 34313 : if (stat == nullptr) continue;
2966 :
2967 : DCHECK(stat->is_target_for_anonymous());
2968 16950 : if (anonymous || ContainsLabel(stat->own_labels(), label)) {
2969 : return stat;
2970 : }
2971 1272 : if (ContainsLabel(stat->labels(), label)) break;
2972 : }
2973 : return nullptr;
2974 : }
2975 :
2976 1721454 : void Parser::HandleSourceURLComments(Isolate* isolate, Handle<Script> script) {
2977 1721454 : Handle<String> source_url = scanner_.SourceUrl(isolate);
2978 1721453 : if (!source_url.is_null()) {
2979 7606 : script->set_source_url(*source_url);
2980 : }
2981 1721453 : Handle<String> source_mapping_url = scanner_.SourceMappingUrl(isolate);
2982 1721452 : if (!source_mapping_url.is_null()) {
2983 200 : script->set_source_mapping_url(*source_mapping_url);
2984 : }
2985 1721452 : }
2986 :
2987 2438320 : void Parser::UpdateStatistics(Isolate* isolate, Handle<Script> script) {
2988 : // Move statistics to Isolate.
2989 373060956 : for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
2990 : ++feature) {
2991 185311323 : if (use_counts_[feature] > 0) {
2992 1914573 : isolate->CountUsage(v8::Isolate::UseCounterFeature(feature));
2993 : }
2994 : }
2995 2438315 : if (scanner_.FoundHtmlComment()) {
2996 10 : isolate->CountUsage(v8::Isolate::kHtmlComment);
2997 20 : if (script->line_offset() == 0 && script->column_offset() == 0) {
2998 10 : isolate->CountUsage(v8::Isolate::kHtmlCommentInExternalScript);
2999 : }
3000 : }
3001 2438315 : isolate->counters()->total_preparse_skipped()->Increment(
3002 2438315 : total_preparse_skipped_);
3003 2438315 : }
3004 :
3005 13308 : void Parser::ParseOnBackground(ParseInfo* info) {
3006 : RuntimeCallTimerScope runtimeTimer(
3007 13308 : runtime_call_stats_, RuntimeCallCounterId::kParseBackgroundProgram);
3008 13308 : parsing_on_main_thread_ = false;
3009 : set_script_id(info->script_id());
3010 :
3011 : DCHECK_NULL(info->literal());
3012 : FunctionLiteral* result = nullptr;
3013 :
3014 13308 : scanner_.Initialize();
3015 : DCHECK(info->maybe_outer_scope_info().is_null());
3016 :
3017 : DCHECK(original_scope_);
3018 :
3019 : // When streaming, we don't know the length of the source until we have parsed
3020 : // it. The raw data can be UTF-8, so we wouldn't know the source length until
3021 : // we have decoded it anyway even if we knew the raw data length (which we
3022 : // don't). We work around this by storing all the scopes which need their end
3023 : // position set at the end of the script (the top scope and possible eval
3024 : // scopes) and set their end position after we know the script length.
3025 13308 : if (info->is_toplevel()) {
3026 13231 : result = DoParseProgram(/* isolate = */ nullptr, info);
3027 : } else {
3028 : result =
3029 77 : DoParseFunction(/* isolate = */ nullptr, info, info->function_name());
3030 : }
3031 13308 : MaybeResetCharacterStream(info, result);
3032 :
3033 : info->set_literal(result);
3034 :
3035 : // We cannot internalize on a background thread; a foreground task will take
3036 : // care of calling AstValueFactory::Internalize just before compilation.
3037 13308 : }
3038 :
3039 38558 : Parser::TemplateLiteralState Parser::OpenTemplateLiteral(int pos) {
3040 38558 : return new (zone()) TemplateLiteral(zone(), pos);
3041 : }
3042 :
3043 83838 : void Parser::AddTemplateSpan(TemplateLiteralState* state, bool should_cook,
3044 : bool tail) {
3045 : int end = scanner()->location().end_pos - (tail ? 1 : 2);
3046 83838 : const AstRawString* raw = scanner()->CurrentRawSymbol(ast_value_factory());
3047 83838 : if (should_cook) {
3048 80122 : const AstRawString* cooked = scanner()->CurrentSymbol(ast_value_factory());
3049 80122 : (*state)->AddTemplateSpan(cooked, raw, end, zone());
3050 : } else {
3051 3716 : (*state)->AddTemplateSpan(nullptr, raw, end, zone());
3052 : }
3053 83838 : }
3054 :
3055 0 : void Parser::AddTemplateExpression(TemplateLiteralState* state,
3056 : Expression* expression) {
3057 48377 : (*state)->AddExpression(expression, zone());
3058 0 : }
3059 :
3060 35461 : Expression* Parser::CloseTemplateLiteral(TemplateLiteralState* state, int start,
3061 : Expression* tag) {
3062 35461 : TemplateLiteral* lit = *state;
3063 : int pos = lit->position();
3064 : const ZonePtrList<const AstRawString>* cooked_strings = lit->cooked();
3065 : const ZonePtrList<const AstRawString>* raw_strings = lit->raw();
3066 : const ZonePtrList<Expression>* expressions = lit->expressions();
3067 : DCHECK_EQ(cooked_strings->length(), raw_strings->length());
3068 : DCHECK_EQ(cooked_strings->length(), expressions->length() + 1);
3069 :
3070 35461 : if (!tag) {
3071 28266 : if (cooked_strings->length() == 1) {
3072 14352 : return factory()->NewStringLiteral(cooked_strings->first(), pos);
3073 : }
3074 21090 : return factory()->NewTemplateLiteral(cooked_strings, expressions, pos);
3075 : } else {
3076 : // GetTemplateObject
3077 : Expression* template_object =
3078 : factory()->NewGetTemplateObject(cooked_strings, raw_strings, pos);
3079 :
3080 : // Call TagFn
3081 : ScopedPtrList<Expression> call_args(pointer_buffer());
3082 : call_args.Add(template_object);
3083 7195 : call_args.AddAll(*expressions);
3084 7195 : return factory()->NewTaggedTemplate(tag, call_args, pos);
3085 : }
3086 : }
3087 :
3088 : namespace {
3089 :
3090 4354 : bool OnlyLastArgIsSpread(const ScopedPtrList<Expression>& args) {
3091 6328 : for (int i = 0; i < args.length() - 1; i++) {
3092 1719 : if (args.at(i)->IsSpread()) {
3093 : return false;
3094 : }
3095 : }
3096 3622 : return args.at(args.length() - 1)->IsSpread();
3097 : }
3098 :
3099 : } // namespace
3100 :
3101 702 : ArrayLiteral* Parser::ArrayLiteralFromListWithSpread(
3102 : const ScopedPtrList<Expression>& list) {
3103 : // If there's only a single spread argument, a fast path using CallWithSpread
3104 : // is taken.
3105 : DCHECK_LT(1, list.length());
3106 :
3107 : // The arguments of the spread call become a single ArrayLiteral.
3108 : int first_spread = 0;
3109 2130 : for (; first_spread < list.length() && !list.at(first_spread)->IsSpread();
3110 : ++first_spread) {
3111 : }
3112 :
3113 : DCHECK_LT(first_spread, list.length());
3114 702 : return factory()->NewArrayLiteral(list, first_spread, kNoSourcePosition);
3115 : }
3116 :
3117 4124 : Expression* Parser::SpreadCall(Expression* function,
3118 : const ScopedPtrList<Expression>& args_list,
3119 : int pos, Call::PossiblyEval is_possibly_eval) {
3120 : // Handle this case in BytecodeGenerator.
3121 4851 : if (OnlyLastArgIsSpread(args_list) || function->IsSuperCallReference()) {
3122 3427 : return factory()->NewCall(function, args_list, pos);
3123 : }
3124 :
3125 : ScopedPtrList<Expression> args(pointer_buffer());
3126 697 : if (function->IsProperty()) {
3127 : // Method calls
3128 488 : if (function->AsProperty()->IsSuperAccess()) {
3129 0 : Expression* home = ThisExpression();
3130 : args.Add(function);
3131 : args.Add(home);
3132 : } else {
3133 : Variable* temp = NewTemporary(ast_value_factory()->empty_string());
3134 : VariableProxy* obj = factory()->NewVariableProxy(temp);
3135 : Assignment* assign_obj = factory()->NewAssignment(
3136 244 : Token::ASSIGN, obj, function->AsProperty()->obj(), kNoSourcePosition);
3137 : function = factory()->NewProperty(
3138 : assign_obj, function->AsProperty()->key(), kNoSourcePosition);
3139 : args.Add(function);
3140 : obj = factory()->NewVariableProxy(temp);
3141 : args.Add(obj);
3142 : }
3143 : } else {
3144 : // Non-method calls
3145 : args.Add(function);
3146 : args.Add(factory()->NewUndefinedLiteral(kNoSourcePosition));
3147 : }
3148 697 : args.Add(ArrayLiteralFromListWithSpread(args_list));
3149 697 : return factory()->NewCallRuntime(Context::REFLECT_APPLY_INDEX, args, pos);
3150 : }
3151 :
3152 230 : Expression* Parser::SpreadCallNew(Expression* function,
3153 : const ScopedPtrList<Expression>& args_list,
3154 : int pos) {
3155 230 : if (OnlyLastArgIsSpread(args_list)) {
3156 : // Handle in BytecodeGenerator.
3157 225 : return factory()->NewCallNew(function, args_list, pos);
3158 : }
3159 : ScopedPtrList<Expression> args(pointer_buffer());
3160 : args.Add(function);
3161 5 : args.Add(ArrayLiteralFromListWithSpread(args_list));
3162 :
3163 5 : return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args, pos);
3164 : }
3165 :
3166 5601036 : void Parser::SetLanguageMode(Scope* scope, LanguageMode mode) {
3167 : v8::Isolate::UseCounterFeature feature;
3168 5601036 : if (is_sloppy(mode))
3169 : feature = v8::Isolate::kSloppyMode;
3170 1399898 : else if (is_strict(mode))
3171 : feature = v8::Isolate::kStrictMode;
3172 : else
3173 0 : UNREACHABLE();
3174 5698887 : ++use_counts_[feature];
3175 : scope->SetLanguageMode(mode);
3176 5601036 : }
3177 :
3178 4288 : void Parser::SetAsmModule() {
3179 : // Store the usage count; The actual use counter on the isolate is
3180 : // incremented after parsing is done.
3181 4288 : ++use_counts_[v8::Isolate::kUseAsm];
3182 : DCHECK(scope()->is_declaration_scope());
3183 4288 : scope()->AsDeclarationScope()->set_is_asm_module();
3184 4288 : info_->set_contains_asm_module(true);
3185 4288 : }
3186 :
3187 62645 : Expression* Parser::ExpressionListToExpression(
3188 : const ScopedPtrList<Expression>& args) {
3189 : Expression* expr = args.at(0);
3190 62645 : if (args.length() == 1) return expr;
3191 59601 : if (args.length() == 2) {
3192 : return factory()->NewBinaryOperation(Token::COMMA, expr, args.at(1),
3193 53537 : args.at(1)->position());
3194 : }
3195 : NaryOperation* result =
3196 12128 : factory()->NewNaryOperation(Token::COMMA, expr, args.length() - 1);
3197 5252292 : for (int i = 1; i < args.length(); i++) {
3198 : result->AddSubsequent(args.at(i), args.at(i)->position());
3199 : }
3200 : return result;
3201 : }
3202 :
3203 : // This method completes the desugaring of the body of async_function.
3204 43073 : void Parser::RewriteAsyncFunctionBody(ScopedPtrList<Statement>* body,
3205 : Block* block, Expression* return_value) {
3206 : // function async_function() {
3207 : // .generator_object = %_AsyncFunctionEnter();
3208 : // BuildRejectPromiseOnException({
3209 : // ... block ...
3210 : // return %_AsyncFunctionResolve(.generator_object, expr);
3211 : // })
3212 : // }
3213 :
3214 86147 : block->statements()->Add(factory()->NewAsyncReturnStatement(
3215 : return_value, return_value->position()),
3216 43074 : zone());
3217 43073 : block = BuildRejectPromiseOnException(block);
3218 : body->Add(block);
3219 43074 : }
3220 :
3221 3460036 : void Parser::SetFunctionNameFromPropertyName(LiteralProperty* property,
3222 : const AstRawString* name,
3223 : const AstRawString* prefix) {
3224 3460036 : if (has_error()) return;
3225 : // Ensure that the function we are going to create has shared name iff
3226 : // we are not going to set it later.
3227 3415661 : if (property->NeedsSetFunctionName()) {
3228 : name = nullptr;
3229 : prefix = nullptr;
3230 : } else {
3231 : // If the property value is an anonymous function or an anonymous class or
3232 : // a concise method or an accessor function which doesn't require the name
3233 : // to be set then the shared name must be provided.
3234 : DCHECK_IMPLIES(property->value()->IsAnonymousFunctionDefinition() ||
3235 : property->value()->IsConciseMethodDefinition() ||
3236 : property->value()->IsAccessorFunctionDefinition(),
3237 : name != nullptr);
3238 : }
3239 :
3240 : Expression* value = property->value();
3241 3415649 : SetFunctionName(value, name, prefix);
3242 : }
3243 :
3244 3035015 : void Parser::SetFunctionNameFromPropertyName(ObjectLiteralProperty* property,
3245 : const AstRawString* name,
3246 : const AstRawString* prefix) {
3247 : // Ignore "__proto__" as a name when it's being used to set the [[Prototype]]
3248 : // of an object literal.
3249 : // See ES #sec-__proto__-property-names-in-object-initializers.
3250 6063435 : if (property->IsPrototype() || has_error()) return;
3251 :
3252 : DCHECK(!property->value()->IsAnonymousFunctionDefinition() ||
3253 : property->kind() == ObjectLiteralProperty::COMPUTED);
3254 :
3255 : SetFunctionNameFromPropertyName(static_cast<LiteralProperty*>(property), name,
3256 3005583 : prefix);
3257 : }
3258 :
3259 12600439 : void Parser::SetFunctionNameFromIdentifierRef(Expression* value,
3260 : Expression* identifier) {
3261 12600439 : if (!identifier->IsVariableProxy()) return;
3262 16964686 : SetFunctionName(value, identifier->AsVariableProxy()->raw_name());
3263 : }
3264 :
3265 11898120 : void Parser::SetFunctionName(Expression* value, const AstRawString* name,
3266 : const AstRawString* prefix) {
3267 35344401 : if (!value->IsAnonymousFunctionDefinition() &&
3268 23080693 : !value->IsConciseMethodDefinition() &&
3269 11182528 : !value->IsAccessorFunctionDefinition()) {
3270 : return;
3271 : }
3272 746989 : auto function = value->AsFunctionLiteral();
3273 746989 : if (value->IsClassLiteral()) {
3274 : function = value->AsClassLiteral()->constructor();
3275 : }
3276 746989 : if (function != nullptr) {
3277 : AstConsString* cons_name = nullptr;
3278 746980 : if (name != nullptr) {
3279 736721 : if (prefix != nullptr) {
3280 27671 : cons_name = ast_value_factory()->NewConsString(prefix, name);
3281 : } else {
3282 709050 : cons_name = ast_value_factory()->NewConsString(name);
3283 : }
3284 : } else {
3285 : DCHECK_NULL(prefix);
3286 : }
3287 : function->set_raw_name(cons_name);
3288 : }
3289 : }
3290 :
3291 0 : Statement* Parser::CheckCallable(Variable* var, Expression* error, int pos) {
3292 : const int nopos = kNoSourcePosition;
3293 : Statement* validate_var;
3294 : {
3295 : Expression* type_of = factory()->NewUnaryOperation(
3296 : Token::TYPEOF, factory()->NewVariableProxy(var), nopos);
3297 : Expression* function_literal = factory()->NewStringLiteral(
3298 : ast_value_factory()->function_string(), nopos);
3299 : Expression* condition = factory()->NewCompareOperation(
3300 : Token::EQ_STRICT, type_of, function_literal, nopos);
3301 :
3302 : Statement* throw_call = factory()->NewExpressionStatement(error, pos);
3303 :
3304 : validate_var = factory()->NewIfStatement(
3305 : condition, factory()->EmptyStatement(), throw_call, nopos);
3306 : }
3307 0 : return validate_var;
3308 : }
3309 :
3310 : } // namespace internal
3311 120216 : } // namespace v8
|
