chromium/v8/test/unittests/parser/parsing-unittest.cc

// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/parsing/parsing.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <memory>

#include "src/api/api-inl.h"
#include "src/ast/ast-value-factory.h"
#include "src/ast/ast.h"
#include "src/base/enum-set.h"
#include "src/base/strings.h"
#include "src/execution/execution.h"
#include "src/execution/isolate.h"
#include "src/flags/flags.h"
#include "src/objects/objects-inl.h"
#include "src/objects/objects.h"
#include "src/parsing/parse-info.h"
#include "src/parsing/parser.h"
#include "src/parsing/preparser.h"
#include "src/parsing/scanner-character-streams.h"
#include "src/parsing/token.h"
#include "src/zone/zone-list-inl.h"  // crbug.com/v8/8816
#include "test/common/flag-utils.h"
#include "test/unittests/parser/scope-test-helper.h"
#include "test/unittests/parser/unicode-helpers.h"
#include "test/unittests/test-utils.h"

namespace v8 {
namespace internal {
namespace test_parsing {

namespace {

int* global_use_counts = …;

void MockUseCounterCallback(v8::Isolate* isolate,
                            v8::Isolate::UseCounterFeature feature) { … }

enum ParserFlag { … };

enum ParserSyncTestResult { … };

void SetGlobalFlags(base::EnumSet<ParserFlag> flags) { … }

void SetParserFlags(i::UnoptimizedCompileFlags* compile_flags,
                    base::EnumSet<ParserFlag> flags) { … }

struct Input { … };

}  // namespace

// Helpers for parsing and checking that the result has no error, implemented as
// macros to report the correct test error location.
#define FAIL_WITH_PENDING_PARSER_ERROR(info, script, isolate) …

#define CHECK_PARSE_PROGRAM(info, script, isolate) …

#define CHECK_PARSE_FUNCTION(info, shared, isolate) …

bool TokenIsAutoSemicolon(Token::Value token) { … }

class ParsingTest : public TestWithContextAndZone { … };

TEST_F(ParsingTest, AutoSemicolonToken) { … }

bool TokenIsAnyIdentifier(Token::Value token) { … }

TEST_F(ParsingTest, AnyIdentifierToken) { … }

bool TokenIsCallable(Token::Value token) { … }

TEST_F(ParsingTest, CallableToken) { … }

bool TokenIsValidIdentifier(Token::Value token, LanguageMode language_mode,
                            bool is_generator, bool disallow_await) { … }

TEST_F(ParsingTest, IsValidIdentifierToken) { … }

bool TokenIsStrictReservedWord(Token::Value token) { … }

TEST_F(ParsingTest, IsStrictReservedWord) { … }

bool TokenIsLiteral(Token::Value token) { … }

TEST_F(ParsingTest, IsLiteralToken) { … }

bool TokenIsAssignmentOp(Token::Value token) { … }

TEST_F(ParsingTest, AssignmentOp) { … }

bool TokenIsArrowOrAssignmentOp(Token::Value token) { … }

TEST_F(ParsingTest, ArrowOrAssignmentOp) { … }

bool TokenIsBinaryOp(Token::Value token) { … }

TEST_F(ParsingTest, BinaryOp) { … }

bool TokenIsCompareOp(Token::Value token) { … }

TEST_F(ParsingTest, CompareOp) { … }

bool TokenIsOrderedRelationalCompareOp(Token::Value token) { … }

TEST_F(ParsingTest, IsOrderedRelationalCompareOp) { … }

bool TokenIsEqualityOp(Token::Value token) { … }

TEST_F(ParsingTest, IsEqualityOp) { … }

bool TokenIsBitOp(Token::Value token) { … }

TEST_F(ParsingTest, IsBitOp) { … }

bool TokenIsUnaryOp(Token::Value token) { … }

TEST_F(ParsingTest, IsUnaryOp) { … }

bool TokenIsPropertyOrCall(Token::Value token) { … }

TEST_F(ParsingTest, IsPropertyOrCall) { … }

bool TokenIsMember(Token::Value token) { … }

bool TokenIsTemplate(Token::Value token) { … }

bool TokenIsProperty(Token::Value token) { … }

TEST_F(ParsingTest, IsMember) { … }

TEST_F(ParsingTest, IsTemplate) { … }

TEST_F(ParsingTest, IsProperty) { … }

bool TokenIsCountOp(Token::Value token) { … }

TEST_F(ParsingTest, IsCountOp) { … }

TEST_F(ParsingTest, IsUnaryOrCountOp) { … }

bool TokenIsShiftOp(Token::Value token) { … }

TEST_F(ParsingTest, IsShiftOp) { … }

TEST_F(ParsingTest, ScanKeywords) { … }

TEST_F(ParsingTest, ScanHTMLEndComments) { … }

TEST_F(ParsingTest, ScanHtmlComments) { … }

class ScriptResource : public v8::String::ExternalOneByteStringResource { … };

TEST_F(ParsingTest, StandAlonePreParser) { … }

TEST_F(ParsingTest, StandAlonePreParserNoNatives) { … }

TEST_F(ParsingTest, RegressChromium62639) { … }

TEST_F(ParsingTest, PreParseOverflow) { … }

TEST_F(ParsingTest, StreamScanner) { … }

TEST_F(ParsingTest, RegExpScanning) { … }

TEST_F(ParsingTest, ScopeUsesArgumentsSuperThis) { … }

TEST_F(ParsingTest, ParseNumbers) { … }

TEST_F(ParsingTest, ScopePositions) { … }

TEST_F(ParsingTest, DiscardFunctionBody) { … }

TEST_F(ParsingTest, ParserSync) { … }

TEST_F(ParsingTest, StrictOctal) { … }

TEST_F(ParsingTest, NonOctalDecimalIntegerStrictError) { … }

TEST_F(ParsingTest, NumericSeparator) { … }

TEST_F(ParsingTest, NumericSeparatorErrors) { … }

TEST_F(ParsingTest, NumericSeparatorImplicitOctalsErrors) { … }

TEST_F(ParsingTest, NumericSeparatorNonOctalDecimalInteger) { … }

TEST_F(ParsingTest, NumericSeparatorNonOctalDecimalIntegerErrors) { … }

TEST_F(ParsingTest, NumericSeparatorUnicodeEscapeSequencesErrors) { … }

TEST_F(ParsingTest, OptionalChaining) { … }

TEST_F(ParsingTest, OptionalChainingTaggedError) { … }

TEST_F(ParsingTest, Nullish) { … }

TEST_F(ParsingTest, NullishNotContained) { … }

TEST_F(ParsingTest, ErrorsEvalAndArguments) { … }

TEST_F(ParsingTest, NoErrorsEvalAndArgumentsSloppy) { … }

TEST_F(ParsingTest, NoErrorsEvalAndArgumentsStrict) { … }

#define FUTURE_STRICT_RESERVED_WORDS_NO_LET(V) …

#define FUTURE_STRICT_RESERVED_WORDS(V) …

#define LIMITED_FUTURE_STRICT_RESERVED_WORDS_NO_LET(V) …

#define LIMITED_FUTURE_STRICT_RESERVED_WORDS …

// clang-format off
#define FUTURE_STRICT_RESERVED_STATEMENTS(NAME) …

#define FUTURE_STRICT_RESERVED_LEX_BINDINGS(NAME) …
// clang-format on

TEST_F(ParsingTest, ErrorsFutureStrictReservedWords) { … }

#undef LIMITED_FUTURE_STRICT_RESERVED_WORDS

TEST_F(ParsingTest, NoErrorsFutureStrictReservedWords) { … }

TEST_F(ParsingTest, NoErrorAccessorAsIdentifier) { … }

// TODO(42202709): Remove when the decorators flag is enabled by default.
TEST_F(ParsingTest, NoErrorAccessorAsIdentifierDecoratorsEnabled) { … }

TEST_F(ParsingTest, ErrorsReservedWords) { … }

TEST_F(ParsingTest, NoErrorsLetSloppyAllModes) { … }

TEST_F(ParsingTest, NoErrorsYieldSloppyAllModes) { … }

TEST_F(ParsingTest, NoErrorsYieldSloppyGeneratorsEnabled) { … }

TEST_F(ParsingTest, ErrorsYieldStrict) { … }

TEST_F(ParsingTest, ErrorsYieldSloppy) { … }

TEST_F(ParsingTest, NoErrorsGenerator) { … }

TEST_F(ParsingTest, ErrorsYieldGenerator) { … }

TEST_F(ParsingTest, ErrorsNameOfStrictFunction) { … }

TEST_F(ParsingTest, NoErrorsNameOfStrictFunction) { … }

TEST_F(ParsingTest, NoErrorsNameOfStrictGenerator) { … }

TEST_F(ParsingTest, ErrorsIllegalWordsAsLabelsSloppy) { … }

TEST_F(ParsingTest, ErrorsIllegalWordsAsLabelsStrict) { … }

TEST_F(ParsingTest, NoErrorsIllegalWordsAsLabels) { … }

TEST_F(ParsingTest, NoErrorsFutureStrictReservedAsLabelsSloppy) { … }

TEST_F(ParsingTest, ErrorsParenthesizedLabels) { … }

TEST_F(ParsingTest, NoErrorsParenthesizedDirectivePrologue) { … }

TEST_F(ParsingTest, ErrorsNotAnIdentifierName) { … }

TEST_F(ParsingTest, NoErrorsIdentifierNames) { … }

TEST_F(ParsingTest, FunctionDeclaresItselfStrict) { … }

TEST_F(ParsingTest, ErrorsTryWithoutCatchOrFinally) { … }

TEST_F(ParsingTest, NoErrorsTryCatchFinally) { … }

TEST_F(ParsingTest, OptionalCatchBinding) { … }

TEST_F(ParsingTest, ErrorsRegexpLiteral) { … }

TEST_F(ParsingTest, NoErrorsRegexpLiteral) { … }

TEST_F(ParsingTest, NoErrorsNewExpression) { … }

TEST_F(ParsingTest, ErrorsNewExpression) { … }

TEST_F(ParsingTest, StrictObjectLiteralChecking) { … }

TEST_F(ParsingTest, ErrorsObjectLiteralChecking) { … }

TEST_F(ParsingTest, NoErrorsObjectLiteralChecking) { … }

TEST_F(ParsingTest, TooManyArguments) { … }

TEST_F(ParsingTest, StrictDelete) { … }

TEST_F(ParsingTest, NoErrorsDeclsInCase) { … }

TEST_F(ParsingTest, InvalidLeftHandSide) { … }

TEST_F(ParsingTest, FuncNameInferrerBasic) { … }

TEST_F(ParsingTest, FuncNameInferrerTwoByte) { … }

TEST_F(ParsingTest, FuncNameInferrerEscaped) { … }

TEST_F(ParsingTest, SerializationOfMaybeAssignmentFlag) { … }

TEST_F(ParsingTest, IfArgumentsArrayAccessedThenParametersMaybeAssigned) { … }

TEST_F(ParsingTest, InnerAssignment) { … }

TEST_F(ParsingTest, MaybeAssignedParameters) { … }

static Input wrap(Input input) { … }

TEST_F(ParsingTest, MaybeAssignedInsideLoop) { … }

TEST_F(ParsingTest, MaybeAssignedTopLevel) { … }

#if V8_ENABLE_WEBASSEMBLY
namespace {

i::Scope* DeserializeFunctionScope(i::Isolate* isolate, i::Zone* zone,
                                   i::Handle<i::JSObject> m, const char* name) { … }

}  // namespace

TEST_F(ParsingTest, AsmModuleFlag) { … }

TEST_F(ParsingTest, UseAsmUseCount) { … }
#endif  // V8_ENABLE_WEBASSEMBLY

TEST_F(ParsingTest, StrictModeUseCount) { … }

TEST_F(ParsingTest, SloppyModeUseCount) { … }

TEST_F(ParsingTest, BothModesUseCount) { … }

TEST_F(ParsingTest, LineOrParagraphSeparatorAsLineTerminator) { … }

TEST_F(ParsingTest, LineOrParagraphSeparatorInStringLiteral) { … }

TEST_F(ParsingTest, ErrorsArrowFormalParameters) { … }

TEST_F(ParsingTest, ErrorsArrowFunctions) { … }

TEST_F(ParsingTest, NoErrorsArrowFunctions) { … }

TEST_F(ParsingTest, ArrowFunctionsSloppyParameterNames) { … }

TEST_F(ParsingTest, ArrowFunctionsYieldParameterNameInGenerator) { … }

TEST_F(ParsingTest, SuperNoErrors) { … }

TEST_F(ParsingTest, SuperErrors) { … }

TEST_F(ParsingTest, ImportExpressionSuccess) { … }

TEST_F(ParsingTest, ImportExpressionWithOptionsSuccess) { … }

TEST_F(ParsingTest, ImportExpressionErrors) { … }

TEST_F(ParsingTest, ImportExpressionWithOptionsErrors) { … }

TEST_F(ParsingTest, BasicImportAssertionParsing) { … }

TEST_F(ParsingTest, ImportAssertionParsingErrors) { … }

TEST_F(ParsingTest, BasicImportAttributesParsing) { … }

TEST_F(ParsingTest, ImportAttributesParsingErrors) { … }

TEST_F(ParsingTest, BasicImportAttributesAndAssertionsParsing) { … }

TEST_F(ParsingTest, ImportAttributesAndAssertionsParsingErrors) { … }

TEST_F(ParsingTest, SuperCall) { … }

TEST_F(ParsingTest, SuperNewNoErrors) { … }

TEST_F(ParsingTest, SuperNewErrors) { … }

TEST_F(ParsingTest, SuperErrorsNonMethods) { … }

TEST_F(ParsingTest, NoErrorsMethodDefinition) { … }

TEST_F(ParsingTest, MethodDefinitionNames) { … }

TEST_F(ParsingTest, MethodDefinitionStrictFormalParamereters) { … }

TEST_F(ParsingTest, MethodDefinitionEvalArguments) { … }

TEST_F(ParsingTest, MethodDefinitionDuplicateEvalArguments) { … }

TEST_F(ParsingTest, MethodDefinitionDuplicateProperty) { … }

TEST_F(ParsingTest, ClassExpressionNoErrors) { … }

TEST_F(ParsingTest, ClassDeclarationNoErrors) { … }

TEST_F(ParsingTest, ClassBodyNoErrors) { … }

TEST_F(ParsingTest, ClassPropertyNameNoErrors) { … }

// TODO(42202709): Remove when the decorators flag is enabled by default.
TEST_F(ParsingTest, ClassPropertyAccessorNameNoErrorsDecoratorsEnabled) { … }

TEST_F(ParsingTest, StaticClassFieldsNoErrors) { … }

TEST_F(ParsingTest, ClassFieldsNoErrors) { … }

// TODO(42202709): Remove when the decorators flag is enabled by default.
TEST_F(ParsingTest, ClassFieldsAccessorNameNoErrorsDecoratorsEnabled) { … }

TEST_F(ParsingTest, PrivateMethodsNoErrors) { … }

TEST_F(ParsingTest, PrivateMethodsAccessorNameNoErrorsDecoratorsEnabled) { … }

TEST_F(ParsingTest, PrivateMethodsAndFieldsNoErrors) { … }

// Test that public auto-accessors do not parse outside class bodies.
TEST_F(ParsingTest, PublicAutoAccessorsInNonClassErrors) { … }

// TODO(42202709): Merge with PrivateMethodsAndFieldsNoErrors once the
// decorators flag is enabled by default.
TEST_F(ParsingTest, PrivateAutoAccessorsAndFieldsNoErrors) { … }

TEST_F(ParsingTest, PublicAutoAccessorsInstanceAndStaticNoErrors) { … }

TEST_F(ParsingTest, PrivateMethodsErrors) { … }

// Test that private members parse in class bodies nested in object literals
TEST_F(ParsingTest, PrivateMembersNestedInObjectLiteralsNoErrors) { … }

// TODO(42202709): Merge with PrivateMembersNestedInObjectLiteralsNoErrors once
// the decorators flag is enabled by default.
TEST_F(ParsingTest, PrivateAutoAccessorsNestedInObjectLiteralsNoErrors) { … }

TEST_F(ParsingTest, PublicAutoAccessorsNestedNoErrors) { … }

// Test that private members parse in class bodies nested in classes
TEST_F(ParsingTest, PrivateMembersInNestedClassNoErrors) { … }

// TODO(42202709): Merge with PrivateMembersInNestedClassNoErrors once
// the decorators flag is enabled by default.
TEST_F(ParsingTest, PrivateAutoAccessorsInNestedClassNoErrors) { … }

// Test that private members do not parse outside class bodies
TEST_F(ParsingTest, PrivateMembersInNonClassErrors) { … }

// TODO(42202709): Merge with PrivateMembersInNonClassErrors once
// the decorators flag is enabled by default.
// Test that private auto-accessors do not parse outside class bodies
TEST_F(ParsingTest, PrivateAutoAccessorsInNonClassErrors) { … }

// Test that nested private members parse
TEST_F(ParsingTest, PrivateMembersNestedNoErrors) { … }

// Test that acessing undeclared private members result in early errors
TEST_F(ParsingTest, PrivateMembersEarlyErrors) { … }

// Test that acessing wrong kind private members do not error early.
// Instead these should be runtime errors.
TEST_F(ParsingTest, PrivateMembersWrongAccessNoEarlyErrors) { … }

TEST_F(ParsingTest, PrivateStaticClassMethodsAndAccessorsNoErrors) { … }

TEST_F(ParsingTest, PrivateStaticClassMethodsAndAccessorsDuplicateErrors) { … }

// TODO(42202709): Merge with
// PrivateStaticClassMethodsAndAccessorsDuplicateErrors once the decorators flag
// is enabled by default.
TEST_F(ParsingTest, PrivateStaticAutoAccessorsDuplicateErrors) { … }

TEST_F(ParsingTest, PrivateAutoAccessorsDuplicateErrors) { … }

TEST_F(ParsingTest, PrivateClassFieldsNoErrors) { … }

TEST_F(ParsingTest, PrivateAutoAccessorsNoErrors) { … }

TEST_F(ParsingTest, StaticClassFieldsErrors) { … }

TEST_F(ParsingTest, ClassFieldsErrors) { … }

TEST_F(ParsingTest, PublicAutoAccessorsInstanceAndStaticErrors) { … }

TEST_F(ParsingTest, PrivateClassFieldsErrors) { … }

TEST_F(ParsingTest, PrivateClassAutoAccessorsErrors) { … }

TEST_F(ParsingTest, PrivateStaticClassFieldsNoErrors) { … }

TEST_F(ParsingTest, PrivateStaticAutoAccessorsNoErrors) { … }

TEST_F(ParsingTest, PrivateStaticClassFieldsErrors) { … }

TEST_F(ParsingTest, PrivateStaticAutoAccessorsErrors) { … }

TEST_F(ParsingTest, PrivateNameResolutionErrors) { … }

TEST_F(ParsingTest, PrivateNameErrors) { … }

TEST_F(ParsingTest, ClassExpressionErrors) { … }

TEST_F(ParsingTest, ClassDeclarationErrors) { … }

TEST_F(ParsingTest, ClassAsyncErrors) { … }

TEST_F(ParsingTest, ClassNameErrors) { … }

TEST_F(ParsingTest, ClassGetterParamNameErrors) { … }

TEST_F(ParsingTest, ClassStaticPrototypeErrors) { … }

TEST_F(ParsingTest, ClassSpecialConstructorErrors) { … }

TEST_F(ParsingTest, ClassConstructorNoErrors) { … }

TEST_F(ParsingTest, ClassMultipleConstructorErrors) { … }

TEST_F(ParsingTest, ClassMultiplePropertyNamesNoErrors) { … }

TEST_F(ParsingTest, ClassesAreStrictErrors) { … }

TEST_F(ParsingTest, ObjectLiteralPropertyShorthandKeywordsError) { … }

TEST_F(ParsingTest, ObjectLiteralPropertyShorthandStrictKeywords) { … }

TEST_F(ParsingTest, ObjectLiteralPropertyShorthandError) { … }

TEST_F(ParsingTest, ObjectLiteralPropertyShorthandYieldInGeneratorError) { … }

TEST_F(ParsingTest, ConstParsingInForIn) { … }

TEST_F(ParsingTest, StatementParsingInForIn) { … }

TEST_F(ParsingTest, ConstParsingInForInError) { … }

TEST_F(ParsingTest, InitializedDeclarationsInForInOf) { … }

TEST_F(ParsingTest, ForInMultipleDeclarationsError) { … }

TEST_F(ParsingTest, ForOfMultipleDeclarationsError) { … }

TEST_F(ParsingTest, ForInOfLetExpression) { … }

TEST_F(ParsingTest, ForInNoDeclarationsError) { … }

TEST_F(ParsingTest, ForOfNoDeclarationsError) { … }

TEST_F(ParsingTest, ForOfInOperator) { … }

TEST_F(ParsingTest, ForOfYieldIdentifier) { … }

TEST_F(ParsingTest, ForOfYieldExpression) { … }

TEST_F(ParsingTest, ForOfExpressionError) { … }

TEST_F(ParsingTest, ForOfAsync) { … }

TEST_F(ParsingTest, InvalidUnicodeEscapes) { … }

TEST_F(ParsingTest, UnicodeEscapes) { … }

TEST_F(ParsingTest, OctalEscapes) { … }

TEST_F(ParsingTest, ScanTemplateLiterals) { … }

TEST_F(ParsingTest, ScanTaggedTemplateLiterals) { … }

TEST_F(ParsingTest, TemplateMaterializedLiterals) { … }

TEST_F(ParsingTest, ScanUnterminatedTemplateLiterals) { … }

TEST_F(ParsingTest, TemplateLiteralsIllegalTokens) { … }

TEST_F(ParsingTest, ParseRestParameters) { … }

TEST_F(ParsingTest, ParseRestParametersErrors) { … }

TEST_F(ParsingTest, RestParameterInSetterMethodError) { … }

TEST_F(ParsingTest, RestParametersEvalArguments) { … }

TEST_F(ParsingTest, RestParametersDuplicateEvalArguments) { … }

TEST_F(ParsingTest, SpreadCall) { … }

TEST_F(ParsingTest, SpreadCallErrors) { … }

TEST_F(ParsingTest, BadRestSpread) { … }

TEST_F(ParsingTest, LexicalScopingSloppyMode) { … }

TEST_F(ParsingTest, ComputedPropertyName) { … }

TEST_F(ParsingTest, ComputedPropertyNameShorthandError) { … }

TEST_F(ParsingTest, BasicImportExportParsing) { … }

TEST_F(ParsingTest, NamespaceExportParsing) { … }

TEST_F(ParsingTest, ImportExportParsingErrors) { … }

TEST_F(ParsingTest, ModuleTopLevelFunctionDecl) { … }

TEST_F(ParsingTest, ModuleAwaitReserved) { … }

TEST_F(ParsingTest, ModuleAwaitReservedPreParse) { … }

TEST_F(ParsingTest, ModuleAwaitPermitted) { … }

TEST_F(ParsingTest, EnumReserved) { … }

static void CheckEntry(const i::SourceTextModuleDescriptor::Entry* entry,
                       const char* export_name, const char* local_name,
                       const char* import_name, int module_request) { … }

TEST_F(ParsingTest, ModuleParsingInternals) { … }

TEST_F(ParsingTest, ModuleParsingInternalsWithImportAssertions) { … }

TEST_F(ParsingTest, ModuleParsingModuleRequestOrdering) { … }

TEST_F(ParsingTest, ModuleParsingImportAssertionKeySorting) { … }

TEST_F(ParsingTest, DuplicateProtoError) { … }

TEST_F(ParsingTest, DuplicateProtoNoError) { … }

TEST_F(ParsingTest, DeclarationsError) { … }

TEST_F(ParsingTest, LanguageModeDirectives) { … }

TEST_F(ParsingTest, PropertyNameEvalArguments) { … }

TEST_F(ParsingTest, FunctionLiteralDuplicateParameters) { … }

TEST_F(ParsingTest, ArrowFunctionASIErrors) { … }

TEST_F(ParsingTest, ObjectSpreadPositiveTests) { … }

TEST_F(ParsingTest, ObjectSpreadNegativeTests) { … }

TEST_F(ParsingTest, TemplateEscapesPositiveTests) { … }

TEST_F(ParsingTest, TemplateEscapesNegativeTests) { … }

TEST_F(ParsingTest, DestructuringPositiveTests) { … }

// v8:5201
TEST_F(ParsingTest, SloppyContextDestructuringPositiveTests) { … }

TEST_F(ParsingTest, DestructuringNegativeTests) { … }

TEST_F(ParsingTest, ObjectRestNegativeTestSlow) { … }

TEST_F(ParsingTest, DestructuringAssignmentPositiveTests) { … }

TEST_F(ParsingTest, DestructuringAssignmentNegativeTests) { … }

TEST_F(ParsingTest, DestructuringDisallowPatternsInForVarIn) { … }

TEST_F(ParsingTest, DestructuringDuplicateParams) { … }

TEST_F(ParsingTest, DestructuringDuplicateParamsSloppy) { … }

TEST_F(ParsingTest, DestructuringDisallowPatternsInSingleParamArrows) { … }

TEST_F(ParsingTest, DefaultParametersYieldInInitializers) { … }

TEST_F(ParsingTest, SpreadArray) { … }

TEST_F(ParsingTest, SpreadArrayError) { … }

TEST_F(ParsingTest, NewTarget) { … }

TEST_F(ParsingTest, ImportMetaSuccess) { … }

TEST_F(ParsingTest, ImportMetaFailure) { … }

TEST_F(ParsingTest, ImportSourceSuccess) { … }

TEST_F(ParsingTest, ImportSourceFailure) { … }

TEST_F(ParsingTest, ImportSourceAttributesNotAllowed) { … }

TEST_F(ParsingTest, ImportCallSourceSuccess) { … }

TEST_F(ParsingTest, ImportCallSourceFailure) { … }

TEST_F(ParsingTest, ImportCallSourceAttributesNotAllowed) { … }

TEST_F(ParsingTest, ConstSloppy) { … }

TEST_F(ParsingTest, LetSloppy) { … }

TEST_F(ParsingTest, LanguageModeDirectivesNonSimpleParameterListErrors) { … }

TEST_F(ParsingTest, LetSloppyOnly) { … }

TEST_F(ParsingTest, EscapedKeywords) { … }

TEST_F(ParsingTest, MiscSyntaxErrors) { … }

TEST_F(ParsingTest, EscapeSequenceErrors) { … }

TEST_F(ParsingTest, NewTargetErrors) { … }

TEST_F(ParsingTest, FunctionDeclarationError) { … }

TEST_F(ParsingTest, ExponentiationOperator) { … }

TEST_F(ParsingTest, ExponentiationOperatorErrors) { … }

TEST_F(ParsingTest, AsyncAwait) { … }

TEST_F(ParsingTest, AsyncAwaitErrors) { … }

TEST_F(ParsingTest, Regress7173) { … }

TEST_F(ParsingTest, AsyncAwaitFormalParameters) { … }

TEST_F(ParsingTest, AsyncAwaitModule) { … }

TEST_F(ParsingTest, AsyncAwaitModuleErrors) { … }

TEST_F(ParsingTest, RestrictiveForInErrors) { … }

TEST_F(ParsingTest, NoDuplicateGeneratorsInBlock) { … }

TEST_F(ParsingTest, NoDuplicateAsyncFunctionInBlock) { … }

TEST_F(ParsingTest, TrailingCommasInParameters) { … }

TEST_F(ParsingTest, TrailingCommasInParametersErrors) { … }

TEST_F(ParsingTest, ArgumentsRedeclaration) { … }

// Test that lazily parsed inner functions don't result in overly pessimistic
// context allocations.
TEST_F(ParsingTest, NoPessimisticContextAllocation) { … }

TEST_F(ParsingTest, EscapedStrictReservedWord) { … }

TEST_F(ParsingTest, ForAwaitOf) { … }

TEST_F(ParsingTest, ForAwaitOfErrors) { … }

TEST_F(ParsingTest, ForAwaitOfFunctionDeclaration) { … }

TEST_F(ParsingTest, AsyncGenerator) { … }

TEST_F(ParsingTest, AsyncGeneratorErrors) { … }

TEST_F(ParsingTest, LexicalLoopVariable) { … }

TEST_F(ParsingTest, PrivateNamesSyntaxErrorEarly) { … }

TEST_F(ParsingTest, HashbangSyntax) { … }

TEST_F(ParsingTest, HashbangSyntaxErrors) { … }

TEST_F(ParsingTest, LogicalAssignmentDestructuringErrors) { … }

}  // namespace test_parsing
}  // namespace internal
}  // namespace v8