diff --git a/.typos.toml b/.typos.toml index e427c79d81d52..430d43141fae0 100644 --- a/.typos.toml +++ b/.typos.toml @@ -23,7 +23,10 @@ extend-exclude = [ ] [default] -extend-ignore-re = ["(?Rm)^.*(#|//)\\s*spellchecker:disable-line$"] +extend-ignore-re = [ + "(?Rm)^.*(#|//)\\s*spellchecker:disable-line$", + "(?s)(#|//)\\s*spellchecker:off.*?\\n\\s*(#|//)\\s*spellchecker:on", +] [default.extend-words] trivias = "trivias" diff --git a/Cargo.lock b/Cargo.lock index b6b9bcc012960..f6c60fe4a4d2d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1619,14 +1619,6 @@ dependencies = [ "rustc-hash", ] -[[package]] -name = "oxc_js_regex" -version = "0.0.0" -dependencies = [ - "oxc_allocator", - "oxc_span", -] - [[package]] name = "oxc_language_server" version = "0.0.1" @@ -1769,6 +1761,7 @@ dependencies = [ "oxc_allocator", "oxc_ast", "oxc_diagnostics", + "oxc_regexp_parser", "oxc_span", "oxc_syntax", "rustc-hash", @@ -1830,6 +1823,18 @@ dependencies = [ "walkdir", ] +[[package]] +name = "oxc_regexp_parser" +version = "0.0.0" +dependencies = [ + "oxc_allocator", + "oxc_diagnostics", + "oxc_span", + "phf 0.11.2", + "rustc-hash", + "unicode-id-start", +] + [[package]] name = "oxc_resolver" version = "1.10.2" diff --git a/Cargo.toml b/Cargo.toml index b407cab9ae2c6..042d76c03e0db 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -95,6 +95,7 @@ oxc_module_lexer = { version = "0.24.2", path = "crates/oxc_module_lexe oxc_cfg = { version = "0.24.2", path = "crates/oxc_cfg" } oxc_isolated_declarations = { version = "0.24.2", path = "crates/oxc_isolated_declarations" } oxc_transform_napi = { version = "0.24.2", path = "napi/transform" } +oxc_regexp_parser = { version = "0.0.0", path = "crates/oxc_regexp_parser" } # publish = false oxc_macros = { path = "crates/oxc_macros" } diff --git a/crates/oxc_js_regex/Cargo.toml b/crates/oxc_js_regex/Cargo.toml deleted file mode 100644 index 4027e4610181e..0000000000000 --- a/crates/oxc_js_regex/Cargo.toml +++ /dev/null @@ -1,24 +0,0 @@ -[package] -name = "oxc_js_regex" -version = "0.0.0" -publish = false -authors = ["Ubugeeei "] -categories.workspace = true -description.workspace = true -edition.workspace = true -homepage.workspace = true -keywords.workspace = true -license.workspace = true -repository.workspace = true -rust-version.workspace = true -include = ["/src"] - -[lints] -workspace = true - -[lib] -doctest = false - -[dependencies] -oxc_allocator = { workspace = true } -oxc_span = { workspace = true } diff --git a/crates/oxc_js_regex/README.md b/crates/oxc_js_regex/README.md deleted file mode 100644 index f1e6b2fc5370f..0000000000000 --- a/crates/oxc_js_regex/README.md +++ /dev/null @@ -1,5 +0,0 @@ -# oxc_js_regex - -⚠️ Work in progress. Do not use yet. - -see: https://github.com/oxc-project/oxc/issues/1164 \ No newline at end of file diff --git a/crates/oxc_js_regex/src/ast.rs b/crates/oxc_js_regex/src/ast.rs deleted file mode 100644 index 54f06cbc40a6d..0000000000000 --- a/crates/oxc_js_regex/src/ast.rs +++ /dev/null @@ -1,387 +0,0 @@ -//! [`@eslint-community/regexpp`](https://github.com/eslint-community/regexpp/blob/2e8f1af992fb12eae46a446253e8fa3f6cede92a/src/ast.ts) - -use oxc_allocator::{Box, Vec}; -use oxc_span::{CompactStr, Span}; - -/// The type which includes all nodes. -#[derive(Debug)] -pub enum Node<'a> { - Branch(Box<'a, Branch<'a>>), - Leaf(Box<'a, Leaf<'a>>), -} - -/// The type which includes all branch nodes. -#[derive(Debug)] -pub enum Branch<'a> { - Alternative(Box<'a, Alternative<'a>>), - CapturingGroup(Box<'a, CapturingGroup<'a>>), - CharacterClass(Box<'a, CharacterClass<'a>>), - CharacterClassRange(Box<'a, CharacterClassRange>), - ClassIntersection(Box<'a, ClassIntersection<'a>>), - ClassStringDisjunction(Box<'a, ClassStringDisjunction<'a>>), - ClassSubtraction(Box<'a, ClassSubtraction<'a>>), - ExpressionCharacterClass(Box<'a, ExpressionCharacterClass<'a>>), - Group(Box<'a, Group<'a>>), - LookaroundAssertion(Box<'a, LookaroundAssertion<'a>>), - Pattern(Box<'a, Pattern<'a>>), - Quantifier(Box<'a, Quantifier<'a>>), - RegExpLiteral(Box<'a, RegExpLiteral<'a>>), - StringAlternative(Box<'a, StringAlternative<'a>>), -} - -/// The type which includes all leaf nodes. -#[derive(Debug)] -pub enum Leaf<'a> { - Backreference(Box<'a, Backreference<'a>>), - BoundaryAssertion(Box<'a, BoundaryAssertion<'a>>), - Character(Box<'a, Character>), - CharacterSet(Box<'a, CharacterSet<'a>>), - Flags(Box<'a, Flags>), -} - -/// The type which includes all atom nodes. -#[derive(Debug)] -pub enum Element<'a> { - Assertion(Box<'a, Assertion<'a>>), - QuantifiableElement(Box<'a, QuantifiableElement<'a>>), - Quantifier(Box<'a, Quantifier<'a>>), -} - -/// The type which includes all atom nodes that Quantifier node can have as children. -#[derive(Debug)] -pub enum QuantifiableElement<'a> { - Backreference(Box<'a, Backreference<'a>>), - CapturingGroup(Box<'a, CapturingGroup<'a>>), - Character(Box<'a, Character>), - CharacterClass(Box<'a, CharacterClass<'a>>), - CharacterSet(Box<'a, CharacterSet<'a>>), - ExpressionCharacterClass(Box<'a, ExpressionCharacterClass<'a>>), - Group(Box<'a, Group<'a>>), - LookaheadAssertion(Box<'a, LookaheadAssertion<'a>>), -} - -/// The type which includes all character class atom nodes. -#[derive(Debug)] -pub enum CharacterClassElement<'a> { - ClassRangesCharacterClassElement(Box<'a, ClassRangesCharacterClassElement<'a>>), - UnicodeSetsCharacterClassElement(Box<'a, UnicodeSetsCharacterClassElement<'a>>), -} -#[derive(Debug)] -pub enum ClassRangesCharacterClassElement<'a> { - Character(Box<'a, Character>), - CharacterClassRange(Box<'a, CharacterClassRange>), - CharacterUnicodePropertyCharacterSet(Box<'a, CharacterUnicodePropertyCharacterSet>), - EscapeCharacterSet(Box<'a, EscapeCharacterSet>), -} -#[derive(Debug)] -pub enum UnicodeSetsCharacterClassElement<'a> { - Character(Box<'a, Character>), - CharacterClassRange(Box<'a, CharacterClassRange>), - ClassStringDisjunction(Box<'a, ClassStringDisjunction<'a>>), - EscapeCharacterSet(Box<'a, EscapeCharacterSet>), - ExpressionCharacterClass(Box<'a, ExpressionCharacterClass<'a>>), - UnicodePropertyCharacterSet(Box<'a, UnicodePropertyCharacterSet<'a>>), - UnicodeSetsCharacterClass(Box<'a, UnicodeSetsCharacterClass<'a>>), -} - -/// The root node. -#[derive(Debug)] -pub struct RegExpLiteral<'a> { - pub span: Span, - pub pattern: Pattern<'a>, - pub flags: Flags, -} - -/// The pattern. -#[derive(Debug)] -pub struct Pattern<'a> { - pub span: Span, - pub alternatives: Vec<'a, Alternative<'a>>, -} - -/// The alternative. -/// E.g. `a|b` -#[derive(Debug)] -pub struct Alternative<'a> { - pub span: Span, - pub elements: Vec<'a, Element<'a>>, -} - -/// The uncapturing group. -/// E.g. `(?:ab)` -#[derive(Debug)] -pub struct Group<'a> { - pub span: Span, - pub alternatives: Vec<'a, Alternative<'a>>, -} - -/// The capturing group. -/// E.g. `(ab)`, `(?ab)` -#[derive(Debug)] -pub struct CapturingGroup<'a> { - pub span: Span, - pub name: Option, - pub alternatives: Vec<'a, Alternative<'a>>, - pub references: Vec<'a, Backreference<'a>>, -} - -/// The lookaround assertion. -#[derive(Debug)] -pub enum LookaroundAssertion<'a> { - LookaheadAssertion(Box<'a, LookaheadAssertion<'a>>), - LookbehindAssertion(Box<'a, LookbehindAssertion<'a>>), -} - -/// The lookahead assertion. -/// E.g. `(?=ab)`, `(?!ab)` -#[derive(Debug)] -pub struct LookaheadAssertion<'a> { - pub span: Span, - pub negate: bool, - pub alternatives: Vec<'a, Alternative<'a>>, -} - -/// The lookbehind assertion. -/// E.g. `(?<=ab)`, `(? { - pub span: Span, - pub negate: bool, - pub alternatives: Vec<'a, Alternative<'a>>, -} - -/// The quantifier. -/// E.g. `a?`, `a*`, `a+`, `a{1,2}`, `a??`, `a*?`, `a+?`, `a{1,2}?` -#[derive(Debug)] -pub struct Quantifier<'a> { - pub span: Span, - pub min: f64, - pub max: f64, // can be f64::INFINITY - pub greedy: bool, - pub element: QuantifiableElement<'a>, -} - -/// The character class. -/// E.g. `[ab]`, `[^ab]` -#[derive(Debug)] -pub enum CharacterClass<'a> { - ClassRangesCharacterClass(Box<'a, ClassRangesCharacterClass<'a>>), - UnicodeSetsCharacterClass(Box<'a, UnicodeSetsCharacterClass<'a>>), -} - -/// The character class used in legacy (neither `u` nor `v` flag) and Unicode mode (`u` flag). -/// This character class is guaranteed to **not** contain strings. -/// In Unicode sets mode (`v` flag), {@link UnicodeSetsCharacterClass} is used. -#[derive(Debug)] -pub struct ClassRangesCharacterClass<'a> { - pub span: Span, - pub unicode_sets: bool, - pub elements: Vec<'a, ClassRangesCharacterClassElement<'a>>, -} - -/// The character class used in Unicode sets mode (`v` flag). -/// This character class may contain strings. -#[derive(Debug)] -pub struct UnicodeSetsCharacterClass<'a> { - pub span: Span, - pub elements: Vec<'a, UnicodeSetsCharacterClassElement<'a>>, -} - -/// The character class. -/// E.g. `[a-b]` -#[derive(Debug)] -pub struct CharacterClassRange { - pub span: Span, - pub min: Character, - pub max: Character, -} - -/// The assertion. -#[derive(Debug)] -pub enum Assertion<'a> { - BoundaryAssertion(Box<'a, BoundaryAssertion<'a>>), - LookaroundAssertion(Box<'a, LookaroundAssertion<'a>>), -} - -/// The boundary assertion. -#[derive(Debug)] -pub enum BoundaryAssertion<'a> { - EdgeAssertion(Box<'a, EdgeAssertion>), - WordBoundaryAssertion(Box<'a, WordBoundaryAssertion>), -} - -/// The edge boundary assertion. -/// E.g. `^`, `$` -#[derive(Debug)] -pub struct EdgeAssertion { - pub span: Span, - pub kind: EdgeAssertionKind, -} - -#[derive(Debug)] -pub enum EdgeAssertionKind { - Start, - End, -} - -/// The word boundary assertion. -/// E.g. `\b`, `\B` -#[derive(Debug)] -pub struct WordBoundaryAssertion { - pub span: Span, - pub negate: bool, -} - -/// The character set. -#[derive(Debug)] -pub enum CharacterSet<'a> { - AnyCharacterSet, - EscapeCharacterSet(Box<'a, EscapeCharacterSet>), - UnicodePropertyCharacterSet(Box<'a, UnicodePropertyCharacterSet<'a>>), -} - -/// The character class escape. -/// E.g. `\d`, `\s`, `\w`, `\D`, `\S`, `\W` -#[derive(Debug)] -pub struct EscapeCharacterSet { - pub span: Span, - pub kind: EscapeCharacterSetKind, - pub negate: bool, -} - -#[derive(Debug)] -pub enum EscapeCharacterSetKind { - Digit, - Space, - Word, -} - -/// The unicode property escape. -/// E.g. `\p{ASCII}`, `\P{ASCII}`, `\p{Script=Hiragana}` -#[derive(Debug)] -pub enum UnicodePropertyCharacterSet<'a> { - CharacterUnicodePropertyCharacterSet(Box<'a, CharacterUnicodePropertyCharacterSet>), - StringsUnicodePropertyCharacterSet(Box<'a, StringsUnicodePropertyCharacterSet>), -} - -#[derive(Debug)] -pub struct CharacterUnicodePropertyCharacterSet { - pub span: Span, - pub key: CompactStr, - pub value: Option, - pub negate: bool, -} - -/// StringsUnicodePropertyCharacterSet is Unicode property escape with property of strings. -#[derive(Debug)] -pub struct StringsUnicodePropertyCharacterSet { - pub span: Span, - pub key: CompactStr, -} - -/// The expression character class. -/// E.g. `[a--b]`, `[a&&b]`,`[^a--b]`, `[^a&&b]` -#[derive(Debug)] -pub struct ExpressionCharacterClass<'a> { - pub span: Span, - pub negate: bool, - pub expression: ExpressionCharacterClassExpr<'a>, -} - -#[derive(Debug)] -pub enum ExpressionCharacterClassExpr<'a> { - ClassIntersection(Box<'a, ClassIntersection<'a>>), - ClassSubtraction(Box<'a, ClassSubtraction<'a>>), -} - -#[derive(Debug)] -pub enum ClassSetOperand<'a> { - Character(Box<'a, Character>), - ClassStringDisjunction(Box<'a, ClassStringDisjunction<'a>>), - EscapeCharacterSet(Box<'a, EscapeCharacterSet>), - ExpressionCharacterClass(Box<'a, ExpressionCharacterClass<'a>>), - UnicodePropertyCharacterSet(Box<'a, UnicodePropertyCharacterSet<'a>>), - UnicodeSetsCharacterClass(Box<'a, UnicodeSetsCharacterClass<'a>>), -} - -/// The character class intersection. -/// E.g. `a&&b` -#[derive(Debug)] -pub struct ClassIntersection<'a> { - pub span: Span, - pub left: ClassIntersectionLeft<'a>, - pub right: ClassSetOperand<'a>, -} - -#[derive(Debug)] -pub enum ClassIntersectionLeft<'a> { - ClassIntersection(Box<'a, ClassIntersection<'a>>), - ClassSetOperand(Box<'a, ClassSetOperand<'a>>), -} - -/// The character class subtraction. -/// E.g. `a--b` -#[derive(Debug)] -pub struct ClassSubtraction<'a> { - pub span: Span, - pub left: ClassSubtractionLeft<'a>, - pub right: ClassSetOperand<'a>, -} - -#[derive(Debug)] -pub enum ClassSubtractionLeft<'a> { - ClassSetOperand(Box<'a, ClassSetOperand<'a>>), - ClassSubtraction(Box<'a, ClassSubtraction<'a>>), -} - -/// The character class string disjunction. -/// E.g. `\q{a|b}` -#[derive(Debug)] -pub struct ClassStringDisjunction<'a> { - pub span: Span, - pub alternatives: Vec<'a, StringAlternative<'a>>, -} - -/// StringAlternative is only used for `\q{alt}`({@link ClassStringDisjunction}). -#[derive(Debug)] -pub struct StringAlternative<'a> { - pub span: Span, - pub elements: Vec<'a, Character>, -} - -/// This includes escape sequences which mean a character. -/// E.g. `a`, `あ`, `✿`, `\x65`, `\u0065`, `\u{65}`, `\/` -#[derive(Debug)] -pub struct Character { - pub span: Span, - pub value: u16, // UTF-16 code point -} - -#[derive(Debug)] -pub enum BackreferenceRef { - Number(i32), - CompactStr(CompactStr), -} - -/// The backreference. -/// E.g. `\1`, `\k` -#[derive(Debug)] -pub struct Backreference<'a> { - pub span: Span, - pub reference: BackreferenceRef, - pub resolved: CapturingGroup<'a>, -} - -/// The flags. -#[derive(Debug)] -pub struct Flags { - pub span: Span, - pub dot_all: bool, - pub global: bool, - pub has_indices: bool, - pub ignore_case: bool, - pub multiline: bool, - pub sticky: bool, - pub unicode: bool, - pub unicode_sets: bool, -} diff --git a/crates/oxc_js_regex/src/lexer/mod.rs b/crates/oxc_js_regex/src/lexer/mod.rs deleted file mode 100644 index 40d3ff585686a..0000000000000 --- a/crates/oxc_js_regex/src/lexer/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod token; diff --git a/crates/oxc_js_regex/src/lexer/token.rs b/crates/oxc_js_regex/src/lexer/token.rs deleted file mode 100644 index 8b137891791fe..0000000000000 --- a/crates/oxc_js_regex/src/lexer/token.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/crates/oxc_js_regex/src/lib.rs b/crates/oxc_js_regex/src/lib.rs deleted file mode 100644 index 6647fb03be8f5..0000000000000 --- a/crates/oxc_js_regex/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -pub mod ast; -mod lexer; -pub mod parser; -pub mod validator; -pub mod visitor; diff --git a/crates/oxc_js_regex/src/parser.rs b/crates/oxc_js_regex/src/parser.rs deleted file mode 100644 index 8b137891791fe..0000000000000 --- a/crates/oxc_js_regex/src/parser.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/crates/oxc_js_regex/src/validator.rs b/crates/oxc_js_regex/src/validator.rs deleted file mode 100644 index 8b137891791fe..0000000000000 --- a/crates/oxc_js_regex/src/validator.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/crates/oxc_js_regex/src/visitor.rs b/crates/oxc_js_regex/src/visitor.rs deleted file mode 100644 index 8b137891791fe..0000000000000 --- a/crates/oxc_js_regex/src/visitor.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/crates/oxc_parser/Cargo.toml b/crates/oxc_parser/Cargo.toml index 3189ba6d195e2..6d469c606c9e3 100644 --- a/crates/oxc_parser/Cargo.toml +++ b/crates/oxc_parser/Cargo.toml @@ -19,11 +19,12 @@ workspace = true doctest = false [dependencies] -oxc_allocator = { workspace = true } -oxc_span = { workspace = true } -oxc_ast = { workspace = true } -oxc_syntax = { workspace = true } -oxc_diagnostics = { workspace = true } +oxc_allocator = { workspace = true } +oxc_span = { workspace = true } +oxc_ast = { workspace = true } +oxc_syntax = { workspace = true } +oxc_diagnostics = { workspace = true } +oxc_regexp_parser = { workspace = true } assert-unchecked = { workspace = true } bitflags = { workspace = true } diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs index 8ef922fc8c957..c0fe7a1f174ff 100644 --- a/crates/oxc_parser/src/js/expression.rs +++ b/crates/oxc_parser/src/js/expression.rs @@ -336,6 +336,7 @@ impl<'a> ParserImpl<'a> { } pub(crate) fn parse_literal_regexp(&mut self) -> RegExpLiteral<'a> { + use oxc_regexp_parser::{ParserOptions, PatternParser}; let span = self.start_span(); // split out pattern @@ -343,6 +344,17 @@ impl<'a> ParserImpl<'a> { let pattern_start = self.cur_token().start + 1; // +1 to exclude `/` let pattern = &self.source_text[pattern_start as usize..pattern_end as usize]; + let options = match (flags.contains(RegExpFlags::U), flags.contains(RegExpFlags::V)) { + (_, true) => ParserOptions::default().with_unicode_sets_mode(), + (true, _) => ParserOptions::default().with_unicode_mode(), + _ => ParserOptions::default(), + } + .with_span_offset(pattern_start); + + if let Err(diagnostic) = PatternParser::new(self.ast.allocator, pattern, options).parse() { + self.error(diagnostic); + } + self.bump_any(); self.ast.reg_exp_literal( self.end_span(span), diff --git a/crates/oxc_regexp_parser/Cargo.toml b/crates/oxc_regexp_parser/Cargo.toml new file mode 100644 index 0000000000000..7aa81556361e1 --- /dev/null +++ b/crates/oxc_regexp_parser/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "oxc_regexp_parser" +version = "0.0.0" +publish = false +authors.workspace = true +categories.workspace = true +description.workspace = true +edition.workspace = true +homepage.workspace = true +keywords.workspace = true +license.workspace = true +repository.workspace = true +rust-version.workspace = true +include = ["/examples","/src"] + +[lints] +workspace = true + +[lib] +doctest = false + +[dependencies] +oxc_allocator = { workspace = true } +oxc_diagnostics = { workspace = true } +oxc_span = { workspace = true } + +phf = { workspace = true, features = ["macros"] } +rustc-hash = { workspace = true } +unicode-id-start = { workspace = true } diff --git a/crates/oxc_regexp_parser/README.md b/crates/oxc_regexp_parser/README.md new file mode 100644 index 0000000000000..974bd3612620f --- /dev/null +++ b/crates/oxc_regexp_parser/README.md @@ -0,0 +1,8 @@ +# oxc_regexp_parser + +Implements ECMAScript® 2024 Language Specification + +- https://tc39.es/ecma262/2024/multipage/ecmascript-language-lexical-grammar.html#sec-literals-regular-expression-literals +- https://tc39.es/ecma262/2024/multipage/text-processing.html#sec-regexp-regular-expression-objects +- https://tc39.es/ecma262/2024/multipage/additional-ecmascript-features-for-web-browsers.html#sec-regular-expressions-patterns + diff --git a/crates/oxc_regexp_parser/examples/parse_literal.rs b/crates/oxc_regexp_parser/examples/parse_literal.rs new file mode 100644 index 0000000000000..7d76d87be4f6f --- /dev/null +++ b/crates/oxc_regexp_parser/examples/parse_literal.rs @@ -0,0 +1,63 @@ +#![allow(clippy::print_stdout)] + +use oxc_allocator::Allocator; +use oxc_regexp_parser::{ast, Parser, ParserOptions}; + +fn main() { + let allocator = Allocator::default(); + + for source_text in [ + "/ab/", + "/abc/i", + "/abcd/igv", + "/emo👈🏻ji/u", + "/ab|c/i", + "/a|b+|c/i", + "/a{0}|b{1,2}|c{3,}/i", + "/(?=a)|(?<=b)|(?!c)|(?x\1c/u", + r"/(cg)(?cg)(?:g)/", + r"/{3}/", // Error + r"/Em🥹j/", + r"/^(?=ab)\b(?!cd)(?<=ef)\B(?)(?)/", // Error + r"/(?noname)/v", // Error + r"/[\bb]/", + ] { + println!("Parse: {source_text}"); + let parser = Parser::new(&allocator, source_text, ParserOptions::default()); + let ret = parser.parse(); + + match ret { + Ok(ast::RegExpLiteral { pattern, flags, .. }) => { + println!("✨ {}", pattern.span.source_text(source_text)); + println!("{pattern:#?}"); + println!("✨ {}", flags.span.source_text(source_text)); + println!("{flags:?}"); + } + Err(error) => { + let error = error.with_source_code(source_text); + println!("💥 {error:?}"); + } + } + println!(); + } +} diff --git a/crates/oxc_regexp_parser/src/ast.rs b/crates/oxc_regexp_parser/src/ast.rs new file mode 100644 index 0000000000000..b3f605e09a59f --- /dev/null +++ b/crates/oxc_regexp_parser/src/ast.rs @@ -0,0 +1,256 @@ +use oxc_allocator::{Box, Vec}; +use oxc_span::{Atom as SpanAtom, Span}; + +// NOTE: Should keep all `enum` size <= 16 + +#[derive(Debug)] +pub struct RegExpLiteral<'a> { + pub span: Span, + pub pattern: Pattern<'a>, + pub flags: Flags, +} + +#[derive(Debug)] +pub struct Flags { + pub span: Span, + pub global: bool, + pub ignore_case: bool, + pub multiline: bool, + pub unicode: bool, + pub sticky: bool, + pub dot_all: bool, + pub has_indices: bool, + pub unicode_sets: bool, +} + +/// The root of the `PatternParser` result. +#[derive(Debug)] +pub struct Pattern<'a> { + pub span: Span, + pub body: Disjunction<'a>, +} + +/// Pile of [`Alternative`]s separated by `|`. +#[derive(Debug)] +pub struct Disjunction<'a> { + pub span: Span, + pub body: Vec<'a, Alternative<'a>>, +} + +/// Single unit of `|` separated alternatives. +#[derive(Debug)] +pub struct Alternative<'a> { + pub span: Span, + pub body: Vec<'a, Term<'a>>, +} + +/// Single unit of [`Alternative`], containing various kinds. +#[derive(Debug)] +pub enum Term<'a> { + // Assertion, QuantifiableAssertion + BoundaryAssertion(BoundaryAssertion), + LookAroundAssertion(Box<'a, LookAroundAssertion<'a>>), + // Quantifier + Quantifier(Box<'a, Quantifier<'a>>), + // Atom, ExtendedAtom + Character(Character), + Dot(Dot), + CharacterClassEscape(CharacterClassEscape), + UnicodePropertyEscape(Box<'a, UnicodePropertyEscape<'a>>), + CharacterClass(Box<'a, CharacterClass<'a>>), + CapturingGroup(Box<'a, CapturingGroup<'a>>), + IgnoreGroup(Box<'a, IgnoreGroup<'a>>), + IndexedReference(IndexedReference), + NamedReference(Box<'a, NamedReference<'a>>), +} + +/// Simple form of assertion. +/// e.g. `^`, `$`, `\b`, `\B` +#[derive(Debug)] +pub struct BoundaryAssertion { + pub span: Span, + pub kind: BoundaryAssertionKind, +} +#[derive(Debug)] +pub enum BoundaryAssertionKind { + Start, + End, + Boundary, + NegativeBoundary, +} + +/// Lookaround assertion. +/// e.g. `(?=...)`, `(?!...)`, `(?<=...)`, `(? { + pub span: Span, + pub kind: LookAroundAssertionKind, + pub body: Disjunction<'a>, +} +#[derive(Debug)] +pub enum LookAroundAssertionKind { + Lookahead, + NegativeLookahead, + Lookbehind, + NegativeLookbehind, +} + +/// Quantifier holding a [`Term`] and its repetition count. +/// e.g. `a*`, `b+`, `c?`, `d{3}`, `e{4,}`, `f{5,6}` +#[derive(Debug)] +pub struct Quantifier<'a> { + pub span: Span, + pub min: u32, + /// `None` means no upper bound. + pub max: Option, + pub greedy: bool, + pub body: Term<'a>, +} + +/// Single character. +#[derive(Debug, Copy, Clone)] +pub struct Character { + /// This will be invalid position when `UnicodeMode` is disabled and `value` is a surrogate pair. + pub span: Span, + pub kind: CharacterKind, + /// Unicode code point or UTF-16 code unit. + pub value: u32, +} +#[derive(Debug, Copy, Clone)] +pub enum CharacterKind { + ControlLetter, + HexadecimalEscape, + Identifier, + Null, + Octal, + SingleEscape, + Symbol, + UnicodeEscape, +} + +/// Character class. +/// e.g. `\d`, `\D`, `\s`, `\S`, `\w`, `\W` +#[derive(Debug)] +pub struct CharacterClassEscape { + pub span: Span, + pub kind: CharacterClassEscapeKind, +} +#[derive(Debug)] +pub enum CharacterClassEscapeKind { + D, + NegativeD, + S, + NegativeS, + W, + NegativeW, +} + +/// Unicode property. +/// e.g. `\p{ASCII}`, `\P{ASCII}`, `\p{sc=Hiragana}`, `\P{sc=Hiragana}` +#[derive(Debug)] +pub struct UnicodePropertyEscape<'a> { + pub span: Span, + pub negative: bool, + /// `true` if `UnicodeSetsMode` and `name` matched unicode property of strings. + pub strings: bool, + pub name: SpanAtom<'a>, + pub value: Option>, +} + +/// The `.`. +#[derive(Debug)] +pub struct Dot { + pub span: Span, +} + +/// Character class wrapped by `[]`. +/// e.g. `[a-z]`, `[^A-Z]`, `[abc]`, `[a&&b&&c]`, `[[a-z]--x--y]` +#[derive(Debug)] +pub struct CharacterClass<'a> { + pub span: Span, + pub negative: bool, + pub kind: CharacterClassContentsKind, + pub body: Vec<'a, CharacterClassContents<'a>>, +} +#[derive(Debug)] +pub enum CharacterClassContentsKind { + Union, + /// `UnicodeSetsMode` only. + Intersection, + /// `UnicodeSetsMode` only. + Subtraction, +} +#[derive(Debug)] +pub enum CharacterClassContents<'a> { + CharacterClassRange(Box<'a, CharacterClassRange>), + CharacterClassEscape(CharacterClassEscape), + UnicodePropertyEscape(Box<'a, UnicodePropertyEscape<'a>>), + Character(Character), + /// `UnicodeSetsMode` only + NestedCharacterClass(Box<'a, CharacterClass<'a>>), + /// `UnicodeSetsMode` only + ClassStringDisjunction(Box<'a, ClassStringDisjunction<'a>>), +} +/// `-` separated range of characters. +/// e.g. `a-z`, `A-Z`, `0-9` +#[derive(Debug)] +pub struct CharacterClassRange { + pub span: Span, + pub min: Character, + pub max: Character, +} +/// `|` separated string of characters wrapped by `\q{}`. +#[derive(Debug)] +pub struct ClassStringDisjunction<'a> { + pub span: Span, + /// `true` if body is empty or contain 2 more characters. + pub strings: bool, + pub body: Vec<'a, ClassString<'a>>, +} +/// Single unit of [`ClassStringDisjunction`]. +#[derive(Debug)] +pub struct ClassString<'a> { + pub span: Span, + pub body: Vec<'a, Character>, +} + +/// Named or unnamed capturing group. +/// e.g. `(...)`, `(?...)` +#[derive(Debug)] +pub struct CapturingGroup<'a> { + pub span: Span, + pub name: Option>, + pub body: Disjunction<'a>, +} + +/// Pseudo-group for ignoring. +/// e.g. `(?:...)` +#[derive(Debug)] +pub struct IgnoreGroup<'a> { + pub span: Span, + pub enabling_modifiers: Option, + pub disabling_modifiers: Option, + pub body: Disjunction<'a>, +} +#[derive(Debug)] +pub struct ModifierFlags { + pub ignore_case: bool, + pub sticky: bool, + pub multiline: bool, +} + +/// Backreference by index. +/// e.g. `\1`, `\2`, `\3` +#[derive(Debug)] +pub struct IndexedReference { + pub span: Span, + pub index: u32, +} + +/// Backreference by name. +/// e.g. `\k` +#[derive(Debug)] +pub struct NamedReference<'a> { + pub span: Span, + pub name: SpanAtom<'a>, +} diff --git a/crates/oxc_regexp_parser/src/body_parser/mod.rs b/crates/oxc_regexp_parser/src/body_parser/mod.rs new file mode 100644 index 0000000000000..43e1a1d2ae547 --- /dev/null +++ b/crates/oxc_regexp_parser/src/body_parser/mod.rs @@ -0,0 +1,251 @@ +mod parser; +mod reader; +mod state; +mod unicode; +mod unicode_property; + +pub use parser::PatternParser; + +#[cfg(test)] +mod test { + use crate::{ParserOptions, PatternParser}; + use oxc_allocator::Allocator; + + // NOTE: These may be useless when integlation tests are added + #[test] + fn should_pass() { + let allocator = Allocator::default(); + + for (source_text, options) in &[ + ("", ParserOptions::default()), + ("a", ParserOptions::default()), + ("a+", ParserOptions::default()), + ("a*", ParserOptions::default()), + ("a?", ParserOptions::default()), + ("^$^$^$", ParserOptions::default()), + ("(?=a){1}", ParserOptions::default()), + ("(?!a){1}", ParserOptions::default()), + ("a{1}", ParserOptions::default()), + ("a{1", ParserOptions::default()), + ("a|{", ParserOptions::default()), + ("a{", ParserOptions::default()), + ("a{,", ParserOptions::default()), + ("a{1,", ParserOptions::default()), + ("a{1,}", ParserOptions::default()), + ("a{1,2}", ParserOptions::default()), + ("a|b", ParserOptions::default()), + ("a|b|c", ParserOptions::default()), + ("a|b+?|c", ParserOptions::default()), + ("a+b*?c{1}d{2,}e{3,4}?", ParserOptions::default()), + (r"^(?=ab)\b(?!cd)(?<=ef)\B(?.)\x1f", ParserOptions::default()), + ("a]", ParserOptions::default()), + ("a}", ParserOptions::default()), + ("]", ParserOptions::default()), + ("[]", ParserOptions::default()), + ("[a]", ParserOptions::default()), + ("[ab]", ParserOptions::default()), + ("[a-b]", ParserOptions::default()), + ("[-]", ParserOptions::default()), + ("[a-]", ParserOptions::default()), + ("[-a]", ParserOptions::default()), + ("[-a-]", ParserOptions::default()), + (r"[a\-b]", ParserOptions::default()), + (r"[-a-b]", ParserOptions::default()), + (r"[a-b-]", ParserOptions::default()), + (r"[a\-b-]", ParserOptions::default()), + (r"[\[\]\-]", ParserOptions::default()), + ("[a-z0-9]", ParserOptions::default()), + ("[a-a]", ParserOptions::default()), + (r"[\d-\D]", ParserOptions::default()), + (r"^([\ud801[\udc28-\udc4f])$", ParserOptions::default()), + (r"[a-c]]", ParserOptions::default()), + ( + r"[ϗϙϛϝϟϡϣϥϧϩϫϭϯ-ϳϵϸϻ-ϼа-џѡѣѥѧѩѫѭѯѱѳѵѷѹѻѽѿҁҋҍҏґғҕҗҙқҝҟҡңҥҧҩҫҭүұҳҵҷҹһҽҿӂӄӆӈӊӌӎ-ӏӑӓӕӗәӛӝӟӡӣӥӧөӫӭӯӱӳӵӷӹӻӽӿԁԃԅԇԉԋԍԏԑԓԕԗԙԛԝԟԡԣա-ևᴀ-ᴫᵢ-ᵷᵹ-ᶚḁḃḅḇḉḋḍḏḑḓḕḗḙḛḝḟḡḣḥḧḩḫḭḯḱḳḵḷḹḻḽḿṁṃṅṇṉṋṍṏṑṓṕṗṙṛṝṟṡṣṥṧṩṫṭṯṱṳṵṷṹṻṽṿẁẃẅẇẉẋẍẏẑẓẕ-ẝẟạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹỻỽỿ-ἇἐ-ἕἠ-ἧἰ-ἷὀ-ὅὐ-ὗὠ-ὧὰ]", + ParserOptions::default(), + ), + (r"[a-z0-9[.\\]]", ParserOptions::default().with_unicode_sets_mode()), + (r"[a&&b&&c]", ParserOptions::default().with_unicode_sets_mode()), + (r"[a--b--c]", ParserOptions::default().with_unicode_sets_mode()), + (r"[[a-z]--b--c]", ParserOptions::default().with_unicode_sets_mode()), + ( + r"[[[[[[[[[[[[[[[[[[[[[[[[a]]]]]]]]]]]]]]]]]]]]]]]]", + ParserOptions::default().with_unicode_sets_mode(), + ), + ( + r"[\q{}\q{a}\q{bc}\q{d|e|f}\q{|||}]", + ParserOptions::default().with_unicode_sets_mode(), + ), + (r"(?A)\k", ParserOptions::default()), + (r"(?)\k", ParserOptions::default()), + (r"\k", ParserOptions::default()), + (r"\k<4>", ParserOptions::default()), + (r"\k", ParserOptions::default()), + (r"(?)\k", ParserOptions::default()), + (r"(?)\k", ParserOptions::default().with_unicode_mode()), + (r"\1", ParserOptions::default()), + (r"\1()", ParserOptions::default()), + (r"\1()", ParserOptions::default().with_unicode_mode()), + (r"(?..)(?..)", ParserOptions::default()), + // TODO: ES2025 Duplicate named capturing groups + // (r"(?..)|(?..)", ParserOptions::default()), + // (r"(?[0-9]{4})-[0-9]{2}|[0-9]{2}-(?[0-9]{4})", ParserOptions::default()), + // (r"(?:(?x)|(?y))\k", ParserOptions::default()), + ] { + let res = PatternParser::new(&allocator, source_text, *options).parse(); + if let Err(err) = res { + panic!("Failed to parse {source_text} with {options:?}\n💥 {err}"); + } + } + } + + #[test] + fn should_fail() { + let allocator = Allocator::default(); + + for (source_text, options) in &[ + ("a)", ParserOptions::default()), + (r"a\", ParserOptions::default()), + ("a]", ParserOptions::default().with_unicode_mode()), + ("a}", ParserOptions::default().with_unicode_mode()), + ("a|+", ParserOptions::default()), + ("a|{", ParserOptions::default().with_unicode_mode()), + ("a{", ParserOptions::default().with_unicode_mode()), + ("a{1", ParserOptions::default().with_unicode_mode()), + ("a{1,", ParserOptions::default().with_unicode_mode()), + ("a{,", ParserOptions::default().with_unicode_mode()), + ("(?=a", ParserOptions::default()), + ("(?", ParserOptions::default().with_unicode_mode()), + (r"\k<4>", ParserOptions::default().with_unicode_mode()), + (r"\k", ParserOptions::default().with_unicode_mode()), + ("a(?:", ParserOptions::default()), + ("(a", ParserOptions::default()), + ("(?", ParserOptions::default()), + ("(?)", ParserOptions::default()), + ("(?=a){1}", ParserOptions::default().with_unicode_mode()), + ("(?!a){1}", ParserOptions::default().with_unicode_mode()), + (r"[\d-\D]", ParserOptions::default().with_unicode_mode()), + ("[z-a]", ParserOptions::default()), + (r"[a-c]]", ParserOptions::default().with_unicode_mode()), + ( + r"^([a-zªµºß-öø-ÿāăąćĉċčďđēĕėęěĝğġģĥħĩīĭįıijĵķ-ĸĺļľŀłńņň-ʼnŋōŏőœŕŗřśŝşšţťŧũūŭůűųŵŷźżž-ƀƃƅƈƌ-ƍƒƕƙ-ƛƞơƣƥƨƪ-ƫƭưƴƶƹ-ƺƽ-ƿdžljnjǎǐǒǔǖǘǚǜ-ǝǟǡǣǥǧǩǫǭǯ-ǰdzǵǹǻǽǿȁȃȅȇȉȋȍȏȑȓȕȗșțȝȟȡȣȥȧȩȫȭȯȱȳ-ȹȼȿ-ɀɂɇɉɋɍɏ-ʓʕ-ʯͱͳͷͻ-ͽΐά-ώϐ-ϑϕ-ϗϙϛϝϟϡϣϥϧϩϫϭϯ-ϳϵϸϻ-ϼа-џѡѣѥѧѩѫѭѯѱѳѵѷѹѻѽѿҁҋҍҏґғҕҗҙқҝҟҡңҥҧҩҫҭүұҳҵҷҹһҽҿӂӄӆӈӊӌӎ-ӏӑӓӕӗәӛӝӟӡӣӥӧөӫӭӯӱӳӵӷӹӻӽӿԁԃԅԇԉԋԍԏԑԓԕԗԙԛԝԟԡԣա-ևᴀ-ᴫᵢ-ᵷᵹ-ᶚḁḃḅḇḉḋḍḏḑḓḕḗḙḛḝḟḡḣḥḧḩḫḭḯḱḳḵḷḹḻḽḿṁṃṅṇṉṋṍṏṑṓṕṗṙṛṝṟṡṣṥṧṩṫṭṯṱṳṵṷṹṻṽṿẁẃẅẇẉẋẍẏẑẓẕ-ẝẟạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹỻỽỿ-ἇἐ-ἕἠ-ἧἰ-ἷὀ-ὅὐ-ὗὠ-ὧὰ-ώᾀ-ᾇᾐ-ᾗᾠ-ᾧᾰ-ᾴᾶ-ᾷιῂ-ῄῆ-ῇῐ-ΐῖ-ῗῠ-ῧῲ-ῴῶ-ῷⁱⁿℊℎ-ℏℓℯℴℹℼ-ℽⅆ-ⅉⅎↄⰰ-ⱞⱡⱥ-ⱦⱨⱪⱬⱱⱳ-ⱴⱶ-ⱼⲁⲃⲅⲇⲉⲋⲍⲏⲑⲓⲕⲗⲙⲛⲝⲟⲡⲣⲥⲧⲩⲫⲭⲯⲱⲳⲵⲷⲹⲻⲽⲿⳁⳃⳅⳇⳉⳋⳍⳏⳑⳓⳕⳗⳙⳛⳝⳟⳡⳣ-ⳤⴀ-ⴥꙁꙃꙅꙇꙉꙋꙍꙏꙑꙓꙕꙗꙙꙛꙝꙟꙣꙥꙧꙩꙫꙭꚁꚃꚅꚇꚉꚋꚍꚏꚑꚓꚕꚗꜣꜥꜧꜩꜫꜭꜯ-ꜱꜳꜵꜷꜹꜻꜽꜿꝁꝃꝅꝇꝉꝋꝍꝏꝑꝓꝕꝗꝙꝛꝝꝟꝡꝣꝥꝧꝩꝫꝭꝯꝱ-ꝸꝺꝼꝿꞁꞃꞅꞇꞌff-stﬓ-ﬗａ-ｚ]|\ud801[\udc28-\udc4f]|\ud835[\udc1a-\udc33\udc4e-\udc54\udc56-\udc67\udc82-\udc9b\udcb6-\udcb9\udcbb\udcbd-\udcc3\udcc5-\udccf\udcea-\udd03\udd1e-\udd37\udd52-\udd6b\udd86-\udd9f\uddba-\uddd3\uddee-\ude07\ude22-\ude3b\ude56-\ude6f\ude8a-\udea5\udec2-\udeda\udedc-\udee1\udefc-\udf14\udf16-\udf1b\udf36-\udf4e\udf50-\udf55\udf70-\udf88\udf8a-\udf8f\udfaa-\udfc2\udfc4-\udfc9\udfcb])$", + ParserOptions::default(), + ), + (r"[[\d-\D]]", ParserOptions::default().with_unicode_sets_mode()), + (r"[a&&b--c]", ParserOptions::default().with_unicode_sets_mode()), + (r"[a--b&&c]", ParserOptions::default().with_unicode_sets_mode()), + (r"[\q{]", ParserOptions::default().with_unicode_sets_mode()), + (r"[\q{\a}]", ParserOptions::default().with_unicode_sets_mode()), + // TODO: ES2025 Duplicate named capturing groups + (r"(?..)|(?..)", ParserOptions::default()), // This will be valid + // (r"(?|(?))", ParserOptions::default()), // Nested, still invalid + ] { + assert!( + PatternParser::new(&allocator, source_text, *options).parse().is_err(), + "{source_text} should fail to parse with {options:?}!" + ); + } + } + + #[test] + fn should_fail_early_errors() { + let allocator = Allocator::default(); + + for (source_text, options, is_err) in &[ + (r"(?..)(?..)", ParserOptions::default(), true), + (r"a{2,1}", ParserOptions::default(), true), + (r"(?)\k", ParserOptions::default(), true), + (r"()\2", ParserOptions::default().with_unicode_mode(), true), + (r"[a-\d]", ParserOptions::default().with_unicode_mode(), true), + (r"[\d-z]", ParserOptions::default().with_unicode_mode(), true), + (r"[\d-\d]", ParserOptions::default().with_unicode_mode(), true), + (r"[z-a]", ParserOptions::default(), true), + (r"\u{110000}", ParserOptions::default().with_unicode_mode(), true), + (r"(?<\uD800\uDBFF>)", ParserOptions::default(), true), + (r"\u{0}\u{110000}", ParserOptions::default().with_unicode_mode(), true), + (r"(?)", ParserOptions::default(), true), + (r"\p{Foo=Bar}", ParserOptions::default().with_unicode_mode(), true), + (r"\p{Foo}", ParserOptions::default().with_unicode_mode(), true), + (r"\p{Basic_Emoji}", ParserOptions::default().with_unicode_mode(), true), + (r"\P{Basic_Emoji}", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[^\p{Basic_Emoji}]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\p{Basic_Emoji}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{ng}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{a|}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{ng}\q{o|k}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{o|k}\q{ng}\q{o|k}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{o|k}\q{o|k}\q{ng}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{}&&\q{ng}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{ng}&&\q{o|k}]]", ParserOptions::default().with_unicode_sets_mode(), false), + ( + r"[[^\q{ng}&&\q{o|k}&&\q{ng}]]", + ParserOptions::default().with_unicode_sets_mode(), + false, + ), + (r"[[^\q{ng}--\q{o|k}]]", ParserOptions::default().with_unicode_sets_mode(), true), + (r"[[^\q{o|k}--\q{ng}]]", ParserOptions::default().with_unicode_sets_mode(), false), + (r"[[z-a]]", ParserOptions::default().with_unicode_sets_mode(), true), + ] { + assert_eq!( + PatternParser::new(&allocator, source_text, *options).parse().is_err(), + *is_err, + "{source_text} should early error with {options:?}!" + ); + } + } + + #[test] + fn should_handle_empty() { + let allocator = Allocator::default(); + let pattern = PatternParser::new(&allocator, "", ParserOptions::default()).parse().unwrap(); + + assert_eq!(pattern.body.body[0].body.len(), 1); + } + + #[test] + fn should_handle_unicode() { + let allocator = Allocator::default(); + let source_text = "このEmoji🥹の数が変わる"; + + for (options, expected) in &[ + (ParserOptions::default(), 15), + (ParserOptions::default().with_unicode_mode(), 14), + (ParserOptions::default().with_unicode_sets_mode(), 14), + ] { + let pattern = PatternParser::new(&allocator, source_text, *options).parse().unwrap(); + assert_eq!(pattern.body.body[0].body.len(), *expected); + } + } +} diff --git a/crates/oxc_regexp_parser/src/body_parser/parser.rs b/crates/oxc_regexp_parser/src/body_parser/parser.rs new file mode 100644 index 0000000000000..4ab0307f7db34 --- /dev/null +++ b/crates/oxc_regexp_parser/src/body_parser/parser.rs @@ -0,0 +1,2092 @@ +use oxc_allocator::{Allocator, Box, Vec}; +use oxc_diagnostics::{OxcDiagnostic, Result}; +use oxc_span::Atom as SpanAtom; + +use crate::{ + ast, + body_parser::{reader::Reader, state::State, unicode, unicode_property}, + options::ParserOptions, + span::SpanFactory, +}; + +pub struct PatternParser<'a> { + allocator: &'a Allocator, + source_text: &'a str, + span_factory: SpanFactory, + reader: Reader<'a>, + state: State<'a>, +} + +impl<'a> PatternParser<'a> { + pub fn new(allocator: &'a Allocator, source_text: &'a str, options: ParserOptions) -> Self { + // `RegExp` can not be empty. + // - Literal `//` means just a single line comment + // - For `new RegExp("")` or `new RegExp()` (= empty), use a placeholder + let source_text = if source_text.is_empty() { "(?:)" } else { source_text }; + + Self { + allocator, + source_text, + span_factory: SpanFactory::new(options.span_offset), + reader: Reader::new(source_text, options.unicode_mode), + state: State::new(options.unicode_mode, options.unicode_sets_mode), + } + } + + pub fn parse(&mut self) -> Result> { + // Pre parse whole pattern to collect: + // - the number of (named|unnamed) capturing groups + // - For `\1` in `\1()` to be handled as indexed reference + // - names of named capturing groups + // - For `\k`, `\k(?)` to be handled as early error in `+NamedCaptureGroups` + // + // NOTE: It means that this perform 2 loops for every cases. + // - Pros: Code is simple enough and easy to understand + // - Cons: 1st pass is completely useless if the pattern does not contain any capturing groups + // We may re-consider this if we need more performance rather than simplicity. + self.state.initialize_with_parsing(self.source_text); + + // [SS:EE] Pattern :: Disjunction + // It is a Syntax Error if CountLeftCapturingParensWithin(Pattern) ≥ 2**32 - 1. + if 2 ^ 32 < self.state.num_of_capturing_groups { + return Err(OxcDiagnostic::error("Too many capturing groups")); + } + // [SS:EE] Pattern :: Disjunction + // It is a Syntax Error if Pattern contains two or more GroupSpecifiers for which the CapturingGroupName of GroupSpecifier is the same. + if self.state.num_of_named_capturing_groups as usize != self.state.found_group_names.len() { + return Err(OxcDiagnostic::error("Duplicated group name")); + } + + let disjunction = self.parse_disjunction()?; + + if self.reader.peek().is_some() { + let span_start = self.reader.offset(); + return Err(OxcDiagnostic::error("Could not parse the entire pattern") + .with_label(self.span_factory.create(span_start, span_start))); + } + + Ok(ast::Pattern { + span: self.span_factory.create(0, self.source_text.len()), + body: disjunction, + }) + } + + // ``` + // Disjunction[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: + // Alternative[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] + // Alternative[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] | Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] + // ``` + fn parse_disjunction(&mut self) -> Result> { + let span_start = self.reader.offset(); + + let mut body = Vec::new_in(self.allocator); + loop { + body.push(self.parse_alternative()?); + + if !self.reader.eat('|') { + break; + } + } + + Ok(ast::Disjunction { + span: self.span_factory.create(span_start, self.reader.offset()), + body, + }) + } + + // ``` + // Alternative[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: + // [empty] + // Alternative[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Term[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] + // ``` + fn parse_alternative(&mut self) -> Result> { + let span_start = self.reader.offset(); + + let mut body = Vec::new_in(self.allocator); + while let Some(term) = self.parse_term()? { + body.push(term); + } + + Ok(ast::Alternative { + span: self.span_factory.create(span_start, self.reader.offset()), + body, + }) + } + + // ``` + // Term[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: + // [+UnicodeMode] Assertion[+UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] + // [+UnicodeMode] Atom[+UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] Quantifier + // [+UnicodeMode] Atom[+UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] + // [~UnicodeMode] QuantifiableAssertion[?NamedCaptureGroups] Quantifier + // [~UnicodeMode] Assertion[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] + // [~UnicodeMode] ExtendedAtom[?NamedCaptureGroups] Quantifier + // [~UnicodeMode] ExtendedAtom[?NamedCaptureGroups] + // ``` + // (Annex B) + fn parse_term(&mut self) -> Result>> { + // [+UnicodeMode] Assertion + // [+UnicodeMode] Atom Quantifier + // [+UnicodeMode] Atom + if self.state.unicode_mode { + if let Some(assertion) = self.parse_assertion()? { + return Ok(Some(assertion)); + } + + let span_start = self.reader.offset(); + return match (self.parse_atom()?, self.consume_quantifier()?) { + (Some(atom), Some(((min, max), greedy))) => { + Ok(Some(ast::Term::Quantifier(Box::new_in( + ast::Quantifier { + span: self.span_factory.create(span_start, self.reader.offset()), + greedy, + min, + max, + body: atom, + }, + self.allocator, + )))) + } + (Some(atom), None) => Ok(Some(atom)), + (None, Some(_)) => { + Err(OxcDiagnostic::error("Lone `Quantifier` found, expected with `Atom`") + .with_label(self.span_factory.create(span_start, self.reader.offset()))) + } + (None, None) => Ok(None), + }; + } + + // [~UnicodeMode] QuantifiableAssertion Quantifier + // [~UnicodeMode] Assertion + // [~UnicodeMode] ExtendedAtom Quantifier + // [~UnicodeMode] ExtendedAtom + let span_start = self.reader.offset(); + if let Some(assertion) = self.parse_assertion()? { + // `QuantifiableAssertion` = (Negative)Lookahead: `(?=...)` or `(?!...)` + if let ast::Term::LookAroundAssertion(look_around) = &assertion { + if matches!( + look_around.kind, + ast::LookAroundAssertionKind::Lookahead + | ast::LookAroundAssertionKind::NegativeLookahead + ) { + if let Some(((min, max), greedy)) = self.consume_quantifier()? { + return Ok(Some(ast::Term::Quantifier(Box::new_in( + ast::Quantifier { + span: self.span_factory.create(span_start, self.reader.offset()), + greedy, + min, + max, + body: assertion, + }, + self.allocator, + )))); + } + } + } + + return Ok(Some(assertion)); + } + + match (self.parse_extended_atom()?, self.consume_quantifier()?) { + (Some(extended_atom), Some(((min, max), greedy))) => { + Ok(Some(ast::Term::Quantifier(Box::new_in( + ast::Quantifier { + span: self.span_factory.create(span_start, self.reader.offset()), + min, + max, + greedy, + body: extended_atom, + }, + self.allocator, + )))) + } + (Some(extended_atom), None) => Ok(Some(extended_atom)), + (None, Some(_)) => { + Err(OxcDiagnostic::error("Lone `Quantifier` found, expected with `ExtendedAtom`") + .with_label(self.span_factory.create(span_start, self.reader.offset()))) + } + (None, None) => Ok(None), + } + } + + // ``` + // Assertion[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: + // ^ + // $ + // \b + // \B + // [+UnicodeMode] (?= Disjunction[+UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // [+UnicodeMode] (?! Disjunction[+UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // [~UnicodeMode] QuantifiableAssertion[?NamedCaptureGroups] + // (?<= Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // (? Result>> { + let span_start = self.reader.offset(); + + let kind = if self.reader.eat('^') { + Some(ast::BoundaryAssertionKind::Start) + } else if self.reader.eat('$') { + Some(ast::BoundaryAssertionKind::End) + } else if self.reader.eat2('\\', 'b') { + Some(ast::BoundaryAssertionKind::Boundary) + } else if self.reader.eat2('\\', 'B') { + Some(ast::BoundaryAssertionKind::NegativeBoundary) + } else { + None + }; + + if let Some(kind) = kind { + return Ok(Some(ast::Term::BoundaryAssertion(ast::BoundaryAssertion { + span: self.span_factory.create(span_start, self.reader.offset()), + kind, + }))); + } + + let kind = if self.reader.eat3('(', '?', '=') { + Some(ast::LookAroundAssertionKind::Lookahead) + } else if self.reader.eat3('(', '?', '!') { + Some(ast::LookAroundAssertionKind::NegativeLookahead) + } else if self.reader.eat4('(', '?', '<', '=') { + Some(ast::LookAroundAssertionKind::Lookbehind) + } else if self.reader.eat4('(', '?', '<', '!') { + Some(ast::LookAroundAssertionKind::NegativeLookbehind) + } else { + None + }; + + if let Some(kind) = kind { + let disjunction = self.parse_disjunction()?; + + if !self.reader.eat(')') { + return Err(OxcDiagnostic::error("Unterminated lookaround assertion") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(ast::Term::LookAroundAssertion(Box::new_in( + ast::LookAroundAssertion { + span: self.span_factory.create(span_start, self.reader.offset()), + kind, + body: disjunction, + }, + self.allocator, + )))); + } + + Ok(None) + } + + // ``` + // Atom[UnicodeMode, UnicodeSetsMode, NamedCaptureGroups] :: + // PatternCharacter + // . + // \ AtomEscape[?UnicodeMode, ?NamedCaptureGroups] + // CharacterClass[?UnicodeMode, ?UnicodeSetsMode] + // ( GroupSpecifier[?UnicodeMode][opt] Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // (?: Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // ``` + fn parse_atom(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + // PatternCharacter + if let Some(cp) = self.reader.peek().filter(|&cp| !unicode::is_syntax_character(cp)) { + self.reader.advance(); + + return Ok(Some(ast::Term::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: cp, + }))); + } + + // . + if self.reader.eat('.') { + return Ok(Some(ast::Term::Dot(ast::Dot { + span: self.span_factory.create(span_start, self.reader.offset()), + }))); + } + + // \ AtomEscape[?UnicodeMode, ?NamedCaptureGroups] + if self.reader.eat('\\') { + if let Some(atom_escape) = self.parse_atom_escape(span_start)? { + return Ok(Some(atom_escape)); + } + } + + // CharacterClass[?UnicodeMode, ?UnicodeSetsMode] + if let Some(character_class) = self.parse_character_class()? { + return Ok(Some(ast::Term::CharacterClass(Box::new_in( + character_class, + self.allocator, + )))); + } + + // (?: Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + if let Some(ignore_group) = self.parse_ignore_group()? { + return Ok(Some(ast::Term::IgnoreGroup(Box::new_in(ignore_group, self.allocator)))); + } + + // ( GroupSpecifier[?UnicodeMode][opt] Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // ( Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + if let Some(capturing_group) = self.parse_capturing_group()? { + return Ok(Some(ast::Term::CapturingGroup(Box::new_in( + capturing_group, + self.allocator, + )))); + } + + Ok(None) + } + + // ``` + // ExtendedAtom[NamedCaptureGroups] :: + // . + // \ AtomEscape[~UnicodeMode, ?NamedCaptureGroups] + // \ [lookahead = c] + // CharacterClass[~UnicodeMode, ~UnicodeSetsMode] + // ( GroupSpecifier[~UnicodeMode][opt] Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + // (?: Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + // InvalidBracedQuantifier + // ExtendedPatternCharacter + // ``` + fn parse_extended_atom(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + // . + if self.reader.eat('.') { + return Ok(Some(ast::Term::Dot(ast::Dot { + span: self.span_factory.create(span_start, self.reader.offset()), + }))); + } + + if self.reader.eat('\\') { + // \ AtomEscape[~UnicodeMode, ?NamedCaptureGroups] + if let Some(atom_escape) = self.parse_atom_escape(span_start)? { + return Ok(Some(atom_escape)); + } + + // \ [lookahead = c] + if self.reader.peek().filter(|&cp| cp == 'c' as u32).is_some() { + return Ok(Some(ast::Term::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: '\\' as u32, + }))); + } + + return Err(OxcDiagnostic::error("Invalid escape") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + // CharacterClass[~UnicodeMode, ~UnicodeSetsMode] + if let Some(character_class) = self.parse_character_class()? { + return Ok(Some(ast::Term::CharacterClass(Box::new_in( + character_class, + self.allocator, + )))); + } + + // (?: Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + if let Some(ignore_group) = self.parse_ignore_group()? { + return Ok(Some(ast::Term::IgnoreGroup(Box::new_in(ignore_group, self.allocator)))); + } + + // ( GroupSpecifier[~UnicodeMode][opt] Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + // ( Disjunction[~UnicodeMode, ~UnicodeSetsMode, ?NamedCaptureGroups] ) + if let Some(capturing_group) = self.parse_capturing_group()? { + return Ok(Some(ast::Term::CapturingGroup(Box::new_in( + capturing_group, + self.allocator, + )))); + } + + // InvalidBracedQuantifier + let span_start = self.reader.offset(); + if self.consume_quantifier()?.is_some() { + // [SS:EE] ExtendedAtom :: InvalidBracedQuantifier + // It is a Syntax Error if any source text is matched by this production. + // (Annex B) + return Err(OxcDiagnostic::error("Invalid braced quantifier") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + // ExtendedPatternCharacter + if let Some(cp) = self.consume_extended_pattern_character() { + return Ok(Some(ast::Term::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: cp, + }))); + } + + Ok(None) + } + + // ``` + // AtomEscape[UnicodeMode, NamedCaptureGroups] :: + // [+UnicodeMode] DecimalEscape + // [~UnicodeMode] DecimalEscape but only if the CapturingGroupNumber of DecimalEscape is ≤ CountLeftCapturingParensWithin(the Pattern containing DecimalEscape) + // CharacterClassEscape[?UnicodeMode] + // CharacterEscape[?UnicodeMode, ?NamedCaptureGroups] + // [+NamedCaptureGroups] k GroupName[?UnicodeMode] + // ``` + // (Annex B) + fn parse_atom_escape(&mut self, span_start: usize) -> Result>> { + let checkpoint = self.reader.checkpoint(); + + // DecimalEscape: \1 means indexed reference + if let Some(index) = self.consume_decimal_escape() { + if self.state.unicode_mode { + // [SS:EE] AtomEscape :: DecimalEscape + // It is a Syntax Error if the CapturingGroupNumber of DecimalEscape is strictly greater than CountLeftCapturingParensWithin(the Pattern containing AtomEscape). + if self.state.num_of_capturing_groups < index { + return Err(OxcDiagnostic::error("Invalid indexed reference") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(ast::Term::IndexedReference(ast::IndexedReference { + span: self.span_factory.create(span_start, self.reader.offset()), + index, + }))); + } + + if index <= self.state.num_of_capturing_groups { + return Ok(Some(ast::Term::IndexedReference(ast::IndexedReference { + span: self.span_factory.create(span_start, self.reader.offset()), + index, + }))); + } + + self.reader.rewind(checkpoint); + } + + // CharacterClassEscape: \d, \p{...} + if let Some(character_class_escape) = self.parse_character_class_escape(span_start) { + return Ok(Some(ast::Term::CharacterClassEscape(character_class_escape))); + } + if let Some(unicode_property_escape) = + self.parse_character_class_escape_unicode(span_start)? + { + return Ok(Some(ast::Term::UnicodePropertyEscape(Box::new_in( + unicode_property_escape, + self.allocator, + )))); + } + + // CharacterEscape: \n, \cM, \0, etc... + if let Some(character_escape) = self.parse_character_escape(span_start)? { + return Ok(Some(ast::Term::Character(character_escape))); + } + + // k GroupName: \k means named reference + if self.state.named_capture_groups && self.reader.eat('k') { + if let Some(name) = self.consume_group_name()? { + // [SS:EE] AtomEscape :: k GroupName + // It is a Syntax Error if GroupSpecifiersThatMatch(GroupName) is empty. + if !self.state.found_group_names.contains(name.as_str()) { + return Err(OxcDiagnostic::error("Group specifier is empty") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(ast::Term::NamedReference(Box::new_in( + ast::NamedReference { + span: self.span_factory.create(span_start, self.reader.offset()), + name, + }, + self.allocator, + )))); + } + + return Err(OxcDiagnostic::error("Invalid named reference") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Err(OxcDiagnostic::error("Invalid atom escape") + .with_label(self.span_factory.create(span_start, self.reader.offset()))) + } + + // ``` + // CharacterClassEscape :: + // d + // D + // s + // S + // w + // W + // ``` + fn parse_character_class_escape( + &mut self, + span_start: usize, + ) -> Option { + let kind = if self.reader.eat('d') { + ast::CharacterClassEscapeKind::D + } else if self.reader.eat('D') { + ast::CharacterClassEscapeKind::NegativeD + } else if self.reader.eat('s') { + ast::CharacterClassEscapeKind::S + } else if self.reader.eat('S') { + ast::CharacterClassEscapeKind::NegativeS + } else if self.reader.eat('w') { + ast::CharacterClassEscapeKind::W + } else if self.reader.eat('W') { + ast::CharacterClassEscapeKind::NegativeW + } else { + return None; + }; + + Some(ast::CharacterClassEscape { + span: self.span_factory.create(span_start, self.reader.offset()), + kind, + }) + } + // ``` + // CharacterClassEscape[UnicodeMode] :: + // [+UnicodeMode] p{ UnicodePropertyValueExpression } + // [+UnicodeMode] P{ UnicodePropertyValueExpression } + // ``` + fn parse_character_class_escape_unicode( + &mut self, + span_start: usize, + ) -> Result>> { + if !self.state.unicode_mode { + return Ok(None); + } + + let negative = if self.reader.eat('p') { + false + } else if self.reader.eat('P') { + true + } else { + return Ok(None); + }; + + if self.reader.eat('{') { + if let Some((name, value, is_strings_related)) = + self.consume_unicode_property_value_expression()? + { + if self.reader.eat('}') { + // [SS:EE] CharacterClassEscape :: P{ UnicodePropertyValueExpression } + // It is a Syntax Error if MayContainStrings of the UnicodePropertyValueExpression is true. + // MayContainStrings is true + // - if the UnicodePropertyValueExpression is LoneUnicodePropertyNameOrValue + // - and it is binary property of strings(can be true only with `UnicodeSetsMode`) + if negative && is_strings_related { + return Err(OxcDiagnostic::error( + "Invalid property name(negative + property of strings)", + ) + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(ast::UnicodePropertyEscape { + span: self.span_factory.create(span_start, self.reader.offset()), + negative, + strings: is_strings_related, + name, + value, + })); + } + } + } + + Err(OxcDiagnostic::error("Unterminated unicode property escape") + .with_label(self.span_factory.create(span_start, self.reader.offset()))) + } + + // ``` + // CharacterEscape[UnicodeMode, NamedCaptureGroups] :: + // ControlEscape + // c AsciiLetter + // 0 [lookahead ∉ DecimalDigit] + // HexEscapeSequence + // RegExpUnicodeEscapeSequence[?UnicodeMode] + // [~UnicodeMode] LegacyOctalEscapeSequence + // IdentityEscape[?UnicodeMode, ?NamedCaptureGroups] + // ``` + // (Annex B) + fn parse_character_escape(&mut self, span_start: usize) -> Result> { + // e.g. \n + if let Some(cp) = self.reader.peek().and_then(unicode::map_control_escape) { + self.reader.advance(); + + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::SingleEscape, + value: cp, + })); + } + + // e.g. \cM + let checkpoint = self.reader.checkpoint(); + if self.reader.eat('c') { + if let Some(cp) = self.reader.peek().and_then(unicode::map_c_ascii_letter) { + self.reader.advance(); + + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::ControlLetter, + value: cp, + })); + } + self.reader.rewind(checkpoint); + } + + // e.g. \0 + if self.reader.peek().filter(|&cp| cp == '0' as u32).is_some() + && self.reader.peek2().filter(|&cp| unicode::is_decimal_digit(cp)).is_none() + { + self.reader.advance(); + + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Null, + value: 0x00, + })); + } + + // e.g. \x41 + if self.reader.eat('x') { + if let Some(cp) = self.consume_fixed_hex_digits(2) { + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::HexadecimalEscape, + value: cp, + })); + } + + return Err(OxcDiagnostic::error("Invalid hexadecimal escape") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + // e.g. \u{1f600} + if let Some(cp) = self.consume_reg_exp_unicode_escape_sequence(self.state.unicode_mode)? { + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::UnicodeEscape, + value: cp, + })); + } + + // e.g. \18 + if !self.state.unicode_mode { + if let Some(cp) = self.consume_legacy_octal_escape_sequence() { + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Octal, + value: cp, + })); + } + } + + // e.g. \. + if let Some(cp) = self.consume_identity_escape() { + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Identifier, + value: cp, + })); + } + + Ok(None) + } + + // ``` + // CharacterClass[UnicodeMode, UnicodeSetsMode] :: + // [ [lookahead ≠ ^] ClassContents[?UnicodeMode, ?UnicodeSetsMode] ] + // [^ ClassContents[?UnicodeMode, ?UnicodeSetsMode] ] + // ``` + fn parse_character_class(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if self.reader.eat('[') { + let negative = self.reader.eat('^'); + let (kind, body) = self.parse_class_contents()?; + + if self.reader.eat(']') { + // [SS:EE] CharacterClass :: [^ ClassContents ] + // It is a Syntax Error if MayContainStrings of the ClassContents is true. + if negative + && body.iter().any(|item| match item { + // MayContainStrings is true + // - if ClassContents contains UnicodePropertyValueExpression + // - and the UnicodePropertyValueExpression is LoneUnicodePropertyNameOrValue + // - and it is binary property of strings(can be true only with `UnicodeSetsMode`) + ast::CharacterClassContents::UnicodePropertyEscape( + unicode_property_escape, + ) => unicode_property_escape.strings, + _ => false, + }) + { + return Err(OxcDiagnostic::error("Invalid character class") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(ast::CharacterClass { + span: self.span_factory.create(span_start, self.reader.offset()), + negative, + kind, + body, + })); + } + + return Err(OxcDiagnostic::error("Unterminated character class") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Ok(None) + } + + // ``` + // ClassContents[UnicodeMode, UnicodeSetsMode] :: + // [empty] + // [~UnicodeSetsMode] NonemptyClassRanges[?UnicodeMode] + // [+UnicodeSetsMode] ClassSetExpression + // ``` + fn parse_class_contents( + &mut self, + ) -> Result<(ast::CharacterClassContentsKind, Vec<'a, ast::CharacterClassContents<'a>>)> { + // [empty] + if self.reader.peek().filter(|&cp| cp == ']' as u32).is_some() { + return Ok((ast::CharacterClassContentsKind::Union, Vec::new_in(self.allocator))); + } + + // [+UnicodeSetsMode] ClassSetExpression + if self.state.unicode_sets_mode { + return self.parse_class_set_expression(); + } + + // [~UnicodeSetsMode] NonemptyClassRanges[?UnicodeMode] + self.parse_nonempty_class_ranges() + } + + // ``` + // NonemptyClassRanges[UnicodeMode] :: + // ClassAtom[?UnicodeMode] + // ClassAtom[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode] + // ClassAtom[?UnicodeMode] - ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode] + // + // NonemptyClassRangesNoDash[UnicodeMode] :: + // ClassAtom[?UnicodeMode] + // ClassAtomNoDash[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode] + // ClassAtomNoDash[?UnicodeMode] - ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode] + // ``` + fn parse_nonempty_class_ranges( + &mut self, + ) -> Result<(ast::CharacterClassContentsKind, Vec<'a, ast::CharacterClassContents<'a>>)> { + let mut body = Vec::new_in(self.allocator); + + loop { + let range_span_start = self.reader.offset(); + + let Some(class_atom) = self.parse_class_atom()? else { + break; + }; + + let span_start = self.reader.offset(); + if !self.reader.eat('-') { + // ClassAtom[?UnicodeMode] + body.push(class_atom); + continue; + } + + let dash = ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: '-' as u32, + }); + + let Some(class_atom_to) = self.parse_class_atom()? else { + // ClassAtom[?UnicodeMode] NonemptyClassRangesNoDash[?UnicodeMode] + // => ClassAtom[?UnicodeMode] ClassAtom[?UnicodeMode] + // => ClassAtom[?UnicodeMode] - + body.push(class_atom); + body.push(dash); + continue; + }; + + // ClassAtom[?UnicodeMode] - ClassAtom[?UnicodeMode] ClassContents[?UnicodeMode, ~UnicodeSetsMode] + // If both sides are characters, it is a range. + if let ( + ast::CharacterClassContents::Character(from), + ast::CharacterClassContents::Character(to), + ) = (&class_atom, &class_atom_to) + { + // [SS:EE] NonemptyClassRanges :: ClassAtom - ClassAtom ClassContents + // [SS:EE] NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassContents + // It is a Syntax Error if IsCharacterClass of the first ClassAtom is false, IsCharacterClass of the second ClassAtom is false, and the CharacterValue of the first ClassAtom is strictly greater than the CharacterValue of the second ClassAtom. + if to.value < from.value { + return Err(OxcDiagnostic::error("Character class range out of order") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + body.push(ast::CharacterClassContents::CharacterClassRange(Box::new_in( + ast::CharacterClassRange { + span: from.span.merge(&to.span), + min: *from, + max: *to, + }, + self.allocator, + ))); + continue; + } + + // If not, it is just a union of characters. + + // [SS:EE] NonemptyClassRanges :: ClassAtom - ClassAtom ClassContents + // [SS:EE] NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassContents + // It is a Syntax Error if IsCharacterClass of the first ClassAtom is true or IsCharacterClass of the second ClassAtom is true and this production has a [UnicodeMode] parameter. + // (Annex B) + if self.state.unicode_mode { + return Err(OxcDiagnostic::error("Invalid character class range") + .with_label(self.span_factory.create(range_span_start, self.reader.offset()))); + } + + body.push(class_atom); + body.push(dash); + body.push(class_atom_to); + } + + // [empty] is already covered by the caller, but for sure + debug_assert!(!body.is_empty()); + + Ok((ast::CharacterClassContentsKind::Union, body)) + } + + // ``` + // ClassAtom[UnicodeMode] :: + // - + // ClassAtomNoDash[?UnicodeMode] + // ``` + fn parse_class_atom(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if self.reader.eat('-') { + return Ok(Some(ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: '-' as u32, + }))); + } + + self.parse_class_atom_no_dash() + } + + // ``` + // ClassAtomNoDash[UnicodeMode, NamedCaptureGroups] :: + // SourceCharacter but not one of \ or ] or - + // \ ClassEscape[?UnicodeMode, ?NamedCaptureGroups] + // \ [lookahead = c] + // ``` + // (Annex B) + fn parse_class_atom_no_dash(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if let Some(cp) = self + .reader + .peek() + .filter(|&cp| cp != '\\' as u32 && cp != ']' as u32 && cp != '-' as u32) + { + self.reader.advance(); + + return Ok(Some(ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: cp, + }))); + } + + if self.reader.eat('\\') { + if self.reader.peek().filter(|&cp| cp == 'c' as u32).is_some() { + return Ok(Some(ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: '\\' as u32, + }))); + } + + if let Some(class_escape) = self.parse_class_escape(span_start)? { + return Ok(Some(class_escape)); + } + + return Err(OxcDiagnostic::error("Invalid class atom") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Ok(None) + } + + // ``` + // ClassEscape[UnicodeMode, NamedCaptureGroups] :: + // b + // [+UnicodeMode] - + // [~UnicodeMode] c ClassControlLetter + // CharacterClassEscape[?UnicodeMode] + // CharacterEscape[?UnicodeMode, ?NamedCaptureGroups] + // + // ClassControlLetter :: + // DecimalDigit + // _ + // ``` + // (Annex B) + fn parse_class_escape( + &mut self, + span_start: usize, + ) -> Result>> { + // b + if self.reader.eat('b') { + return Ok(Some(ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::SingleEscape, + value: 0x08, + }))); + } + + // [+UnicodeMode] - + if self.state.unicode_mode && self.reader.eat('-') { + return Ok(Some(ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: '-' as u32, + }))); + } + + // [~UnicodeMode] c ClassControlLetter + if !self.state.unicode_mode { + let checkpoint = self.reader.checkpoint(); + + if self.reader.eat('c') { + if let Some(cp) = self + .reader + .peek() + .filter(|&cp| unicode::is_decimal_digit(cp) || cp == '-' as u32) + { + self.reader.advance(); + + return Ok(Some(ast::CharacterClassContents::Character(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::ControlLetter, + value: cp, + }))); + } + + self.reader.rewind(checkpoint); + } + } + + // CharacterClassEscape[?UnicodeMode] + if let Some(character_class_escape) = self.parse_character_class_escape(span_start) { + return Ok(Some(ast::CharacterClassContents::CharacterClassEscape( + character_class_escape, + ))); + } + if let Some(unicode_property_escape) = + self.parse_character_class_escape_unicode(span_start)? + { + return Ok(Some(ast::CharacterClassContents::UnicodePropertyEscape(Box::new_in( + unicode_property_escape, + self.allocator, + )))); + } + + // CharacterEscape[?UnicodeMode, ?NamedCaptureGroups] + if let Some(character_escape) = self.parse_character_escape(span_start)? { + return Ok(Some(ast::CharacterClassContents::Character(character_escape))); + } + + Ok(None) + } + + // ``` + // ClassSetExpression :: + // ClassUnion + // ClassIntersection + // ClassSubtraction + // ``` + fn parse_class_set_expression( + &mut self, + ) -> Result<(ast::CharacterClassContentsKind, Vec<'a, ast::CharacterClassContents<'a>>)> { + // ClassUnion :: ClassSetRange ClassUnion[opt] + if let Some(class_set_range) = self.parse_class_set_range()? { + return self.parse_class_set_union(class_set_range); + } + + if let Some(class_set_operand) = self.parse_class_set_operand()? { + // ClassIntersection + if self.reader.peek().filter(|&cp| cp == '&' as u32).is_some() + && self.reader.peek2().filter(|&cp| cp == '&' as u32).is_some() + { + return self.parse_class_set_intersection(class_set_operand); + } + // ClassSubtraction + if self.reader.peek().filter(|&cp| cp == '-' as u32).is_some() + && self.reader.peek2().filter(|&cp| cp == '-' as u32).is_some() + { + return self.parse_class_set_subtraction(class_set_operand); + } + + // ClassUnion :: ClassSetOperand ClassUnion[opt] + return self.parse_class_set_union(class_set_operand); + } + + let span_start = self.reader.offset(); + Err(OxcDiagnostic::error("Expected nonempty class set expression") + .with_label(self.span_factory.create(span_start, self.reader.offset()))) + } + + // ``` + // ClassUnion :: + // ClassSetRange ClassUnion[opt] + // ClassSetOperand ClassUnion[opt] + // ``` + fn parse_class_set_union( + &mut self, + class_set_range_or_class_set_operand: ast::CharacterClassContents<'a>, + ) -> Result<(ast::CharacterClassContentsKind, Vec<'a, ast::CharacterClassContents<'a>>)> { + let mut body = Vec::new_in(self.allocator); + body.push(class_set_range_or_class_set_operand); + + loop { + if let Some(class_set_range) = self.parse_class_set_range()? { + body.push(class_set_range); + continue; + } + if let Some(class_set_operand) = self.parse_class_set_operand()? { + body.push(class_set_operand); + continue; + } + + break; + } + + Ok((ast::CharacterClassContentsKind::Union, body)) + } + + // ``` + // ClassIntersection :: + // ClassSetOperand && [lookahead ≠ &] ClassSetOperand + // ClassIntersection && [lookahead ≠ &] ClassSetOperand + // ``` + fn parse_class_set_intersection( + &mut self, + class_set_operand: ast::CharacterClassContents<'a>, + ) -> Result<(ast::CharacterClassContentsKind, Vec<'a, ast::CharacterClassContents<'a>>)> { + let mut body = Vec::new_in(self.allocator); + body.push(class_set_operand); + + loop { + if self.reader.peek().filter(|&cp| cp == ']' as u32).is_some() { + break; + } + + if self.reader.eat2('&', '&') { + let span_start = self.reader.offset(); + if self.reader.eat('&') { + return Err(OxcDiagnostic::error( + "Unexpected `&` inside of class interseciton", // spellchecker:disable-line + ) + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + if let Some(class_set_operand) = self.parse_class_set_operand()? { + body.push(class_set_operand); + continue; + } + } + + let span_start = self.reader.offset(); + return Err(OxcDiagnostic::error( + "Invalid character in character class set interseciton", // spellchecker:disable-line + ) + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Ok((ast::CharacterClassContentsKind::Intersection, body)) + } + + // ``` + // ClassSubtraction :: + // ClassSetOperand -- ClassSetOperand + // ClassSubtraction -- ClassSetOperand + // ``` + fn parse_class_set_subtraction( + &mut self, + class_set_operand: ast::CharacterClassContents<'a>, + ) -> Result<(ast::CharacterClassContentsKind, Vec<'a, ast::CharacterClassContents<'a>>)> { + let mut body = Vec::new_in(self.allocator); + body.push(class_set_operand); + + loop { + if self.reader.peek().filter(|&cp| cp == ']' as u32).is_some() { + break; + } + + if self.reader.eat2('-', '-') { + if let Some(class_set_operand) = self.parse_class_set_operand()? { + body.push(class_set_operand); + continue; + } + } + + let span_start = self.reader.offset(); + return Err(OxcDiagnostic::error( + "Invalid character in character class set subtraction", + ) + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Ok((ast::CharacterClassContentsKind::Subtraction, body)) + } + + // ``` + // ClassSetRange :: + // ClassSetCharacter - ClassSetCharacter + // ``` + fn parse_class_set_range(&mut self) -> Result>> { + let checkpoint = self.reader.checkpoint(); + + if let Some(class_set_character) = self.parse_class_set_character()? { + if self.reader.eat('-') { + if let Some(class_set_character_to) = self.parse_class_set_character()? { + // [SS:EE] ClassSetRange :: ClassSetCharacter - ClassSetCharacter + // It is a Syntax Error if the CharacterValue of the first ClassSetCharacter is strictly greater than the CharacterValue of the second ClassSetCharacter. + if class_set_character_to.value < class_set_character.value { + return Err(OxcDiagnostic::error("Character set class range out of order") + .with_label( + class_set_character.span.merge(&class_set_character_to.span), + )); + } + + return Ok(Some(ast::CharacterClassContents::CharacterClassRange( + Box::new_in( + ast::CharacterClassRange { + span: class_set_character.span.merge(&class_set_character_to.span), + min: class_set_character, + max: class_set_character_to, + }, + self.allocator, + ), + ))); + } + } + } + self.reader.rewind(checkpoint); + + Ok(None) + } + + // ``` + // ClassSetOperand :: + // NestedClass + // ClassStringDisjunction + // ClassSetCharacter + // + // ClassStringDisjunction :: + // \q{ ClassStringDisjunctionContents } + // ``` + fn parse_class_set_operand(&mut self) -> Result>> { + if let Some(nested_class) = self.parse_nested_class()? { + return Ok(Some(nested_class)); + } + + let span_start = self.reader.offset(); + if self.reader.eat3('\\', 'q', '{') { + let (class_string_disjunction_contents, strings) = + self.parse_class_string_disjunction_contents()?; + + if self.reader.eat('}') { + return Ok(Some(ast::CharacterClassContents::ClassStringDisjunction(Box::new_in( + ast::ClassStringDisjunction { + span: self.span_factory.create(span_start, self.reader.offset()), + strings, + body: class_string_disjunction_contents, + }, + self.allocator, + )))); + } + + return Err(OxcDiagnostic::error("Unterminated class string disjunction") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + if let Some(class_set_character) = self.parse_class_set_character()? { + return Ok(Some(ast::CharacterClassContents::Character(class_set_character))); + } + + Ok(None) + } + + // ``` + // NestedClass :: + // [ [lookahead ≠ ^] ClassContents[+UnicodeMode, +UnicodeSetsMode] ] + // [^ ClassContents[+UnicodeMode, +UnicodeSetsMode] ] + // \ CharacterClassEscape[+UnicodeMode] + // ``` + fn parse_nested_class(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + // [ [lookahead ≠ ^] ClassContents[+UnicodeMode, +UnicodeSetsMode] ] + // [^ ClassContents[+UnicodeMode, +UnicodeSetsMode] ] + if self.reader.eat('[') { + let negative = self.reader.eat('^'); + let (kind, body) = self.parse_class_contents()?; + + if self.reader.eat(']') { + // [SS:EE] NestedClass :: [^ ClassContents ] + // It is a Syntax Error if MayContainStrings of the ClassContents is true. + if negative { + let may_contain_strings = |item: &ast::CharacterClassContents| match item { + // MayContainStrings is true + // - if ClassContents contains UnicodePropertyValueExpression + // - && UnicodePropertyValueExpression is LoneUnicodePropertyNameOrValue + // - && it is binary property of strings(can be true only with `UnicodeSetsMode`) + ast::CharacterClassContents::UnicodePropertyEscape( + unicode_property_escape, + ) => unicode_property_escape.strings, + // MayContainStrings is true + // - if ClassStringDisjunction is [empty] + // - || if ClassStringDisjunction contains ClassString + // - && ClassString is [empty] + // - || ClassString contains 2 more ClassSetCharacters + ast::CharacterClassContents::ClassStringDisjunction( + class_string_disjunction, + ) => class_string_disjunction.strings, + _ => false, + }; + + if match kind { + // MayContainStrings is true + // - if ClassContents is ClassUnion + // - && ClassUnion has ClassOperands + // - && at least 1 ClassOperand has MayContainStrings: true + ast::CharacterClassContentsKind::Union => { + body.iter().any(|item| may_contain_strings(item)) + } + // MayContainStrings is true + // - if ClassContents is ClassIntersection + // - && ClassIntersection has ClassOperands + // - && all ClassOperands have MayContainStrings: true + ast::CharacterClassContentsKind::Intersection => { + body.iter().all(|item| may_contain_strings(item)) + } + // MayContainStrings is true + // - if ClassContents is ClassSubtraction + // - && ClassSubtraction has ClassOperands + // - && the first ClassOperand has MayContainStrings: true + ast::CharacterClassContentsKind::Subtraction => { + body.iter().next().map_or(false, |item| may_contain_strings(item)) + } + } { + return Err(OxcDiagnostic::error("Invalid character class").with_label( + self.span_factory.create(span_start, self.reader.offset()), + )); + } + } + + return Ok(Some(ast::CharacterClassContents::NestedCharacterClass(Box::new_in( + ast::CharacterClass { + span: self.span_factory.create(span_start, self.reader.offset()), + negative, + kind, + body, + }, + self.allocator, + )))); + } + + return Err(OxcDiagnostic::error("Unterminated nested class") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + // \ CharacterClassEscape[+UnicodeMode] + let span_start = self.reader.offset(); + let checkpoint = self.reader.checkpoint(); + if self.reader.eat('\\') { + if let Some(character_class_escape) = self.parse_character_class_escape(span_start) { + return Ok(Some(ast::CharacterClassContents::CharacterClassEscape( + character_class_escape, + ))); + } + if let Some(unicode_property_escape) = + self.parse_character_class_escape_unicode(span_start)? + { + return Ok(Some(ast::CharacterClassContents::UnicodePropertyEscape(Box::new_in( + unicode_property_escape, + self.allocator, + )))); + } + + self.reader.rewind(checkpoint); + } + + Ok(None) + } + + // ``` + // ClassStringDisjunctionContents :: + // ClassString + // ClassString | ClassStringDisjunctionContents + // ``` + // Returns: (ClassStringDisjunctionContents, contain_strings) + fn parse_class_string_disjunction_contents( + &mut self, + ) -> Result<(Vec<'a, ast::ClassString<'a>>, bool)> { + let mut body = Vec::new_in(self.allocator); + let mut strings = false; + + loop { + let (class_string, contain_strings) = self.parse_class_string()?; + body.push(class_string); + if contain_strings { + strings = true; + } + + if !self.reader.eat('|') { + break; + } + } + + if body.is_empty() { + strings = true; + } + + Ok((body, strings)) + } + + // ``` + // ClassString :: + // [empty] + // NonEmptyClassString + // + // NonEmptyClassString :: + // ClassSetCharacter NonEmptyClassString[opt] + // ``` + // Returns (ClassString, contain_strings) + fn parse_class_string(&mut self) -> Result<(ast::ClassString<'a>, bool)> { + let span_start = self.reader.offset(); + + let mut body = Vec::new_in(self.allocator); + while let Some(class_set_character) = self.parse_class_set_character()? { + body.push(class_set_character); + } + + // True if empty or contains 2 or more characters + let contain_strings = body.len() != 1; + + Ok(( + ast::ClassString { + span: self.span_factory.create(span_start, self.reader.offset()), + body, + }, + contain_strings, + )) + } + + // ``` + // ClassSetCharacter :: + // [lookahead ∉ ClassSetReservedDoublePunctuator] SourceCharacter but not ClassSetSyntaxCharacter + // \ CharacterEscape[+UnicodeMode] + // \ ClassSetReservedPunctuator + // \b + // ``` + fn parse_class_set_character(&mut self) -> Result> { + let span_start = self.reader.offset(); + + if let (Some(cp1), Some(cp2)) = (self.reader.peek(), self.reader.peek2()) { + if !unicode::is_class_set_reserved_double_punctuator(cp1, cp2) + && !unicode::is_class_set_syntax_character(cp1) + { + self.reader.advance(); + + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Symbol, + value: cp1, + })); + } + } + + let checkpoint = self.reader.checkpoint(); + if self.reader.eat('\\') { + if let Some(character_escape) = self.parse_character_escape(span_start)? { + return Ok(Some(character_escape)); + } + + if let Some(cp) = + self.reader.peek().filter(|&cp| unicode::is_class_set_reserved_punctuator(cp)) + { + self.reader.advance(); + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::Identifier, + value: cp, + })); + } + + if self.reader.eat('b') { + return Ok(Some(ast::Character { + span: self.span_factory.create(span_start, self.reader.offset()), + kind: ast::CharacterKind::SingleEscape, + value: 0x08, + })); + } + + self.reader.rewind(checkpoint); + } + + Ok(None) + } + + // ``` + // ( GroupSpecifier[?UnicodeMode][opt] Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // + // GroupSpecifier[UnicodeMode] :: + // ? GroupName[?UnicodeMode] + // ``` + fn parse_capturing_group(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if self.reader.eat('(') { + let mut group_name = None; + + // GroupSpecifier is optional, but if it exists, `?` is also required + if self.reader.eat('?') { + let Some(name) = self.consume_group_name()? else { + return Err(OxcDiagnostic::error("Capturing group name is missing") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + }; + group_name = Some(name); + } + + let disjunction = self.parse_disjunction()?; + if self.reader.eat(')') { + return Ok(Some(ast::CapturingGroup { + span: self.span_factory.create(span_start, self.reader.offset()), + name: group_name, + body: disjunction, + })); + } + + return Err(OxcDiagnostic::error("Unterminated capturing group") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Ok(None) + } + + // ``` + // (?: Disjunction[?UnicodeMode, ?UnicodeSetsMode, ?NamedCaptureGroups] ) + // ``` + fn parse_ignore_group(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if self.reader.eat3('(', '?', ':') { + let disjunction = self.parse_disjunction()?; + + if !self.reader.eat(')') { + return Err(OxcDiagnostic::error("Unterminated ignore group") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(ast::IgnoreGroup { + span: self.span_factory.create(span_start, self.reader.offset()), + // TODO: Stage3 ModifierFlags + enabling_modifiers: None, + disabling_modifiers: None, + body: disjunction, + })); + } + + Ok(None) + } + + // --- + + // ``` + // Quantifier :: + // QuantifierPrefix + // QuantifierPrefix ? + // + // QuantifierPrefix :: + // * + // + + // ? + // { DecimalDigits[~Sep] } + // { DecimalDigits[~Sep] ,} + // { DecimalDigits[~Sep] , DecimalDigits[~Sep] } + // ``` + /// Returns: ((min, max), greedy) + #[allow(clippy::type_complexity)] + fn consume_quantifier(&mut self) -> Result), bool)>> { + let is_greedy = |reader: &mut Reader| !reader.eat('?'); + + if self.reader.eat('*') { + return Ok(Some(((0, None), is_greedy(&mut self.reader)))); + } + if self.reader.eat('+') { + return Ok(Some(((1, None), is_greedy(&mut self.reader)))); + } + if self.reader.eat('?') { + return Ok(Some(((0, Some(1)), is_greedy(&mut self.reader)))); + } + + let span_start = self.reader.offset(); + let checkpoint = self.reader.checkpoint(); + if self.reader.eat('{') { + if let Some(min) = self.consume_decimal_digits() { + if self.reader.eat('}') { + return Ok(Some(((min, Some(min)), is_greedy(&mut self.reader)))); + } + + if self.reader.eat(',') { + if self.reader.eat('}') { + return Ok(Some(((min, None), is_greedy(&mut self.reader)))); + } + + if let Some(max) = self.consume_decimal_digits() { + if self.reader.eat('}') { + if max < min { + // [SS:EE] QuantifierPrefix :: { DecimalDigits , DecimalDigits } + // It is a Syntax Error if the MV of the first DecimalDigits is strictly greater than the MV of the second DecimalDigits. + return Err(OxcDiagnostic::error( + "Numbers out of order in braced quantifier", + ) + .with_label( + self.span_factory.create(span_start, self.reader.offset()), + )); + } + + return Ok(Some(((min, Some(max)), is_greedy(&mut self.reader)))); + } + } + } + } + + self.reader.rewind(checkpoint); + } + + Ok(None) + } + + // ``` + // DecimalEscape :: + // NonZeroDigit DecimalDigits[~Sep][opt] [lookahead ∉ DecimalDigit] + // ``` + fn consume_decimal_escape(&mut self) -> Option { + let checkpoint = self.reader.checkpoint(); + + if let Some(index) = self.consume_decimal_digits() { + // \0 is CharacterEscape, not DecimalEscape + if index != 0 { + return Some(index); + } + + self.reader.rewind(checkpoint); + } + + None + } + + // ``` + // DecimalDigits[Sep] :: + // DecimalDigit + // DecimalDigits[?Sep] DecimalDigit + // [+Sep] DecimalDigits[+Sep] NumericLiteralSeparator DecimalDigit + // ``` + // ([Sep] is disabled for `QuantifierPrefix` and `DecimalEscape`, skip it) + fn consume_decimal_digits(&mut self) -> Option { + let checkpoint = self.reader.checkpoint(); + + let mut value = 0; + while let Some(cp) = self.reader.peek().filter(|&cp| unicode::is_decimal_digit(cp)) { + // `- '0' as u32`: convert code point to digit + value = (10 * value) + (cp - '0' as u32); + self.reader.advance(); + } + + if self.reader.checkpoint() != checkpoint { + return Some(value); + } + + None + } + + // ``` + // UnicodePropertyValueExpression :: + // UnicodePropertyName = UnicodePropertyValue + // LoneUnicodePropertyNameOrValue + // ``` + /// Returns: `(name, Option, is_strings_related_unicode_property)` + fn consume_unicode_property_value_expression( + &mut self, + ) -> Result, Option>, bool)>> { + let checkpoint = self.reader.checkpoint(); + + // UnicodePropertyName=UnicodePropertyValue + if let Some(name) = self.consume_unicode_property_name() { + if self.reader.eat('=') { + let span_start = self.reader.offset(); + if let Some(value) = self.consume_unicode_property_value() { + // [SS:EE] UnicodePropertyValueExpression :: UnicodePropertyName = UnicodePropertyValue + // It is a Syntax Error if the source text matched by UnicodePropertyName is not a Unicode property name or property alias listed in the “Property name and aliases” column of Table 65. + // [SS:EE] UnicodePropertyValueExpression :: UnicodePropertyName = UnicodePropertyValue + // It is a Syntax Error if the source text matched by UnicodePropertyValue is not a property value or property value alias for the Unicode property or property alias given by the source text matched by UnicodePropertyName listed in PropertyValueAliases.txt. + if !unicode_property::is_valid_unicode_property(&name, &value) { + return Err(OxcDiagnostic::error("Invalid unicode property name") + .with_label( + self.span_factory.create(span_start, self.reader.offset()), + )); + } + + return Ok(Some((name, Some(value), false))); + } + } + } + self.reader.rewind(checkpoint); + + let span_start = self.reader.offset(); + // LoneUnicodePropertyNameOrValue + if let Some(name_or_value) = self.consume_unicode_property_value() { + // [SS:EE] UnicodePropertyValueExpression :: LoneUnicodePropertyNameOrValue + // It is a Syntax Error if the source text matched by LoneUnicodePropertyNameOrValue is not a Unicode property value or property value alias for the General_Category (gc) property listed in PropertyValueAliases.txt, nor a binary property or binary property alias listed in the “Property name and aliases” column of Table 66, nor a binary property of strings listed in the “Property name” column of Table 67. + if unicode_property::is_valid_unicode_property("General_Category", &name_or_value) { + return Ok(Some(("General_Category".into(), Some(name_or_value), false))); + } + if unicode_property::is_valid_lone_unicode_property(&name_or_value) { + return Ok(Some((name_or_value, None, false))); + } + // [SS:EE] UnicodePropertyValueExpression :: LoneUnicodePropertyNameOrValue + // It is a Syntax Error if the enclosing Pattern does not have a [UnicodeSetsMode] parameter and the source text matched by LoneUnicodePropertyNameOrValue is a binary property of strings listed in the “Property name” column of Table 67. + if unicode_property::is_valid_lone_unicode_property_of_strings(&name_or_value) { + if !self.state.unicode_sets_mode { + return Err(OxcDiagnostic::error( + "`UnicodeSetsMode` is required for binary property of strings", + ) + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some((name_or_value, None, true))); + } + + return Err(OxcDiagnostic::error("Invalid unicode property name or value") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + Ok(None) + } + + fn consume_unicode_property_name(&mut self) -> Option> { + let span_start = self.reader.offset(); + + let checkpoint = self.reader.checkpoint(); + while unicode::is_unicode_property_name_character(self.reader.peek()?) { + self.reader.advance(); + } + + if checkpoint == self.reader.checkpoint() { + return None; + } + + Some(SpanAtom::from(&self.source_text[span_start..self.reader.offset()])) + } + + fn consume_unicode_property_value(&mut self) -> Option> { + let span_start = self.reader.offset(); + + let checkpoint = self.reader.checkpoint(); + while unicode::is_unicode_property_value_character(self.reader.peek()?) { + self.reader.advance(); + } + + if checkpoint == self.reader.checkpoint() { + return None; + } + + Some(SpanAtom::from(&self.source_text[span_start..self.reader.offset()])) + } + + // ``` + // GroupName[UnicodeMode] :: + // < RegExpIdentifierName[?UnicodeMode] > + // ``` + fn consume_group_name(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if !self.reader.eat('<') { + return Ok(None); + } + + if let Some(group_name) = self.consume_reg_exp_idenfigier_name()? { + if self.reader.eat('>') { + return Ok(Some(group_name)); + } + } + + Err(OxcDiagnostic::error("Unterminated capturing group name") + .with_label(self.span_factory.create(span_start, self.reader.offset()))) + } + + // ``` + // RegExpIdentifierName[UnicodeMode] :: + // RegExpIdentifierStart[?UnicodeMode] + // RegExpIdentifierName[?UnicodeMode] RegExpIdentifierPart[?UnicodeMode] + // ``` + fn consume_reg_exp_idenfigier_name(&mut self) -> Result>> { + let span_start = self.reader.offset(); + + if self.consume_reg_exp_idenfigier_start()?.is_some() { + while self.consume_reg_exp_idenfigier_part()?.is_some() {} + + return Ok(Some(SpanAtom::from(&self.source_text[span_start..self.reader.offset()]))); + } + + Ok(None) + } + + // ``` + // RegExpIdentifierStart[UnicodeMode] :: + // IdentifierStartChar + // \ RegExpUnicodeEscapeSequence[+UnicodeMode] + // [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate + // ``` + fn consume_reg_exp_idenfigier_start(&mut self) -> Result> { + if let Some(cp) = self.reader.peek().filter(|&cp| unicode::is_identifier_start_char(cp)) { + self.reader.advance(); + return Ok(Some(cp)); + } + + let span_start = self.reader.offset(); + if self.reader.eat('\\') { + if let Some(cp) = self.consume_reg_exp_unicode_escape_sequence(true)? { + // [SS:EE] RegExpIdentifierStart :: \ RegExpUnicodeEscapeSequence + // It is a Syntax Error if the CharacterValue of RegExpUnicodeEscapeSequence is not the numeric value of some code point matched by the IdentifierStartChar lexical grammar production. + if !unicode::is_identifier_start_char(cp) { + return Err(OxcDiagnostic::error("Invalid unicode escape sequence") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(cp)); + } + } + + if !self.state.unicode_mode { + let span_start = self.reader.offset(); + + if let Some(lead_surrogate) = + self.reader.peek().filter(|&cp| unicode::is_lead_surrogate(cp)) + { + if let Some(trail_surrogate) = + self.reader.peek2().filter(|&cp| unicode::is_trail_surrogate(cp)) + { + self.reader.advance(); + self.reader.advance(); + let cp = unicode::combine_surrogate_pair(lead_surrogate, trail_surrogate); + + // [SS:EE] RegExpIdentifierStart :: UnicodeLeadSurrogate UnicodeTrailSurrogate + // It is a Syntax Error if the RegExpIdentifierCodePoint of RegExpIdentifierStart is not matched by the UnicodeIDStart lexical grammar production. + if !unicode::is_unicode_id_start(cp) { + return Err(OxcDiagnostic::error("Invalid surrogate pair").with_label( + self.span_factory.create(span_start, self.reader.offset()), + )); + } + + return Ok(Some(cp)); + } + } + } + + Ok(None) + } + + // ``` + // RegExpIdentifierPart[UnicodeMode] :: + // IdentifierPartChar + // \ RegExpUnicodeEscapeSequence[+UnicodeMode] + // [~UnicodeMode] UnicodeLeadSurrogate UnicodeTrailSurrogate + // ``` + fn consume_reg_exp_idenfigier_part(&mut self) -> Result> { + if let Some(cp) = self.reader.peek() { + if unicode::is_identifier_part_char(cp) { + self.reader.advance(); + return Ok(Some(cp)); + } + } + + let span_start = self.reader.offset(); + if self.reader.eat('\\') { + if let Some(cp) = self.consume_reg_exp_unicode_escape_sequence(true)? { + // [SS:EE] RegExpIdentifierPart :: \ RegExpUnicodeEscapeSequence + // It is a Syntax Error if the CharacterValue of RegExpUnicodeEscapeSequence is not the numeric value of some code point matched by the IdentifierPartChar lexical grammar production. + if !unicode::is_identifier_part_char(cp) { + return Err(OxcDiagnostic::error("Invalid unicode escape sequence") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + + return Ok(Some(cp)); + } + } + + if !self.state.unicode_mode { + let span_start = self.reader.offset(); + + if let Some(lead_surrogate) = + self.reader.peek().filter(|&cp| unicode::is_lead_surrogate(cp)) + { + if let Some(trail_surrogate) = + self.reader.peek2().filter(|&cp| unicode::is_trail_surrogate(cp)) + { + self.reader.advance(); + self.reader.advance(); + + let cp = unicode::combine_surrogate_pair(lead_surrogate, trail_surrogate); + // [SS:EE] RegExpIdentifierPart :: UnicodeLeadSurrogate UnicodeTrailSurrogate + // It is a Syntax Error if the RegExpIdentifierCodePoint of RegExpIdentifierPart is not matched by the UnicodeIDContinue lexical grammar production. + if !unicode::is_unicode_id_continue(cp) { + return Err(OxcDiagnostic::error("Invalid surrogate pair").with_label( + self.span_factory.create(span_start, self.reader.offset()), + )); + } + + return Ok(Some(cp)); + } + } + } + + Ok(None) + } + + // ``` + // RegExpUnicodeEscapeSequence[UnicodeMode] :: + // [+UnicodeMode] u HexLeadSurrogate \u HexTrailSurrogate + // [+UnicodeMode] u HexLeadSurrogate + // [+UnicodeMode] u HexTrailSurrogate + // [+UnicodeMode] u HexNonSurrogate + // [~UnicodeMode] u Hex4Digits + // [+UnicodeMode] u{ CodePoint } + // ``` + fn consume_reg_exp_unicode_escape_sequence( + &mut self, + unicode_mode: bool, + ) -> Result> { + let span_start = self.reader.offset(); + let checkpoint = self.reader.checkpoint(); + + if self.reader.eat('u') { + if unicode_mode { + let checkpoint = self.reader.checkpoint(); + + // HexLeadSurrogate + HexTrailSurrogate + if let Some(lead_surrogate) = + self.consume_fixed_hex_digits(4).filter(|&cp| unicode::is_lead_surrogate(cp)) + { + if self.reader.eat2('\\', 'u') { + if let Some(trail_surrogate) = self + .consume_fixed_hex_digits(4) + .filter(|&cp| unicode::is_trail_surrogate(cp)) + { + return Ok(Some(unicode::combine_surrogate_pair( + lead_surrogate, + trail_surrogate, + ))); + } + } + } + self.reader.rewind(checkpoint); + + // HexLeadSurrogate + if let Some(lead_surrogate) = + self.consume_fixed_hex_digits(4).filter(|&cp| unicode::is_lead_surrogate(cp)) + { + return Ok(Some(lead_surrogate)); + } + self.reader.rewind(checkpoint); + + // HexTrailSurrogate + if let Some(trail_surrogate) = + self.consume_fixed_hex_digits(4).filter(|&cp| unicode::is_trail_surrogate(cp)) + { + return Ok(Some(trail_surrogate)); + } + self.reader.rewind(checkpoint); + } + + // HexNonSurrogate and Hex4Digits are the same + if let Some(hex_digits) = self.consume_fixed_hex_digits(4) { + return Ok(Some(hex_digits)); + } + + // {CodePoint} + if unicode_mode { + let checkpoint = self.reader.checkpoint(); + + if self.reader.eat('{') { + if let Some(hex_digits) = + self.consume_hex_digits().filter(|&cp| unicode::is_valid_unicode(cp)) + { + if self.reader.eat('}') { + return Ok(Some(hex_digits)); + } + } + } + self.reader.rewind(checkpoint); + } + + if self.state.unicode_mode { + return Err(OxcDiagnostic::error("Invalid unicode escape sequence") + .with_label(self.span_factory.create(span_start, self.reader.offset()))); + } + self.reader.rewind(checkpoint); + } + + Ok(None) + } + + // ``` + // LegacyOctalEscapeSequence :: + // 0 [lookahead ∈ { 8, 9 }] + // NonZeroOctalDigit [lookahead ∉ OctalDigit] + // ZeroToThree OctalDigit [lookahead ∉ OctalDigit] + // FourToSeven OctalDigit + // ZeroToThree OctalDigit OctalDigit + // ``` + fn consume_legacy_octal_escape_sequence(&mut self) -> Option { + if let Some(first) = self.consume_octal_digit() { + // 0 [lookahead ∈ { 8, 9 }] + if first == 0 + && self.reader.peek().filter(|&cp| cp == '8' as u32 || cp == '9' as u32).is_some() + { + return Some(first); + } + + if let Some(second) = self.consume_octal_digit() { + if let Some(third) = self.consume_octal_digit() { + // ZeroToThree OctalDigit OctalDigit + if first <= 3 { + return Some(first * 64 + second * 8 + third); + } + } + + // ZeroToThree OctalDigit [lookahead ∉ OctalDigit] + // FourToSeven OctalDigit + return Some(first * 8 + second); + } + + // NonZeroOctalDigit [lookahead ∉ OctalDigit] + return Some(first); + } + + None + } + + fn consume_octal_digit(&mut self) -> Option { + let cp = self.reader.peek()?; + + if unicode::is_octal_digit(cp) { + self.reader.advance(); + // `- '0' as u32`: convert code point to digit + return Some(cp - '0' as u32); + } + + None + } + + // ``` + // IdentityEscape[UnicodeMode, NamedCaptureGroups] :: + // [+UnicodeMode] SyntaxCharacter + // [+UnicodeMode] / + // [~UnicodeMode] SourceCharacterIdentityEscape[?NamedCaptureGroups] + // + // SourceCharacterIdentityEscape[NamedCaptureGroups] :: + // [~NamedCaptureGroups] SourceCharacter but not c + // [+NamedCaptureGroups] SourceCharacter but not one of c or k + // ``` + // (Annex B) + fn consume_identity_escape(&mut self) -> Option { + let cp = self.reader.peek()?; + + if self.state.unicode_mode { + if unicode::is_syntax_character(cp) || cp == '/' as u32 { + self.reader.advance(); + return Some(cp); + } + return None; + } + + if self.state.named_capture_groups { + if cp != 'c' as u32 && cp != 'k' as u32 { + self.reader.advance(); + return Some(cp); + } + return None; + } + + if cp != 'c' as u32 { + self.reader.advance(); + return Some(cp); + } + + None + } + + // ``` + // ExtendedPatternCharacter :: + // SourceCharacter but not one of ^ $ \ . * + ? ( ) [ | + // ``` + fn consume_extended_pattern_character(&mut self) -> Option { + let cp = self.reader.peek()?; + + if cp == '^' as u32 + || cp == '$' as u32 + || cp == '\\' as u32 + || cp == '.' as u32 + || cp == '*' as u32 + || cp == '+' as u32 + || cp == '?' as u32 + || cp == '(' as u32 + || cp == ')' as u32 + || cp == '[' as u32 + || cp == '|' as u32 + { + return None; + } + + self.reader.advance(); + Some(cp) + } + + fn consume_hex_digits(&mut self) -> Option { + let checkpoint = self.reader.checkpoint(); + + let mut value = 0; + while let Some(hex) = self.reader.peek().and_then(unicode::map_hex_digit) { + value = (16 * value) + hex; + self.reader.advance(); + } + + if self.reader.checkpoint() != checkpoint { + return Some(value); + } + + None + } + + fn consume_fixed_hex_digits(&mut self, len: usize) -> Option { + let checkpoint = self.reader.checkpoint(); + + let mut value = 0; + for _ in 0..len { + let Some(hex) = self.reader.peek().and_then(unicode::map_hex_digit) else { + self.reader.rewind(checkpoint); + return None; + }; + + value = (16 * value) + hex; + self.reader.advance(); + } + + Some(value) + } +} diff --git a/crates/oxc_regexp_parser/src/body_parser/reader.rs b/crates/oxc_regexp_parser/src/body_parser/reader.rs new file mode 100644 index 0000000000000..7828d9b7ffb7c --- /dev/null +++ b/crates/oxc_regexp_parser/src/body_parser/reader.rs @@ -0,0 +1,242 @@ +pub struct Reader<'a> { + source: &'a str, + unicode_mode: bool, + /// Current index for `u8_units`(unicode mode) or `u16_units`(non-unicode mode). + index: usize, + /// Even in non-unicode mode, used for `Span` offset calculation. + u8_units: Vec<(usize, char)>, + u16_units: Vec, + /// Last offset caches for non-unicode mode. + last_offset_indices: (usize, usize), +} + +impl<'a> Reader<'a> { + pub fn new(source: &'a str, unicode_mode: bool) -> Self { + // NOTE: Distinguish these 2 units looks cleaner, but it may not be necessary. + // As as a parser, AST `Character[kind=Symbol]` only needs to be aware of this for surrogate pairs. + // NOTE: Collecting `Vec` may not be efficient if the source is too large. + // Implements lookahead cache with `VecDeque` is better...? + let u8_units = source.char_indices().collect::>(); + let u16_units = if unicode_mode { "" } else { source }.encode_utf16().collect::>(); + + Self { source, unicode_mode, index: 0, u8_units, u16_units, last_offset_indices: (0, 0) } + } + + pub fn offset(&mut self) -> usize { + if self.unicode_mode { + self.u8_units.get(self.index).map_or(self.source.len(), |(idx, _)| *idx) + } else { + let (mut u16_idx, mut u8_idx) = self.last_offset_indices; + for (idx, ch) in &self.u8_units[u8_idx..] { + if self.index <= u16_idx { + self.last_offset_indices = (u16_idx, u8_idx); + return *idx; + } + + u16_idx += ch.len_utf16(); + u8_idx += 1; + } + self.source.len() + } + } + + // NOTE: For now, `usize` is enough for the checkpoint. + // But `last_offset_indices` should be stored as well for more performance? + pub fn checkpoint(&self) -> usize { + self.index + } + pub fn rewind(&mut self, checkpoint: usize) { + self.index = checkpoint; + self.last_offset_indices = (0, 0); + } + + pub fn advance(&mut self) { + self.index += 1; + } + + fn peek_nth(&self, n: usize) -> Option { + let nth = self.index + n; + + if self.unicode_mode { + self.u8_units.get(nth).map(|&(_, ch)| ch as u32) + } else { + #[allow(clippy::cast_lossless)] + self.u16_units.get(nth).map(|&cu| cu as u32) + } + } + + pub fn peek(&self) -> Option { + self.peek_nth(0) + } + pub fn peek2(&self) -> Option { + self.peek_nth(1) + } + + pub fn eat(&mut self, ch: char) -> bool { + if self.peek_nth(0) == Some(ch as u32) { + self.advance(); + return true; + } + false + } + pub fn eat2(&mut self, ch: char, ch2: char) -> bool { + if self.peek_nth(0) == Some(ch as u32) && self.peek_nth(1) == Some(ch2 as u32) { + self.advance(); + self.advance(); + return true; + } + false + } + pub fn eat3(&mut self, ch: char, ch2: char, ch3: char) -> bool { + if self.peek_nth(0) == Some(ch as u32) + && self.peek_nth(1) == Some(ch2 as u32) + && self.peek_nth(2) == Some(ch3 as u32) + { + self.advance(); + self.advance(); + self.advance(); + return true; + } + false + } + pub fn eat4(&mut self, ch: char, ch2: char, ch3: char, ch4: char) -> bool { + if self.peek_nth(0) == Some(ch as u32) + && self.peek_nth(1) == Some(ch2 as u32) + && self.peek_nth(2) == Some(ch3 as u32) + && self.peek_nth(3) == Some(ch4 as u32) + { + self.advance(); + self.advance(); + self.advance(); + self.advance(); + return true; + } + false + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn index_basic() { + let source_text = "/RegExp✨/i"; + let unicode_reader = Reader::new(source_text, true); + let legacy_reader = Reader::new(source_text, false); + + for mut reader in [unicode_reader, legacy_reader] { + assert_eq!(reader.index, 0); + assert_eq!(reader.peek(), Some('/' as u32)); + + reader.advance(); + assert_eq!(reader.index, 1); + assert_eq!(reader.peek(), Some('R' as u32)); + assert_eq!(reader.peek2(), Some('e' as u32)); + + assert!(reader.eat('R')); + assert!(!reader.eat('R')); + assert!(reader.eat('e')); + assert!(reader.eat('g')); + assert!(reader.eat('E')); + assert!(!reader.eat3('E', 'x', 'p')); + assert!(reader.eat2('x', 'p')); + + let checkpoint = reader.checkpoint(); + assert_eq!(checkpoint, 7); + assert_eq!(reader.peek(), Some('✨' as u32)); + + reader.advance(); + reader.advance(); + assert_eq!(reader.peek(), Some('i' as u32)); + + reader.advance(); + assert_eq!(reader.peek(), None); + + reader.rewind(checkpoint); + assert_eq!(reader.peek(), Some('✨' as u32)); + } + } + + #[test] + fn index_unicode() { + let source_text = "𠮷野家は👈🏻あっち"; + + let mut unicode_reader = Reader::new(source_text, true); + + assert!(unicode_reader.eat('𠮷')); // Can eat + assert!(unicode_reader.eat2('野', '家')); + let checkpoint = unicode_reader.checkpoint(); + assert!(unicode_reader.eat('は')); + + // Emoji + Skin tone + unicode_reader.advance(); + unicode_reader.advance(); + + assert!(unicode_reader.eat('あ')); + assert_eq!(unicode_reader.peek(), Some('っ' as u32)); + assert_eq!(unicode_reader.peek2(), Some('ち' as u32)); + + unicode_reader.rewind(checkpoint); + assert!(unicode_reader.eat('は')); + + let mut legacy_reader = Reader::new(source_text, false); + + assert!(!legacy_reader.eat('𠮷')); // Can not eat + legacy_reader.advance(); + assert!(!legacy_reader.eat('𠮷')); // Also can not + legacy_reader.advance(); + + assert!(legacy_reader.eat('野')); + assert!(legacy_reader.eat('家')); + let checkpoint = unicode_reader.checkpoint(); + assert!(legacy_reader.eat('は')); + + legacy_reader.advance(); + legacy_reader.advance(); + legacy_reader.advance(); + legacy_reader.advance(); + + assert_eq!(legacy_reader.peek(), Some('あ' as u32)); + assert_eq!(legacy_reader.peek2(), Some('っ' as u32)); + assert!(legacy_reader.eat3('あ', 'っ', 'ち')); + + legacy_reader.rewind(checkpoint); + assert!(legacy_reader.eat('は')); + } + + #[test] + fn span_position() { + let source_text = "^ Catch😎 @ symbols🇺🇳 $"; + + let unicode_reader = Reader::new(source_text, true); + let legacy_reader = Reader::new(source_text, false); + + for mut reader in [unicode_reader, legacy_reader] { + while reader.peek() != Some('^' as u32) { + reader.advance(); + } + let s1 = reader.offset(); + assert!(reader.eat('^')); + let e1 = reader.offset(); + + while reader.peek() != Some('@' as u32) { + reader.advance(); + } + let s2 = reader.offset(); + assert!(reader.eat('@')); + let e2 = reader.offset(); + + while reader.peek() != Some('$' as u32) { + reader.advance(); + } + let s3 = reader.offset(); + assert!(reader.eat('$')); + let e3 = reader.offset(); + + assert_eq!(&source_text[s1..e1], "^"); + assert_eq!(&source_text[s2..e2], "@"); + assert_eq!(&source_text[s3..e3], "$"); + } + } +} diff --git a/crates/oxc_regexp_parser/src/body_parser/state.rs b/crates/oxc_regexp_parser/src/body_parser/state.rs new file mode 100644 index 0000000000000..cc6f21f134b35 --- /dev/null +++ b/crates/oxc_regexp_parser/src/body_parser/state.rs @@ -0,0 +1,141 @@ +use rustc_hash::FxHashSet; + +use super::reader::Reader; + +/// Currently all of properties are read only from outside of this module. +/// Even inside of this module, it is not changed after initialized. +#[derive(Debug)] +pub struct State<'a> { + // Mode flags + pub unicode_mode: bool, + pub unicode_sets_mode: bool, + pub named_capture_groups: bool, + // Other states + pub num_of_capturing_groups: u32, + pub num_of_named_capturing_groups: u32, + pub found_group_names: FxHashSet<&'a str>, +} + +impl<'a> State<'a> { + pub fn new(unicode_mode: bool, unicode_sets_mode: bool) -> Self { + Self { + unicode_mode, + unicode_sets_mode, + named_capture_groups: false, + num_of_capturing_groups: 0, + num_of_named_capturing_groups: 0, + found_group_names: FxHashSet::default(), + } + } + + pub fn initialize_with_parsing(&mut self, source_text: &'a str) { + let (num_of_left_parens, num_of_named_capturing_groups, named_capturing_groups) = + parse_capturing_groups(source_text); + + // In Annex B, this is `false` by default. + // It is `true` + // - if `u` or `v` flag is set + // - or if `GroupName` is found in pattern + self.named_capture_groups = + self.unicode_mode || self.unicode_sets_mode || 0 < num_of_named_capturing_groups; + + self.num_of_capturing_groups = num_of_left_parens; + self.num_of_named_capturing_groups = num_of_named_capturing_groups; + self.found_group_names = named_capturing_groups; + } +} + +/// Returns: (num_of_left_parens, num_of_named_capturing_groups, named_capturing_groups) +fn parse_capturing_groups(source_text: &str) -> (u32, u32, FxHashSet<&str>) { + let mut num_of_left_parens = 0; + let mut num_of_named_capturing_groups = 0; + let mut named_capturing_groups = FxHashSet::default(); + + let mut reader = Reader::new(source_text, true); + + let mut in_escape = false; + let mut in_character_class = false; + + // Count only normal CapturingGroup(named, unnamed) + // (?...), (...) + // IgnoreGroup, and LookaroundAssertions are ignored + // (?:...) + // (?=...), (?!...), (?<=...), (?' as u32 { + break; + } + reader.advance(); + } + let span_end = reader.offset(); + + if reader.eat('>') { + let group_name = &source_text[span_start..span_end]; + // May be duplicated, but it's OK + named_capturing_groups.insert(group_name); + num_of_named_capturing_groups += 1; + continue; + } + } + } + + reader.advance(); + } + + (num_of_left_parens, num_of_named_capturing_groups, named_capturing_groups) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_count_capturing_groups() { + for (source_text, expected_num_of_left_parens, expected_num_of_named_capturing_groups) in [ + ("()", 1, 0), + (r"\1()", 1, 0), + ("(foo)", 1, 0), + ("(foo)(bar)", 2, 0), + ("(foo(bar))", 2, 0), + ("(foo)[(bar)]", 1, 0), + (r"(foo)\(bar\)", 1, 0), + ("(foo)(?bar)", 2, 1), + ("(foo)(?=...)(?!...)(?<=...)(?bar)(?baz)", 3, 2), + ("(?.)(?..)", 2, 2), + ] { + let (num_of_left_parens, num_of_named_capturing_groups, _) = + parse_capturing_groups(source_text); + assert_eq!(expected_num_of_left_parens, num_of_left_parens); + assert_eq!(expected_num_of_named_capturing_groups, num_of_named_capturing_groups); + } + } +} diff --git a/crates/oxc_regexp_parser/src/body_parser/unicode.rs b/crates/oxc_regexp_parser/src/body_parser/unicode.rs new file mode 100644 index 0000000000000..31731a26b5e4f --- /dev/null +++ b/crates/oxc_regexp_parser/src/body_parser/unicode.rs @@ -0,0 +1,145 @@ +// ``` +// SyntaxCharacter :: one of +// ^ $ \ . * + ? ( ) [ ] { } | +// ``` +pub fn is_syntax_character(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| { + matches!( + ch, + '^' | '$' | '\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' + ) + }) +} + +// ``` +// ClassSetSyntaxCharacter :: one of +// ( ) [ ] { } / - \ | +// ``` +pub fn is_class_set_syntax_character(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| { + matches!(ch, '(' | ')' | '[' | ']' | '{' | '}' | '/' | '-' | '\\' | '|') + }) +} + +// ``` +// ClassSetReservedDoublePunctuator :: one of +// && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ +// ```` +pub fn is_class_set_reserved_double_punctuator(cp1: u32, cp2: u32) -> bool { + char::from_u32(cp1).map_or(false, |ch1| { + char::from_u32(cp2).map_or(false, |ch2| { + matches!( + (ch1, ch2), + ('&', '&') + | ('!', '!') + | ('#', '#') + | ('$', '$') + | ('%', '%') + | ('*', '*') + | ('+', '+') + | (',', ',') + | ('.', '.') + | (':', ':') + | (';', ';') + | ('<', '<') + | ('=', '=') + | ('>', '>') + | ('?', '?') + | ('@', '@') + | ('^', '^') + | ('`', '`') + | ('~', '~') + ) + }) + }) +} + +// ``` +// ClassSetReservedPunctuator :: one of +// & - ! # % , : ; < = > @ ` ~ +// ``` +pub fn is_class_set_reserved_punctuator(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| { + matches!( + ch, + '&' | '-' | '!' | '#' | '%' | ',' | ':' | ';' | '<' | '=' | '>' | '@' | '`' | '~' + ) + }) +} + +pub fn is_decimal_digit(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| ch.is_ascii_digit()) +} + +pub fn is_octal_digit(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| ch.is_ascii_digit() && ch < '8') +} + +pub fn is_valid_unicode(cp: u32) -> bool { + (0..=0x0010_ffff).contains(&cp) +} + +// ``` +// UnicodePropertyNameCharacter :: +// AsciiLetter +// _ +// ``` +pub fn is_unicode_property_name_character(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| ch.is_ascii_alphabetic() || ch == '_') +} + +// ``` +// UnicodePropertyValueCharacter :: +// UnicodePropertyNameCharacter +// DecimalDigit +// ``` +pub fn is_unicode_property_value_character(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| ch.is_ascii_alphanumeric() || ch == '_') +} + +pub fn is_unicode_id_start(cp: u32) -> bool { + char::from_u32(cp).map_or(false, unicode_id_start::is_id_start) +} +pub fn is_unicode_id_continue(cp: u32) -> bool { + char::from_u32(cp).map_or(false, unicode_id_start::is_id_continue) +} + +pub fn is_identifier_start_char(cp: u32) -> bool { + char::from_u32(cp) + .map_or(false, |ch| unicode_id_start::is_id_start(ch) || ch == '$' || ch == '_') +} + +pub fn is_identifier_part_char(cp: u32) -> bool { + char::from_u32(cp).map_or(false, |ch| unicode_id_start::is_id_continue(ch) || ch == '$') +} + +pub fn is_lead_surrogate(cp: u32) -> bool { + (0xd800..=0xdbff).contains(&cp) +} + +pub fn is_trail_surrogate(cp: u32) -> bool { + (0xdc00..=0xdfff).contains(&cp) +} + +pub fn combine_surrogate_pair(lead: u32, trail: u32) -> u32 { + (lead - 0xd800) * 0x400 + trail - 0xdc00 + 0x10000 +} + +pub fn map_control_escape(cp: u32) -> Option { + match char::from_u32(cp) { + Some('f') => Some(0x0c), + Some('n') => Some(0x0a), + Some('r') => Some(0x0d), + Some('t') => Some(0x09), + Some('v') => Some(0x0b), + _ => None, + } +} + +pub fn map_c_ascii_letter(cp: u32) -> Option { + char::from_u32(cp).filter(char::is_ascii_alphabetic).map(|_| cp % 0x20) +} + +pub fn map_hex_digit(cp: u32) -> Option { + char::from_u32(cp).filter(char::is_ascii_hexdigit).and_then(|c| c.to_digit(16)) +} diff --git a/crates/oxc_regexp_parser/src/body_parser/unicode_property.rs b/crates/oxc_regexp_parser/src/body_parser/unicode_property.rs new file mode 100644 index 0000000000000..28841f9c40da8 --- /dev/null +++ b/crates/oxc_regexp_parser/src/body_parser/unicode_property.rs @@ -0,0 +1,352 @@ +use phf::{phf_set, Set}; + +// https://tc39.es/ecma262/2024/multipage/text-processing.html#table-nonbinary-unicode-properties +pub fn is_valid_unicode_property(name: &str, value: &str) -> bool { + if matches!(name, "General_Category" | "gc") { + return GC_PROPERTY_VALUES.contains(value); + } + if matches!(name, "Script" | "sc") { + return SC_PROPERTY_VALUES.contains(value); + } + if matches!(name, "Script_Extensions" | "scx") { + return SC_PROPERTY_VALUES.contains(value) || SCX_PROPERTY_VALUES.contains(value); + } + false +} + +pub fn is_valid_lone_unicode_property(name_or_value: &str) -> bool { + BINARY_UNICODE_PROPERTIES.contains(name_or_value) +} +/// This should be used with `UnicodeSetsMode` +pub fn is_valid_lone_unicode_property_of_strings(name_or_value: &str) -> bool { + BINARY_UNICODE_PROPERTIES_OF_STRINGS.contains(name_or_value) +} + +// spellchecker:off +// https://unicode.org/Public/UCD/latest/ucd/PropertyValueAliases.txt +static GC_PROPERTY_VALUES: Set<&'static str> = phf_set! { +"C", "Other", +"Cc", "Control", +"Cf", "Format", +"Cn", "Unassigned", +"Co", "Private_Use", +"Cs", "Surrogate", +"L", "Letter", +"LC", "Cased_Letter", +"Ll", "Lowercase_Letter", +"Lm", "Modifier_Letter", +"Lo", "Other_Letter", +"Lt", "Titlecase_Letter", +"Lu", "Uppercase_Letter", +"M", "Mark", +"Mc", "Spacing_Mark", +"Me", "Enclosing_Mark", +"Mn", "Nonspacing_Mark", +"N", "Number", +"Nd", "Decimal_Number", +"Nl", "Letter_Number", +"No", "Other_Number", +"P", "Punctuation", +"Pc", "Connector_Punctuation", +"Pd", "Dash_Punctuation", +"Pe", "Close_Punctuation", +"Pf", "Final_Punctuation", +"Pi", "Initial_Punctuation", +"Po", "Other_Punctuation", +"Ps", "Open_Punctuation", +"S", "Symbol", +"Sc", "Currency_Symbol", +"Sk", "Modifier_Symbol", +"Sm", "Math_Symbol", +"So", "Other_Symbol", +"Z", "Separator", +"Zl", "Line_Separator", +"Zp", "Paragraph_Separator", +"Zs", "Space_Separator" +}; +static SC_PROPERTY_VALUES: Set<&'static str> = phf_set! { +"Adlm", "Adlam", +"Aghb", "Caucasian_Albanian", +"Ahom", +"Arab", "Arabic", +"Armi", "Imperial_Aramaic", +"Armn", "Armenian", +"Avst", "Avestan", +"Bali", "Balinese", +"Bamu", "Bamum", +"Bass", "Bassa_Vah", +"Batk", "Batak", +"Beng", "Bengali", +"Bhks", "Bhaiksuki", +"Bopo", "Bopomofo", +"Brah", "Brahmi", +"Brai", "Braille", +"Bugi", "Buginese", +"Buhd", "Buhid", +"Cakm", "Chakma", +"Cans", "Canadian_Aboriginal", +"Cari", "Carian", +"Cham", +"Cher", "Cherokee", +"Chrs", "Chorasmian", +"Copt", "Coptic", +"Cpmn", "Cypro_Minoan", +"Cprt", "Cypriot", +"Cyrl", "Cyrillic", +"Deva", "Devanagari", +"Diak", "Dives_Akuru", +"Dogr", "Dogra", +"Dsrt", "Deseret", +"Dupl", "Duployan", +"Egyp", "Egyptian_Hieroglyphs", +"Elba", "Elbasan", +"Elym", "Elymaic", +"Ethi", "Ethiopic", +"Geor", "Georgian", +"Glag", "Glagolitic", +"Gong", "Gunjala_Gondi", +"Gonm", "Masaram_Gondi", +"Goth", "Gothic", +"Gran", "Grantha", +"Grek", "Greek", +"Gujr", "Gujarati", +"Guru", "Gurmukhi", +"Hang", "Hangul", +"Hani", "Han", +"Hano", "Hanunoo", +"Hatr", "Hatran", +"Hebr", "Hebrew", +"Hira", "Hiragana", +"Hluw", "Anatolian_Hieroglyphs", +"Hmng", "Pahawh_Hmong", +"Hmnp", "Nyiakeng_Puachue_Hmong", +"Hrkt", "Katakana_Or_Hiragana", +"Hung", "Old_Hungarian", +"Ital", "Old_Italic", +"Java", "Javanese", +"Kali", "Kayah_Li", +"Kana", "Katakana", +"Kawi", +"Khar", "Kharoshthi", +"Khmr", "Khmer", +"Khoj", "Khojki", +"Kits", "Khitan_Small_Script", +"Knda", "Kannada", +"Kthi", "Kaithi", +"Lana", "Tai_Tham", +"Laoo", "Lao", +"Latn", "Latin", +"Lepc", "Lepcha", +"Limb", "Limbu", +"Lina", "Linear_A", +"Linb", "Linear_B", +"Lisu", +"Lyci", "Lycian", +"Lydi", "Lydian", +"Mahj", "Mahajani", +"Maka", "Makasar", +"Mand", "Mandaic", +"Mani", "Manichaean", +"Marc", "Marchen", +"Medf", "Medefaidrin", +"Mend", "Mende_Kikakui", +"Merc", "Meroitic_Cursive", +"Mero", "Meroitic_Hieroglyphs", +"Mlym", "Malayalam", +"Modi", +"Mong", "Mongolian", +"Mroo", "Mro", +"Mtei", "Meetei_Mayek", +"Mult", "Multani", +"Mymr", "Myanmar", +"Nagm", "Nag_Mundari", +"Nand", "Nandinagari", +"Narb", "Old_North_Arabian", +"Nbat", "Nabataean", +"Newa", +"Nkoo", "Nko", +"Nshu", "Nushu", +"Ogam", "Ogham", +"Olck", "Ol_Chiki", +"Orkh", "Old_Turkic", +"Orya", "Oriya", +"Osge", "Osage", +"Osma", "Osmanya", +"Ougr", "Old_Uyghur", +"Palm", "Palmyrene", +"Pauc", "Pau_Cin_Hau", +"Perm", "Old_Permic", +"Phag", "Phags_Pa", +"Phli", "Inscriptional_Pahlavi", +"Phlp", "Psalter_Pahlavi", +"Phnx", "Phoenician", +"Plrd", "Miao", +"Prti", "Inscriptional_Parthian", +"Rjng", "Rejang", +"Rohg", "Hanifi_Rohingya", +"Runr", "Runic", +"Samr", "Samaritan", +"Sarb", "Old_South_Arabian", +"Saur", "Saurashtra", +"Sgnw", "SignWriting", +"Shaw", "Shavian", +"Shrd", "Sharada", +"Sidd", "Siddham", +"Sind", "Khudawadi", +"Sinh", "Sinhala", +"Sogd", "Sogdian", +"Sogo", "Old_Sogdian", +"Sora", "Sora_Sompeng", +"Soyo", "Soyombo", +"Sund", "Sundanese", +"Sylo", "Syloti_Nagri", +"Syrc", "Syriac", +"Tagb", "Tagbanwa", +"Takr", "Takri", +"Tale", "Tai_Le", +"Talu", "New_Tai_Lue", +"Taml", "Tamil", +"Tang", "Tangut", +"Tavt", "Tai_Viet", +"Telu", "Telugu", +"Tfng", "Tifinagh", +"Tglg", "Tagalog", +"Thaa", "Thaana", +"Thai", +"Tibt", "Tibetan", +"Tirh", "Tirhuta", +"Tnsa", "Tangsa", +"Toto", +"Ugar", "Ugaritic", +"Vaii", "Vai", +"Vith", "Vithkuqi", +"Wara", "Warang_Citi", +"Wcho", "Wancho", +"Xpeo", "Old_Persian", +"Xsux", "Cuneiform", +"Yezi", "Yezidi", +"Yiii", "Yi", +"Zanb", "Zanabazar_Square", +"Zinh", "Inherited", +"Zyyy", "Common", +"Zzzz", "Unknown" +}; +static SCX_PROPERTY_VALUES: Set<&'static str> = phf_set! { +// Empty +}; + +// Table 66: Binary Unicode property aliases +// https://tc39.es/ecma262/2024/multipage/text-processing.html#table-binary-unicode-properties +static BINARY_UNICODE_PROPERTIES: Set<&'static str> = phf_set! { +"ASCII", +"ASCII_Hex_Digit", +"AHex", +"Alphabetic", +"Alpha", +"Any", +"Assigned", +"Bidi_Control", +"Bidi_C", +"Bidi_Mirrored", +"Bidi_M", +"Case_Ignorable", +"CI", +"Cased", +"Changes_When_Casefolded", +"CWCF", +"Changes_When_Casemapped", +"CWCM", +"Changes_When_Lowercased", +"CWL", +"Changes_When_NFKC_Casefolded", +"CWKCF", +"Changes_When_Titlecased", +"CWT", +"Changes_When_Uppercased", +"CWU", +"Dash", +"Default_Ignorable_Code_Point", +"DI", +"Deprecated", +"Dep", +"Diacritic", +"Dia", +"Emoji", +"Emoji_Component", +"EComp", +"Emoji_Modifier", +"EMod", +"Emoji_Modifier_Base", +"EBase", +"Emoji_Presentation", +"EPres", +"Extended_Pictographic", +"ExtPict", +"Extender", +"Ext", +"Grapheme_Base", +"Gr_Base", +"Grapheme_Extend", +"Gr_Ext", +"Hex_Digit", +"Hex", +"IDS_Binary_Operator", +"IDSB", +"IDS_Trinary_Operator", +"IDST", +"ID_Continue", +"IDC", +"ID_Start", +"IDS", +"Ideographic", +"Ideo", +"Join_Control", +"Join_C", +"Logical_Order_Exception", +"LOE", +"Lowercase", +"Lower", +"Math", +"Noncharacter_Code_Point", +"NChar", +"Pattern_Syntax", +"Pat_Syn", +"Pattern_White_Space", +"Pat_WS", +"Quotation_Mark", +"QMark", +"Radical", +"Regional_Indicator", +"RI", +"Sentence_Terminal", +"STerm", +"Soft_Dotted", +"SD", +"Terminal_Punctuation", +"Term", +"Unified_Ideograph", +"UIdeo", +"Uppercase", +"Upper", +"Variation_Selector", +"VS", +"White_Space", +"space", +"XID_Continue", +"XIDC", +"XID_Start", +"XIDS", +}; + +// Table 67: Binary Unicode properties of strings +// https://tc39.es/ecma262/2024/multipage/text-processing.html#table-binary-unicode-properties-of-strings +static BINARY_UNICODE_PROPERTIES_OF_STRINGS: Set<&'static str> = phf_set! { +"Basic_Emoji", +"Emoji_Keycap_Sequence", +"RGI_Emoji_Modifier_Sequence", +"RGI_Emoji_Flag_Sequence", +"RGI_Emoji_Tag_Sequence", +"RGI_Emoji_ZWJ_Sequence", +"RGI_Emoji", +}; +// spellchecker:on diff --git a/crates/oxc_regexp_parser/src/flag_parser.rs b/crates/oxc_regexp_parser/src/flag_parser.rs new file mode 100644 index 0000000000000..90f8b0cffdad4 --- /dev/null +++ b/crates/oxc_regexp_parser/src/flag_parser.rs @@ -0,0 +1,69 @@ +use oxc_allocator::Allocator; +use oxc_diagnostics::{OxcDiagnostic, Result}; +use rustc_hash::FxHashSet; + +use crate::{ast, options::ParserOptions, span::SpanFactory}; + +pub struct FlagsParser<'a> { + source_text: &'a str, + // options: ParserOptions, + span_factory: SpanFactory, +} + +impl<'a> FlagsParser<'a> { + pub fn new(_allocator: &'a Allocator, source_text: &'a str, options: ParserOptions) -> Self { + Self { + source_text, + // options, + span_factory: SpanFactory::new(options.span_offset), + } + } + + pub fn parse(&mut self) -> Result { + let mut existing_flags = FxHashSet::default(); + + let mut global = false; + let mut ignore_case = false; + let mut multiline = false; + let mut unicode = false; + let mut sticky = false; + let mut dot_all = false; + let mut has_indices = false; + let mut unicode_sets = false; + + for c in self.source_text.chars() { + if !existing_flags.insert(c) { + return Err(OxcDiagnostic::error(format!("Duplicated flag `{c}`"))); + } + + match c { + 'g' => global = true, + 'i' => ignore_case = true, + 'm' => multiline = true, + 'u' => unicode = true, + 'y' => sticky = true, + 's' => dot_all = true, + 'd' => has_indices = true, + 'v' => unicode_sets = true, + _ => return Err(OxcDiagnostic::error(format!("Invalid flag `{c}`"))), + } + } + + // This should be a `SyntaxError` + if unicode && unicode_sets { + return Err(OxcDiagnostic::error("Invalid regular expression flags")); + } + + Ok(ast::Flags { + span: self.span_factory.create(0, self.source_text.len()), + global, + ignore_case, + multiline, + unicode, + sticky, + dot_all, + has_indices, + unicode_sets, + }) + } +} diff --git a/crates/oxc_regexp_parser/src/lib.rs b/crates/oxc_regexp_parser/src/lib.rs new file mode 100644 index 0000000000000..ae2f1c0a58bc0 --- /dev/null +++ b/crates/oxc_regexp_parser/src/lib.rs @@ -0,0 +1,13 @@ +#![allow(clippy::missing_errors_doc)] + +pub mod ast; +mod body_parser; +mod flag_parser; +mod literal_parser; +mod options; +mod span; + +pub use crate::body_parser::PatternParser; +pub use crate::flag_parser::FlagsParser; +pub use crate::literal_parser::Parser; +pub use crate::options::ParserOptions; diff --git a/crates/oxc_regexp_parser/src/literal_parser.rs b/crates/oxc_regexp_parser/src/literal_parser.rs new file mode 100644 index 0000000000000..64d694aee05ad --- /dev/null +++ b/crates/oxc_regexp_parser/src/literal_parser.rs @@ -0,0 +1,161 @@ +use oxc_allocator::Allocator; +use oxc_diagnostics::{OxcDiagnostic, Result}; + +use crate::{ + ast, body_parser::PatternParser, flag_parser::FlagsParser, options::ParserOptions, + span::SpanFactory, +}; + +/// LiteralParser +pub struct Parser<'a> { + allocator: &'a Allocator, + source_text: &'a str, + options: ParserOptions, + span_factory: SpanFactory, +} + +impl<'a> Parser<'a> { + pub fn new(allocator: &'a Allocator, source_text: &'a str, options: ParserOptions) -> Self { + Self { + allocator, + source_text, + options, + span_factory: SpanFactory::new(options.span_offset), + } + } + + pub fn parse(self) -> Result> { + // Precheck if the source text is a valid regular expression literal + // If valid, parse the pattern and flags with returned span offsets + let (body_start_offset, body_end_offset, flag_start_offset) = + parse_reg_exp_literal(self.source_text)?; + + // Parse flags first to know if unicode mode is enabled or not + let flags = FlagsParser::new( + self.allocator, + &self.source_text[flag_start_offset..], + #[allow(clippy::cast_possible_truncation)] + self.options.with_span_offset(self.options.span_offset + flag_start_offset as u32), + ) + .parse()?; + + // Then parse the pattern with the flags + let pattern_options = match (flags.unicode, flags.unicode_sets) { + (true, false) => self.options.with_unicode_mode(), + (_, true) => self.options.with_unicode_sets_mode(), + _ => self.options, + }; + + let pattern = PatternParser::new( + self.allocator, + &self.source_text[body_start_offset..body_end_offset], + #[allow(clippy::cast_possible_truncation)] + pattern_options.with_span_offset(self.options.span_offset + body_start_offset as u32), + ) + .parse()?; + + Ok(ast::RegExpLiteral { + span: self.span_factory.create(0, self.source_text.len()), + pattern, + flags, + }) + } +} + +/// Check passed source text is a valid regular expression literal. +/// ``` +/// / RegularExpressionBody / RegularExpressionFlags +/// ``` +/// Returns `(body_start_offset, body_end_offset, flag_start_offset)`. +fn parse_reg_exp_literal(source_text: &str) -> Result<(usize, usize, usize)> { + let mut offset = 0; + let mut chars = source_text.chars().peekable(); + + let Some('/') = chars.next() else { + return Err(OxcDiagnostic::error("Unexpected character")); + }; + offset += 1; // '/' + + let body_start = offset; + + let mut in_escape = false; + let mut in_character_class = false; + loop { + match chars.peek() { + // Line terminators are not allowed + Some('\u{a}' | '\u{d}' | '\u{2028}' | '\u{2029}') | None => { + let kind = + if in_character_class { "character class" } else { "regular expression" }; + return Err(OxcDiagnostic::error(format!("Unterminated {kind}"))); + } + Some(&ch) => { + if in_escape { + in_escape = false; + } else if ch == '\\' { + in_escape = true; + } else if ch == '[' { + in_character_class = true; + } else if ch == ']' { + in_character_class = false; + } else if ch == '/' && !in_character_class + // `*` is not allowed as `RegularExpressionFirstChar` + || offset == body_start && ch == '*' + { + break; + } + + offset += ch.len_utf8(); + } + } + + chars.next(); + } + + let Some('/') = chars.next() else { + return Err(OxcDiagnostic::error("Unexpected character")); + }; + let body_end = offset; + + if body_end == body_start { + return Err(OxcDiagnostic::error("Empty")); + } + + Ok((body_start, body_end, body_end + 1)) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn parse_valid_reg_exp_literal() { + for literal_text in [ + "/(?:)/", + "/abc/", + "/abcd/igsmv", + r"/\w+/u", + r"/foo\/bar|baz/i", + "/[a-z]/", + "/正規表現/u", + "/あっち👈🏻/i", + "/👈🏻こっち/u", + ] { + let (body_start_offset, body_end_offset, flag_start_offset) = + parse_reg_exp_literal(literal_text) + .unwrap_or_else(|_| panic!("{literal_text} should be parsed")); + + let body_text = &literal_text[body_start_offset..body_end_offset]; + let flag_text = &literal_text[flag_start_offset..]; + assert_eq!(format!("/{body_text}/{flag_text}",), literal_text); + } + } + + #[test] + fn parse_invalid_reg_exp_literal() { + for literal_text in + ["", "foo", ":(", "a\nb", "/", "/x", "/y\nz/", "/1[\n]/", "//", "///", "/*abc/", "/\\/"] + { + assert!(parse_reg_exp_literal(literal_text).is_err()); + } + } +} diff --git a/crates/oxc_regexp_parser/src/options.rs b/crates/oxc_regexp_parser/src/options.rs new file mode 100644 index 0000000000000..02280ed3378f1 --- /dev/null +++ b/crates/oxc_regexp_parser/src/options.rs @@ -0,0 +1,25 @@ +#[derive(Clone, Copy, Debug, Default)] +pub struct ParserOptions { + /// Used to adjust Span positions to fit the global source code. + pub span_offset: u32, + /// Unicode mode enabled or not. + pub unicode_mode: bool, + /// Extended Unicode mode enabled or not. + pub unicode_sets_mode: bool, +} + +impl ParserOptions { + #[must_use] + pub fn with_span_offset(self, span_offset: u32) -> ParserOptions { + ParserOptions { span_offset, ..self } + } + + #[must_use] + pub fn with_unicode_mode(self) -> ParserOptions { + ParserOptions { unicode_mode: true, ..self } + } + #[must_use] + pub fn with_unicode_sets_mode(self) -> ParserOptions { + ParserOptions { unicode_mode: true, unicode_sets_mode: true, ..self } + } +} diff --git a/crates/oxc_regexp_parser/src/span.rs b/crates/oxc_regexp_parser/src/span.rs new file mode 100644 index 0000000000000..ed57d43c54159 --- /dev/null +++ b/crates/oxc_regexp_parser/src/span.rs @@ -0,0 +1,16 @@ +use oxc_span::Span; + +pub struct SpanFactory { + span_offset: u32, +} + +impl SpanFactory { + pub fn new(span_offset: u32) -> Self { + Self { span_offset } + } + + #[allow(clippy::cast_possible_truncation)] + pub fn create(&self, start: usize, end: usize) -> Span { + Span::new((start as u32) + self.span_offset, (end as u32) + self.span_offset) + } +} diff --git a/tasks/coverage/codegen_test262.snap b/tasks/coverage/codegen_test262.snap index 7a9970a818292..daa9fc5f1be03 100644 --- a/tasks/coverage/codegen_test262.snap +++ b/tasks/coverage/codegen_test262.snap @@ -1,5 +1,5 @@ commit: a1587416 codegen_test262 Summary: -AST Parsed : 46406/46406 (100.00%) -Positive Passed: 46406/46406 (100.00%) +AST Parsed : 46466/46466 (100.00%) +Positive Passed: 46466/46466 (100.00%) diff --git a/tasks/coverage/minifier_test262.snap b/tasks/coverage/minifier_test262.snap index 6f4e52f07c749..2fa5198dc72ab 100644 --- a/tasks/coverage/minifier_test262.snap +++ b/tasks/coverage/minifier_test262.snap @@ -1,5 +1,5 @@ commit: a1587416 minifier_test262 Summary: -AST Parsed : 46406/46406 (100.00%) -Positive Passed: 46406/46406 (100.00%) +AST Parsed : 46466/46466 (100.00%) +Positive Passed: 46466/46466 (100.00%) diff --git a/tasks/coverage/parser_babel.snap b/tasks/coverage/parser_babel.snap index aa6945a802af7..25aad3e883271 100644 --- a/tasks/coverage/parser_babel.snap +++ b/tasks/coverage/parser_babel.snap @@ -1717,6 +1717,13 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" 2 │ / ╰──── + × Invalid atom escape + ╭─[core/uncategorised/441/input.js:1:3] + 1 │ /a\ + · ─ + 2 │ / + ╰──── + × Unexpected token ╭─[core/uncategorised/441/input.js:2:2] 1 │ /a\ @@ -8953,6 +8960,13 @@ Expect to Parse: "typescript/types/const-type-parameters-babel-7/input.ts" 2 │ / ╰──── + × Invalid atom escape + ╭─[esprima/invalid-syntax/migrated_0157/input.js:1:3] + 1 │ /a\ + · ─ + 2 │ / + ╰──── + × Unexpected token ╭─[esprima/invalid-syntax/migrated_0157/input.js:3:1] 2 │ / diff --git a/tasks/coverage/parser_test262.snap b/tasks/coverage/parser_test262.snap index 08ebbf9d7b195..1aec5d4bf1250 100644 --- a/tasks/coverage/parser_test262.snap +++ b/tasks/coverage/parser_test262.snap @@ -1,19016 +1,23952 @@ commit: a1587416 parser_test262 Summary: -AST Parsed : 45859/45859 (100.00%) -Positive Passed: 45859/45859 (100.00%) -Negative Passed: 3925/3929 (99.90%) +AST Parsed : 46466/46466 (100.00%) +Positive Passed: 46377/46466 (99.81%) +Negative Passed: 4301/4307 (99.86%) Expect Syntax Error: "language/import/import-assertions/json-invalid.js" Expect Syntax Error: "language/import/import-assertions/json-named-bindings.js" Expect Syntax Error: "language/import/import-attributes/json-invalid.js" Expect Syntax Error: "language/import/import-attributes/json-named-bindings.js" - - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[annexB/language/expressions/template-literal/legacy-octal-escape-sequence-strict.js:18:4] - 17 │ - 18 │ `${'\07'}`; - · ───── +Expect Syntax Error: "language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4-u.js" +Expect Syntax Error: "language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4.js" +Expect to Parse: "annexB/built-ins/RegExp/incomplete_hex_unicode_escape.js" + + × Invalid hexadecimal escape + ╭─[annexB/built-ins/RegExp/incomplete_hex_unicode_escape.js:13:9] + 12 │ // Hex escape + 13 │ assert(/\x/.test("x"), "/\\x/"); + · ── + 14 │ assert(/\xa/.test("xa"), "/\\xa/"); ╰──── - help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[annexB/language/statements/for-in/bare-initializer.js:15:6] - 14 │ - 15 │ for (a = 0 in {}); - · ───── + × Invalid hexadecimal escape + ╭─[annexB/built-ins/RegExp/incomplete_hex_unicode_escape.js:14:9] + 13 │ assert(/\x/.test("x"), "/\\x/"); + 14 │ assert(/\xa/.test("xa"), "/\\xa/"); + · ── + 15 │ ╰──── +Expect to Parse: "annexB/language/literals/regexp/class-escape.js" - × for-in loop variable declaration may not have an initializer - ╭─[annexB/language/statements/for-in/const-initializer.js:14:6] - 13 │ - 14 │ for (const a = 0 in {}); - · ─────────── - 15 │ + × Invalid atom escape + ╭─[annexB/language/literals/regexp/class-escape.js:30:10] + 29 │ + 30 │ match = /\c0/.exec('\x0f\x10\x11'); + · ─ + 31 │ assert.sameValue(match, null, '\\c0 outside of CharacterClass'); ╰──── - × for-in loop variable declaration may not have an initializer - ╭─[annexB/language/statements/for-in/let-initializer.js:14:6] - 13 │ - 14 │ for (let a = 0 in {}); - · ───────── - 15 │ + × Invalid atom escape + ╭─[annexB/language/literals/regexp/class-escape.js:39:10] + 38 │ + 39 │ match = /\c1/.exec('\x10\x11\x12'); + · ─ + 40 │ assert.sameValue(match, null, '\\c1 outside of CharacterClass'); ╰──── - × for-in loop variable declaration may not have an initializer - ╭─[annexB/language/statements/for-in/strict-initializer.js:15:6] - 14 │ - 15 │ for (var a = 0 in {}); - · ───────── + × Invalid atom escape + ╭─[annexB/language/literals/regexp/class-escape.js:48:10] + 47 │ + 48 │ match = /\c8/.exec('\x17\x18\x19'); + · ─ + 49 │ assert.sameValue(match, null, '\\c8 outside of CharacterClass'); ╰──── - × for-in loop variable declaration may not have an initializer - ╭─[annexB/language/statements/for-in/var-arraybindingpattern-initializer.js:14:6] - 13 │ - 14 │ for (var [a] = 0 in {}); - · ─────────── + × Invalid atom escape + ╭─[annexB/language/literals/regexp/class-escape.js:57:10] + 56 │ + 57 │ match = /\c9/.exec('\x18\x19\x1a'); + · ─ + 58 │ assert.sameValue(match, null, '\\c9 outside of CharacterClass'); ╰──── - × for-in loop variable declaration may not have an initializer - ╭─[annexB/language/statements/for-in/var-objectbindingpattern-initializer.js:14:6] - 13 │ - 14 │ for (var {a} = 0 in {}); - · ─────────── - 15 │ + × Invalid atom escape + ╭─[annexB/language/literals/regexp/class-escape.js:66:10] + 65 │ + 66 │ match = /\c_/.exec('\x1e\x1f\x20'); + · ─ + 67 │ assert.sameValue(match, null, '\\c_ outside of CharacterClass'); ╰──── +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-exec.js" - × Cannot assign to 'arguments' in strict mode - ╭─[language/arguments-object/10.5-1gs.js:17:5] - 16 │ function f_10_5_1_gs(){ - 17 │ arguments = 7; - · ───────── - 18 │ } + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-group-property-enumeration-order.js" + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-match-indices.js" + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-match.js" + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-matchall.js" + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-replace.js" + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-replaceall.js" + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-search.js" + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-split.js" + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/named-groups/duplicate-names-test.js" + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js" + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js:34:25] + 33 │ testPropertyEscapes( + 34 │ /^\p{General_Category=cntrl}+$/u, + · ───── + 35 │ matchSymbols, ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/asi/S7.9.2_A1_T1.js:16:4] - 15 │ //CHECK#1 - 16 │ { 1 2 } 3 - · ▲ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js:49:11] + 48 │ testPropertyEscapes( + 49 │ /^\p{gc=cntrl}+$/u, + · ───── + 50 │ matchSymbols, ╰──── - help: Try insert a semicolon here - × Expected `;` but found `)` - ╭─[language/asi/S7.9.2_A1_T3.js:17:1] - 16 │ for( a ; b - 17 │ ) - · ┬ - · ╰── `;` expected + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js:64:8] + 63 │ testPropertyEscapes( + 64 │ /^\p{cntrl}+$/u, + · ───── + 65 │ matchSymbols, ╰──── - × Unexpected token - ╭─[language/asi/S7.9.2_A1_T6.js:20:1] - 19 │ if(a>b) - 20 │ else c=d - · ──── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js:89:25] + 88 │ testPropertyEscapes( + 89 │ /^\P{General_Category=cntrl}+$/u, + · ───── + 90 │ nonMatchSymbols, ╰──── - × Unexpected token - ╭─[language/asi/S7.9_A10_T2.js:16:4] - 15 │ //CHECK#1 - 16 │ {} * 1 - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js:104:11] + 103 │ testPropertyEscapes( + 104 │ /^\P{gc=cntrl}+$/u, + · ───── + 105 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js:119:8] + 118 │ testPropertyEscapes( + 119 │ /^\P{cntrl}+$/u, + · ───── + 120 │ nonMatchSymbols, + ╰──── +Expect to Parse: "built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js" + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js:96:25] + 95 │ testPropertyEscapes( + 96 │ /^\p{General_Category=digit}+$/u, + · ───── + 97 │ matchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js:111:11] + 110 │ testPropertyEscapes( + 111 │ /^\p{gc=digit}+$/u, + · ───── + 112 │ matchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js:126:8] + 125 │ testPropertyEscapes( + 126 │ /^\p{digit}+$/u, + · ───── + 127 │ matchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js:214:25] + 213 │ testPropertyEscapes( + 214 │ /^\P{General_Category=digit}+$/u, + · ───── + 215 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js:229:11] + 228 │ testPropertyEscapes( + 229 │ /^\P{gc=digit}+$/u, + · ───── + 230 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js:244:8] + 243 │ testPropertyEscapes( + 244 │ /^\P{digit}+$/u, + · ───── + 245 │ nonMatchSymbols, + ╰──── +Expect to Parse: "built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js" + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js:343:25] + 342 │ testPropertyEscapes( + 343 │ /^\p{General_Category=Combining_Mark}+$/u, + · ────────────── + 344 │ matchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js:358:11] + 357 │ testPropertyEscapes( + 358 │ /^\p{gc=Combining_Mark}+$/u, + · ────────────── + 359 │ matchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js:373:8] + 372 │ testPropertyEscapes( + 373 │ /^\p{Combining_Mark}+$/u, + · ────────────── + 374 │ matchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js:708:25] + 707 │ testPropertyEscapes( + 708 │ /^\P{General_Category=Combining_Mark}+$/u, + · ────────────── + 709 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js:723:11] + 722 │ testPropertyEscapes( + 723 │ /^\P{gc=Combining_Mark}+$/u, + · ────────────── + 724 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js:738:8] + 737 │ testPropertyEscapes( + 738 │ /^\P{Combining_Mark}+$/u, + · ────────────── + 739 │ nonMatchSymbols, + ╰──── +Expect to Parse: "built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js" + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js:224:25] + 223 │ testPropertyEscapes( + 224 │ /^\p{General_Category=punct}+$/u, + · ───── + 225 │ matchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js:239:11] + 238 │ testPropertyEscapes( + 239 │ /^\p{gc=punct}+$/u, + · ───── + 240 │ matchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js:254:8] + 253 │ testPropertyEscapes( + 254 │ /^\p{punct}+$/u, + · ───── + 255 │ matchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js:470:25] + 469 │ testPropertyEscapes( + 470 │ /^\P{General_Category=punct}+$/u, + · ───── + 471 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js:485:11] + 484 │ testPropertyEscapes( + 485 │ /^\P{gc=punct}+$/u, + · ───── + 486 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js:500:8] + 499 │ testPropertyEscapes( + 500 │ /^\P{punct}+$/u, + · ───── + 501 │ nonMatchSymbols, + ╰──── +Expect to Parse: "built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js" + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js:35:15] + 34 │ testPropertyEscapes( + 35 │ /^\p{Script=Qaac}+$/u, + · ──── + 36 │ matchSymbols, ╰──── - × Expected `,` but found `;` - ╭─[language/asi/S7.9_A10_T4.js:16:4] - 15 │ //CHECK#1 - 16 │ ({};) * 1 - · ┬ - · ╰── `,` expected + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js:50:11] + 49 │ testPropertyEscapes( + 50 │ /^\p{sc=Qaac}+$/u, + · ──── + 51 │ matchSymbols, ╰──── - × Unexpected token - ╭─[language/asi/S7.9_A10_T6.js:17:2] - 16 │ {} - 17 │ * 1 - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js:77:15] + 76 │ testPropertyEscapes( + 77 │ /^\P{Script=Qaac}+$/u, + · ──── + 78 │ nonMatchSymbols, ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/asi/S7.9_A10_T8.js:16:3] - 15 │ //CHECK#1 - 16 │ {1 2} 3 - · ▲ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js:92:11] + 91 │ testPropertyEscapes( + 92 │ /^\P{sc=Qaac}+$/u, + · ──── + 93 │ nonMatchSymbols, ╰──── - help: Try insert a semicolon here +Expect to Parse: "built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js" - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/asi/S7.9_A11_T4.js:17:17] - 16 │ var x = 0; - 17 │ if (false) x = 1 else x = -1 - · ▲ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js:62:15] + 61 │ testPropertyEscapes( + 62 │ /^\p{Script=Qaai}+$/u, + · ──── + 63 │ matchSymbols, ╰──── - help: Try insert a semicolon here - × Unexpected token - ╭─[language/asi/S7.9_A11_T8.js:16:1] - 15 │ if (false) {}; - 16 │ else {} - · ──── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js:77:11] + 76 │ testPropertyEscapes( + 77 │ /^\p{sc=Qaai}+$/u, + · ──── + 78 │ matchSymbols, ╰──── - × Illegal newline after throw - ╭─[language/asi/S7.9_A4.js:17:3] - 16 │ try { - 17 │ throw - · ──┬── - · ╰── throw starts here - 18 │ 1; - · ┬ - · ╰── A newline is not expected here - 19 │ } catch(e) { + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js:131:15] + 130 │ testPropertyEscapes( + 131 │ /^\P{Script=Qaai}+$/u, + · ──── + 132 │ nonMatchSymbols, + ╰──── + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js:146:11] + 145 │ testPropertyEscapes( + 146 │ /^\P{sc=Qaai}+$/u, + · ──── + 147 │ nonMatchSymbols, + ╰──── +Expect to Parse: "built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js" + + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js:36:26] + 35 │ testPropertyEscapes( + 36 │ /^\p{Script_Extensions=Qaac}+$/u, + · ──── + 37 │ matchSymbols, ╰──── - × Unexpected token - ╭─[language/asi/S7.9_A5.1_T1.js:17:3] - 16 │ x - 17 │ ++; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js:51:12] + 50 │ testPropertyEscapes( + 51 │ /^\p{scx=Qaac}+$/u, + · ──── + 52 │ matchSymbols, ╰──── - × Unexpected token - ╭─[language/asi/S7.9_A5.3_T1.js:18:3] - 17 │ x - 18 │ --; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js:79:26] + 78 │ testPropertyEscapes( + 79 │ /^\P{Script_Extensions=Qaac}+$/u, + · ──── + 80 │ nonMatchSymbols, ╰──── - × Cannot assign to this expression - ╭─[language/asi/S7.9_A5.7_T1.js:23:1] - 22 │ x - 23 │ ╭─▶ ++ - 24 │ │ ++ - 25 │ ╰─▶ y + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js:94:12] + 93 │ testPropertyEscapes( + 94 │ /^\P{scx=Qaac}+$/u, + · ──── + 95 │ nonMatchSymbols, ╰──── +Expect to Parse: "built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js" - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T1.js:20:1] - 19 │ for(; - 20 │ ) { - · ┬ - · ╰── `;` expected - 21 │ break; + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js:53:26] + 52 │ testPropertyEscapes( + 53 │ /^\p{Script_Extensions=Qaai}+$/u, + · ──── + 54 │ matchSymbols, ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T10.js:21:2] - 20 │ false - 21 │ ;) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js:68:12] + 67 │ testPropertyEscapes( + 68 │ /^\p{scx=Qaai}+$/u, + · ──── + 69 │ matchSymbols, ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T2.js:21:1] - 20 │ ; - 21 │ ) { - · ┬ - · ╰── `;` expected - 22 │ break; - ╰──── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js:113:26] + 112 │ testPropertyEscapes( + 113 │ /^\P{Script_Extensions=Qaai}+$/u, + · ──── + 114 │ nonMatchSymbols, + ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T3.js:20:2] - 19 │ for( - 20 │ ;) { - · ┬ - · ╰── `;` expected - 21 │ break; - ╰──── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js:128:12] + 127 │ testPropertyEscapes( + 128 │ /^\P{scx=Qaai}+$/u, + · ──── + 129 │ nonMatchSymbols, + ╰──── +Expect to Parse: "built-ins/RegExp/prototype/exec/duplicate-named-groups-properties.js" - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T4.js:21:2] - 20 │ - 21 │ ;) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/prototype/exec/duplicate-named-indices-groups-properties.js" + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-dotAll-property.js" + + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-dotAll-property.js:36:12] + 35 │ + 36 │ var re1 = /(?s:)/; + · ── + 37 │ assert(!re1.dotAll, "RegExp instance dotAll flag should not be set"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T5.js:20:1] - 19 │ for(false;false - 20 │ ) { - · ┬ - · ╰── `;` expected - 21 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-dotAll-property.js:42:12] + 41 │ + 42 │ var re3 = /(?s-:)/; + · ── + 43 │ assert(!re3.dotAll, "RegExp instance dotAll flag should not be set"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-ignoreCase-flag.js" - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T6.js:21:1] - 20 │ false - 21 │ ) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-ignoreCase-flag.js:42:12] + 41 │ + 42 │ var re1 = /(?s:.es)/; + · ── + 43 │ assert(re1.test("aes"), "s should match s in modified group"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T7.js:21:1] - 20 │ ; - 21 │ ) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-ignoreCase-flag.js:48:12] + 47 │ + 48 │ var re2 = /(?s:.es)/i; + · ── + 49 │ assert(re2.test("aes"), "s should match s in modified group"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T8.js:21:1] - 20 │ ;false - 21 │ ) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-ignoreCase-flag.js:54:12] + 53 │ + 54 │ var re3 = /(?s-:.es)/; + · ── + 55 │ assert(re3.test("aes"), "s should match s in modified group"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.2_T9.js:20:7] - 19 │ for( - 20 │ ;false) { - · ┬ - · ╰── `;` expected - 21 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-ignoreCase-flag.js:60:12] + 59 │ + 60 │ var re4 = /(?s-:.es)/i; + · ── + 61 │ assert(re4.test("aes"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-multiline-flag.js" - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.3_T1.js:20:1] - 19 │ for( - 20 │ ) { - · ┬ - · ╰── `;` expected - 21 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-multiline-flag.js:42:12] + 41 │ + 42 │ var re1 = /(?s:.es$)/; + · ── + 43 │ assert(re1.test("\nes"), ". should match newline in modified group"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.3_T2.js:21:1] - 20 │ - 21 │ ) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-multiline-flag.js:46:12] + 45 │ + 46 │ var re2 = /(?s:.es$)/m; + · ── + 47 │ assert(re2.test("\nes"), ". should match newline in modified group"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.3_T3.js:22:1] - 21 │ - 22 │ ) { - · ┬ - · ╰── `;` expected - 23 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-multiline-flag.js:50:12] + 49 │ + 50 │ var re3 = /(?s-:.es$)/; + · ── + 51 │ assert(re3.test("\nes"), ". should match newline in modified group"); ╰──── - × Expected `;` but found `)` - ╭─[language/asi/S7.9_A6.3_T4.js:21:1] - 20 │ false - 21 │ ) { - · ┬ - · ╰── `;` expected - 22 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll-does-not-affect-multiline-flag.js:54:12] + 53 │ + 54 │ var re4 = /(?s-:.es$)/m; + · ── + 55 │ assert(re4.test("\nes"), ". should match newline in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-dotAll.js" - × Expected `;` but found `false` - ╭─[language/asi/S7.9_A6.3_T5.js:20:5] - 19 │ for(false - 20 │ false - · ──┬── - · ╰── `;` expected - 21 │ ) { + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll.js:36:12] + 35 │ + 36 │ var re1 = /(?s:^.$)/; + · ── + 37 │ assert(re1.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── - × Expected `;` but found `false` - ╭─[language/asi/S7.9_A6.3_T6.js:21:5] - 20 │ false - 21 │ false - · ──┬── - · ╰── `;` expected - 22 │ ) { + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-dotAll.js:70:12] + 69 │ + 70 │ var re3 = /(?s-:^.$)/; + · ── + 71 │ assert(re3.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-backreferences.js" - × Expected `;` but found `false` - ╭─[language/asi/S7.9_A6.3_T7.js:21:5] - 20 │ false - 21 │ false - · ──┬── - · ╰── `;` expected - 22 │ false + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-backreferences.js:42:15] + 41 │ + 42 │ var re1 = /(a)(?i:\1)/; + · ── + 43 │ assert(!re1.test("AA"), "a should not match first A"); ╰──── - × Expected `)` but found `;` - ╭─[language/asi/S7.9_A6.4_T1.js:18:22] - 17 │ //CHECK#1 - 18 │ for(false;false;false;) { - · ┬ - · ╰── `)` expected - 19 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-backreferences.js:48:15] + 47 │ + 48 │ var re2 = /(a)(?i-:\1)/; + · ── + 49 │ assert(!re2.test("AA"), "a should not match first A"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterClasses.js" - × Unexpected token - ╭─[language/asi/S7.9_A6.4_T2.js:18:17] - 17 │ //CHECK#1 - 18 │ for(false;false;;false) { - · ─ - 19 │ break; + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterClasses.js:42:12] + 41 │ + 42 │ var re1 = /(?i:[ab])c/; + · ── + 43 │ assert(re1.test("ac"), "[ab] should match a"); ╰──── - × Unexpected token - ╭─[language/asi/S7.9_A9_T6.js:18:1] - 17 │ while (false) + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterClasses.js:48:12] + 47 │ + 48 │ var re2 = /(?i-:[ab])c/; + · ── + 49 │ assert(re2.test("ac"), "[ab] should match a"); ╰──── - × Unexpected token - ╭─[language/asi/S7.9_A9_T7.js:19:1] - 18 │ while (false) + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterClasses.js:54:12] + 53 │ + 54 │ var re3 = /(?i:[^ab])c/; + · ── + 55 │ assert(!re3.test("ac"), "[^ab] should not match a"); ╰──── - × Expected `while` but found `;` - ╭─[language/asi/S7.9_A9_T8.js:16:6] - 15 │ //CHECK#1 - 16 │ do {}; - · ┬ - · ╰── `while` expected - 17 │ while (false) + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterClasses.js:60:12] + 59 │ + 60 │ var re4 = /(?i-:[^ab])c/; + · ── + 61 │ assert(!re4.test("ac"), "[^ab] should not match a"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js" - × for-in loop variable declaration may not have an initializer - ╭─[language/block-scope/syntax/for-in/disallow-initialization-assignment.js:14:6] - 13 │ $DONOTEVALUATE(); - 14 │ for (let x = 3 in {}) { } - · ───────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js:42:12] + 41 │ + 42 │ var re1 = /(?i:\x61)b/; + · ── + 43 │ assert(re1.test("ab"), "\\x61 should match a"); ╰──── - × Only a single declaration is allowed in a `for...in` statement - ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-and-without-initializer.js:14:6] - 13 │ $DONOTEVALUATE(); - 14 │ for (let x = 3, y in {}) { } - · ──────────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js:46:12] + 45 │ + 46 │ var re2 = /(?i:\u0061)b/; + · ── + 47 │ assert(re2.test("ab"), "\\u0061 should match a"); ╰──── - × Only a single declaration is allowed in a `for...in` statement - ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-initializer.js:14:6] - 13 │ $DONOTEVALUATE(); - 14 │ for (let x = 3, y = 4 in {}) { } - · ──────────────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js:50:12] + 49 │ + 50 │ var re3 = /(?i:\u{0061})b/u; + · ── + 51 │ assert(re3.test("ab"), "\\u0061 should match a"); ╰──── - × Only a single declaration is allowed in a `for...in` statement - ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-without-and-with-initializer.js:14:6] - 13 │ $DONOTEVALUATE(); - 14 │ for (let x, y = 4 in {}) { } - · ──────────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js:54:12] + 53 │ + 54 │ var re4 = /(?i-:\x61)b/; + · ── + 55 │ assert(re4.test("ab"), "\\x61 should match a"); ╰──── - × Only a single declaration is allowed in a `for...in` statement - ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings.js:14:6] - 13 │ $DONOTEVALUATE(); - 14 │ for (let x, y in {}) { } - · ──────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js:58:12] + 57 │ + 58 │ var re5 = /(?i-:\u0061)b/; + · ── + 59 │ assert(re5.test("ab"), "\\u0061 should match a"); ╰──── - × Invalid function declaration - ╭─[language/block-scope/syntax/function-declarations/in-statement-position-do-statement-while-expression.js:14:4] - 13 │ $DONOTEVALUATE(); - 14 │ do function g() {} while (false) - · ─────────────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-characterEscapes.js:62:12] + 61 │ + 62 │ var re6 = /(?i-:\u{0061})b/u; + · ── + 63 │ assert(re6.test("ab"), "\\u0061 should match a"); ╰──── - help: In strict mode code, functions can only be declared at top level or inside a block +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js" - × Invalid function declaration - ╭─[language/block-scope/syntax/function-declarations/in-statement-position-for-statement.js:14:15] - 13 │ $DONOTEVALUATE(); - 14 │ for (;false;) function g() {} - · ─────────────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js:48:12] + 47 │ + 48 │ var re1 = /(?i:\b)/; + · ── + 49 │ assert(re1.test("A"), "\\b should match after A"); ╰──── - help: In strict mode code, functions can only be declared at top level or inside a block - × Invalid function declaration - ╭─[language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement-else-statement.js:15:19] - 14 │ $DONOTEVALUATE(); - 15 │ if (true) {} else function g() {} - · ─────────────── - 16 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js:54:12] + 53 │ + 54 │ var re2 = /(?i:\b)/u; + · ── + 55 │ assert(re2.test("A"), "\\b should match after A"); ╰──── - help: In strict mode code, functions can only be declared at top level or inside a block - × Invalid function declaration - ╭─[language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement.js:15:11] - 14 │ $DONOTEVALUATE(); - 15 │ if (true) function g() {} - · ─────────────── - 16 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js:62:12] + 61 │ + 62 │ var re3 = /(?i-:\b)/; + · ── + 63 │ assert(re3.test("A"), "\\b should match after A"); ╰──── - help: In strict mode code, functions can only be declared at top level or inside a block - × Invalid function declaration - ╭─[language/block-scope/syntax/function-declarations/in-statement-position-while-expression-statement.js:14:15] - 13 │ $DONOTEVALUATE(); - 14 │ while (false) function g() {} - · ─────────────── - 15 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js:68:12] + 67 │ + 68 │ var re4 = /(?i-:\b)/u; + · ── + 69 │ assert(re4.test("A"), "\\b should match after A"); ╰──── - help: In strict mode code, functions can only be declared at top level or inside a block +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-p.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-function.js:23:18] - 22 │ - 23 │ { async function f() {} async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-p.js:48:12] + 47 │ + 48 │ var re1 = /(?i:\p{Lu})/u; + · ── + 49 │ assert(re1.test("A"), "\\p{Lu} should match A"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-generator.js:23:18] - 22 │ - 23 │ { async function f() {} async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-p.js:54:12] + 53 │ + 54 │ var re2 = /(?i-:\p{Lu})/u; + · ── + 55 │ assert(re2.test("A"), "\\p{Lu} should match A"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-class.js:23:18] - 22 │ - 23 │ { async function f() {} class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js:48:12] + 47 │ + 48 │ var re1 = /(?i:\w)/; + · ── + 49 │ assert(re1.test("A"), "\\w should match A"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-const.js:23:18] - 22 │ - 23 │ { async function f() {} const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js:54:12] + 53 │ + 54 │ var re2 = /(?i:\w)/u; + · ── + 55 │ assert(re2.test("A"), "\\w should match A"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-function.js:23:18] - 22 │ - 23 │ { async function f() {} function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js:62:12] + 61 │ + 62 │ var re3 = /(?i-:\w)/; + · ── + 63 │ assert(re3.test("A"), "\\w should match A"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-generator.js:23:18] - 22 │ - 23 │ { async function f() {} function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js:68:12] + 67 │ + 68 │ var re4 = /(?i-:\w)/u; + · ── + 69 │ assert(re4.test("A"), "\\w should match A"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-b.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-let.js:23:18] - 22 │ - 23 │ { async function f() {} let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-b.js:48:12] + 47 │ + 48 │ var re1 = /(?i:Z\B)/u; + · ── + 49 │ assert(re1.test("Z\u017f"), "\\B should match between Z and \u017f"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-var.js:23:18] - 22 │ - 23 │ { async function f() {} var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-b.js:52:12] + 51 │ + 52 │ var re2 = /(?i-:Z\B)/u; + · ── + 53 │ assert(re2.test("Z\u017f"), "\\B should match between Z and \u017f"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-p.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-function.js:23:19] - 22 │ - 23 │ { async function* f() {} async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-p.js:48:12] + 47 │ + 48 │ var re1 = /(?i:\P{Lu})/u; + · ── + 49 │ assert(re1.test("A"), "\\P{Lu} should match A (ignores case)"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-generator.js:23:19] - 22 │ - 23 │ { async function* f() {} async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-p.js:55:12] + 54 │ + 55 │ var re2 = /(?i-:\P{Lu})/u; + · ── + 56 │ assert(re2.test("A"), "\\P{Lu} should match A (ignores case)"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-w.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-class.js:23:19] - 22 │ - 23 │ { async function* f() {} class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-w.js:48:12] + 47 │ + 48 │ var re1 = /(?i:\W)/u; + · ── + 49 │ assert(!re1.test("\u017f"), "\\W should not match \u017f"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-const.js:23:19] - 22 │ - 23 │ { async function* f() {} const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-w.js:52:12] + 51 │ + 52 │ var re2 = /(?i-:\W)/u; + · ── + 53 │ assert(!re2.test("\u017f"), "\\W should not match \u017f"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-dotAll-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-function.js:23:19] - 22 │ - 23 │ { async function* f() {} function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-dotAll-flag.js:42:12] + 41 │ + 42 │ var re1 = /(?i:.es)/; + · ── + 43 │ assert(re1.test("aes"), ". should match a in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-generator.js:23:19] - 22 │ - 23 │ { async function* f() {} function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-dotAll-flag.js:48:12] + 47 │ + 48 │ var re2 = /(?i:.es)/s; + · ── + 49 │ assert(re2.test("aes"), ". should match a in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-let.js:23:19] - 22 │ - 23 │ { async function* f() {} let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-dotAll-flag.js:54:12] + 53 │ + 54 │ var re3 = /(?i-:.es)/; + · ── + 55 │ assert(re3.test("aes"), ". should match a in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-var.js:23:19] - 22 │ - 23 │ { async function* f() {} var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-dotAll-flag.js:60:12] + 59 │ + 60 │ var re4 = /(?i-:.es)/s; + · ── + 61 │ assert(re4.test("aes"), ". should match a in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-ignoreCase-property.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-function.js:23:9] - 22 │ - 23 │ { class f {} async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-ignoreCase-property.js:42:12] + 41 │ + 42 │ var re1 = /(?i:)/; + · ── + 43 │ assert(!re1.ignoreCase, "RegExp instance ignoreCase property should not be set"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-generator.js:23:9] - 22 │ - 23 │ { class f {} async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-ignoreCase-property.js:48:12] + 47 │ + 48 │ var re3 = /(?i-:)/; + · ── + 49 │ assert(!re3.ignoreCase, "RegExp instance ignoreCase property should not be set"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-multiline-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-class.js:22:9] - 21 │ - 22 │ { class f {} class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-multiline-flag.js:42:12] + 41 │ + 42 │ var re1 = /(?i:es$)/; + · ── + 43 │ assert(re1.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-const.js:22:9] - 21 │ - 22 │ { class f {} const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-multiline-flag.js:48:12] + 47 │ + 48 │ var re2 = /(?i:es$)/m; + · ── + 49 │ assert(re2.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-function.js:22:9] - 21 │ - 22 │ { class f {} function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-multiline-flag.js:54:12] + 53 │ + 54 │ var re3 = /(?i-:es$)/; + · ── + 55 │ assert(re3.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-generator.js:23:9] - 22 │ - 23 │ { class f {} function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase-does-not-affect-multiline-flag.js:60:12] + 59 │ + 60 │ var re4 = /(?i-:es$)/m; + · ── + 61 │ assert(re4.test("es"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-ignoreCase.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-let.js:22:9] - 21 │ - 22 │ { class f {} let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-ignoreCase.js:36:12] + 35 │ + 36 │ var re1 = /(?i:a)b/; + · ── + 37 │ assert(!re1.test("AB"), "b should not match B in AB"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-dotAll-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-var.js:22:9] - 21 │ - 22 │ { class f {} var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-dotAll-flag.js:42:12] + 41 │ + 42 │ var re1 = /(?m:es.$)/; + · ── + 43 │ assert(re1.test("esz\n"), "$ should match newline in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-function.js:23:9] - 22 │ - 23 │ { const f = 0; async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-dotAll-flag.js:46:12] + 45 │ + 46 │ var re2 = /(?m:es.$)/s; + · ── + 47 │ assert(re2.test("esz\n"), "$ should match newline in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-generator.js:23:9] - 22 │ - 23 │ { const f = 0; async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-dotAll-flag.js:50:12] + 49 │ + 50 │ var re3 = /(?m-:es.$)/; + · ── + 51 │ assert(re3.test("esz\n"), "$ should match newline in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-class.js:22:9] - 21 │ - 22 │ { const f = 0; class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-dotAll-flag.js:54:12] + 53 │ + 54 │ var re4 = /(?m-:es.$)/s; + · ── + 55 │ assert(re4.test("esz\n"), "$ should match newline in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-ignoreCase-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-const.js:22:9] - 21 │ - 22 │ { const f = 0; const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-ignoreCase-flag.js:42:12] + 41 │ + 42 │ var re1 = /(?m:es$)/; + · ── + 43 │ assert(re1.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-function.js:22:9] - 21 │ - 22 │ { const f = 0; function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-ignoreCase-flag.js:48:12] + 47 │ + 48 │ var re2 = /(?m:es$)/i; + · ── + 49 │ assert(re2.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-generator.js:23:9] - 22 │ - 23 │ { const f = 0; function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-ignoreCase-flag.js:54:12] + 53 │ + 54 │ var re3 = /(?m-:es$)/; + · ── + 55 │ assert(re3.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-let.js:22:9] - 21 │ - 22 │ { const f = 0; let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-ignoreCase-flag.js:60:12] + 59 │ + 60 │ var re4 = /(?m-:es$)/i; + · ── + 61 │ assert(re4.test("es"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-multiline-property.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-var.js:22:9] - 21 │ - 22 │ { const f = 0; var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-multiline-property.js:36:12] + 35 │ + 36 │ var re1 = /(?m:)/; + · ── + 37 │ assert(!re1.multiline, "RegExp instance multiline flag should not be set"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-function.js:24:20] - 23 │ function x() { - 24 │ { async function f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 25 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline-does-not-affect-multiline-property.js:42:12] + 41 │ + 42 │ var re3 = /(?m-:)/; + · ── + 43 │ assert(!re3.multiline, "RegExp instance multiline flag should not be set"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-multiline.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-generator.js:24:21] - 23 │ function x() { - 24 │ { async function* f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 25 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline.js:36:12] + 35 │ + 36 │ var re1 = /(?m:es$)/; + · ── + 37 │ assert(re1.test("es\ns"), "$ should match newline in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-class.js:23:11] - 22 │ function x() { - 23 │ { class f {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 24 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-multiline.js:42:12] + 41 │ + 42 │ var re3 = /(?m-:es$)/; + · ── + 43 │ assert(re3.test("es\ns"), "$ should match newline in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/add-remove-modifiers.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-const.js:23:11] - 22 │ function x() { - 23 │ { const f = 0; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 24 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/add-remove-modifiers.js:36:12] + 35 │ + 36 │ var re1 = /(?m-i:^a$)/i; + · ── + 37 │ assert(!re1.test("A\n"), "Should not match 'A\\n'"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/changing-dotAll-flag-does-not-affect-dotAll-modifier.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-function.js:23:14] - 22 │ function x() { - 23 │ { function f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 24 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/changing-dotAll-flag-does-not-affect-dotAll-modifier.js:42:23] + 41 │ + 42 │ var re1 = new RegExp(/(?s:^.$)/s, ""); + · ── + 43 │ assert(re1.test("a"), "Pattern character '.' still should match non-line terminators in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-generator.js:24:15] - 23 │ function x() { - 24 │ { function* f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 25 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/changing-dotAll-flag-does-not-affect-dotAll-modifier.js:59:23] + 58 │ + 59 │ var re2 = new RegExp(/(?-s:^.$)/, "s"); + · ── + 60 │ assert(re2.test("a"), "Pattern character '.' still should match non-line terminators in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/changing-ignoreCase-flag-does-not-affect-ignoreCase-modifier.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-let.js:23:9] - 22 │ function x() { - 23 │ { let f; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here - 24 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/changing-ignoreCase-flag-does-not-affect-ignoreCase-modifier.js:42:23] + 41 │ + 42 │ var re1 = new RegExp(/(?i:aB)/i, ""); + · ── + 43 │ assert(re1.test("AB"), "still should ignore case in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-declaration-attempt-to-redeclare-with-var-declaration-nested-in-function.js:24:18] - 23 │ // A lexically declared function declaration. - 24 │ function f() {} - · ┬ - · ╰── `f` has already been declared here - 25 │ - 26 │ // An inner block-statement with a variable-declared name. - 27 │ { - 28 │ var f; - · ┬ - · ╰── It can not be redeclared here - 29 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/changing-ignoreCase-flag-does-not-affect-ignoreCase-modifier.js:48:23] + 47 │ + 48 │ var re2 = new RegExp(/(?-i:aB)/, "i"); + · ── + 49 │ assert(!re2.test("AB"), "still should preserve case in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/changing-multiline-flag-does-not-affect-multiline-modifier.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-function.js:23:12] - 22 │ - 23 │ { function f() {} async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/changing-multiline-flag-does-not-affect-multiline-modifier.js:42:23] + 41 │ + 42 │ var re1 = new RegExp(/(?m:es$)/m, ""); + · ── + 43 │ assert(re1.test("es"), "$ still should match end of input in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-generator.js:23:12] - 22 │ - 23 │ { function f() {} async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/changing-multiline-flag-does-not-affect-multiline-modifier.js:46:24] + 45 │ + 46 │ var re2 = new RegExp(/^(?-m:es$)/, "m"); + · ── + 47 │ assert(re2.test("es"), "$ still should match end of input in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nested-add-remove-modifiers.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-class.js:22:12] - 21 │ - 22 │ { function f() {} class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nested-add-remove-modifiers.js:36:12] + 35 │ + 36 │ var re1 = /(?m:^(?-i:a)$)/i; + · ── + 37 │ assert(!re1.test("A\n"), "Should not match 'A\\n'"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nesting-add-dotAll-within-remove-dotAll.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-const.js:22:12] - 21 │ - 22 │ { function f() {} const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-add-dotAll-within-remove-dotAll.js:36:12] + 35 │ + 36 │ var re1 = /(?-s:(?s:^.$))/s; + · ── + 37 │ assert(re1.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-function.js:22:12] - 21 │ - 22 │ { function f() {} function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-add-dotAll-within-remove-dotAll.js:53:12] + 52 │ + 53 │ var re2 = /(?-s:(?s-:^.$))/s; + · ── + 54 │ assert(re2.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nesting-add-ignoreCase-within-remove-ignoreCase.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-generator.js:23:12] - 22 │ - 23 │ { function f() {} function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-add-ignoreCase-within-remove-ignoreCase.js:36:12] + 35 │ + 36 │ var re1 = /(?-i:a(?i:b))c/i; + · ── + 37 │ assert(!re1.test("ABC"), "a should not match A in ABC"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nesting-add-multiline-within-remove-multiline.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-let.js:22:12] - 21 │ - 22 │ { function f() {} let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-add-multiline-within-remove-multiline.js:36:12] + 35 │ + 36 │ var re1 = /(?-m:es(?m:$)|js$)/m; + · ── + 37 │ assert(re1.test("es\ns"), "$ should match newline in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-var.js:22:12] - 21 │ - 22 │ { function f() {} var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-add-multiline-within-remove-multiline.js:41:12] + 40 │ + 41 │ var re2 = /(?-m:es(?m-:$)|js$)/m; + · ── + 42 │ assert(re2.test("es\ns"), "$ should match newline in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nesting-remove-dotAll-within-add-dotAll.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-function.js:23:13] - 22 │ - 23 │ { function* f() {} async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-remove-dotAll-within-add-dotAll.js:36:12] + 35 │ + 36 │ var re1 = /(?s:(?-s:^.$))/; + · ── + 37 │ assert(re1.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-generator.js:23:13] - 22 │ - 23 │ { function* f() {} async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-remove-dotAll-within-add-dotAll.js:53:12] + 52 │ + 53 │ var re2 = /(?s-:(?-s:^.$))/; + · ── + 54 │ assert(re2.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nesting-remove-ignoreCase-within-add-ignoreCase.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-class.js:23:13] - 22 │ - 23 │ { function* f() {} class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-remove-ignoreCase-within-add-ignoreCase.js:36:12] + 35 │ + 36 │ var re1 = /(?-i:a(?i:b))c/i; + · ── + 37 │ assert(!re1.test("ABC"), "a should not match A in ABC"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/nesting-remove-multiline-within-add-multiline.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-const.js:23:13] - 22 │ - 23 │ { function* f() {} const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-remove-multiline-within-add-multiline.js:36:12] + 35 │ + 36 │ var re1 = /(?m:es$|(?-m:js$))/; + · ── + 37 │ assert(re1.test("es\ns"), "first $ should match newline in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-function.js:23:13] - 22 │ - 23 │ { function* f() {} function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/nesting-remove-multiline-within-add-multiline.js:41:12] + 40 │ + 41 │ var re2 = /(?m-:es$|(?-m:js$))/; + · ── + 42 │ assert(re2.test("es\ns"), "first $ should match newline in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-dotAll-property.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-generator.js:23:13] - 22 │ - 23 │ { function* f() {} function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-dotAll-property.js:36:12] + 35 │ + 36 │ var re1 = /(?-s:^.$)/s; + · ── + 37 │ assert(re1.dotAll, "RegExp instance dotAll flag should still be set"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-ignoreCase-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-let.js:23:13] - 22 │ - 23 │ { function* f() {} let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-ignoreCase-flag.js:36:12] + 35 │ + 36 │ var re1 = /(?-s:.es)/s; + · ── + 37 │ assert(re1.test("aes"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-var.js:23:13] - 22 │ - 23 │ { function* f() {} var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-ignoreCase-flag.js:42:12] + 41 │ + 42 │ var re2 = /(?-s:.es)/si; + · ── + 43 │ assert(re2.test("aes"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-multiline-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-function.js:39:9] - 38 │ - 39 │ { { var f; } async function f() {}; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-multiline-flag.js:36:12] + 35 │ + 36 │ var re1 = /(?-s:.es$)/s; + · ── + 37 │ assert(re1.test("aes"), ". should match a in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-generator.js:39:9] - 38 │ - 39 │ { { var f; } async function* f() {}; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-dotAll-does-not-affect-multiline-flag.js:42:12] + 41 │ + 42 │ var re2 = /(?-s:.es$)/sm; + · ── + 43 │ assert(re2.test("aes"), ". should match a in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-dotAll.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-class.js:38:9] - 37 │ - 38 │ { { var f; } class f {}; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-dotAll.js:36:12] + 35 │ + 36 │ var re1 = /(?-s:^.$)/s; + · ── + 37 │ assert(re1.test("a"), "Pattern character '.' should match non-line terminators in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-backreferences.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-const.js:38:9] - 37 │ - 38 │ { { var f; } const f = 0; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-backreferences.js:36:15] + 35 │ + 36 │ var re1 = /(a)(?-i:\1)/i; + · ── + 37 │ assert(re1.test("AA"), "a matches first A, so \\1 should match second A"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterClasses.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-function.js:38:9] - 37 │ - 38 │ { { var f; } function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterClasses.js:42:12] + 41 │ + 42 │ var re1 = /(?-i:[ab])c/i; + · ── + 43 │ assert(re1.test("ac"), "[ab] should match a"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-generator.js:39:9] - 38 │ - 39 │ { { var f; } function* f() {}; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterClasses.js:48:12] + 47 │ + 48 │ var re2 = /(?-i:[^ab])c/i; + · ── + 49 │ assert(!re2.test("ac"), "[^ab] should not match a"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterEscapes.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-let.js:38:9] - 37 │ - 38 │ { { var f; } let f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterEscapes.js:36:12] + 35 │ + 36 │ var re1 = /(?-i:\x61)b/i; + · ── + 37 │ assert(re1.test("ab"), "\\x61 should match a"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-function.js:39:18] - 38 │ - 39 │ { async function f() {}; { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterEscapes.js:41:12] + 40 │ + 41 │ var re2 = /(?-i:\u0061)b/i; + · ── + 42 │ assert(re2.test("ab"), "\\u0061 should match a"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-generator.js:39:19] - 38 │ - 39 │ { async function* f() {}; { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-characterEscapes.js:46:12] + 45 │ + 46 │ var re3 = /(?-i:\u{0061})b/iu; + · ── + 47 │ assert(re3.test("ab"), "\\u0061 should match a"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-b.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-class.js:38:9] - 37 │ - 38 │ { class f {}; { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-b.js:48:12] + 47 │ + 48 │ var re1 = /(?-i:\b)/ui; + · ── + 49 │ assert(!re1.test("\u017f"), "\\b should not match after \u017f"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-p.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-const.js:38:9] - 37 │ - 38 │ { const f = 0; { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-p.js:48:12] + 47 │ + 48 │ var re1 = /(?-i:\p{Lu})/ui; + · ── + 49 │ assert(re1.test("A"), "\\p{Lu} should match A"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-w.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-function.js:38:12] - 37 │ - 38 │ { function f() {} { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-lower-w.js:48:12] + 47 │ + 48 │ var re1 = /(?-i:\w)/ui; + · ── + 49 │ assert(!re1.test("\u017f"), "\\w should not match \u017f"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-b.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-generator.js:39:13] - 38 │ - 39 │ { function* f() {}; { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-b.js:48:12] + 47 │ + 48 │ var re1 = /(?-i:Z\B)/ui; + · ── + 49 │ assert(!re1.test("Z\u017f"), "\\B should not match between Z and \u017f"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-p.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-let.js:38:7] - 37 │ - 38 │ { let f; { var f; } } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-p.js:48:12] + 47 │ + 48 │ var re1 = /(?-i:\P{Lu})/ui; + · ── + 49 │ assert(!re1.test("A"), "\\P{Lu} should not match A"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-w.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-function.js:23:7] - 22 │ - 23 │ { let f; async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-affects-slash-upper-w.js:48:12] + 47 │ + 48 │ var re1 = /(?-i:\W)/ui; + · ── + 49 │ assert(re1.test("\u017f"), "\\W should match \u017f"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-dotAll-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-generator.js:23:7] - 22 │ - 23 │ { let f; async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-dotAll-flag.js:36:12] + 35 │ + 36 │ var re1 = /(?-i:.es)/i; + · ── + 37 │ assert(re1.test("aes"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-class.js:22:7] - 21 │ - 22 │ { let f; class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-dotAll-flag.js:42:12] + 41 │ + 42 │ var re2 = /(?-i:.es)/is; + · ── + 43 │ assert(re2.test("aes"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-ignoreCase-property.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-const.js:22:7] - 21 │ - 22 │ { let f; const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-ignoreCase-property.js:42:12] + 41 │ + 42 │ var re1 = /(?-i:)/i; + · ── + 43 │ assert(re1.ignoreCase, "RegExp instance ignoreCase property should still be set"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-multiline-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-function.js:22:7] - 21 │ - 22 │ { let f; function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-multiline-flag.js:36:12] + 35 │ + 36 │ var re1 = /(?-i:es$)/i; + · ── + 37 │ assert(re1.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-generator.js:23:7] - 22 │ - 23 │ { let f; function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase-does-not-affect-multiline-flag.js:42:12] + 41 │ + 42 │ var re2 = /(?-i:es$)/im; + · ── + 43 │ assert(re2.test("es"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-ignoreCase.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-let.js:22:7] - 21 │ - 22 │ { let f; let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-ignoreCase.js:36:12] + 35 │ + 36 │ var re1 = /(?-i:fo)o/i; + · ── + 37 │ assert(!re1.test("FOO"), "Pattern should not match as modified group does not ignore case"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-dotAll-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-var.js:22:7] - 21 │ - 22 │ { let f; var f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-dotAll-flag.js:36:12] + 35 │ + 36 │ var re1 = /(?-m:es.$)/m; + · ── + 37 │ assert(re1.test("esz"), ". should match z in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-function.js:23:7] - 22 │ - 23 │ { var f; async function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-dotAll-flag.js:42:12] + 41 │ + 42 │ var re2 = /(?-m:es.$)/ms; + · ── + 43 │ assert(re2.test("esz"), ". should match z in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-ignoreCase-flag.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-generator.js:23:7] - 22 │ - 23 │ { var f; async function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-ignoreCase-flag.js:36:12] + 35 │ + 36 │ var re1 = /(?-m:es$)/m; + · ── + 37 │ assert(re1.test("es"), "s should match s in modified group"); ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-class.js:22:7] - 21 │ - 22 │ { var f; class f {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-ignoreCase-flag.js:42:12] + 41 │ + 42 │ var re2 = /(?-m:es$)/mi; + · ── + 43 │ assert(re2.test("es"), "s should match s in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-multiline-property.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-const.js:22:7] - 21 │ - 22 │ { var f; const f = 0 } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-multiline-property.js:36:12] + 35 │ + 36 │ var re1 = /(?-m:)/m; + · ── + 37 │ assert(re1.multiline, "RegExp instance multiline flag should still be set"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/remove-multiline.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-function.js:22:7] - 21 │ - 22 │ { var f; function f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/remove-multiline.js:36:13] + 35 │ + 36 │ var re1 = /^(?-m:es$)/m; + · ── + 37 │ assert(!re1.test("\nes\ns"), "$ should not match newline in modified group"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js" - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-generator.js:23:7] - 22 │ - 23 │ { var f; function* f() {} } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:36:2] + 35 │ + 36 │ /(?i-:)/; + · ── + 37 │ /(?is-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-let.js:22:7] - 21 │ - 22 │ { var f; let f } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:37:2] + 36 │ /(?i-:)/; + 37 │ /(?is-:)/; + · ── + 38 │ /(?im-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-function.js:23:18] - 22 │ - 23 │ { async function f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:38:2] + 37 │ /(?is-:)/; + 38 │ /(?im-:)/; + · ── + 39 │ /(?s-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-generator.js:23:19] - 22 │ - 23 │ { async function* f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:39:2] + 38 │ /(?im-:)/; + 39 │ /(?s-:)/; + · ── + 40 │ /(?si-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-class.js:22:9] - 21 │ - 22 │ { class f {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:40:2] + 39 │ /(?s-:)/; + 40 │ /(?si-:)/; + · ── + 41 │ /(?sm-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-const.js:22:9] - 21 │ - 22 │ { const f = 0; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:41:2] + 40 │ /(?si-:)/; + 41 │ /(?sm-:)/; + · ── + 42 │ /(?m-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-function.js:22:12] - 21 │ - 22 │ { function f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:42:2] + 41 │ /(?sm-:)/; + 42 │ /(?m-:)/; + · ── + 43 │ /(?mi-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-generator.js:23:13] - 22 │ - 23 │ { function* f() {}; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:43:2] + 42 │ /(?m-:)/; + 43 │ /(?mi-:)/; + · ── + 44 │ /(?ms-:)/; ╰──── - × Identifier `f` has already been declared - ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-let.js:22:7] - 21 │ - 22 │ { let f; var f; } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `f` has already been declared here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:44:2] + 43 │ /(?mi-:)/; + 44 │ /(?ms-:)/; + · ── + 45 │ /(?ims-:)/; ╰──── - × Unterminated multiline comment - ╭─[language/comments/S7.4_A2_T2.js:15:1] - 14 │ - 15 │ /*CHECK#1/ - · ─────────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:45:2] + 44 │ /(?ms-:)/; + 45 │ /(?ims-:)/; + · ── + 46 │ /(?ism-:)/; ╰──── - × Unexpected token - ╭─[language/comments/S7.4_A3.js:21:1] - 20 │ /* x */ - 21 │ = 1; - · ─ - 22 │ */ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:46:2] + 45 │ /(?ims-:)/; + 46 │ /(?ism-:)/; + · ── + 47 │ /(?sim-:)/; ╰──── - × Unterminated regular expression - ╭─[language/comments/S7.4_A4_T1.js:18:3] - 17 │ /* var*/ - 18 │ x*/ - · ── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:47:2] + 46 │ /(?ism-:)/; + 47 │ /(?sim-:)/; + · ── + 48 │ /(?smi-:)/; ╰──── - × Unterminated regular expression - ╭─[language/comments/S7.4_A4_T4.js:18:3] - 17 │ // var /* - 18 │ x*/ - · ── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:48:2] + 47 │ /(?sim-:)/; + 48 │ /(?smi-:)/; + · ── + 49 │ /(?mis-:)/; ╰──── - × Invalid Unicode escape sequence - ╭─[language/comments/hashbang/escaped-bang-041.js:1:3] - 1 │ #\041 - · ─ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:49:2] + 48 │ /(?smi-:)/; + 49 │ /(?mis-:)/; + · ── + 50 │ /(?msi-:)/; + ╰──── - × Expected `in` but found `throw` - ╭─[language/comments/hashbang/escaped-bang-041.js:20:1] - 19 │ - 20 │ throw "Test262: This statement should not be evaluated."; - · ──┬── - · ╰── `in` expected + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers-can-have-empty-remove-modifiers.js:50:2] + 49 │ /(?mis-:)/; + 50 │ /(?msi-:)/; + · ── + 51 │ new RegExp("(?i-:)"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js" - × Invalid Character `!` - ╭─[language/comments/hashbang/escaped-bang-u0021.js:1:8] - 1 │ #\u0021 - · ▲ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:36:2] + 35 │ + 36 │ /(?i-s:)/; + · ── + 37 │ /(?i-sm:)/; + ╰──── - × Expected `in` but found `throw` - ╭─[language/comments/hashbang/escaped-bang-u0021.js:20:1] - 19 │ - 20 │ throw "Test262: This statement should not be evaluated."; - · ──┬── - · ╰── `in` expected + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:37:2] + 36 │ /(?i-s:)/; + 37 │ /(?i-sm:)/; + · ── + 38 │ /(?i-m:)/; ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/escaped-bang-u21.js:1:8] - 1 │ #\u{21} - · ▲ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:38:2] + 37 │ /(?i-sm:)/; + 38 │ /(?i-m:)/; + · ── + 39 │ /(?i-ms:)/; + ╰──── - × Expected `in` but found `throw` - ╭─[language/comments/hashbang/escaped-bang-u21.js:20:1] - 19 │ - 20 │ throw "Test262: This statement should not be evaluated."; - · ──┬── - · ╰── `in` expected + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:39:2] + 38 │ /(?i-m:)/; + 39 │ /(?i-ms:)/; + · ── + 40 │ /(?s-i:)/; ╰──── - × Invalid Unicode escape sequence - ╭─[language/comments/hashbang/escaped-bang-x21.js:1:3] - 1 │ #\x21 - · ─ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:40:2] + 39 │ /(?i-ms:)/; + 40 │ /(?s-i:)/; + · ── + 41 │ /(?s-im:)/; + ╰──── - × Expected `in` but found `throw` - ╭─[language/comments/hashbang/escaped-bang-x21.js:20:1] - 19 │ - 20 │ throw "Test262: This statement should not be evaluated."; - · ──┬── - · ╰── `in` expected + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:41:2] + 40 │ /(?s-i:)/; + 41 │ /(?s-im:)/; + · ── + 42 │ /(?s-m:)/; ╰──── - × Invalid Unicode escape sequence - ╭─[language/comments/hashbang/escaped-hash-043.js:1:2] - 1 │ \043! - · ─ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:42:2] + 41 │ /(?s-im:)/; + 42 │ /(?s-m:)/; + · ── + 43 │ /(?s-mi:)/; + ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/comments/hashbang/escaped-hash-043.js:1:5] - 1 │ \043! - · ▲ - 2 │ - ╰──── - help: Try insert a semicolon here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:43:2] + 42 │ /(?s-m:)/; + 43 │ /(?s-mi:)/; + · ── + 44 │ /(?m-i:)/; + ╰──── - × Invalid Character `#` - ╭─[language/comments/hashbang/escaped-hash-u0023.js:1:7] - 1 │ \u0023! - · ▲ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:44:2] + 43 │ /(?s-mi:)/; + 44 │ /(?m-i:)/; + · ── + 45 │ /(?m-is:)/; + ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/comments/hashbang/escaped-hash-u0023.js:1:7] - 1 │ \u0023! - · ▲ - 2 │ - ╰──── - help: Try insert a semicolon here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:45:2] + 44 │ /(?m-i:)/; + 45 │ /(?m-is:)/; + · ── + 46 │ /(?m-s:)/; + ╰──── - × Invalid Character `#` - ╭─[language/comments/hashbang/escaped-hash-u23.js:1:7] - 1 │ \u{23}! - · ▲ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:46:2] + 45 │ /(?m-is:)/; + 46 │ /(?m-s:)/; + · ── + 47 │ /(?m-si:)/; + ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/comments/hashbang/escaped-hash-u23.js:1:7] - 1 │ \u{23}! - · ▲ - 2 │ - ╰──── - help: Try insert a semicolon here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:47:2] + 46 │ /(?m-s:)/; + 47 │ /(?m-si:)/; + · ── + 48 │ /(?is-m:)/; + ╰──── - × Invalid Unicode escape sequence - ╭─[language/comments/hashbang/escaped-hash-x23.js:1:2] - 1 │ \x23! - · ─ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:48:2] + 47 │ /(?m-si:)/; + 48 │ /(?is-m:)/; + · ── + 49 │ /(?im-s:)/; + ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/comments/hashbang/escaped-hash-x23.js:1:5] - 1 │ \x23! - · ▲ - 2 │ - ╰──── - help: Try insert a semicolon here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:49:2] + 48 │ /(?is-m:)/; + 49 │ /(?im-s:)/; + · ── + 50 │ /(?si-m:)/; + ╰──── - × Invalid Character `#` - ╭─[language/comments/hashbang/escaped-hashbang.js:1:7] - 1 │ \u0023\u0021 - · ▲ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:50:2] + 49 │ /(?im-s:)/; + 50 │ /(?si-m:)/; + · ── + 51 │ /(?sm-i:)/; + ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/escaped-hashbang.js:1:13] - 1 │ \u0023\u0021 - · ▲ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:51:2] + 50 │ /(?si-m:)/; + 51 │ /(?sm-i:)/; + · ── + 52 │ /(?mi-s:)/; + ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/function-body.js:19:17] - 18 │ - 19 │ function fn() {#! - · ─ - 20 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:52:2] + 51 │ /(?sm-i:)/; + 52 │ /(?mi-s:)/; + · ── + 53 │ /(?ms-i:)/; ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/comments/hashbang/multi-line-comment.js:3:6] - 2 │ throw "Test262: This statement should not be evaluated."; - 3 │ these characters should not be considered within a comment - · ▲ - 4 │ */ - ╰──── - help: Try insert a semicolon here + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-and-remove-modifiers.js:53:2] + 52 │ /(?mi-s:)/; + 53 │ /(?ms-i:)/; + · ── + 54 │ new RegExp("(?i-s:)"); + ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-nested.js" - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-directive-prologue-sc.js:2:2] - 1 │ "use strict"; - 2 │ #! - · ─ - 3 │ - ╰──── - - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-directive-prologue.js:2:2] - 1 │ "use strict" - 2 │ #! - · ─ - 3 │ - ╰──── - - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-empty-statement.js:1:3] - 1 │ ;#! - · ─ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-nested.js:36:2] + 35 │ + 36 │ /(?i:(?i:))/; + · ── + 37 │ /(?s:(?s:))/; + ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-hashbang.js:2:2] - 1 │ #! - 2 │ #! - · ─ - 3 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-nested.js:37:2] + 36 │ /(?i:(?i:))/; + 37 │ /(?s:(?s:))/; + · ── + 38 │ /(?m:(?m:))/; + ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-line-comment.js:2:2] - 1 │ // - 2 │ #! - · ─ - 3 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-nested.js:38:2] + 37 │ /(?s:(?s:))/; + 38 │ /(?m:(?m:))/; + · ── + 39 │ new RegExp("(?i:(?i:))"); + ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js" - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-multi-line-comment.js:2:4] - 1 │ /* - 2 │ */#! - · ─ - 3 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:36:2] + 35 │ + 36 │ /(?i:)/; + · ── + 37 │ /(?is:)/; + ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/preceding-whitespace.js:1:3] - 1 │ #! - · ─ - 2 │ - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:37:2] + 36 │ /(?i:)/; + 37 │ /(?is:)/; + · ── + 38 │ /(?im:)/; + ╰──── - × Invalid Character `!` - ╭─[language/comments/hashbang/statement-block.js:20:4] - 19 │ { - 20 │ #! - · ─ - 21 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:38:2] + 37 │ /(?is:)/; + 38 │ /(?im:)/; + · ── + 39 │ /(?s:)/; ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/comments/multi-line-html-close-extra.js:25:7] - 24 │ /* - 25 │ */ the comment should not include these characters, regardless of AnnexB extensions --> - · ▲ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:39:2] + 38 │ /(?im:)/; + 39 │ /(?s:)/; + · ── + 40 │ /(?si:)/; ╰──── - help: Try insert a semicolon here - × Unexpected token - ╭─[language/comments/single-line-html-close-without-lt.js:23:4] - 22 │ - 23 │ ;--> - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:40:2] + 39 │ /(?s:)/; + 40 │ /(?si:)/; + · ── + 41 │ /(?sm:)/; ╰──── - × The keyword 'public' is reserved - ╭─[language/directive-prologue/10.1.1-2gs.js:17:5] - 16 │ throw "Test262: This statement should not be evaluated."; - 17 │ var public = 1; - · ────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:41:2] + 40 │ /(?si:)/; + 41 │ /(?sm:)/; + · ── + 42 │ /(?m:)/; ╰──── - × The keyword 'public' is reserved - ╭─[language/directive-prologue/10.1.1-5gs.js:17:5] - 16 │ throw "Test262: This statement should not be evaluated."; - 17 │ var public = 1; - · ────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:42:2] + 41 │ /(?sm:)/; + 42 │ /(?m:)/; + · ── + 43 │ /(?mi:)/; ╰──── - × The keyword 'public' is reserved - ╭─[language/directive-prologue/10.1.1-8gs.js:18:5] - 17 │ throw "Test262: This statement should not be evaluated."; - 18 │ var public = 1; - · ────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:43:2] + 42 │ /(?m:)/; + 43 │ /(?mi:)/; + · ── + 44 │ /(?ms:)/; ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/directive-prologue/14.1-4gs.js:17:1] - 16 │ throw "Test262: This statement should not be evaluated."; - 17 │ eval = 42; - · ──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:44:2] + 43 │ /(?mi:)/; + 44 │ /(?ms:)/; + · ── + 45 │ /(?ims:)/; ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/directive-prologue/14.1-5gs.js:19:1] - 18 │ throw "Test262: This statement should not be evaluated."; - 19 │ eval = 42; - · ──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:45:2] + 44 │ /(?ms:)/; + 45 │ /(?ims:)/; + · ── + 46 │ /(?ism:)/; ╰──── - × The keyword 'static' is reserved - ╭─[language/directive-prologue/func-decl-inside-func-decl-parse.js:22:9] - 21 │ function fun() { - 22 │ var static; - · ────── - 23 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:46:2] + 45 │ /(?ims:)/; + 46 │ /(?ism:)/; + · ── + 47 │ /(?sim:)/; ╰──── - × The keyword 'static' is reserved - ╭─[language/directive-prologue/func-decl-no-semi-parse.js:20:7] - 19 │ "use strict" - 20 │ var static; - · ────── - 21 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:47:2] + 46 │ /(?ism:)/; + 47 │ /(?sim:)/; + · ── + 48 │ /(?smi:)/; ╰──── - × The keyword 'static' is reserved - ╭─[language/directive-prologue/func-decl-parse.js:20:7] - 19 │ "use strict"; - 20 │ var static; - · ────── - 21 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:48:2] + 47 │ /(?sim:)/; + 48 │ /(?smi:)/; + · ── + 49 │ /(?mis:)/; ╰──── - × The keyword 'static' is reserved - ╭─[language/directive-prologue/func-expr-inside-func-decl-parse.js:21:7] - 20 │ "use strict"; - 21 │ var static; - · ────── - 22 │ } + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:49:2] + 48 │ /(?smi:)/; + 49 │ /(?mis:)/; + · ── + 50 │ /(?msi:)/; ╰──── - × The keyword 'static' is reserved - ╭─[language/directive-prologue/func-expr-no-semi-parse.js:21:7] - 20 │ - 21 │ var static; - · ────── - 22 │ }); + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-not-set-as-flags.js:50:2] + 49 │ /(?mis:)/; + 50 │ /(?msi:)/; + · ── + 51 │ new RegExp("(?i:)"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-set-as-flags.js" - × The keyword 'static' is reserved - ╭─[language/directive-prologue/func-expr-parse.js:21:7] - 20 │ - 21 │ var static; - · ────── - 22 │ }); + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-set-as-flags.js:36:2] + 35 │ + 36 │ /(?i:)/i; + · ── + 37 │ /(?s:)/s; ╰──── - × Keywords cannot contain escape characters - ╭─[language/export/escaped-as-export-specifier.js:25:11] - 24 │ export var a = 0; - 25 │ export {a \u0061s b} from "./escaped-as-export-specifier.js"; - · ─────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-set-as-flags.js:37:2] + 36 │ /(?i:)/i; + 37 │ /(?s:)/s; + · ── + 38 │ /(?m:)/m; ╰──── - × Keywords cannot contain escape characters - ╭─[language/export/escaped-default.js:24:8] - 23 │ - 24 │ export d\u0065fault 0; - · ──────────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-set-as-flags.js:38:2] + 37 │ /(?s:)/s; + 38 │ /(?m:)/m; + · ── + 39 │ /(?ims:)/ims; ╰──── - × Keywords cannot contain escape characters - ╭─[language/export/escaped-from.js:24:11] - 23 │ - 24 │ export {} \u0066rom "./escaped-from.js"; - · ───────── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/add-modifiers-when-set-as-flags.js:39:2] + 38 │ /(?m:)/m; + 39 │ /(?ims:)/ims; + · ── + 40 │ new RegExp("(?i:)", "i"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-nested.js" - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/arrow-function/array-destructuring-param-strict-body.js:130:3] - 129 │ 0, ([element]) => { - 130 │ "use strict"; - · ───────────── - 131 │ }; - ╰──── + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-nested.js:36:2] + 35 │ + 36 │ /(?-i:(?-i:))/; + · ── + 37 │ /(?-s:(?-s:))/; + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/dflt-params-duplicates.js:58:5] - 57 │ - 58 │ 0, (x = 0, x) => { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 59 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-nested.js:37:2] + 36 │ /(?-i:(?-i:))/; + 37 │ /(?-s:(?-s:))/; + · ── + 38 │ /(?-m:(?-m:))/; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dflt-params-rest.js:62:8] - 61 │ - 62 │ 0, (...x = []) => { - · ────── - 63 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-nested.js:38:2] + 37 │ /(?-s:(?-s:))/; + 38 │ /(?-m:(?-m:))/; + · ── + 39 │ new RegExp("(?-i:(?-i:))"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js" - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-init-ary.js:52:10] - 51 │ var f; - 52 │ f = ([...[ x ] = []]) => { - · ────────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:36:2] + 35 │ + 36 │ /(?-i:)/; + · ── + 37 │ /(?-is:)/; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-init-id.js:52:10] - 51 │ var f; - 52 │ f = ([...x = []]) => { - · ────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:37:2] + 36 │ /(?-i:)/; + 37 │ /(?-is:)/; + · ── + 38 │ /(?-im:)/; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-init-obj.js:52:10] - 51 │ var f; - 52 │ f = ([...{ x } = []]) => { - · ────────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:38:2] + 37 │ /(?-is:)/; + 38 │ /(?-im:)/; + · ── + 39 │ /(?-s:)/; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-ary.js:52:7] - 51 │ var f; - 52 │ f = ([...[x], y]) => { - · ────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:39:2] + 38 │ /(?-im:)/; + 39 │ /(?-s:)/; + · ── + 40 │ /(?-si:)/; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-id.js:52:7] - 51 │ var f; - 52 │ f = ([...x, y]) => { - · ──── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:40:2] + 39 │ /(?-s:)/; + 40 │ /(?-si:)/; + · ── + 41 │ /(?-sm:)/; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-obj.js:52:7] - 51 │ var f; - 52 │ f = ([...{ x }, y]) => { - · ──────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:41:2] + 40 │ /(?-si:)/; + 41 │ /(?-sm:)/; + · ── + 42 │ /(?-m:)/; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-ary.js:52:10] - 51 │ var f; - 52 │ f = ([...[ x ] = []] = []) => { - · ────────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:42:2] + 41 │ /(?-sm:)/; + 42 │ /(?-m:)/; + · ── + 43 │ /(?-mi:)/; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-id.js:52:10] - 51 │ var f; - 52 │ f = ([...x = []] = []) => { - · ────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:43:2] + 42 │ /(?-m:)/; + 43 │ /(?-mi:)/; + · ── + 44 │ /(?-ms:)/; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-obj.js:52:10] - 51 │ var f; - 52 │ f = ([...{ x } = []] = []) => { - · ────────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:44:2] + 43 │ /(?-mi:)/; + 44 │ /(?-ms:)/; + · ── + 45 │ /(?-ims:)/; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-ary.js:52:7] - 51 │ var f; - 52 │ f = ([...[x], y] = [1, 2, 3]) => { - · ────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:45:2] + 44 │ /(?-ms:)/; + 45 │ /(?-ims:)/; + · ── + 46 │ /(?-ism:)/; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-id.js:52:7] - 51 │ var f; - 52 │ f = ([...x, y] = [1, 2, 3]) => { - · ──── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:46:2] + 45 │ /(?-ims:)/; + 46 │ /(?-ism:)/; + · ── + 47 │ /(?-smi:)/; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-obj.js:52:7] - 51 │ var f; - 52 │ f = ([...{ x }, y] = [1, 2, 3]) => { - · ──────── - 53 │ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:47:2] + 46 │ /(?-ism:)/; + 47 │ /(?-smi:)/; + · ── + 48 │ /(?-sim:)/; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-break-escaped.js:40:23] - 39 │ - 40 │ var x = ({ bre\u0061k }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:48:2] + 47 │ /(?-smi:)/; + 48 │ /(?-sim:)/; + · ── + 49 │ /(?-mis:)/; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-case-escaped.js:40:22] - 39 │ - 40 │ var x = ({ c\u0061se }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:49:2] + 48 │ /(?-sim:)/; + 49 │ /(?-mis:)/; + · ── + 50 │ /(?-msi:)/; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-catch-escaped.js:40:23] - 39 │ - 40 │ var x = ({ c\u0061tch }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-not-set-as-flags.js:50:2] + 49 │ /(?-mis:)/; + 50 │ /(?-msi:)/; + · ── + 51 │ new RegExp("(?-i:)"); ╰──── +Expect to Parse: "built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js" - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-class-escaped.js:40:23] - 39 │ - 40 │ var x = ({ cl\u0061ss }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:36:2] + 35 │ + 36 │ /(?-i:)/i; + · ── + 37 │ /(?-is:)/is; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-const-escaped.js:40:23] - 39 │ - 40 │ var x = ({ \u0063onst }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:37:2] + 36 │ /(?-i:)/i; + 37 │ /(?-is:)/is; + · ── + 38 │ /(?-im:)/im; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-continue-escaped.js:40:26] - 39 │ - 40 │ var x = ({ \u0063ontinue }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:38:2] + 37 │ /(?-is:)/is; + 38 │ /(?-im:)/im; + · ── + 39 │ /(?-s:)/s; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-debugger-escaped.js:40:26] - 39 │ - 40 │ var x = ({ \u0064ebugger }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:39:2] + 38 │ /(?-im:)/im; + 39 │ /(?-s:)/s; + · ── + 40 │ /(?-si:)/si; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped-ext.js:40:25] - 39 │ - 40 │ var x = ({ def\u{61}ult }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:40:2] + 39 │ /(?-s:)/s; + 40 │ /(?-si:)/si; + · ── + 41 │ /(?-sm:)/sm; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped.js:40:25] - 39 │ - 40 │ var x = ({ def\u0061ult }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:41:2] + 40 │ /(?-si:)/si; + 41 │ /(?-sm:)/sm; + · ── + 42 │ /(?-m:)/m; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-default.js:40:20] - 39 │ - 40 │ var x = ({ default }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:42:2] + 41 │ /(?-sm:)/sm; + 42 │ /(?-m:)/m; + · ── + 43 │ /(?-mi:)/mi; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-delete-escaped.js:40:24] - 39 │ - 40 │ var x = ({ \u0064elete }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:43:2] + 42 │ /(?-m:)/m; + 43 │ /(?-mi:)/mi; + · ── + 44 │ /(?-ms:)/ms; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-do-escaped.js:40:20] - 39 │ - 40 │ var x = ({ \u0064o }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:44:2] + 43 │ /(?-mi:)/mi; + 44 │ /(?-ms:)/ms; + · ── + 45 │ /(?-ims:)/ims; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-else-escaped.js:40:22] - 39 │ - 40 │ var x = ({ \u0065lse }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:45:2] + 44 │ /(?-ms:)/ms; + 45 │ /(?-ims:)/ims; + · ── + 46 │ /(?-ism:)/ism; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-enum-escaped.js:40:22] - 39 │ - 40 │ var x = ({ \u0065num }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:46:2] + 45 │ /(?-ims:)/ims; + 46 │ /(?-ism:)/ism; + · ── + 47 │ /(?-sim:)/sim; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-export-escaped.js:40:24] - 39 │ - 40 │ var x = ({ \u0065xport }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:47:2] + 46 │ /(?-ism:)/ism; + 47 │ /(?-sim:)/sim; + · ── + 48 │ /(?-smi:)/smi; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped-ext.js:40:25] - 39 │ - 40 │ var x = ({ \u{65}xtends }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:48:2] + 47 │ /(?-sim:)/sim; + 48 │ /(?-smi:)/smi; + · ── + 49 │ /(?-mis:)/mis; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped.js:40:25] - 39 │ - 40 │ var x = ({ \u0065xtends }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:49:2] + 48 │ /(?-smi:)/smi; + 49 │ /(?-mis:)/mis; + · ── + 50 │ /(?-msi:)/msi; ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends.js:40:20] - 39 │ - 40 │ var x = ({ extends }) => {}; - · ─ + × Capturing group name is missing + ╭─[built-ins/RegExp/regexp-modifiers/syntax/valid/remove-modifiers-when-set-as-flags.js:50:2] + 49 │ /(?-mis:)/mis; + 50 │ /(?-msi:)/msi; + · ── + 51 │ new RegExp("(?-i:)", "i"); ╰──── +Expect to Parse: "built-ins/String/prototype/match/duplicate-named-groups-properties.js" - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-finally-escaped.js:40:25] - 39 │ - 40 │ var x = ({ \u0066inally }) => {}; - · ─ + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/String/prototype/match/duplicate-named-indices-groups-properties.js" + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "built-ins/String/prototype/split/separator-regexp.js" + + × Invalid hexadecimal escape + ╭─[built-ins/String/prototype/split/separator-regexp.js:56:32] + 55 │ assert.compareArray("x".split(/[\b]/), ["x"], '"x".split(/[\\b]/) must return ["x"]'); + 56 │ assert.compareArray("x".split(/\x/), ["", ""], '"x".split(/\\x/) must return ["", ""]'); + · ── + 57 │ assert.compareArray("x".split(/\X/), ["x"], '"x".split(/\\X/) must return ["x"]'); ╰──── +Expect to Parse: "staging/built-ins/RegExp/named-groups/duplicate-named-groups-replace.js" - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-for-escaped.js:40:21] - 39 │ - 40 │ var x = ({ \u0066or }) => {}; - · ─ + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "staging/built-ins/RegExp/named-groups/duplicate-named-groups-search.js" + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name +Expect to Parse: "staging/built-ins/RegExp/named-groups/duplicate-named-groups.js" + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[annexB/language/expressions/template-literal/legacy-octal-escape-sequence-strict.js:18:4] + 17 │ + 18 │ `${'\07'}`; + · ───── ╰──── + help: for octal literals use the '0o' prefix instead × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-function-escaped.js:40:26] - 39 │ - 40 │ var x = ({ \u0066unction }) => {}; - · ─ + ╭─[annexB/language/statements/for-in/bare-initializer.js:15:6] + 14 │ + 15 │ for (a = 0 in {}); + · ───── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-if-escaped.js:40:20] - 39 │ - 40 │ var x = ({ i\u0066 }) => {}; - · ─ + × for-in loop variable declaration may not have an initializer + ╭─[annexB/language/statements/for-in/const-initializer.js:14:6] + 13 │ + 14 │ for (const a = 0 in {}); + · ─────────── + 15 │ ╰──── - × The keyword 'implements' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-implements-escaped.js:40:12] - 39 │ - 40 │ var x = ({ \u0069mplements }) => {}; - · ─────────────── + × for-in loop variable declaration may not have an initializer + ╭─[annexB/language/statements/for-in/let-initializer.js:14:6] + 13 │ + 14 │ for (let a = 0 in {}); + · ───────── + 15 │ ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-import-escaped.js:40:24] - 39 │ - 40 │ var x = ({ \u0069mport }) => {}; - · ─ + × for-in loop variable declaration may not have an initializer + ╭─[annexB/language/statements/for-in/strict-initializer.js:15:6] + 14 │ + 15 │ for (var a = 0 in {}); + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-in-escaped.js:40:20] - 39 │ - 40 │ var x = ({ \u0069n }) => {}; - · ─ + × for-in loop variable declaration may not have an initializer + ╭─[annexB/language/statements/for-in/var-arraybindingpattern-initializer.js:14:6] + 13 │ + 14 │ for (var [a] = 0 in {}); + · ─────────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-instanceof-escaped.js:40:28] - 39 │ - 40 │ var x = ({ \u0069nstanceof }) => {}; - · ─ + × for-in loop variable declaration may not have an initializer + ╭─[annexB/language/statements/for-in/var-objectbindingpattern-initializer.js:14:6] + 13 │ + 14 │ for (var {a} = 0 in {}); + · ─────────── + 15 │ ╰──── - × The keyword 'interface' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-interface-escaped.js:40:12] - 39 │ - 40 │ var x = ({ interf\u0061ce }) => {}; - · ────────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_F-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=F}/u; + · ─ ╰──── - × The keyword 'let' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-let-escaped.js:40:12] - 39 │ - 40 │ var x = ({ l\u0065t }) => {}; - · ──────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_F.js:18:11] + 17 │ + 18 │ /\p{ASCII=F}/u; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-new-escaped.js:40:21] - 39 │ - 40 │ var x = ({ n\u0065w }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Invalid-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=Invalid}/u; + · ─────── ╰──── - × The keyword 'package' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-package-escaped.js:40:12] - 39 │ - 40 │ var x = ({ p\u0061ckage }) => {}; - · ──────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Invalid.js:18:11] + 17 │ + 18 │ /\p{ASCII=Invalid}/u; + · ─────── ╰──── - × The keyword 'private' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-private-escaped.js:40:12] - 39 │ - 40 │ var x = ({ privat\u0065 }) => {}; - · ──────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_N-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=N}/u; + · ─ ╰──── - × The keyword 'protected' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-protected-escaped.js:40:12] - 39 │ - 40 │ var x = ({ prot\u0065cted }) => {}; - · ────────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_N.js:18:11] + 17 │ + 18 │ /\p{ASCII=N}/u; + · ─ ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-public-escaped.js:40:12] - 39 │ - 40 │ var x = ({ pu\u0062lic }) => {}; - · ─────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_No-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=No}/u; + · ── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-return-escaped.js:40:24] - 39 │ - 40 │ var x = ({ r\u0065turn }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_No.js:18:11] + 17 │ + 18 │ /\p{ASCII=No}/u; + · ── ╰──── - × The keyword 'static' is reserved - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-static-escaped.js:40:12] - 39 │ - 40 │ var x = ({ st\u0061tic }) => {}; - · ─────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_T-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=T}/u; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-super-escaped.js:40:23] - 39 │ - 40 │ var x = ({ sup\u0065r }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_T.js:18:11] + 17 │ + 18 │ /\p{ASCII=T}/u; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-switch-escaped.js:40:24] - 39 │ - 40 │ var x = ({ sw\u0069tch }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Y-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=Y}/u; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-this-escaped.js:40:22] - 39 │ - 40 │ var x = ({ th\u0069s }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Y.js:18:11] + 17 │ + 18 │ /\p{ASCII=Y}/u; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-throw-escaped.js:40:23] - 39 │ - 40 │ var x = ({ t\u0068row }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Yes-negated.js:18:11] + 17 │ + 18 │ /\P{ASCII=Yes}/u; + · ─── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-try-escaped.js:40:21] - 39 │ - 40 │ var x = ({ tr\u0079 }) => {}; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/binary-property-with-value-ASCII_-_Yes.js:18:11] + 17 │ + 18 │ /\p{ASCII=Yes}/u; + · ─── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-typeof-escaped.js:40:24] - 39 │ - 40 │ var x = ({ typ\u0065of }) => {}; - · ─ + × Invalid character class range + ╭─[built-ins/RegExp/property-escapes/character-class-range-end.js:20:3] + 19 │ + 20 │ /[--\p{Hex}]/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-var-escaped.js:40:21] - 39 │ - 40 │ var x = ({ v\u0061r }) => {}; - · ─ + × Invalid character class range + ╭─[built-ins/RegExp/property-escapes/character-class-range-no-dash-end.js:20:3] + 19 │ + 20 │ /[\uFFFF-\p{Hex}]/u; + · ────────────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-void-escaped.js:40:22] - 39 │ - 40 │ var x = ({ voi\u0064 }) => {}; - · ─ + × Invalid character class range + ╭─[built-ins/RegExp/property-escapes/character-class-range-no-dash-start.js:20:3] + 19 │ + 20 │ /[\p{Hex}-\uFFFF]/u; + · ────────────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-while-escaped.js:40:23] - 39 │ - 40 │ var x = ({ whil\u0065 }) => {}; - · ─ + × Invalid character class range + ╭─[built-ins/RegExp/property-escapes/character-class-range-start.js:20:3] + 19 │ + 20 │ /[\p{Hex}--]/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-with-escaped.js:40:22] - 39 │ - 40 │ var x = ({ w\u0069th }) => {}; - · ─ + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{Basic_Emoji}]/v; + · ────────────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/arrow-function/object-destructuring-param-strict-body.js:130:3] - 129 │ 0, ({property}) => { - 130 │ "use strict"; - · ───────────── - 131 │ }; - ╰──── + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji-negative-P.js:20:2] + 19 │ + 20 │ /\P{Basic_Emoji}/v; + · ─────────────── + ╰──── - × yield expression not allowed in formal parameter - ╭─[language/expressions/arrow-function/param-dflt-yield-expr.js:27:8] - 26 │ function *g() { - 27 │ (x = yield) => {}; - · ──┬── - · ╰── yield expression not allowed in formal parameter - 28 │ } + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/Basic_Emoji-negative-u.js:20:5] + 19 │ + 20 │ /\p{Basic_Emoji}/u; + · ─────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/arrow-function/param-dflt-yield-id-strict.js:21:6] - 20 │ - 21 │ (x = yield) => {}; - · ───── + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{Emoji_Keycap_Sequence}]/v; + · ──────────────────────────── ╰──── - × Identifier `a` has already been declared - ╭─[language/expressions/arrow-function/params-duplicate.js:33:5] - 32 │ - 33 │ 0, (a, a) => { }; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `a` has already been declared here + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence-negative-P.js:20:2] + 19 │ + 20 │ /\P{Emoji_Keycap_Sequence}/v; + · ───────────────────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/arrow-function/rest-param-strict-body.js:130:3] - 129 │ 0, (a,...rest) => { - 130 │ "use strict"; - · ───────────── - 131 │ }; - ╰──── + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/Emoji_Keycap_Sequence-negative-u.js:20:5] + 19 │ + 20 │ /\p{Emoji_Keycap_Sequence}/u; + · ───────────────────── + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/arrow-function/rest-params-trailing-comma-early-error.js:54:5] - 53 │ - 54 │ 0, (...a,) => { - · ──── - 55 │ + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{RGI_Emoji}]/v; + · ──────────────── ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/arrow-function/static-init-await-binding.js:16:6] - 15 │ static { - 16 │ (await => 0); - · ───── - 17 │ } + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji-negative-P.js:20:2] + 19 │ + 20 │ /\P{RGI_Emoji}/v; + · ───────────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/static-init-await-reference.js:16:16] - 15 │ static { - 16 │ ((x = await) => 0); - · ─ - 17 │ } + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji-negative-u.js:20:5] + 19 │ + 20 │ /\p{RGI_Emoji}/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-futurereservedword.js:24:10] - 23 │ $DONOTEVALUATE(); - 24 │ var af = enum => 1; - · ──── + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{RGI_Emoji_Flag_Sequence}]/v; + · ────────────────────────────── ╰──── - × The keyword 'package' is reserved - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-strict-futurereservedword.js:27:10] - 26 │ $DONOTEVALUATE(); - 27 │ var af = package => 1; - · ─────── + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence-negative-P.js:20:2] + 19 │ + 20 │ /\P{RGI_Emoji_Flag_Sequence}/v; + · ─────────────────────────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier.js:24:10] - 23 │ $DONOTEVALUATE(); - 24 │ var af = switch => 1; - · ────── + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Flag_Sequence-negative-u.js:20:5] + 19 │ + 20 │ /\p{RGI_Emoji_Flag_Sequence}/u; + · ─────────────────────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-arguments.js:19:10] - 18 │ $DONOTEVALUATE(); - 19 │ var af = arguments => 1; - · ───────── + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{RGI_Emoji_Modifier_Sequence}]/v; + · ────────────────────────────────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-eval.js:20:10] - 19 │ $DONOTEVALUATE(); - 20 │ var af = eval => 1; - · ──── + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence-negative-P.js:20:2] + 19 │ + 20 │ /\P{RGI_Emoji_Modifier_Sequence}/v; + · ─────────────────────────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-yield.js:20:10] - 19 │ $DONOTEVALUATE(); - 20 │ var af = yield => 1; - · ───── + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Modifier_Sequence-negative-u.js:20:5] + 19 │ + 20 │ /\p{RGI_Emoji_Modifier_Sequence}/u; + · ─────────────────────────── ╰──── - × Unexpected token - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-rest.js:16:10] - 15 │ $DONOTEVALUATE(); - 16 │ var af = ...x => x; - · ─── + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{RGI_Emoji_Tag_Sequence}]/v; + · ───────────────────────────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-arguments.js:24:11] - 23 │ $DONOTEVALUATE(); - 24 │ var af = (arguments) => 1; - · ───────── + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence-negative-P.js:20:2] + 19 │ + 20 │ /\P{RGI_Emoji_Tag_Sequence}/v; + · ────────────────────────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-1.js:25:11] - 24 │ $DONOTEVALUATE(); - 25 │ var af = (x, [x]) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_Tag_Sequence-negative-u.js:20:5] + 19 │ + 20 │ /\p{RGI_Emoji_Tag_Sequence}/u; + · ────────────────────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-2.js:25:12] - 24 │ $DONOTEVALUATE(); - 25 │ var af = ([x, x]) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid character class + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence-negative-CharacterClass.js:20:2] + 19 │ + 20 │ /[^\p{RGI_Emoji_ZWJ_Sequence}]/v; + · ───────────────────────────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-3.js:27:12] - 26 │ $DONOTEVALUATE(); - 27 │ var af = ([x], ...x) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid property name(negative + property of strings) + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence-negative-P.js:20:2] + 19 │ + 20 │ /\P{RGI_Emoji_ZWJ_Sequence}/v; + · ────────────────────────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-1.js:25:11] - 24 │ $DONOTEVALUATE(); - 25 │ var af = (x, {x}) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × `UnicodeSetsMode` is required for binary property of strings + ╭─[built-ins/RegExp/property-escapes/generated/strings/RGI_Emoji_ZWJ_Sequence-negative-u.js:20:5] + 19 │ + 20 │ /\p{RGI_Emoji_ZWJ_Sequence}/u; + · ────────────────────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-2.js:27:11] - 26 │ $DONOTEVALUATE(); - 27 │ var af = (x, {y: x}) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Block-implicit-negated.js:21:5] + 20 │ + 21 │ /\P{InAdlam}/u; + · ─────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-3.js:27:12] - 26 │ $DONOTEVALUATE(); - 27 │ var af = ({x}, {y: x}) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Block-implicit.js:21:5] + 20 │ + 21 │ /\p{InAdlam}/u; + · ─────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-4.js:29:12] - 28 │ $DONOTEVALUATE(); - 29 │ var af = ({x}, ...x) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Script-implicit-negated.js:21:5] + 20 │ + 21 │ /\P{InAdlam}/u; + · ─────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-5.js:29:15] - 28 │ $DONOTEVALUATE(); - 29 │ var af = ({y: x}, ...x) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Script-implicit.js:21:5] + 20 │ + 21 │ /\p{InAdlam}/u; + · ─────── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-6.js:27:15] - 26 │ $DONOTEVALUATE(); - 27 │ var af = ({y: x, x}) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Script-negated.js:21:14] + 20 │ + 21 │ /\P{InScript=Adlam}/u; + · ───── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-rest.js:23:11] - 22 │ $DONOTEVALUATE(); - 23 │ var af = (x, ...x) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/grammar-extension-In-prefix-Script.js:21:14] + 20 │ + 21 │ /\p{InScript=Adlam}/u; + · ───── ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates.js:23:11] - 22 │ $DONOTEVALUATE(); - 23 │ var af = (x, x) => 1; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/grammar-extension-Is-prefix-Script-negated.js:21:14] + 20 │ + 21 │ /\P{IsScript=Adlam}/u; + · ───── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-eval.js:24:11] - 23 │ $DONOTEVALUATE(); - 24 │ var af = (eval) => 1; - · ──── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/grammar-extension-Is-prefix-Script.js:21:14] + 20 │ + 21 │ /\p{IsScript=Adlam}/u; + · ───── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-yield.js:19:11] - 18 │ $DONOTEVALUATE(); - 19 │ var af = (yield) => 1; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-circumflex-negation-negated.js:21:2] + 20 │ + 21 │ /\P{^General_Category=Letter}/u; + · ─── ╰──── - × Line terminator not permitted before arrow - ╭─[language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters-expression-body.js:16:1] - 15 │ var af = x - 16 │ => x; - · ── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-circumflex-negation.js:21:2] + 20 │ + 21 │ /\p{^General_Category=Letter}/u; + · ─── ╰──── - × Line terminator not permitted before arrow - ╭─[language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters.js:18:1] - 17 │ var af = x - 18 │ => {}; - · ── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-empty-negated.js:21:3] + 20 │ + 21 │ /[\p{}]/u; + · ─── ╰──── - × Line terminator not permitted before arrow - ╭─[language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid.js:15:1] - 14 │ var af = () - 15 │ => {}; - · ── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-empty.js:21:3] + 20 │ + 21 │ /[\P{}]/u; + · ─── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/arrow-function/syntax/early-errors/use-strict-with-non-simple-param.js:20:3] - 19 │ var f = (a = 0) => { - 20 │ "use strict"; - · ───────────── - 21 │ }; + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-invalid-negated.js:21:6] + 20 │ + 21 │ /[\P{invalid}]/u; + · ─────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-elem-init-yield-ident-invalid.js:23:10] - 22 │ - 23 │ 0, [ x = yield ] = []; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-invalid.js:21:6] + 20 │ + 21 │ /[\p{invalid}]/u; + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-elem-nested-array-invalid.js:23:7] - 22 │ - 23 │ 0, [[(x, y)]] = [[]]; - · ──── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-no-braces-negated.js:21:2] + 20 │ + 21 │ /\P/u; + · ── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-elem-nested-array-yield-ident-invalid.js:23:8] - 22 │ - 23 │ 0, [[x[yield]]] = [[]]; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-no-braces-value-negated.js:21:2] + 20 │ + 21 │ /\PL/u; + · ── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-elem-nested-memberexpr-optchain-prop-ref-init.js:56:5] - 55 │ - 56 │ 0, [x?.y = 42] = [23]; - · ──── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-no-braces-value.js:21:2] + 20 │ + 21 │ /\pL/u; + · ── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-elem-nested-obj-invalid.js:23:12] - 22 │ - 23 │ 0, [{ get x() {} }] = [{}]; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-no-braces.js:21:2] + 20 │ + 21 │ /\p/u; + · ── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-elem-nested-obj-yield-ident-invalid.js:23:11] - 22 │ - 23 │ 0, [{ x = yield }] = [{}]; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-separator-and-value-only-negated.js:21:2] + 20 │ + 21 │ /\P{=Letter}/u; + · ─── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-elem-put-obj-literal-optchain-prop-ref-init.js:55:5] - 54 │ - 55 │ ╭─▶ 0, [{ - 56 │ │ set y(val) { - 57 │ │ throw new Test262Error('The property should not be accessed.'); - 58 │ │ } - 59 │ ╰─▶ }?.y = 42] = [23]; + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-separator-and-value-only.js:21:2] + 20 │ + 21 │ /\p{=Letter}/u; + · ─── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/assignment/dstr/array-elem-target-simple-strict.js:23:5] - 22 │ - 23 │ 0, [arguments] = []; - · ───────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-separator-negated.js:21:5] + 20 │ + 21 │ /\P{General_Category:Letter}/u; + · ──────────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-elem-target-yield-invalid.js:23:8] - 22 │ - 23 │ 0, [ x[yield] ] = []; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-separator-only-negated.js:21:2] + 20 │ + 21 │ /\P{=}/u; + · ─── ╰──── - × Spread must be last element - ╭─[language/expressions/assignment/dstr/array-rest-before-element.js:23:5] - 22 │ - 23 │ 0, [...x, y] = []; - · ──── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-separator-only.js:21:2] + 20 │ + 21 │ /\p{=}/u; + · ─── ╰──── - × Unexpected trailing comma after rest element - ╭─[language/expressions/assignment/dstr/array-rest-before-elision.js:23:9] - 22 │ - 23 │ 0, [...x,] = []; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/grammar-extension-separator.js:21:5] + 20 │ + 21 │ /\p{General_Category:Letter}/u; + · ──────────────── ╰──── - × Spread must be last element - ╭─[language/expressions/assignment/dstr/array-rest-before-rest.js:23:5] - 22 │ - 23 │ 0, [...x, ...y] = []; - · ──── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-unclosed-negated.js:21:2] + 20 │ + 21 │ /\P{/u; + · ─── ╰──── - × Unexpected trailing comma after rest element - ╭─[language/expressions/assignment/dstr/array-rest-elision-invalid.js:23:9] - 22 │ - 23 │ 0, [...x,] = []; - · ─ + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-unclosed.js:21:2] + 20 │ + 21 │ /\p{/u; + · ─── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-rest-init.js:24:8] - 23 │ - 24 │ 0, [...x = 1] = []; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-unopened-negated.js:21:2] + 20 │ + 21 │ /\P}/u; + · ── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-rest-nested-array-invalid.js:23:10] - 22 │ - 23 │ 0, [...[(x, y)]] = [[]]; - · ──── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/grammar-extension-unopened.js:21:2] + 20 │ + 21 │ /\p}/u; + · ── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-rest-nested-array-yield-ident-invalid.js:23:11] - 22 │ - 23 │ 0, [...[x[yield]]] = []; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/loose-matching-01-negated.js:18:2] + 17 │ + 18 │ /\P{ General_Category=Uppercase_Letter }/u; + · ─── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/array-rest-nested-obj-invalid.js:23:15] - 22 │ - 23 │ 0, [...{ get x() {} }] = [[]]; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/loose-matching-01.js:18:2] + 17 │ + 18 │ /\p{ General_Category=Uppercase_Letter }/u; + · ─── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-rest-nested-obj-yield-ident-invalid.js:23:14] - 22 │ - 23 │ 0, [...{ x = yield }] = [{}]; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/loose-matching-02-negated.js:18:2] + 17 │ + 18 │ /\P{ Lowercase }/u; + · ─── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/array-rest-yield-ident-invalid.js:24:10] - 23 │ - 24 │ 0, [...x[yield]] = []; - · ───── + × Unterminated unicode property escape + ╭─[built-ins/RegExp/property-escapes/loose-matching-02.js:18:2] + 17 │ + 18 │ /\p{ Lowercase }/u; + · ─── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/assignment/dstr/obj-id-identifier-yield-expr.js:24:6] - 23 │ - 24 │ 0, { yield } = {}; - · ───── - 25 │ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-03-negated.js:18:5] + 17 │ + 18 │ /\P{ANY}/u; + · ─── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/obj-id-identifier-yield-ident-invalid.js:23:6] - 22 │ - 23 │ 0, { yield } = {}; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-03.js:18:5] + 17 │ + 18 │ /\p{ANY}/u; + · ─── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/assignment/dstr/obj-id-init-simple-strict.js:23:6] - 22 │ - 23 │ 0, { eval = 0 } = {}; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-04-negated.js:18:5] + 17 │ + 18 │ /\P{ASSIGNED}/u; + · ──────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/obj-id-init-yield-ident-invalid.js:23:10] - 22 │ - 23 │ 0, { x = yield } = {}; - · ───── - ╰──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-04.js:18:5] + 17 │ + 18 │ /\p{ASSIGNED}/u; + · ──────── + ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/assignment/dstr/obj-id-simple-strict.js:23:6] - 22 │ - 23 │ 0, { eval } = {}; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-05-negated.js:18:5] + 17 │ + 18 │ /\P{Ascii}/u; + · ───── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/obj-prop-elem-init-yield-ident-invalid.js:23:13] - 22 │ - 23 │ 0, { x: x = yield } = {}; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-05.js:18:5] + 17 │ + 18 │ /\p{Ascii}/u; + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/obj-prop-elem-target-memberexpr-optchain-prop-ref-init.js:56:9] - 55 │ - 56 │ 0, { x: y?.z = 42 } = { x: 23 }; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-06-negated.js:18:5] + 17 │ + 18 │ /\P{General_Category = Uppercase_Letter}/u; + · ──────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/obj-prop-elem-target-obj-literal-optchain-prop-ref-init.js:55:9] - 54 │ - 55 │ ╭─▶ 0, { x: { - 56 │ │ set y(val) { - 57 │ │ throw new Test262Error('The property should not be accessed.'); - 58 │ │ } - 59 │ ╰─▶ }?.y = 42} = {x: 42}; + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-06.js:18:5] + 17 │ + 18 │ /\p{General_Category = Uppercase_Letter}/u; + · ──────────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/obj-prop-elem-target-yield-ident-invalid.js:23:11] - 22 │ - 23 │ 0, { x: x[yield] } = {}; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-07-negated.js:18:5] + 17 │ + 18 │ /\P{_-_lOwEr_C-A_S-E_-_}/u; + · ─ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/obj-prop-nested-array-invalid.js:23:11] - 22 │ - 23 │ 0, { x: [(x, y)] } = { x: [] }; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-07.js:18:5] + 17 │ + 18 │ /\p{_-_lOwEr_C-A_S-E_-_}/u; + · ─ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/obj-prop-nested-array-yield-ident-invalid.js:23:14] - 22 │ - 23 │ 0, { x: [x = yield] } = { x: [] }; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-08-negated.js:18:5] + 17 │ + 18 │ /\P{any}/u; + · ─── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/dstr/obj-prop-nested-obj-invalid.js:23:16] - 22 │ - 23 │ 0, { x: { get x() {} } } = { x: {} }; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-08.js:18:5] + 17 │ + 18 │ /\p{any}/u; + · ─── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/assignment/dstr/obj-prop-nested-obj-yield-ident-invalid.js:23:15] - 22 │ - 23 │ 0, { x: { x = yield } } = { x: {} }; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-09-negated.js:18:5] + 17 │ + 18 │ /\P{ascii}/u; + · ───── ╰──── - × Spread must be last element - ╭─[language/expressions/assignment/dstr/obj-rest-not-last-element-invalid.js:24:5] - 23 │ - 24 │ 0, {...rest, b} = {} - · ─────── - 25 │ ; + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-09.js:18:5] + 17 │ + 18 │ /\p{ascii}/u; + · ───── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-break-escaped.js:40:22] - 39 │ - 40 │ var x = { bre\u0061k } = { break: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-10-negated.js:18:5] + 17 │ + 18 │ /\P{assigned}/u; + · ──────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-case-escaped.js:40:21] - 39 │ - 40 │ var x = { c\u0061se } = { case: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-10.js:18:5] + 17 │ + 18 │ /\p{assigned}/u; + · ──────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-catch-escaped.js:40:22] - 39 │ - 40 │ var x = { c\u0061tch } = { catch: 42 }; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/loose-matching-11-negated.js:18:8] + 17 │ + 18 │ /\P{gC=uppercase_letter}/u; + · ──────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-class-escaped.js:40:22] - 39 │ - 40 │ var x = { cl\u0061ss } = { class: 42 }; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/loose-matching-11.js:18:8] + 17 │ + 18 │ /\p{gC=uppercase_letter}/u; + · ──────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-const-escaped.js:40:22] - 39 │ - 40 │ var x = { \u0063onst } = { const: 42 }; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/loose-matching-12-negated.js:18:8] + 17 │ + 18 │ /\P{gc=uppercaseletter}/u; + · ─────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-continue-escaped.js:40:25] - 39 │ - 40 │ var x = { \u0063ontinue } = { continue: 42 }; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/loose-matching-12.js:18:8] + 17 │ + 18 │ /\p{gc=uppercaseletter}/u; + · ─────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-debugger-escaped.js:40:25] - 39 │ - 40 │ var x = { \u0064ebugger } = { debugger: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-13-negated.js:18:5] + 17 │ + 18 │ /\P{lowercase}/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped-ext.js:40:24] - 39 │ - 40 │ var x = { def\u{61}ult } = { default: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-13.js:18:5] + 17 │ + 18 │ /\p{lowercase}/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped.js:40:24] - 39 │ - 40 │ var x = { def\u0061ult } = { default: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-14-negated.js:18:5] + 17 │ + 18 │ /\P{lowercase}/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-default.js:40:19] - 39 │ - 40 │ var x = { default } = { default: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/loose-matching-14.js:18:5] + 17 │ + 18 │ /\p{lowercase}/u; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-delete-escaped.js:40:23] - 39 │ - 40 │ var x = { \u0064elete } = { delete: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-General_Category-equals-negated.js:17:5] + 16 │ + 17 │ /\P{General_Category=}/u; + · ──────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-do-escaped.js:40:19] - 39 │ - 40 │ var x = { \u0064o } = { do: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-General_Category-equals.js:17:5] + 16 │ + 17 │ /\p{General_Category=}/u; + · ──────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-else-escaped.js:40:21] - 39 │ - 40 │ var x = { \u0065lse } = { else: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-General_Category-negated.js:17:5] + 16 │ + 17 │ /\P{General_Category}/u; + · ──────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-enum-escaped.js:40:21] - 39 │ - 40 │ var x = { \u0065num } = { enum: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-General_Category.js:17:5] + 16 │ + 17 │ /\p{General_Category}/u; + · ──────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-export-escaped.js:40:23] - 39 │ - 40 │ var x = { \u0065xport } = { export: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script-equals-negated.js:17:5] + 16 │ + 17 │ /\P{Script=}/u; + · ────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped-ext.js:40:24] - 39 │ - 40 │ var x = { \u{65}xtends } = { extends: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script-equals.js:17:5] + 16 │ + 17 │ /\p{Script=}/u; + · ────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped.js:40:24] - 39 │ - 40 │ var x = { \u0065xtends } = { extends: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script-negated.js:17:5] + 16 │ + 17 │ /\P{Script}/u; + · ────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-extends.js:40:19] - 39 │ - 40 │ var x = { extends } = { extends: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script.js:17:5] + 16 │ + 17 │ /\p{Script}/u; + · ────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-finally-escaped.js:40:24] - 39 │ - 40 │ var x = { \u0066inally } = { finally: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions-equals-negated.js:17:5] + 16 │ + 17 │ /\P{Script_Extensions=}/u; + · ───────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-for-escaped.js:40:20] - 39 │ - 40 │ var x = { \u0066or } = { for: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions-equals.js:17:5] + 16 │ + 17 │ /\p{Script_Extensions=}/u; + · ───────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-function-escaped.js:40:25] - 39 │ - 40 │ var x = { \u0066unction } = { function: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions-negated.js:17:5] + 16 │ + 17 │ /\P{Script_Extensions}/u; + · ───────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-if-escaped.js:40:19] - 39 │ - 40 │ var x = { i\u0066 } = { if: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-binary-property-without-value-Script_Extensions.js:17:5] + 16 │ + 17 │ /\p{Script_Extensions}/u; + · ───────────────── ╰──── - × The keyword 'implements' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-implements-escaped.js:40:11] - 39 │ - 40 │ var x = { \u0069mplements } = { implements: 42 }; - · ─────────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-existent-binary-property-negated.js:17:5] + 16 │ + 17 │ /\P{UnknownBinaryProperty}/u; + · ───────────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-import-escaped.js:40:23] - 39 │ - 40 │ var x = { \u0069mport } = { import: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/non-existent-binary-property.js:17:5] + 16 │ + 17 │ /\p{UnknownBinaryProperty}/u; + · ───────────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-in-escaped.js:40:19] - 39 │ - 40 │ var x = { \u0069n } = { in: 42 }; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/non-existent-property-and-value-negated.js:18:17] + 17 │ + 18 │ /\P{Line_Breakz=WAT}/u; + · ─── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-instanceof-escaped.js:40:27] - 39 │ - 40 │ var x = { \u0069nstanceof } = { instanceof: 42 }; - · ─ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/non-existent-property-and-value.js:18:17] + 17 │ + 18 │ /\p{Line_Breakz=WAT}/u; + · ─── ╰──── - × The keyword 'interface' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-interface-escaped.js:40:11] - 39 │ - 40 │ var x = { interf\u0061ce } = { interface: 42 }; - · ────────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/non-existent-property-existing-value-negated.js:17:17] + 16 │ + 17 │ /\P{Line_Breakz=Alphabetic}/u; + · ────────── ╰──── - × The keyword 'let' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-let-escaped.js:40:11] - 39 │ - 40 │ var x = { l\u0065t } = { let: 42 }; - · ──────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/non-existent-property-existing-value.js:17:17] + 16 │ + 17 │ /\p{Line_Breakz=Alphabetic}/u; + · ────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-new-escaped.js:40:20] - 39 │ - 40 │ var x = { n\u0065w } = { new: 42 }; - · ─ + × Could not parse the entire pattern + ╭─[built-ins/RegExp/property-escapes/non-existent-property-value-General_Category-negated.js:18:5] + 17 │ + 18 │ /\\P{General_Category=WAT}/u; + · ▲ ╰──── - × The keyword 'package' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-package-escaped.js:40:11] - 39 │ - 40 │ var x = { p\u0061ckage } = { package: 42 }; - · ──────────── + × Could not parse the entire pattern + ╭─[built-ins/RegExp/property-escapes/non-existent-property-value-Script-negated.js:18:5] + 17 │ + 18 │ /\\P{Script=FooBarBazInvalid}/u; + · ▲ ╰──── - × The keyword 'private' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-private-escaped.js:40:11] - 39 │ - 40 │ var x = { privat\u0065 } = { private: 42 }; - · ──────────── + × Could not parse the entire pattern + ╭─[built-ins/RegExp/property-escapes/non-existent-property-value-Script.js:18:5] + 17 │ + 18 │ /\\p{Script=FooBarBazInvalid}/u; + · ▲ ╰──── - × The keyword 'protected' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-protected-escaped.js:40:11] - 39 │ - 40 │ var x = { prot\u0065cted } = { protected: 42 }; - · ────────────── + × Could not parse the entire pattern + ╭─[built-ins/RegExp/property-escapes/non-existent-property-value-Script_Extensions-negated.js:18:5] + 17 │ + 18 │ /\\P{Script_Extensions=H_e_h}/u; + · ▲ ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-public-escaped.js:40:11] - 39 │ - 40 │ var x = { pu\u0062lic } = { public: 42 }; - · ─────────── + × Could not parse the entire pattern + ╭─[built-ins/RegExp/property-escapes/non-existent-property-value-Script_Extensions.js:18:5] + 17 │ + 18 │ /\\p{Script_Extensions=H_e_h}/u; + · ▲ ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-return-escaped.js:40:23] - 39 │ - 40 │ var x = { r\u0065turn } = { return: 42 }; - · ─ + × Could not parse the entire pattern + ╭─[built-ins/RegExp/property-escapes/non-existent-property-value-general-category.js:18:5] + 17 │ + 18 │ /\\p{General_Category=WAT}/u; + · ▲ ╰──── - × The keyword 'static' is reserved - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-static-escaped.js:40:11] - 39 │ - 40 │ var x = { st\u0061tic } = { static: 42 }; - · ─────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Composition_Exclusion-negated.js:18:5] + 17 │ + 18 │ /\P{Composition_Exclusion}/u; + · ───────────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-super-escaped.js:40:22] - 39 │ - 40 │ var x = { sup\u0065r } = { super: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Composition_Exclusion.js:18:5] + 17 │ + 18 │ /\p{Composition_Exclusion}/u; + · ───────────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-switch-escaped.js:40:23] - 39 │ - 40 │ var x = { sw\u0069tch } = { switch: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFC-negated.js:18:5] + 17 │ + 18 │ /\P{Expands_On_NFC}/u; + · ────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-this-escaped.js:40:21] - 39 │ - 40 │ var x = { th\u0069s } = { this: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFC.js:18:5] + 17 │ + 18 │ /\p{Expands_On_NFC}/u; + · ────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-throw-escaped.js:40:22] - 39 │ - 40 │ var x = { t\u0068row } = { throw: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFD-negated.js:18:5] + 17 │ + 18 │ /\P{Expands_On_NFD}/u; + · ────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-try-escaped.js:40:20] - 39 │ - 40 │ var x = { tr\u0079 } = { try: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFD.js:18:5] + 17 │ + 18 │ /\p{Expands_On_NFD}/u; + · ────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-typeof-escaped.js:40:23] - 39 │ - 40 │ var x = { typ\u0065of } = { typeof: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKC-negated.js:18:5] + 17 │ + 18 │ /\P{Expands_On_NFKC}/u; + · ─────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-var-escaped.js:40:20] - 39 │ - 40 │ var x = { v\u0061r } = { var: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKC.js:18:5] + 17 │ + 18 │ /\p{Expands_On_NFKC}/u; + · ─────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-void-escaped.js:40:21] - 39 │ - 40 │ var x = { voi\u0064 } = { void: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKD-negated.js:18:5] + 17 │ + 18 │ /\P{Expands_On_NFKD}/u; + · ─────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-while-escaped.js:40:22] - 39 │ - 40 │ var x = { whil\u0065 } = { while: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Expands_On_NFKD.js:18:5] + 17 │ + 18 │ /\p{Expands_On_NFKD}/u; + · ─────────────── ╰──── - × Unexpected token - ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-with-escaped.js:40:21] - 39 │ - 40 │ var x = { w\u0069th } = { with: 42 }; - · ─ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-FC_NFKC_Closure-negated.js:18:5] + 17 │ + 18 │ /\P{FC_NFKC_Closure}/u; + · ─────────────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/assignment/id-arguments-strict.js:16:2] - 15 │ - 16 │ (arguments) = 20; - · ───────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-FC_NFKC_Closure.js:18:5] + 17 │ + 18 │ /\p{FC_NFKC_Closure}/u; + · ─────────────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/assignment/id-eval-strict.js:16:2] - 15 │ - 16 │ (eval) = 20; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Full_Composition_Exclusion-negated.js:18:5] + 17 │ + 18 │ /\P{Full_Composition_Exclusion}/u; + · ────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/non-simple-target.js:18:1] + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Full_Composition_Exclusion.js:18:5] 17 │ - 18 │ 1 = 1; - · ─ + 18 │ /\p{Full_Composition_Exclusion}/u; + · ────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-assignment-inside-function.js:22:4] - 21 │ var a, b = 2; - 22 │ (a = b) = 1; - · ───── - 23 │ } + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Grapheme_Link-negated.js:18:5] + 17 │ + 18 │ /\P{Grapheme_Link}/u; + · ───────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-assignment.js:21:2] - 20 │ var a, b = 2; - 21 │ (a = b) = 1; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Grapheme_Link.js:18:5] + 17 │ + 18 │ /\p{Grapheme_Link}/u; + · ───────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-boolean.js:22:1] - 21 │ - 22 │ true = 42; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Hyphen-negated.js:18:5] + 17 │ + 18 │ /\P{Hyphen}/u; + · ────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-cover-newtarget.js:29:4] - 28 │ function f() { - 29 │ (new.target) = 1; - · ────────── - 30 │ } + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Hyphen.js:18:5] + 17 │ + 18 │ /\p{Hyphen}/u; + · ────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-cover-yieldexpr.js:32:4] - 31 │ function* g() { - 32 │ (yield) = 1; - · ───── - 33 │ } + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Alphabetic-negated.js:18:5] + 17 │ + 18 │ /\P{Other_Alphabetic}/u; + · ──────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-newtarget.js:29:3] - 28 │ function f() { - 29 │ new.target = 1; - · ────────── - 30 │ } + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Alphabetic.js:18:5] + 17 │ + 18 │ /\p{Other_Alphabetic}/u; + · ──────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-null.js:22:1] - 21 │ - 22 │ null = 42; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Default_Ignorable_Code_Point-negated.js:18:5] + 17 │ + 18 │ /\P{Other_Default_Ignorable_Code_Point}/u; + · ────────────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-number.js:22:1] - 21 │ - 22 │ 42 = 42; - · ── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Default_Ignorable_Code_Point.js:18:5] + 17 │ + 18 │ /\p{Other_Default_Ignorable_Code_Point}/u; + · ────────────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignment/target-string.js:22:1] - 21 │ - 22 │ 'x' = 42; - · ─── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Grapheme_Extend-negated.js:18:5] + 17 │ + 18 │ /\P{Other_Grapheme_Extend}/u; + · ───────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-0.js:20:1] - 19 │ - 20 │ x - y = 1; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Grapheme_Extend.js:18:5] + 17 │ + 18 │ /\p{Other_Grapheme_Extend}/u; + · ───────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-1.js:20:1] - 19 │ - 20 │ 1 - 2 = 1; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Continue-negated.js:18:5] + 17 │ + 18 │ /\P{Other_ID_Continue}/u; + · ───────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-2.js:20:1] - 19 │ - 20 │ true - false = 1; - · ──────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Continue.js:18:5] + 17 │ + 18 │ /\p{Other_ID_Continue}/u; + · ───────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-0.js:20:1] - 19 │ - 20 │ x + y = 1; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Start-negated.js:18:5] + 17 │ + 18 │ /\P{Other_ID_Start}/u; + · ────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-1.js:20:1] - 19 │ - 20 │ 1 + 2 = 1; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_ID_Start.js:18:5] + 17 │ + 18 │ /\p{Other_ID_Start}/u; + · ────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-2.js:20:1] - 19 │ - 20 │ true + false = 1; - · ──────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Lowercase-negated.js:18:5] + 17 │ + 18 │ /\P{Other_Lowercase}/u; + · ─────────────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-0.js:20:9] - 19 │ - 20 │ () => {} = 1; - · ▲ + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Lowercase.js:18:5] + 17 │ + 18 │ /\p{Other_Lowercase}/u; + · ─────────────── ╰──── - help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-1.js:20:7] - 19 │ - 20 │ () => ({}) = 1; - · ──── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Math-negated.js:18:5] + 17 │ + 18 │ /\P{Other_Math}/u; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-2.js:20:2] - 19 │ - 20 │ (x => x) = 1; - · ────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Math.js:18:5] + 17 │ + 18 │ /\p{Other_Math}/u; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-3.js:20:2] - 19 │ - 20 │ ((x) => x) = 1; - · ──────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Uppercase-negated.js:18:5] + 17 │ + 18 │ /\P{Other_Uppercase}/u; + · ─────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-4.js:20:2] - 19 │ - 20 │ (() => 1) = 1; - · ─────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Other_Uppercase.js:18:5] + 17 │ + 18 │ /\p{Other_Uppercase}/u; + · ─────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-5.js:20:2] - 19 │ - 20 │ (() => true) = 1; - · ────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Prepended_Concatenation_Mark-negated.js:18:5] + 17 │ + 18 │ /\P{Prepended_Concatenation_Mark}/u; + · ──────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-6.js:20:2] - 19 │ - 20 │ (() => 1) = 1; - · ─────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-binary-property-Prepended_Concatenation_Mark.js:18:5] + 17 │ + 18 │ /\p{Prepended_Concatenation_Mark}/u; + · ──────────────────────────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-0.js:20:15] - 19 │ - 20 │ async () => {} = 1; - · ▲ + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/unsupported-property-Block-with-value-negated.js:18:11] + 17 │ + 18 │ /\P{Block=Adlam}/u; + · ───── ╰──── - help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-1.js:20:13] - 19 │ - 20 │ async () => ({}) = 1; - · ──── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/unsupported-property-Block-with-value.js:18:11] + 17 │ + 18 │ /\p{Block=Adlam}/u; + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-2.js:20:2] - 19 │ - 20 │ (async x => x) = 1; - · ──────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-property-FC_NFKC_Closure-negated.js:18:5] + 17 │ + 18 │ /\P{FC_NFKC_Closure}/u; + · ─────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-3.js:20:2] - 19 │ - 20 │ (async (x) => x) = 1; - · ────────────── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-property-FC_NFKC_Closure.js:18:5] + 17 │ + 18 │ /\p{FC_NFKC_Closure}/u; + · ─────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-4.js:20:2] - 19 │ - 20 │ (async () => 1) = 1; - · ───────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/unsupported-property-Line_Break-negated.js:18:16] + 17 │ + 18 │ /\P{Line_Break=Alphabetic}/u; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-5.js:20:2] - 19 │ - 20 │ (async () => true) = 1; - · ──────────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/unsupported-property-Line_Break-with-value-negated.js:18:16] + 17 │ + 18 │ /\P{Line_Break=Alphabetic}/u; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-6.js:20:2] - 19 │ - 20 │ (async () => 1) = 1; - · ───────────── + × Invalid unicode property name + ╭─[built-ins/RegExp/property-escapes/unsupported-property-Line_Break-with-value.js:18:16] + 17 │ + 18 │ /\p{Line_Break=Alphabetic}/u; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-0.js:20:1] - 19 │ - 20 │ x & y = 1; - · ───── + × Invalid unicode property name or value + ╭─[built-ins/RegExp/property-escapes/unsupported-property-Line_Break.js:18:5] + 17 │ + 18 │ /\p{Line_Break}/u; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-1.js:20:1] - 19 │ - 20 │ 1 & 2 = 1; - · ───── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-01.js:19:3] + 18 │ + 19 │ /[(]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-2.js:20:1] - 19 │ - 20 │ true & false = 1; - · ──────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-02.js:19:3] + 18 │ + 19 │ /[)]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js:20:1] - 19 │ - 20 │ x | y = 1; - · ───── + × Unterminated character class + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-03.js:19:2] + 18 │ + 19 │ /[[]/v; + · ─── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js:20:1] - 19 │ - 20 │ 1 | 2 = 1; - · ───── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-04.js:19:3] + 18 │ + 19 │ /[{]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js:20:1] - 19 │ - 20 │ true | false = 1; - · ──────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-05.js:19:3] + 18 │ + 19 │ /[}]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js:20:1] - 19 │ - 20 │ x ^ y = 1; - · ───── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-06.js:19:3] + 18 │ + 19 │ /[/]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js:20:1] - 19 │ - 20 │ 1 ^ 2 = 1; - · ───── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-07.js:19:3] + 18 │ + 19 │ /[-]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js:20:1] - 19 │ - 20 │ true ^ false = 1; - · ──────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-08.js:19:3] + 18 │ + 19 │ /[|]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-callexpression-arguments.js:20:1] - 19 │ - 20 │ f() = 1; - · ─── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-09.js:19:3] + 18 │ + 19 │ /[&&]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-callexpression-templateliteral.js:20:1] - 19 │ - 20 │ f()`` = 1; - · ───── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-10.js:19:3] + 18 │ + 19 │ /[!!]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js:20:1] - 19 │ - 20 │ x ?? y = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-11.js:19:3] + 18 │ + 19 │ /[##]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js:20:1] - 19 │ - 20 │ 1 ?? 2 = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-12.js:19:3] + 18 │ + 19 │ /[$$]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js:20:1] - 19 │ - 20 │ true ?? false = 1; - · ───────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-13.js:19:3] + 18 │ + 19 │ /[%%]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-0.js:20:1] - 19 │ - 20 │ x == y = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-14.js:19:3] + 18 │ + 19 │ /[**]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-1.js:20:1] - 19 │ - 20 │ 1 == 2 = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-15.js:19:3] + 18 │ + 19 │ /[++]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-2.js:20:1] - 19 │ - 20 │ true == false = 1; - · ───────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-16.js:19:3] + 18 │ + 19 │ /[,,]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-0.js:20:1] - 19 │ - 20 │ x != y = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-17.js:19:3] + 18 │ + 19 │ /[..]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-1.js:20:1] - 19 │ - 20 │ 1 != 2 = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-18.js:19:3] + 18 │ + 19 │ /[::]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-2.js:20:1] - 19 │ - 20 │ true != false = 1; - · ───────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-19.js:19:3] + 18 │ + 19 │ /[;;]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-0.js:20:1] - 19 │ - 20 │ x == y = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-20.js:19:3] + 18 │ + 19 │ /[<<]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-1.js:20:1] - 19 │ - 20 │ 1 == 2 = 1; - · ────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-21.js:19:3] + 18 │ + 19 │ /[==]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-2.js:20:1] - 19 │ - 20 │ true == false = 1; - · ───────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-22.js:19:3] + 18 │ + 19 │ /[>>]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-0.js:20:1] - 19 │ - 20 │ x !== y = 1; - · ─────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-23.js:19:3] + 18 │ + 19 │ /[??]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-1.js:20:1] - 19 │ - 20 │ 1 !== 2 = 1; - · ─────── - ╰──── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-24.js:19:3] + 18 │ + 19 │ /[@@]/v; + · ▲ + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-2.js:20:1] - 19 │ - 20 │ true !== false = 1; - · ────────────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-25.js:19:3] + 18 │ + 19 │ /[``]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-0.js:20:2] - 19 │ - 20 │ (x, y = z) = 1; - · ──────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-26.js:19:3] + 18 │ + 19 │ /[~~]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-1.js:20:2] - 19 │ - 20 │ (x, y = 1) = 1; - · ──────── + × Expected nonempty class set expression + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-27.js:19:4] + 18 │ + 19 │ /[^^^]/v; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-2.js:20:2] - 19 │ - 20 │ (x, y = true) = 1; - · ─────────── + × Unterminated character class + ╭─[built-ins/RegExp/prototype/unicodeSets/breaking-change-from-u-to-v-28.js:19:2] + 18 │ + 19 │ /[_^^]/v; + · ── + ╰──── + + × The 'u' and 'v' regular expression flags cannot be enabled at the same time + ╭─[built-ins/RegExp/prototype/unicodeSets/uv-flags.js:17:1] + 16 │ + 17 │ /./uv; + · ───── ╰──── × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/assignmenttargettype/direct-identifierreference-arguments-strict.js:16:1] - 15 │ - 16 │ arguments = 1; - · ───────── + ╭─[language/arguments-object/10.5-1gs.js:17:5] + 16 │ function f_10_5_1_gs(){ + 17 │ arguments = 7; + · ───────── + 18 │ } ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/assignmenttargettype/direct-identifierreference-eval-strict.js:16:1] - 15 │ - 16 │ eval = 1; - · ──── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/asi/S7.9.2_A1_T1.js:16:4] + 15 │ //CHECK#1 + 16 │ { 1 2 } 3 + · ▲ ╰──── + help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-import.meta.js:20:1] - 19 │ - 20 │ import.meta = 1; - · ─────────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9.2_A1_T3.js:17:1] + 16 │ for( a ; b + 17 │ ) + · ┬ + · ╰── `;` expected ╰──── × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-importcall.js:20:8] - 19 │ - 20 │ import() = 1; - · ─ + ╭─[language/asi/S7.9.2_A1_T6.js:20:1] + 19 │ if(a>b) + 20 │ else c=d + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-0.js:20:2] - 19 │ - 20 │ (x = y) = 1; - · ───── + × Unexpected token + ╭─[language/asi/S7.9_A10_T2.js:16:4] + 15 │ //CHECK#1 + 16 │ {} * 1 + · ─ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-1.js:20:2] - 19 │ - 20 │ (x = 1) = 1; - · ───── + × Expected `,` but found `;` + ╭─[language/asi/S7.9_A10_T4.js:16:4] + 15 │ //CHECK#1 + 16 │ ({};) * 1 + · ┬ + · ╰── `,` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-2.js:20:2] - 19 │ - 20 │ (x = true) = 1; - · ──────── + × Unexpected token + ╭─[language/asi/S7.9_A10_T6.js:17:2] + 16 │ {} + 17 │ * 1 + · ─ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js:20:2] - 19 │ - 20 │ (x ??= y) = 1; - · ─────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/asi/S7.9_A10_T8.js:16:3] + 15 │ //CHECK#1 + 16 │ {1 2} 3 + · ▲ ╰──── + help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js:20:2] - 19 │ - 20 │ (x ??= 1) = 1; - · ─────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/asi/S7.9_A11_T4.js:17:17] + 16 │ var x = 0; + 17 │ if (false) x = 1 else x = -1 + · ▲ ╰──── + help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js:20:2] - 19 │ - 20 │ (x ??= true) = 1; - · ────────── + × Unexpected token + ╭─[language/asi/S7.9_A11_T8.js:16:1] + 15 │ if (false) {}; + 16 │ else {} + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js:20:2] - 19 │ - 20 │ (x &&= y) = 1; - · ─────── + × Illegal newline after throw + ╭─[language/asi/S7.9_A4.js:17:3] + 16 │ try { + 17 │ throw + · ──┬── + · ╰── throw starts here + 18 │ 1; + · ┬ + · ╰── A newline is not expected here + 19 │ } catch(e) { ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js:20:2] - 19 │ - 20 │ (x &&= 1) = 1; - · ─────── + × Unexpected token + ╭─[language/asi/S7.9_A5.1_T1.js:17:3] + 16 │ x + 17 │ ++; + · ─ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js:20:2] - 19 │ - 20 │ (x &&= true) = 1; - · ────────── + × Unexpected token + ╭─[language/asi/S7.9_A5.3_T1.js:18:3] + 17 │ x + 18 │ --; + · ─ ╰──── × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js:20:2] - 19 │ - 20 │ (x ||= y) = 1; - · ─────── + ╭─[language/asi/S7.9_A5.7_T1.js:23:1] + 22 │ x + 23 │ ╭─▶ ++ + 24 │ │ ++ + 25 │ ╰─▶ y ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js:20:2] - 19 │ - 20 │ (x ||= 1) = 1; - · ─────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T1.js:20:1] + 19 │ for(; + 20 │ ) { + · ┬ + · ╰── `;` expected + 21 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js:20:2] - 19 │ - 20 │ (x ||= true) = 1; - · ────────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T10.js:21:2] + 20 │ false + 21 │ ;) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-minus-minus.js:20:1] - 19 │ - 20 │ x-- = 1; - · ─── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T2.js:21:1] + 20 │ ; + 21 │ ) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-plus-plus.js:20:1] - 19 │ - 20 │ x++ = 1; - · ─── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T3.js:20:2] + 19 │ for( + 20 │ ;) { + · ┬ + · ╰── `;` expected + 21 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-0.js:20:1] - 19 │ - 20 │ x && y = 1; - · ────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T4.js:21:2] + 20 │ + 21 │ ;) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-1.js:20:1] - 19 │ - 20 │ 1 && 2 = 1; - · ────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T5.js:20:1] + 19 │ for(false;false + 20 │ ) { + · ┬ + · ╰── `;` expected + 21 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-2.js:20:1] - 19 │ - 20 │ true && false = 1; - · ───────────── - ╰──── - - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-0.js:20:1] - 19 │ - 20 │ x || y = 1; - · ────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T6.js:21:1] + 20 │ false + 21 │ ) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-1.js:20:1] - 19 │ - 20 │ 1 || 2 = 1; - · ────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T7.js:21:1] + 20 │ ; + 21 │ ) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-2.js:20:1] - 19 │ - 20 │ true || false = 1; - · ───────────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T8.js:21:1] + 20 │ ;false + 21 │ ) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-memberexpression-templateliteral.js:20:1] - 19 │ - 20 │ o.f()`` = 1; - · ─────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.2_T9.js:20:7] + 19 │ for( + 20 │ ;false) { + · ┬ + · ╰── `;` expected + 21 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-minus-minus-unaryexpression.js:20:1] - 19 │ - 20 │ --x = 1; - · ─── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.3_T1.js:20:1] + 19 │ for( + 20 │ ) { + · ┬ + · ╰── `;` expected + 21 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js:20:1] - 19 │ - 20 │ x * y = 1; - · ───── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.3_T2.js:21:1] + 20 │ + 21 │ ) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js:20:1] - 19 │ - 20 │ 1 * 2 = 1; - · ───── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.3_T3.js:22:1] + 21 │ + 22 │ ) { + · ┬ + · ╰── `;` expected + 23 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js:20:1] - 19 │ - 20 │ true * false = 1; - · ──────────── + × Expected `;` but found `)` + ╭─[language/asi/S7.9_A6.3_T4.js:21:1] + 20 │ false + 21 │ ) { + · ┬ + · ╰── `;` expected + 22 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js:20:1] - 19 │ - 20 │ x / y = 1; - · ───── + × Expected `;` but found `false` + ╭─[language/asi/S7.9_A6.3_T5.js:20:5] + 19 │ for(false + 20 │ false + · ──┬── + · ╰── `;` expected + 21 │ ) { ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js:20:1] - 19 │ - 20 │ 1 / 2 = 1; - · ───── + × Expected `;` but found `false` + ╭─[language/asi/S7.9_A6.3_T6.js:21:5] + 20 │ false + 21 │ false + · ──┬── + · ╰── `;` expected + 22 │ ) { ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js:20:1] - 19 │ - 20 │ true / false = 1; - · ──────────── + × Expected `;` but found `false` + ╭─[language/asi/S7.9_A6.3_T7.js:21:5] + 20 │ false + 21 │ false + · ──┬── + · ╰── `;` expected + 22 │ false ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-new-memberexpression-arguments.js:20:1] - 19 │ - 20 │ new f() = 1; - · ─────── + × Expected `)` but found `;` + ╭─[language/asi/S7.9_A6.4_T1.js:18:22] + 17 │ //CHECK#1 + 18 │ for(false;false;false;) { + · ┬ + · ╰── `)` expected + 19 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-new-newexpression.js:20:1] - 19 │ - 20 │ new f = 1; - · ───── + × Unexpected token + ╭─[language/asi/S7.9_A6.4_T2.js:18:17] + 17 │ //CHECK#1 + 18 │ for(false;false;;false) { + · ─ + 19 │ break; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-optionalexpression.js:21:1] - 20 │ - 21 │ x?.y = 1; - · ──── + × Unexpected token + ╭─[language/asi/S7.9_A9_T6.js:18:1] + 17 │ while (false) ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-plus-plus-unaryexpression.js:20:1] - 19 │ - 20 │ ++x = 1; - · ─── + × Unexpected token + ╭─[language/asi/S7.9_A9_T7.js:19:1] + 18 │ while (false) ╰──── - × Expected function name - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js:16:16] - 15 │ - 16 │ async function () {} = 1; - · ─ + × Expected `while` but found `;` + ╭─[language/asi/S7.9_A9_T8.js:16:6] + 15 │ //CHECK#1 + 16 │ do {}; + · ┬ + · ╰── `while` expected + 17 │ while (false) ╰──── - help: Function name is required in function declaration or named export - × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js:16:22] + × for-in loop variable declaration may not have an initializer + ╭─[language/block-scope/syntax/for-in/disallow-initialization-assignment.js:14:6] + 13 │ $DONOTEVALUATE(); + 14 │ for (let x = 3 in {}) { } + · ───────── 15 │ - 16 │ async function () {} = 1; - · ─ ╰──── - × Expected function name - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js:16:16] + × Only a single declaration is allowed in a `for...in` statement + ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-and-without-initializer.js:14:6] + 13 │ $DONOTEVALUATE(); + 14 │ for (let x = 3, y in {}) { } + · ──────────── 15 │ - 16 │ async function () {} = 1; - · ─ ╰──── - help: Function name is required in function declaration or named export - × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js:16:22] + × Only a single declaration is allowed in a `for...in` statement + ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-initializer.js:14:6] + 13 │ $DONOTEVALUATE(); + 14 │ for (let x = 3, y = 4 in {}) { } + · ──────────────── 15 │ - 16 │ async function () {} = 1; - · ─ ╰──── - × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-classexpression.js:16:10] + × Only a single declaration is allowed in a `for...in` statement + ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-without-and-with-initializer.js:14:6] + 13 │ $DONOTEVALUATE(); + 14 │ for (let x, y = 4 in {}) { } + · ──────────── 15 │ - 16 │ class {} = 1; - · ─ ╰──── - × Expected function name - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js:16:9] + × Only a single declaration is allowed in a `for...in` statement + ╭─[language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings.js:14:6] + 13 │ $DONOTEVALUATE(); + 14 │ for (let x, y in {}) { } + · ──────── 15 │ - 16 │ function() {} = 1; - · ─ ╰──── - help: Function name is required in function declaration or named export - × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js:16:15] + × Invalid function declaration + ╭─[language/block-scope/syntax/function-declarations/in-statement-position-do-statement-while-expression.js:14:4] + 13 │ $DONOTEVALUATE(); + 14 │ do function g() {} while (false) + · ─────────────── 15 │ - 16 │ function() {} = 1; - · ─ ╰──── + help: In strict mode code, functions can only be declared at top level or inside a block - × Expected function name - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js:16:12] + × Invalid function declaration + ╭─[language/block-scope/syntax/function-declarations/in-statement-position-for-statement.js:14:15] + 13 │ $DONOTEVALUATE(); + 14 │ for (;false;) function g() {} + · ─────────────── 15 │ - 16 │ function * () {} = 1; - · ─ ╰──── - help: Function name is required in function declaration or named export + help: In strict mode code, functions can only be declared at top level or inside a block - × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js:16:18] - 15 │ - 16 │ function * () {} = 1; - · ─ + × Invalid function declaration + ╭─[language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement-else-statement.js:15:19] + 14 │ $DONOTEVALUATE(); + 15 │ if (true) {} else function g() {} + · ─────────────── + 16 │ ╰──── + help: In strict mode code, functions can only be declared at top level or inside a block - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-boolean.js:16:1] - 15 │ - 16 │ true = 1; - · ──── + × Invalid function declaration + ╭─[language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement.js:15:11] + 14 │ $DONOTEVALUATE(); + 15 │ if (true) function g() {} + · ─────────────── + 16 │ ╰──── + help: In strict mode code, functions can only be declared at top level or inside a block - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-null.js:16:1] + × Invalid function declaration + ╭─[language/block-scope/syntax/function-declarations/in-statement-position-while-expression-statement.js:14:15] + 13 │ $DONOTEVALUATE(); + 14 │ while (false) function g() {} + · ─────────────── 15 │ - 16 │ null = 1; - · ──── ╰──── + help: In strict mode code, functions can only be declared at top level or inside a block - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-numeric.js:16:1] - 15 │ - 16 │ 0 = 1; - · ─ + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-function.js:23:18] + 22 │ + 23 │ { async function f() {} async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-string.js:16:1] - 15 │ - 16 │ '' = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-generator.js:23:18] + 22 │ + 23 │ { async function f() {} async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Unexpected token - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-objectliteral.js:16:4] - 15 │ - 16 │ {} = 1; - · ─ + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-class.js:23:18] + 22 │ + 23 │ { async function f() {} class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-regularexpressionliteral.js:16:1] - 15 │ - 16 │ /1/ = 1; - · ─── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-const.js:23:18] + 22 │ + 23 │ { async function f() {} const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-templateliteral.js:16:1] - 15 │ - 16 │ `` = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-function.js:23:18] + 22 │ + 23 │ { async function f() {} function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-this.js:16:1] - 15 │ - 16 │ this = 1; - · ──── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-generator.js:23:18] + 22 │ + 23 │ { async function f() {} function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js:20:1] - 19 │ - 20 │ x >= y = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-let.js:23:18] + 22 │ + 23 │ { async function f() {} let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js:20:1] - 19 │ - 20 │ 1 >= 2 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-var.js:23:18] + 22 │ + 23 │ { async function f() {} var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js:20:1] - 19 │ - 20 │ true >= false = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-function.js:23:19] + 22 │ + 23 │ { async function* f() {} async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-0.js:20:1] - 19 │ - 20 │ x > y = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-generator.js:23:19] + 22 │ + 23 │ { async function* f() {} async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-1.js:20:1] - 19 │ - 20 │ 1 > 2 = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-class.js:23:19] + 22 │ + 23 │ { async function* f() {} class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-2.js:20:1] - 19 │ - 20 │ true > false = 1; - · ──────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-const.js:23:19] + 22 │ + 23 │ { async function* f() {} const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-0.js:20:1] - 19 │ - 20 │ x in y = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-function.js:23:19] + 22 │ + 23 │ { async function* f() {} function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-1.js:20:1] - 19 │ - 20 │ 1 in 2 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-generator.js:23:19] + 22 │ + 23 │ { async function* f() {} function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-2.js:20:1] - 19 │ - 20 │ true in false = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-let.js:23:19] + 22 │ + 23 │ { async function* f() {} let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-0.js:20:1] - 19 │ - 20 │ x instanceof y = 1; - · ────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-var.js:23:19] + 22 │ + 23 │ { async function* f() {} var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-1.js:20:1] - 19 │ - 20 │ 1 instanceof 2 = 1; - · ────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-function.js:23:9] + 22 │ + 23 │ { class f {} async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-2.js:20:1] - 19 │ - 20 │ true instanceof false = 1; - · ───────────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-generator.js:23:9] + 22 │ + 23 │ { class f {} async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-0.js:20:1] - 19 │ - 20 │ x <= y = 1; - · ────── - ╰──── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-class.js:22:9] + 21 │ + 22 │ { class f {} class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-1.js:20:1] - 19 │ - 20 │ 1 <= 2 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-const.js:22:9] + 21 │ + 22 │ { class f {} const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-2.js:20:1] - 19 │ - 20 │ true <= false = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-function.js:22:9] + 21 │ + 22 │ { class f {} function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-0.js:20:1] - 19 │ - 20 │ x < y = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-generator.js:23:9] + 22 │ + 23 │ { class f {} function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-1.js:20:1] - 19 │ - 20 │ 1 < 2 = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-let.js:22:9] + 21 │ + 22 │ { class f {} let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-2.js:20:1] - 19 │ - 20 │ true < false = 1; - · ──────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-var.js:22:9] + 21 │ + 22 │ { class f {} var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-0.js:20:1] - 19 │ - 20 │ x << y = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-function.js:23:9] + 22 │ + 23 │ { const f = 0; async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-1.js:20:1] - 19 │ - 20 │ 1 << 2 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-generator.js:23:9] + 22 │ + 23 │ { const f = 0; async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-2.js:20:1] - 19 │ - 20 │ true << false = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-class.js:22:9] + 21 │ + 22 │ { const f = 0; class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-0.js:20:1] - 19 │ - 20 │ x >> y = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-const.js:22:9] + 21 │ + 22 │ { const f = 0; const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-1.js:20:1] - 19 │ - 20 │ 1 >> 2 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-function.js:22:9] + 21 │ + 22 │ { const f = 0; function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-2.js:20:1] - 19 │ - 20 │ true >> false = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-generator.js:23:9] + 22 │ + 23 │ { const f = 0; function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js:20:1] - 19 │ - 20 │ x >>> y = 1; - · ─────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-let.js:22:9] + 21 │ + 22 │ { const f = 0; let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js:20:1] - 19 │ - 20 │ 1 >>> 2 = 1; - · ─────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-var.js:22:9] + 21 │ + 22 │ { const f = 0; var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js:20:1] - 19 │ - 20 │ true >>> false = 1; - · ────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-function.js:24:20] + 23 │ function x() { + 24 │ { async function f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 25 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js:20:2] - 19 │ - 20 │ (x ? y : z) = 1; - · ───────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-generator.js:24:21] + 23 │ function x() { + 24 │ { async function* f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 25 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js:20:2] - 19 │ - 20 │ (1 ? 2 : 3) = 1; - · ───────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-class.js:23:11] + 22 │ function x() { + 23 │ { class f {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 24 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js:20:2] - 19 │ - 20 │ (true ? false : true) = 1; - · ─────────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-const.js:23:11] + 22 │ function x() { + 23 │ { const f = 0; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 24 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-delete-unaryexpression.js:20:1] - 19 │ - 20 │ delete x.y = 1; - · ────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-function.js:23:14] + 22 │ function x() { + 23 │ { function f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 24 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-0.js:20:1] - 19 │ - 20 │ !x = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-generator.js:24:15] + 23 │ function x() { + 24 │ { function* f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 25 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-1.js:20:1] - 19 │ - 20 │ !1 = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-let.js:23:9] + 22 │ function x() { + 23 │ { let f; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here + 24 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-2.js:20:1] - 19 │ - 20 │ !true = 1; - · ───── - ╰──── - - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-0.js:20:1] - 19 │ - 20 │ -x = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-declaration-attempt-to-redeclare-with-var-declaration-nested-in-function.js:24:18] + 23 │ // A lexically declared function declaration. + 24 │ function f() {} + · ┬ + · ╰── `f` has already been declared here + 25 │ + 26 │ // An inner block-statement with a variable-declared name. + 27 │ { + 28 │ var f; + · ┬ + · ╰── It can not be redeclared here + 29 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-1.js:20:1] - 19 │ - 20 │ -1 = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-function.js:23:12] + 22 │ + 23 │ { function f() {} async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-2.js:20:1] - 19 │ - 20 │ -true = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-generator.js:23:12] + 22 │ + 23 │ { function f() {} async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-0.js:20:1] - 19 │ - 20 │ +x = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-class.js:22:12] + 21 │ + 22 │ { function f() {} class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-1.js:20:1] - 19 │ - 20 │ +1 = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-const.js:22:12] + 21 │ + 22 │ { function f() {} const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-2.js:20:1] - 19 │ - 20 │ +true = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-function.js:22:12] + 21 │ + 22 │ { function f() {} function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-0.js:20:1] - 19 │ - 20 │ ~x = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-generator.js:23:12] + 22 │ + 23 │ { function f() {} function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-1.js:20:1] - 19 │ - 20 │ ~1 = 1; - · ── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-let.js:22:12] + 21 │ + 22 │ { function f() {} let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-2.js:20:1] - 19 │ - 20 │ ~true = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-var.js:22:12] + 21 │ + 22 │ { function f() {} var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-0.js:20:1] - 19 │ - 20 │ typeof x = 1; - · ──────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-function.js:23:13] + 22 │ + 23 │ { function* f() {} async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-1.js:20:1] - 19 │ - 20 │ typeof 1 = 1; - · ──────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-generator.js:23:13] + 22 │ + 23 │ { function* f() {} async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-2.js:20:1] - 19 │ - 20 │ typeof true = 1; - · ─────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-class.js:23:13] + 22 │ + 23 │ { function* f() {} class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-0.js:20:1] - 19 │ - 20 │ void x = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-const.js:23:13] + 22 │ + 23 │ { function* f() {} const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-1.js:20:1] - 19 │ - 20 │ void 1 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-function.js:23:13] + 22 │ + 23 │ { function* f() {} function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-2.js:20:1] - 19 │ - 20 │ void true = 1; - · ───────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-generator.js:23:13] + 22 │ + 23 │ { function* f() {} function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-0.js:21:1] - 20 │ - 21 │ x ** y = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-let.js:23:13] + 22 │ + 23 │ { function* f() {} let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-1.js:21:1] - 20 │ - 21 │ 1 ** 2 = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-var.js:23:13] + 22 │ + 23 │ { function* f() {} var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-2.js:21:1] - 20 │ - 21 │ true ** false = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-function.js:39:9] + 38 │ + 39 │ { { var f; } async function f() {}; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × A 'yield' expression is only allowed in a generator body. - ╭─[language/expressions/assignmenttargettype/direct-yieldexpression-0.js:20:1] - 19 │ - 20 │ yield x = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-generator.js:39:9] + 38 │ + 39 │ { { var f; } async function* f() {}; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/direct-yieldexpression-1.js:20:1] - 19 │ - 20 │ yield * x = 1; - · ───────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-class.js:38:9] + 37 │ + 38 │ { { var f; } class f {}; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-0.js:23:2] - 22 │ - 23 │ (x - y) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-const.js:38:9] + 37 │ + 38 │ { { var f; } const f = 0; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-1.js:23:2] - 22 │ - 23 │ (1 - 2) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-function.js:38:9] + 37 │ + 38 │ { { var f; } function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-2.js:23:2] - 22 │ - 23 │ (true - false) = 1; - · ──────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-generator.js:39:9] + 38 │ + 39 │ { { var f; } function* f() {}; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-0.js:23:2] - 22 │ - 23 │ (x + y) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-let.js:38:9] + 37 │ + 38 │ { { var f; } let f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-1.js:23:2] - 22 │ - 23 │ (1 + 2) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-function.js:39:18] + 38 │ + 39 │ { async function f() {}; { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-2.js:23:2] - 22 │ - 23 │ (true + false) = 1; - · ──────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-generator.js:39:19] + 38 │ + 39 │ { async function* f() {}; { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-0.js:23:2] - 22 │ - 23 │ (() => {}) = 1; - · ──────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-class.js:38:9] + 37 │ + 38 │ { class f {}; { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-1.js:23:2] - 22 │ - 23 │ (() => ({})) = 1; - · ────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-const.js:38:9] + 37 │ + 38 │ { const f = 0; { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-2.js:23:3] - 22 │ - 23 │ ((x => x)) = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-function.js:38:12] + 37 │ + 38 │ { function f() {} { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-3.js:23:3] - 22 │ - 23 │ (((x) => x)) = 1; - · ──────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-generator.js:39:13] + 38 │ + 39 │ { function* f() {}; { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-4.js:23:3] - 22 │ - 23 │ ((() => 1)) = 1; - · ─────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-let.js:38:7] + 37 │ + 38 │ { let f; { var f; } } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-5.js:23:3] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-function.js:23:7] 22 │ - 23 │ ((() => true)) = 1; - · ────────── + 23 │ { let f; async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-6.js:23:3] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-generator.js:23:7] 22 │ - 23 │ ((() => 1)) = 1; - · ─────── + 23 │ { let f; async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-0.js:23:2] - 22 │ - 23 │ (async () => {}) = 1; - · ────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-class.js:22:7] + 21 │ + 22 │ { let f; class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-1.js:23:2] - 22 │ - 23 │ (async () => ({})) = 1; - · ──────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-const.js:22:7] + 21 │ + 22 │ { let f; const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-2.js:23:3] - 22 │ - 23 │ ((async x => x)) = 1; - · ──────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-function.js:22:7] + 21 │ + 22 │ { let f; function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-3.js:23:3] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-generator.js:23:7] 22 │ - 23 │ ((async (x) => x)) = 1; - · ────────────── + 23 │ { let f; function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-4.js:23:3] - 22 │ - 23 │ ((async () => 1)) = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-let.js:22:7] + 21 │ + 22 │ { let f; let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-5.js:23:3] - 22 │ - 23 │ ((async () => true)) = 1; - · ──────────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-var.js:22:7] + 21 │ + 22 │ { let f; var f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-6.js:23:3] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-function.js:23:7] 22 │ - 23 │ ((async () => 1)) = 1; - · ───────────── + 23 │ { var f; async function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-0.js:23:2] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-generator.js:23:7] 22 │ - 23 │ (x & y) = 1; - · ───── + 23 │ { var f; async function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-1.js:23:2] - 22 │ - 23 │ (1 & 2) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-class.js:22:7] + 21 │ + 22 │ { var f; class f {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-2.js:23:2] - 22 │ - 23 │ (true & false) = 1; - · ──────────── - ╰──── - - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js:23:2] - 22 │ - 23 │ (x | y) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-const.js:22:7] + 21 │ + 22 │ { var f; const f = 0 } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js:23:2] - 22 │ - 23 │ (1 | 2) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-function.js:22:7] + 21 │ + 22 │ { var f; function f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js:23:2] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-generator.js:23:7] 22 │ - 23 │ (true | false) = 1; - · ──────────── + 23 │ { var f; function* f() {} } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js:23:2] - 22 │ - 23 │ (x ^ y) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-let.js:22:7] + 21 │ + 22 │ { var f; let f } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js:23:2] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-function.js:23:18] 22 │ - 23 │ (1 ^ 2) = 1; - · ───── + 23 │ { async function f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js:23:2] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-generator.js:23:19] 22 │ - 23 │ (true ^ false) = 1; - · ──────────── + 23 │ { async function* f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-callexpression-arguments.js:23:2] - 22 │ - 23 │ (f()) = 1; - · ─── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-class.js:22:9] + 21 │ + 22 │ { class f {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-callexpression-templateliteral.js:23:2] - 22 │ - 23 │ (f()``) = 1; - · ───── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-const.js:22:9] + 21 │ + 22 │ { const f = 0; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js:23:2] - 22 │ - 23 │ (x ?? y) = 1; - · ────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-function.js:22:12] + 21 │ + 22 │ { function f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js:23:2] + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-generator.js:23:13] 22 │ - 23 │ (1 ?? 2) = 1; - · ────── + 23 │ { function* f() {}; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js:23:2] - 22 │ - 23 │ (true ?? false) = 1; - · ───────────── + × Identifier `f` has already been declared + ╭─[language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-let.js:22:7] + 21 │ + 22 │ { let f; var f; } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `f` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-0.js:23:2] - 22 │ - 23 │ (x == y) = 1; - · ────── + × Unterminated multiline comment + ╭─[language/comments/S7.4_A2_T2.js:15:1] + 14 │ + 15 │ /*CHECK#1/ + · ─────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-1.js:23:2] - 22 │ - 23 │ (1 == 2) = 1; - · ────── + × Unexpected token + ╭─[language/comments/S7.4_A3.js:21:1] + 20 │ /* x */ + 21 │ = 1; + · ─ + 22 │ */ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-2.js:23:2] - 22 │ - 23 │ (true == false) = 1; - · ───────────── + × Unterminated regular expression + ╭─[language/comments/S7.4_A4_T1.js:18:3] + 17 │ /* var*/ + 18 │ x*/ + · ── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-0.js:23:2] - 22 │ - 23 │ (x != y) = 1; - · ────── + × Unterminated regular expression + ╭─[language/comments/S7.4_A4_T4.js:18:3] + 17 │ // var /* + 18 │ x*/ + · ── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-1.js:23:2] - 22 │ - 23 │ (1 != 2) = 1; - · ────── - ╰──── + × Invalid Unicode escape sequence + ╭─[language/comments/hashbang/escaped-bang-041.js:1:3] + 1 │ #\041 + · ─ + 2 │ + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-2.js:23:2] - 22 │ - 23 │ (true != false) = 1; - · ───────────── + × Expected `in` but found `throw` + ╭─[language/comments/hashbang/escaped-bang-041.js:20:1] + 19 │ + 20 │ throw "Test262: This statement should not be evaluated."; + · ──┬── + · ╰── `in` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-0.js:23:2] - 22 │ - 23 │ (x == y) = 1; - · ────── - ╰──── + × Invalid Character `!` + ╭─[language/comments/hashbang/escaped-bang-u0021.js:1:8] + 1 │ #\u0021 + · ▲ + 2 │ + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-1.js:23:2] - 22 │ - 23 │ (1 == 2) = 1; - · ────── + × Expected `in` but found `throw` + ╭─[language/comments/hashbang/escaped-bang-u0021.js:20:1] + 19 │ + 20 │ throw "Test262: This statement should not be evaluated."; + · ──┬── + · ╰── `in` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-2.js:23:2] - 22 │ - 23 │ (true == false) = 1; - · ───────────── - ╰──── + × Invalid Character `!` + ╭─[language/comments/hashbang/escaped-bang-u21.js:1:8] + 1 │ #\u{21} + · ▲ + 2 │ + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-0.js:23:2] - 22 │ - 23 │ (x !== y) = 1; - · ─────── + × Expected `in` but found `throw` + ╭─[language/comments/hashbang/escaped-bang-u21.js:20:1] + 19 │ + 20 │ throw "Test262: This statement should not be evaluated."; + · ──┬── + · ╰── `in` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-1.js:23:2] - 22 │ - 23 │ (1 !== 2) = 1; - · ─────── + × Invalid Unicode escape sequence + ╭─[language/comments/hashbang/escaped-bang-x21.js:1:3] + 1 │ #\x21 + · ─ + 2 │ + ╰──── + + × Expected `in` but found `throw` + ╭─[language/comments/hashbang/escaped-bang-x21.js:20:1] + 19 │ + 20 │ throw "Test262: This statement should not be evaluated."; + · ──┬── + · ╰── `in` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-2.js:23:2] - 22 │ + × Invalid Unicode escape sequence + ╭─[language/comments/hashbang/escaped-hash-043.js:1:2] + 1 │ \043! + · ─ + 2 │ + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/comments/hashbang/escaped-hash-043.js:1:5] + 1 │ \043! + · ▲ + 2 │ + ╰──── + help: Try insert a semicolon here + + × Invalid Character `#` + ╭─[language/comments/hashbang/escaped-hash-u0023.js:1:7] + 1 │ \u0023! + · ▲ + 2 │ + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/comments/hashbang/escaped-hash-u0023.js:1:7] + 1 │ \u0023! + · ▲ + 2 │ + ╰──── + help: Try insert a semicolon here + + × Invalid Character `#` + ╭─[language/comments/hashbang/escaped-hash-u23.js:1:7] + 1 │ \u{23}! + · ▲ + 2 │ + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/comments/hashbang/escaped-hash-u23.js:1:7] + 1 │ \u{23}! + · ▲ + 2 │ + ╰──── + help: Try insert a semicolon here + + × Invalid Unicode escape sequence + ╭─[language/comments/hashbang/escaped-hash-x23.js:1:2] + 1 │ \x23! + · ─ + 2 │ + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/comments/hashbang/escaped-hash-x23.js:1:5] + 1 │ \x23! + · ▲ + 2 │ + ╰──── + help: Try insert a semicolon here + + × Invalid Character `#` + ╭─[language/comments/hashbang/escaped-hashbang.js:1:7] + 1 │ \u0023\u0021 + · ▲ + 2 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/escaped-hashbang.js:1:13] + 1 │ \u0023\u0021 + · ▲ + 2 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/function-body.js:19:17] + 18 │ + 19 │ function fn() {#! + · ─ + 20 │ } + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/comments/hashbang/multi-line-comment.js:3:6] + 2 │ throw "Test262: This statement should not be evaluated."; + 3 │ these characters should not be considered within a comment + · ▲ + 4 │ */ + ╰──── + help: Try insert a semicolon here + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-directive-prologue-sc.js:2:2] + 1 │ "use strict"; + 2 │ #! + · ─ + 3 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-directive-prologue.js:2:2] + 1 │ "use strict" + 2 │ #! + · ─ + 3 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-empty-statement.js:1:3] + 1 │ ;#! + · ─ + 2 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-hashbang.js:2:2] + 1 │ #! + 2 │ #! + · ─ + 3 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-line-comment.js:2:2] + 1 │ // + 2 │ #! + · ─ + 3 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-multi-line-comment.js:2:4] + 1 │ /* + 2 │ */#! + · ─ + 3 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/preceding-whitespace.js:1:3] + 1 │ #! + · ─ + 2 │ + ╰──── + + × Invalid Character `!` + ╭─[language/comments/hashbang/statement-block.js:20:4] + 19 │ { + 20 │ #! + · ─ + 21 │ } + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/comments/multi-line-html-close-extra.js:25:7] + 24 │ /* + 25 │ */ the comment should not include these characters, regardless of AnnexB extensions --> + · ▲ + ╰──── + help: Try insert a semicolon here + + × Unexpected token + ╭─[language/comments/single-line-html-close-without-lt.js:23:4] + 22 │ + 23 │ ;--> + · ─ + ╰──── + + × The keyword 'public' is reserved + ╭─[language/directive-prologue/10.1.1-2gs.js:17:5] + 16 │ throw "Test262: This statement should not be evaluated."; + 17 │ var public = 1; + · ────── + ╰──── + + × The keyword 'public' is reserved + ╭─[language/directive-prologue/10.1.1-5gs.js:17:5] + 16 │ throw "Test262: This statement should not be evaluated."; + 17 │ var public = 1; + · ────── + ╰──── + + × The keyword 'public' is reserved + ╭─[language/directive-prologue/10.1.1-8gs.js:18:5] + 17 │ throw "Test262: This statement should not be evaluated."; + 18 │ var public = 1; + · ────── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/directive-prologue/14.1-4gs.js:17:1] + 16 │ throw "Test262: This statement should not be evaluated."; + 17 │ eval = 42; + · ──── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/directive-prologue/14.1-5gs.js:19:1] + 18 │ throw "Test262: This statement should not be evaluated."; + 19 │ eval = 42; + · ──── + ╰──── + + × The keyword 'static' is reserved + ╭─[language/directive-prologue/func-decl-inside-func-decl-parse.js:22:9] + 21 │ function fun() { + 22 │ var static; + · ────── + 23 │ } + ╰──── + + × The keyword 'static' is reserved + ╭─[language/directive-prologue/func-decl-no-semi-parse.js:20:7] + 19 │ "use strict" + 20 │ var static; + · ────── + 21 │ } + ╰──── + + × The keyword 'static' is reserved + ╭─[language/directive-prologue/func-decl-parse.js:20:7] + 19 │ "use strict"; + 20 │ var static; + · ────── + 21 │ } + ╰──── + + × The keyword 'static' is reserved + ╭─[language/directive-prologue/func-expr-inside-func-decl-parse.js:21:7] + 20 │ "use strict"; + 21 │ var static; + · ────── + 22 │ } + ╰──── + + × The keyword 'static' is reserved + ╭─[language/directive-prologue/func-expr-no-semi-parse.js:21:7] + 20 │ + 21 │ var static; + · ────── + 22 │ }); + ╰──── + + × The keyword 'static' is reserved + ╭─[language/directive-prologue/func-expr-parse.js:21:7] + 20 │ + 21 │ var static; + · ────── + 22 │ }); + ╰──── + + × Keywords cannot contain escape characters + ╭─[language/export/escaped-as-export-specifier.js:25:11] + 24 │ export var a = 0; + 25 │ export {a \u0061s b} from "./escaped-as-export-specifier.js"; + · ─────── + ╰──── + + × Keywords cannot contain escape characters + ╭─[language/export/escaped-default.js:24:8] + 23 │ + 24 │ export d\u0065fault 0; + · ──────────── + ╰──── + + × Keywords cannot contain escape characters + ╭─[language/export/escaped-from.js:24:11] + 23 │ + 24 │ export {} \u0066rom "./escaped-from.js"; + · ───────── + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/arrow-function/array-destructuring-param-strict-body.js:130:3] + 129 │ 0, ([element]) => { + 130 │ "use strict"; + · ───────────── + 131 │ }; + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/dflt-params-duplicates.js:58:5] + 57 │ + 58 │ 0, (x = 0, x) => { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 59 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dflt-params-rest.js:62:8] + 61 │ + 62 │ 0, (...x = []) => { + · ────── + 63 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-init-ary.js:52:10] + 51 │ var f; + 52 │ f = ([...[ x ] = []]) => { + · ────────── + 53 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-init-id.js:52:10] + 51 │ var f; + 52 │ f = ([...x = []]) => { + · ────── + 53 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-init-obj.js:52:10] + 51 │ var f; + 52 │ f = ([...{ x } = []]) => { + · ────────── + 53 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-ary.js:52:7] + 51 │ var f; + 52 │ f = ([...[x], y]) => { + · ────── + 53 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-id.js:52:7] + 51 │ var f; + 52 │ f = ([...x, y]) => { + · ──── + 53 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-obj.js:52:7] + 51 │ var f; + 52 │ f = ([...{ x }, y]) => { + · ──────── + 53 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-ary.js:52:10] + 51 │ var f; + 52 │ f = ([...[ x ] = []] = []) => { + · ────────── + 53 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-id.js:52:10] + 51 │ var f; + 52 │ f = ([...x = []] = []) => { + · ────── + 53 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-obj.js:52:10] + 51 │ var f; + 52 │ f = ([...{ x } = []] = []) => { + · ────────── + 53 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-ary.js:52:7] + 51 │ var f; + 52 │ f = ([...[x], y] = [1, 2, 3]) => { + · ────── + 53 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-id.js:52:7] + 51 │ var f; + 52 │ f = ([...x, y] = [1, 2, 3]) => { + · ──── + 53 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-obj.js:52:7] + 51 │ var f; + 52 │ f = ([...{ x }, y] = [1, 2, 3]) => { + · ──────── + 53 │ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-break-escaped.js:40:23] + 39 │ + 40 │ var x = ({ bre\u0061k }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-case-escaped.js:40:22] + 39 │ + 40 │ var x = ({ c\u0061se }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-catch-escaped.js:40:23] + 39 │ + 40 │ var x = ({ c\u0061tch }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-class-escaped.js:40:23] + 39 │ + 40 │ var x = ({ cl\u0061ss }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-const-escaped.js:40:23] + 39 │ + 40 │ var x = ({ \u0063onst }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-continue-escaped.js:40:26] + 39 │ + 40 │ var x = ({ \u0063ontinue }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-debugger-escaped.js:40:26] + 39 │ + 40 │ var x = ({ \u0064ebugger }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped-ext.js:40:25] + 39 │ + 40 │ var x = ({ def\u{61}ult }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped.js:40:25] + 39 │ + 40 │ var x = ({ def\u0061ult }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-default.js:40:20] + 39 │ + 40 │ var x = ({ default }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-delete-escaped.js:40:24] + 39 │ + 40 │ var x = ({ \u0064elete }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-do-escaped.js:40:20] + 39 │ + 40 │ var x = ({ \u0064o }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-else-escaped.js:40:22] + 39 │ + 40 │ var x = ({ \u0065lse }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-enum-escaped.js:40:22] + 39 │ + 40 │ var x = ({ \u0065num }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-export-escaped.js:40:24] + 39 │ + 40 │ var x = ({ \u0065xport }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped-ext.js:40:25] + 39 │ + 40 │ var x = ({ \u{65}xtends }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped.js:40:25] + 39 │ + 40 │ var x = ({ \u0065xtends }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends.js:40:20] + 39 │ + 40 │ var x = ({ extends }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-finally-escaped.js:40:25] + 39 │ + 40 │ var x = ({ \u0066inally }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-for-escaped.js:40:21] + 39 │ + 40 │ var x = ({ \u0066or }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-function-escaped.js:40:26] + 39 │ + 40 │ var x = ({ \u0066unction }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-if-escaped.js:40:20] + 39 │ + 40 │ var x = ({ i\u0066 }) => {}; + · ─ + ╰──── + + × The keyword 'implements' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-implements-escaped.js:40:12] + 39 │ + 40 │ var x = ({ \u0069mplements }) => {}; + · ─────────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-import-escaped.js:40:24] + 39 │ + 40 │ var x = ({ \u0069mport }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-in-escaped.js:40:20] + 39 │ + 40 │ var x = ({ \u0069n }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-instanceof-escaped.js:40:28] + 39 │ + 40 │ var x = ({ \u0069nstanceof }) => {}; + · ─ + ╰──── + + × The keyword 'interface' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-interface-escaped.js:40:12] + 39 │ + 40 │ var x = ({ interf\u0061ce }) => {}; + · ────────────── + ╰──── + + × The keyword 'let' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-let-escaped.js:40:12] + 39 │ + 40 │ var x = ({ l\u0065t }) => {}; + · ──────── + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-new-escaped.js:40:21] + 39 │ + 40 │ var x = ({ n\u0065w }) => {}; + · ─ + ╰──── + + × The keyword 'package' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-package-escaped.js:40:12] + 39 │ + 40 │ var x = ({ p\u0061ckage }) => {}; + · ──────────── + ╰──── + + × The keyword 'private' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-private-escaped.js:40:12] + 39 │ + 40 │ var x = ({ privat\u0065 }) => {}; + · ──────────── + ╰──── + + × The keyword 'protected' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-protected-escaped.js:40:12] + 39 │ + 40 │ var x = ({ prot\u0065cted }) => {}; + · ────────────── + ╰──── + + × The keyword 'public' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-public-escaped.js:40:12] + 39 │ + 40 │ var x = ({ pu\u0062lic }) => {}; + · ─────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-return-escaped.js:40:24] + 39 │ + 40 │ var x = ({ r\u0065turn }) => {}; + · ─ + ╰──── + + × The keyword 'static' is reserved + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-static-escaped.js:40:12] + 39 │ + 40 │ var x = ({ st\u0061tic }) => {}; + · ─────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-super-escaped.js:40:23] + 39 │ + 40 │ var x = ({ sup\u0065r }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-switch-escaped.js:40:24] + 39 │ + 40 │ var x = ({ sw\u0069tch }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-this-escaped.js:40:22] + 39 │ + 40 │ var x = ({ th\u0069s }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-throw-escaped.js:40:23] + 39 │ + 40 │ var x = ({ t\u0068row }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-try-escaped.js:40:21] + 39 │ + 40 │ var x = ({ tr\u0079 }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-typeof-escaped.js:40:24] + 39 │ + 40 │ var x = ({ typ\u0065of }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-var-escaped.js:40:21] + 39 │ + 40 │ var x = ({ v\u0061r }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-void-escaped.js:40:22] + 39 │ + 40 │ var x = ({ voi\u0064 }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-while-escaped.js:40:23] + 39 │ + 40 │ var x = ({ whil\u0065 }) => {}; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/dstr/syntax-error-ident-ref-with-escaped.js:40:22] + 39 │ + 40 │ var x = ({ w\u0069th }) => {}; + · ─ + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/arrow-function/object-destructuring-param-strict-body.js:130:3] + 129 │ 0, ({property}) => { + 130 │ "use strict"; + · ───────────── + 131 │ }; + ╰──── + + × yield expression not allowed in formal parameter + ╭─[language/expressions/arrow-function/param-dflt-yield-expr.js:27:8] + 26 │ function *g() { + 27 │ (x = yield) => {}; + · ──┬── + · ╰── yield expression not allowed in formal parameter + 28 │ } + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/arrow-function/param-dflt-yield-id-strict.js:21:6] + 20 │ + 21 │ (x = yield) => {}; + · ───── + ╰──── + + × Identifier `a` has already been declared + ╭─[language/expressions/arrow-function/params-duplicate.js:33:5] + 32 │ + 33 │ 0, (a, a) => { }; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `a` has already been declared here + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/arrow-function/rest-param-strict-body.js:130:3] + 129 │ 0, (a,...rest) => { + 130 │ "use strict"; + · ───────────── + 131 │ }; + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/arrow-function/rest-params-trailing-comma-early-error.js:54:5] + 53 │ + 54 │ 0, (...a,) => { + · ──── + 55 │ + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/arrow-function/static-init-await-binding.js:16:6] + 15 │ static { + 16 │ (await => 0); + · ───── + 17 │ } + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/static-init-await-reference.js:16:16] + 15 │ static { + 16 │ ((x = await) => 0); + · ─ + 17 │ } + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-futurereservedword.js:24:10] + 23 │ $DONOTEVALUATE(); + 24 │ var af = enum => 1; + · ──── + ╰──── + + × The keyword 'package' is reserved + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-strict-futurereservedword.js:27:10] + 26 │ $DONOTEVALUATE(); + 27 │ var af = package => 1; + · ─────── + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier.js:24:10] + 23 │ $DONOTEVALUATE(); + 24 │ var af = switch => 1; + · ────── + ╰──── + + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-arguments.js:19:10] + 18 │ $DONOTEVALUATE(); + 19 │ var af = arguments => 1; + · ───────── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-eval.js:20:10] + 19 │ $DONOTEVALUATE(); + 20 │ var af = eval => 1; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-yield.js:20:10] + 19 │ $DONOTEVALUATE(); + 20 │ var af = yield => 1; + · ───── + ╰──── + + × Unexpected token + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-rest.js:16:10] + 15 │ $DONOTEVALUATE(); + 16 │ var af = ...x => x; + · ─── + ╰──── + + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-arguments.js:24:11] + 23 │ $DONOTEVALUATE(); + 24 │ var af = (arguments) => 1; + · ───────── + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-1.js:25:11] + 24 │ $DONOTEVALUATE(); + 25 │ var af = (x, [x]) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-2.js:25:12] + 24 │ $DONOTEVALUATE(); + 25 │ var af = ([x, x]) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-3.js:27:12] + 26 │ $DONOTEVALUATE(); + 27 │ var af = ([x], ...x) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-1.js:25:11] + 24 │ $DONOTEVALUATE(); + 25 │ var af = (x, {x}) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-2.js:27:11] + 26 │ $DONOTEVALUATE(); + 27 │ var af = (x, {y: x}) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-3.js:27:12] + 26 │ $DONOTEVALUATE(); + 27 │ var af = ({x}, {y: x}) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-4.js:29:12] + 28 │ $DONOTEVALUATE(); + 29 │ var af = ({x}, ...x) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-5.js:29:15] + 28 │ $DONOTEVALUATE(); + 29 │ var af = ({y: x}, ...x) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-6.js:27:15] + 26 │ $DONOTEVALUATE(); + 27 │ var af = ({y: x, x}) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-rest.js:23:11] + 22 │ $DONOTEVALUATE(); + 23 │ var af = (x, ...x) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates.js:23:11] + 22 │ $DONOTEVALUATE(); + 23 │ var af = (x, x) => 1; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-eval.js:24:11] + 23 │ $DONOTEVALUATE(); + 24 │ var af = (eval) => 1; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-yield.js:19:11] + 18 │ $DONOTEVALUATE(); + 19 │ var af = (yield) => 1; + · ───── + ╰──── + + × Line terminator not permitted before arrow + ╭─[language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters-expression-body.js:16:1] + 15 │ var af = x + 16 │ => x; + · ── + ╰──── + + × Line terminator not permitted before arrow + ╭─[language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters.js:18:1] + 17 │ var af = x + 18 │ => {}; + · ── + ╰──── + + × Line terminator not permitted before arrow + ╭─[language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid.js:15:1] + 14 │ var af = () + 15 │ => {}; + · ── + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/arrow-function/syntax/early-errors/use-strict-with-non-simple-param.js:20:3] + 19 │ var f = (a = 0) => { + 20 │ "use strict"; + · ───────────── + 21 │ }; + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-elem-init-yield-ident-invalid.js:23:10] + 22 │ + 23 │ 0, [ x = yield ] = []; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-elem-nested-array-invalid.js:23:7] + 22 │ + 23 │ 0, [[(x, y)]] = [[]]; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-elem-nested-array-yield-ident-invalid.js:23:8] + 22 │ + 23 │ 0, [[x[yield]]] = [[]]; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-elem-nested-memberexpr-optchain-prop-ref-init.js:56:5] + 55 │ + 56 │ 0, [x?.y = 42] = [23]; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-elem-nested-obj-invalid.js:23:12] + 22 │ + 23 │ 0, [{ get x() {} }] = [{}]; + · ───── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-elem-nested-obj-yield-ident-invalid.js:23:11] + 22 │ + 23 │ 0, [{ x = yield }] = [{}]; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-elem-put-obj-literal-optchain-prop-ref-init.js:55:5] + 54 │ + 55 │ ╭─▶ 0, [{ + 56 │ │ set y(val) { + 57 │ │ throw new Test262Error('The property should not be accessed.'); + 58 │ │ } + 59 │ ╰─▶ }?.y = 42] = [23]; + ╰──── + + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/assignment/dstr/array-elem-target-simple-strict.js:23:5] + 22 │ + 23 │ 0, [arguments] = []; + · ───────── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-elem-target-yield-invalid.js:23:8] + 22 │ + 23 │ 0, [ x[yield] ] = []; + · ───── + ╰──── + + × Spread must be last element + ╭─[language/expressions/assignment/dstr/array-rest-before-element.js:23:5] + 22 │ + 23 │ 0, [...x, y] = []; + · ──── + ╰──── + + × Unexpected trailing comma after rest element + ╭─[language/expressions/assignment/dstr/array-rest-before-elision.js:23:9] + 22 │ + 23 │ 0, [...x,] = []; + · ─ + ╰──── + + × Spread must be last element + ╭─[language/expressions/assignment/dstr/array-rest-before-rest.js:23:5] + 22 │ + 23 │ 0, [...x, ...y] = []; + · ──── + ╰──── + + × Unexpected trailing comma after rest element + ╭─[language/expressions/assignment/dstr/array-rest-elision-invalid.js:23:9] + 22 │ + 23 │ 0, [...x,] = []; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-rest-init.js:24:8] + 23 │ + 24 │ 0, [...x = 1] = []; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-rest-nested-array-invalid.js:23:10] + 22 │ + 23 │ 0, [...[(x, y)]] = [[]]; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-rest-nested-array-yield-ident-invalid.js:23:11] + 22 │ + 23 │ 0, [...[x[yield]]] = []; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/array-rest-nested-obj-invalid.js:23:15] + 22 │ + 23 │ 0, [...{ get x() {} }] = [[]]; + · ───── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-rest-nested-obj-yield-ident-invalid.js:23:14] + 22 │ + 23 │ 0, [...{ x = yield }] = [{}]; + · ───── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/array-rest-yield-ident-invalid.js:24:10] + 23 │ + 24 │ 0, [...x[yield]] = []; + · ───── + ╰──── + + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/assignment/dstr/obj-id-identifier-yield-expr.js:24:6] + 23 │ + 24 │ 0, { yield } = {}; + · ───── + 25 │ + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/obj-id-identifier-yield-ident-invalid.js:23:6] + 22 │ + 23 │ 0, { yield } = {}; + · ───── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/assignment/dstr/obj-id-init-simple-strict.js:23:6] + 22 │ + 23 │ 0, { eval = 0 } = {}; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/obj-id-init-yield-ident-invalid.js:23:10] + 22 │ + 23 │ 0, { x = yield } = {}; + · ───── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/assignment/dstr/obj-id-simple-strict.js:23:6] + 22 │ + 23 │ 0, { eval } = {}; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/obj-prop-elem-init-yield-ident-invalid.js:23:13] + 22 │ + 23 │ 0, { x: x = yield } = {}; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/obj-prop-elem-target-memberexpr-optchain-prop-ref-init.js:56:9] + 55 │ + 56 │ 0, { x: y?.z = 42 } = { x: 23 }; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/obj-prop-elem-target-obj-literal-optchain-prop-ref-init.js:55:9] + 54 │ + 55 │ ╭─▶ 0, { x: { + 56 │ │ set y(val) { + 57 │ │ throw new Test262Error('The property should not be accessed.'); + 58 │ │ } + 59 │ ╰─▶ }?.y = 42} = {x: 42}; + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/obj-prop-elem-target-yield-ident-invalid.js:23:11] + 22 │ + 23 │ 0, { x: x[yield] } = {}; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/obj-prop-nested-array-invalid.js:23:11] + 22 │ + 23 │ 0, { x: [(x, y)] } = { x: [] }; + · ──── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/obj-prop-nested-array-yield-ident-invalid.js:23:14] + 22 │ + 23 │ 0, { x: [x = yield] } = { x: [] }; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/dstr/obj-prop-nested-obj-invalid.js:23:16] + 22 │ + 23 │ 0, { x: { get x() {} } } = { x: {} }; + · ───── + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/assignment/dstr/obj-prop-nested-obj-yield-ident-invalid.js:23:15] + 22 │ + 23 │ 0, { x: { x = yield } } = { x: {} }; + · ───── + ╰──── + + × Spread must be last element + ╭─[language/expressions/assignment/dstr/obj-rest-not-last-element-invalid.js:24:5] + 23 │ + 24 │ 0, {...rest, b} = {} + · ─────── + 25 │ ; + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-break-escaped.js:40:22] + 39 │ + 40 │ var x = { bre\u0061k } = { break: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-case-escaped.js:40:21] + 39 │ + 40 │ var x = { c\u0061se } = { case: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-catch-escaped.js:40:22] + 39 │ + 40 │ var x = { c\u0061tch } = { catch: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-class-escaped.js:40:22] + 39 │ + 40 │ var x = { cl\u0061ss } = { class: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-const-escaped.js:40:22] + 39 │ + 40 │ var x = { \u0063onst } = { const: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-continue-escaped.js:40:25] + 39 │ + 40 │ var x = { \u0063ontinue } = { continue: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-debugger-escaped.js:40:25] + 39 │ + 40 │ var x = { \u0064ebugger } = { debugger: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped-ext.js:40:24] + 39 │ + 40 │ var x = { def\u{61}ult } = { default: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped.js:40:24] + 39 │ + 40 │ var x = { def\u0061ult } = { default: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-default.js:40:19] + 39 │ + 40 │ var x = { default } = { default: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-delete-escaped.js:40:23] + 39 │ + 40 │ var x = { \u0064elete } = { delete: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-do-escaped.js:40:19] + 39 │ + 40 │ var x = { \u0064o } = { do: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-else-escaped.js:40:21] + 39 │ + 40 │ var x = { \u0065lse } = { else: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-enum-escaped.js:40:21] + 39 │ + 40 │ var x = { \u0065num } = { enum: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-export-escaped.js:40:23] + 39 │ + 40 │ var x = { \u0065xport } = { export: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped-ext.js:40:24] + 39 │ + 40 │ var x = { \u{65}xtends } = { extends: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped.js:40:24] + 39 │ + 40 │ var x = { \u0065xtends } = { extends: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-extends.js:40:19] + 39 │ + 40 │ var x = { extends } = { extends: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-finally-escaped.js:40:24] + 39 │ + 40 │ var x = { \u0066inally } = { finally: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-for-escaped.js:40:20] + 39 │ + 40 │ var x = { \u0066or } = { for: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-function-escaped.js:40:25] + 39 │ + 40 │ var x = { \u0066unction } = { function: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-if-escaped.js:40:19] + 39 │ + 40 │ var x = { i\u0066 } = { if: 42 }; + · ─ + ╰──── + + × The keyword 'implements' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-implements-escaped.js:40:11] + 39 │ + 40 │ var x = { \u0069mplements } = { implements: 42 }; + · ─────────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-import-escaped.js:40:23] + 39 │ + 40 │ var x = { \u0069mport } = { import: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-in-escaped.js:40:19] + 39 │ + 40 │ var x = { \u0069n } = { in: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-instanceof-escaped.js:40:27] + 39 │ + 40 │ var x = { \u0069nstanceof } = { instanceof: 42 }; + · ─ + ╰──── + + × The keyword 'interface' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-interface-escaped.js:40:11] + 39 │ + 40 │ var x = { interf\u0061ce } = { interface: 42 }; + · ────────────── + ╰──── + + × The keyword 'let' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-let-escaped.js:40:11] + 39 │ + 40 │ var x = { l\u0065t } = { let: 42 }; + · ──────── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-new-escaped.js:40:20] + 39 │ + 40 │ var x = { n\u0065w } = { new: 42 }; + · ─ + ╰──── + + × The keyword 'package' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-package-escaped.js:40:11] + 39 │ + 40 │ var x = { p\u0061ckage } = { package: 42 }; + · ──────────── + ╰──── + + × The keyword 'private' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-private-escaped.js:40:11] + 39 │ + 40 │ var x = { privat\u0065 } = { private: 42 }; + · ──────────── + ╰──── + + × The keyword 'protected' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-protected-escaped.js:40:11] + 39 │ + 40 │ var x = { prot\u0065cted } = { protected: 42 }; + · ────────────── + ╰──── + + × The keyword 'public' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-public-escaped.js:40:11] + 39 │ + 40 │ var x = { pu\u0062lic } = { public: 42 }; + · ─────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-return-escaped.js:40:23] + 39 │ + 40 │ var x = { r\u0065turn } = { return: 42 }; + · ─ + ╰──── + + × The keyword 'static' is reserved + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-static-escaped.js:40:11] + 39 │ + 40 │ var x = { st\u0061tic } = { static: 42 }; + · ─────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-super-escaped.js:40:22] + 39 │ + 40 │ var x = { sup\u0065r } = { super: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-switch-escaped.js:40:23] + 39 │ + 40 │ var x = { sw\u0069tch } = { switch: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-this-escaped.js:40:21] + 39 │ + 40 │ var x = { th\u0069s } = { this: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-throw-escaped.js:40:22] + 39 │ + 40 │ var x = { t\u0068row } = { throw: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-try-escaped.js:40:20] + 39 │ + 40 │ var x = { tr\u0079 } = { try: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-typeof-escaped.js:40:23] + 39 │ + 40 │ var x = { typ\u0065of } = { typeof: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-var-escaped.js:40:20] + 39 │ + 40 │ var x = { v\u0061r } = { var: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-void-escaped.js:40:21] + 39 │ + 40 │ var x = { voi\u0064 } = { void: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-while-escaped.js:40:22] + 39 │ + 40 │ var x = { whil\u0065 } = { while: 42 }; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignment/dstr/syntax-error-ident-ref-with-escaped.js:40:21] + 39 │ + 40 │ var x = { w\u0069th } = { with: 42 }; + · ─ + ╰──── + + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/assignment/id-arguments-strict.js:16:2] + 15 │ + 16 │ (arguments) = 20; + · ───────── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/assignment/id-eval-strict.js:16:2] + 15 │ + 16 │ (eval) = 20; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/non-simple-target.js:18:1] + 17 │ + 18 │ 1 = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-assignment-inside-function.js:22:4] + 21 │ var a, b = 2; + 22 │ (a = b) = 1; + · ───── + 23 │ } + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-assignment.js:21:2] + 20 │ var a, b = 2; + 21 │ (a = b) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-boolean.js:22:1] + 21 │ + 22 │ true = 42; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-cover-newtarget.js:29:4] + 28 │ function f() { + 29 │ (new.target) = 1; + · ────────── + 30 │ } + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-cover-yieldexpr.js:32:4] + 31 │ function* g() { + 32 │ (yield) = 1; + · ───── + 33 │ } + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-newtarget.js:29:3] + 28 │ function f() { + 29 │ new.target = 1; + · ────────── + 30 │ } + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-null.js:22:1] + 21 │ + 22 │ null = 42; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-number.js:22:1] + 21 │ + 22 │ 42 = 42; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignment/target-string.js:22:1] + 21 │ + 22 │ 'x' = 42; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-0.js:20:1] + 19 │ + 20 │ x - y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-1.js:20:1] + 19 │ + 20 │ 1 - 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-2.js:20:1] + 19 │ + 20 │ true - false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-0.js:20:1] + 19 │ + 20 │ x + y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-1.js:20:1] + 19 │ + 20 │ 1 + 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-2.js:20:1] + 19 │ + 20 │ true + false = 1; + · ──────────── + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-0.js:20:9] + 19 │ + 20 │ () => {} = 1; + · ▲ + ╰──── + help: Try insert a semicolon here + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-1.js:20:7] + 19 │ + 20 │ () => ({}) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-2.js:20:2] + 19 │ + 20 │ (x => x) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-3.js:20:2] + 19 │ + 20 │ ((x) => x) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-4.js:20:2] + 19 │ + 20 │ (() => 1) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-5.js:20:2] + 19 │ + 20 │ (() => true) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-arrowfunction-6.js:20:2] + 19 │ + 20 │ (() => 1) = 1; + · ─────── + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-0.js:20:15] + 19 │ + 20 │ async () => {} = 1; + · ▲ + ╰──── + help: Try insert a semicolon here + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-1.js:20:13] + 19 │ + 20 │ async () => ({}) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-2.js:20:2] + 19 │ + 20 │ (async x => x) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-3.js:20:2] + 19 │ + 20 │ (async (x) => x) = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-4.js:20:2] + 19 │ + 20 │ (async () => 1) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-5.js:20:2] + 19 │ + 20 │ (async () => true) = 1; + · ──────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-asyncarrowfunction-6.js:20:2] + 19 │ + 20 │ (async () => 1) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-0.js:20:1] + 19 │ + 20 │ x & y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-1.js:20:1] + 19 │ + 20 │ 1 & 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-2.js:20:1] + 19 │ + 20 │ true & false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js:20:1] + 19 │ + 20 │ x | y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js:20:1] + 19 │ + 20 │ 1 | 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js:20:1] + 19 │ + 20 │ true | false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js:20:1] + 19 │ + 20 │ x ^ y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js:20:1] + 19 │ + 20 │ 1 ^ 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js:20:1] + 19 │ + 20 │ true ^ false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-callexpression-arguments.js:20:1] + 19 │ + 20 │ f() = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-callexpression-templateliteral.js:20:1] + 19 │ + 20 │ f()`` = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js:20:1] + 19 │ + 20 │ x ?? y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js:20:1] + 19 │ + 20 │ 1 ?? 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js:20:1] + 19 │ + 20 │ true ?? false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-0.js:20:1] + 19 │ + 20 │ x == y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-1.js:20:1] + 19 │ + 20 │ 1 == 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-2.js:20:1] + 19 │ + 20 │ true == false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-0.js:20:1] + 19 │ + 20 │ x != y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-1.js:20:1] + 19 │ + 20 │ 1 != 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-2.js:20:1] + 19 │ + 20 │ true != false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-0.js:20:1] + 19 │ + 20 │ x == y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-1.js:20:1] + 19 │ + 20 │ 1 == 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-2.js:20:1] + 19 │ + 20 │ true == false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-0.js:20:1] + 19 │ + 20 │ x !== y = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-1.js:20:1] + 19 │ + 20 │ 1 !== 2 = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-2.js:20:1] + 19 │ + 20 │ true !== false = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-0.js:20:2] + 19 │ + 20 │ (x, y = z) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-1.js:20:2] + 19 │ + 20 │ (x, y = 1) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-2.js:20:2] + 19 │ + 20 │ (x, y = true) = 1; + · ─────────── + ╰──── + + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/assignmenttargettype/direct-identifierreference-arguments-strict.js:16:1] + 15 │ + 16 │ arguments = 1; + · ───────── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/assignmenttargettype/direct-identifierreference-eval-strict.js:16:1] + 15 │ + 16 │ eval = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-import.meta.js:20:1] + 19 │ + 20 │ import.meta = 1; + · ─────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-importcall.js:20:8] + 19 │ + 20 │ import() = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-0.js:20:2] + 19 │ + 20 │ (x = y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-1.js:20:2] + 19 │ + 20 │ (x = 1) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-2.js:20:2] + 19 │ + 20 │ (x = true) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js:20:2] + 19 │ + 20 │ (x ??= y) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js:20:2] + 19 │ + 20 │ (x ??= 1) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js:20:2] + 19 │ + 20 │ (x ??= true) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js:20:2] + 19 │ + 20 │ (x &&= y) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js:20:2] + 19 │ + 20 │ (x &&= 1) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js:20:2] + 19 │ + 20 │ (x &&= true) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js:20:2] + 19 │ + 20 │ (x ||= y) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js:20:2] + 19 │ + 20 │ (x ||= 1) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js:20:2] + 19 │ + 20 │ (x ||= true) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-minus-minus.js:20:1] + 19 │ + 20 │ x-- = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-lefthandsideexpression-plus-plus.js:20:1] + 19 │ + 20 │ x++ = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-0.js:20:1] + 19 │ + 20 │ x && y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-1.js:20:1] + 19 │ + 20 │ 1 && 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-2.js:20:1] + 19 │ + 20 │ true && false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-0.js:20:1] + 19 │ + 20 │ x || y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-1.js:20:1] + 19 │ + 20 │ 1 || 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-2.js:20:1] + 19 │ + 20 │ true || false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-memberexpression-templateliteral.js:20:1] + 19 │ + 20 │ o.f()`` = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-minus-minus-unaryexpression.js:20:1] + 19 │ + 20 │ --x = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js:20:1] + 19 │ + 20 │ x * y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js:20:1] + 19 │ + 20 │ 1 * 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js:20:1] + 19 │ + 20 │ true * false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js:20:1] + 19 │ + 20 │ x / y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js:20:1] + 19 │ + 20 │ 1 / 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js:20:1] + 19 │ + 20 │ true / false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-new-memberexpression-arguments.js:20:1] + 19 │ + 20 │ new f() = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-new-newexpression.js:20:1] + 19 │ + 20 │ new f = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-optionalexpression.js:21:1] + 20 │ + 21 │ x?.y = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-plus-plus-unaryexpression.js:20:1] + 19 │ + 20 │ ++x = 1; + · ─── + ╰──── + + × Expected function name + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js:16:16] + 15 │ + 16 │ async function () {} = 1; + · ─ + ╰──── + help: Function name is required in function declaration or named export + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js:16:22] + 15 │ + 16 │ async function () {} = 1; + · ─ + ╰──── + + × Expected function name + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js:16:16] + 15 │ + 16 │ async function () {} = 1; + · ─ + ╰──── + help: Function name is required in function declaration or named export + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js:16:22] + 15 │ + 16 │ async function () {} = 1; + · ─ + ╰──── + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-classexpression.js:16:10] + 15 │ + 16 │ class {} = 1; + · ─ + ╰──── + + × Expected function name + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js:16:9] + 15 │ + 16 │ function() {} = 1; + · ─ + ╰──── + help: Function name is required in function declaration or named export + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js:16:15] + 15 │ + 16 │ function() {} = 1; + · ─ + ╰──── + + × Expected function name + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js:16:12] + 15 │ + 16 │ function * () {} = 1; + · ─ + ╰──── + help: Function name is required in function declaration or named export + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js:16:18] + 15 │ + 16 │ function * () {} = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-boolean.js:16:1] + 15 │ + 16 │ true = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-null.js:16:1] + 15 │ + 16 │ null = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-numeric.js:16:1] + 15 │ + 16 │ 0 = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-literal-string.js:16:1] + 15 │ + 16 │ '' = 1; + · ── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-objectliteral.js:16:4] + 15 │ + 16 │ {} = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-regularexpressionliteral.js:16:1] + 15 │ + 16 │ /1/ = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-templateliteral.js:16:1] + 15 │ + 16 │ `` = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-primaryexpression-this.js:16:1] + 15 │ + 16 │ this = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js:20:1] + 19 │ + 20 │ x >= y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js:20:1] + 19 │ + 20 │ 1 >= 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js:20:1] + 19 │ + 20 │ true >= false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-0.js:20:1] + 19 │ + 20 │ x > y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-1.js:20:1] + 19 │ + 20 │ 1 > 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-2.js:20:1] + 19 │ + 20 │ true > false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-0.js:20:1] + 19 │ + 20 │ x in y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-1.js:20:1] + 19 │ + 20 │ 1 in 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-2.js:20:1] + 19 │ + 20 │ true in false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-0.js:20:1] + 19 │ + 20 │ x instanceof y = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-1.js:20:1] + 19 │ + 20 │ 1 instanceof 2 = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-2.js:20:1] + 19 │ + 20 │ true instanceof false = 1; + · ───────────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-0.js:20:1] + 19 │ + 20 │ x <= y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-1.js:20:1] + 19 │ + 20 │ 1 <= 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-2.js:20:1] + 19 │ + 20 │ true <= false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-0.js:20:1] + 19 │ + 20 │ x < y = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-1.js:20:1] + 19 │ + 20 │ 1 < 2 = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-2.js:20:1] + 19 │ + 20 │ true < false = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-0.js:20:1] + 19 │ + 20 │ x << y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-1.js:20:1] + 19 │ + 20 │ 1 << 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-2.js:20:1] + 19 │ + 20 │ true << false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-0.js:20:1] + 19 │ + 20 │ x >> y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-1.js:20:1] + 19 │ + 20 │ 1 >> 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-2.js:20:1] + 19 │ + 20 │ true >> false = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js:20:1] + 19 │ + 20 │ x >>> y = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js:20:1] + 19 │ + 20 │ 1 >>> 2 = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js:20:1] + 19 │ + 20 │ true >>> false = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js:20:2] + 19 │ + 20 │ (x ? y : z) = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js:20:2] + 19 │ + 20 │ (1 ? 2 : 3) = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js:20:2] + 19 │ + 20 │ (true ? false : true) = 1; + · ─────────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-delete-unaryexpression.js:20:1] + 19 │ + 20 │ delete x.y = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-0.js:20:1] + 19 │ + 20 │ !x = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-1.js:20:1] + 19 │ + 20 │ !1 = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-2.js:20:1] + 19 │ + 20 │ !true = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-0.js:20:1] + 19 │ + 20 │ -x = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-1.js:20:1] + 19 │ + 20 │ -1 = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-2.js:20:1] + 19 │ + 20 │ -true = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-0.js:20:1] + 19 │ + 20 │ +x = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-1.js:20:1] + 19 │ + 20 │ +1 = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-2.js:20:1] + 19 │ + 20 │ +true = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-0.js:20:1] + 19 │ + 20 │ ~x = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-1.js:20:1] + 19 │ + 20 │ ~1 = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-2.js:20:1] + 19 │ + 20 │ ~true = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-0.js:20:1] + 19 │ + 20 │ typeof x = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-1.js:20:1] + 19 │ + 20 │ typeof 1 = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-2.js:20:1] + 19 │ + 20 │ typeof true = 1; + · ─────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-0.js:20:1] + 19 │ + 20 │ void x = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-1.js:20:1] + 19 │ + 20 │ void 1 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-2.js:20:1] + 19 │ + 20 │ void true = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-0.js:21:1] + 20 │ + 21 │ x ** y = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-1.js:21:1] + 20 │ + 21 │ 1 ** 2 = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-2.js:21:1] + 20 │ + 21 │ true ** false = 1; + · ───────────── + ╰──── + + × A 'yield' expression is only allowed in a generator body. + ╭─[language/expressions/assignmenttargettype/direct-yieldexpression-0.js:20:1] + 19 │ + 20 │ yield x = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/direct-yieldexpression-1.js:20:1] + 19 │ + 20 │ yield * x = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-0.js:23:2] + 22 │ + 23 │ (x - y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-1.js:23:2] + 22 │ + 23 │ (1 - 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-2.js:23:2] + 22 │ + 23 │ (true - false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-0.js:23:2] + 22 │ + 23 │ (x + y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-1.js:23:2] + 22 │ + 23 │ (1 + 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-2.js:23:2] + 22 │ + 23 │ (true + false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-0.js:23:2] + 22 │ + 23 │ (() => {}) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-1.js:23:2] + 22 │ + 23 │ (() => ({})) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-2.js:23:3] + 22 │ + 23 │ ((x => x)) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-3.js:23:3] + 22 │ + 23 │ (((x) => x)) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-4.js:23:3] + 22 │ + 23 │ ((() => 1)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-5.js:23:3] + 22 │ + 23 │ ((() => true)) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-arrowfunction-6.js:23:3] + 22 │ + 23 │ ((() => 1)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-0.js:23:2] + 22 │ + 23 │ (async () => {}) = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-1.js:23:2] + 22 │ + 23 │ (async () => ({})) = 1; + · ──────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-2.js:23:3] + 22 │ + 23 │ ((async x => x)) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-3.js:23:3] + 22 │ + 23 │ ((async (x) => x)) = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-4.js:23:3] + 22 │ + 23 │ ((async () => 1)) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-5.js:23:3] + 22 │ + 23 │ ((async () => true)) = 1; + · ──────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-6.js:23:3] + 22 │ + 23 │ ((async () => 1)) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-0.js:23:2] + 22 │ + 23 │ (x & y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-1.js:23:2] + 22 │ + 23 │ (1 & 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-2.js:23:2] + 22 │ + 23 │ (true & false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js:23:2] + 22 │ + 23 │ (x | y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js:23:2] + 22 │ + 23 │ (1 | 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js:23:2] + 22 │ + 23 │ (true | false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js:23:2] + 22 │ + 23 │ (x ^ y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js:23:2] + 22 │ + 23 │ (1 ^ 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js:23:2] + 22 │ + 23 │ (true ^ false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-callexpression-arguments.js:23:2] + 22 │ + 23 │ (f()) = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-callexpression-templateliteral.js:23:2] + 22 │ + 23 │ (f()``) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js:23:2] + 22 │ + 23 │ (x ?? y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js:23:2] + 22 │ + 23 │ (1 ?? 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js:23:2] + 22 │ + 23 │ (true ?? false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-0.js:23:2] + 22 │ + 23 │ (x == y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-1.js:23:2] + 22 │ + 23 │ (1 == 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-2.js:23:2] + 22 │ + 23 │ (true == false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-0.js:23:2] + 22 │ + 23 │ (x != y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-1.js:23:2] + 22 │ + 23 │ (1 != 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-2.js:23:2] + 22 │ + 23 │ (true != false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-0.js:23:2] + 22 │ + 23 │ (x == y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-1.js:23:2] + 22 │ + 23 │ (1 == 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-2.js:23:2] + 22 │ + 23 │ (true == false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-0.js:23:2] + 22 │ + 23 │ (x !== y) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-1.js:23:2] + 22 │ + 23 │ (1 !== 2) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-2.js:23:2] + 22 │ 23 │ (true !== false) = 1; · ────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-0.js:23:3] - 22 │ - 23 │ ((x, y = z)) = 1; - · ──────── + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-0.js:23:3] + 22 │ + 23 │ ((x, y = z)) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-1.js:23:3] + 22 │ + 23 │ ((x, y = 1)) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-2.js:23:3] + 22 │ + 23 │ ((x, y = true)) = 1; + · ─────────── + ╰──── + + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/assignmenttargettype/parenthesized-identifierreference-arguments-strict.js:19:2] + 18 │ + 19 │ (arguments) = 1; + · ───────── + ╰──── + + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/assignmenttargettype/parenthesized-identifierreference-eval-strict.js:19:2] + 18 │ + 19 │ (eval) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-import.meta.js:23:2] + 22 │ + 23 │ (import.meta) = 1; + · ─────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/assignmenttargettype/parenthesized-importcall.js:23:9] + 22 │ + 23 │ (import()) = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-0.js:23:3] + 22 │ + 23 │ ((x = y)) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-1.js:23:3] + 22 │ + 23 │ ((x = 1)) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-2.js:23:3] + 22 │ + 23 │ ((x = true)) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js:23:3] + 22 │ + 23 │ ((x ??= y)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js:23:3] + 22 │ + 23 │ ((x ??= 1)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js:23:3] + 22 │ + 23 │ ((x ??= true)) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js:23:3] + 22 │ + 23 │ ((x &&= y)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js:23:3] + 22 │ + 23 │ ((x &&= 1)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js:23:3] + 22 │ + 23 │ ((x &&= true)) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js:23:3] + 22 │ + 23 │ ((x ||= y)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js:23:3] + 22 │ + 23 │ ((x ||= 1)) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js:23:3] + 22 │ + 23 │ ((x ||= true)) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-minus-minus.js:23:2] + 22 │ + 23 │ (x--) = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-plus-plus.js:23:2] + 22 │ + 23 │ (x++) = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-0.js:23:2] + 22 │ + 23 │ (x && y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-1.js:23:2] + 22 │ + 23 │ (1 && 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-2.js:23:2] + 22 │ + 23 │ (true && false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-0.js:23:2] + 22 │ + 23 │ (x || y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-1.js:23:2] + 22 │ + 23 │ (1 || 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-2.js:23:2] + 22 │ + 23 │ (true || false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-memberexpression-templateliteral.js:23:2] + 22 │ + 23 │ (o.f()``) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-minus-minus-unaryexpression.js:23:2] + 22 │ + 23 │ (--x) = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js:23:2] + 22 │ + 23 │ (x * y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js:23:2] + 22 │ + 23 │ (1 * 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js:23:2] + 22 │ + 23 │ (true * false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js:23:2] + 22 │ + 23 │ (x / y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js:23:2] + 22 │ + 23 │ (1 / 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js:23:2] + 22 │ + 23 │ (true / false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-new-memberexpression-arguments.js:23:2] + 22 │ + 23 │ (new f()) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-new-newexpression.js:23:2] + 22 │ + 23 │ (new f) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-optionalexpression.js:24:2] + 23 │ + 24 │ (x?.y) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-plus-plus-unaryexpression.js:23:2] + 22 │ + 23 │ (++x) = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncfunctionexpression.js:19:2] + 18 │ + 19 │ (async function () {}) = 1; + · ──────────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncgeneratorexpression.js:19:2] + 18 │ + 19 │ (async function () {}) = 1; + · ──────────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-classexpression.js:19:2] + 18 │ + 19 │ (class {}) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-functionexpression.js:19:2] + 18 │ + 19 │ (function() {}) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-generatorexpression.js:19:2] + 18 │ + 19 │ (function * () {}) = 1; + · ──────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-boolean.js:19:2] + 18 │ + 19 │ (true) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-null.js:19:2] + 18 │ + 19 │ (null) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-numeric.js:19:2] + 18 │ + 19 │ (0) = 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-string.js:19:2] + 18 │ + 19 │ ('') = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-objectliteral.js:19:1] + 18 │ + 19 │ ({}) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-regularexpressionliteral.js:19:2] + 18 │ + 19 │ (/1/) = 1; + · ─── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-templateliteral.js:19:2] + 18 │ + 19 │ (``) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-this.js:19:2] + 18 │ + 19 │ (this) = 1; + · ──── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js:23:2] + 22 │ + 23 │ (x >= y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js:23:2] + 22 │ + 23 │ (1 >= 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js:23:2] + 22 │ + 23 │ (true >= false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-0.js:23:2] + 22 │ + 23 │ (x > y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-1.js:23:2] + 22 │ + 23 │ (1 > 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-2.js:23:2] + 22 │ + 23 │ (true > false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-0.js:23:2] + 22 │ + 23 │ (x in y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-1.js:23:2] + 22 │ + 23 │ (1 in 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-2.js:23:2] + 22 │ + 23 │ (true in false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-0.js:23:2] + 22 │ + 23 │ (x instanceof y) = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-1.js:23:2] + 22 │ + 23 │ (1 instanceof 2) = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-2.js:23:2] + 22 │ + 23 │ (true instanceof false) = 1; + · ───────────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-0.js:23:2] + 22 │ + 23 │ (x <= y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-1.js:23:2] + 22 │ + 23 │ (1 <= 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-2.js:23:2] + 22 │ + 23 │ (true <= false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-0.js:23:2] + 22 │ + 23 │ (x < y) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-1.js:23:2] + 22 │ + 23 │ (1 < 2) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-2.js:23:2] + 22 │ + 23 │ (true < false) = 1; + · ──────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-0.js:23:2] + 22 │ + 23 │ (x << y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-1.js:23:2] + 22 │ + 23 │ (1 << 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-2.js:23:2] + 22 │ + 23 │ (true << false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-0.js:23:2] + 22 │ + 23 │ (x >> y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-1.js:23:2] + 22 │ + 23 │ (1 >> 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-2.js:23:2] + 22 │ + 23 │ (true >> false) = 1; + · ───────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js:23:2] + 22 │ + 23 │ (x >>> y) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js:23:2] + 22 │ + 23 │ (1 >>> 2) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js:23:2] + 22 │ + 23 │ (true >>> false) = 1; + · ────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js:23:3] + 22 │ + 23 │ ((x ? y : z)) = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js:23:3] + 22 │ + 23 │ ((1 ? 2 : 3)) = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js:23:3] + 22 │ + 23 │ ((true ? false : true)) = 1; + · ─────────────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-delete-unaryexpression.js:23:2] + 22 │ + 23 │ (delete x.y) = 1; + · ────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-0.js:23:2] + 22 │ + 23 │ (!x) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-1.js:23:2] + 22 │ + 23 │ (!1) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-2.js:23:2] + 22 │ + 23 │ (!true) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-0.js:23:2] + 22 │ + 23 │ (-x) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-1.js:23:2] + 22 │ + 23 │ (-1) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-2.js:23:2] + 22 │ + 23 │ (-true) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-0.js:23:2] + 22 │ + 23 │ (+x) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-1.js:23:2] + 22 │ + 23 │ (+1) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-2.js:23:2] + 22 │ + 23 │ (+true) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-0.js:23:2] + 22 │ + 23 │ (~x) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-1.js:23:2] + 22 │ + 23 │ (~1) = 1; + · ── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-2.js:23:2] + 22 │ + 23 │ (~true) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-0.js:23:2] + 22 │ + 23 │ (typeof x) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-1.js:23:2] + 22 │ + 23 │ (typeof 1) = 1; + · ──────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-2.js:23:2] + 22 │ + 23 │ (typeof true) = 1; + · ─────────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-0.js:23:2] + 22 │ + 23 │ (void x) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-1.js:23:2] + 22 │ + 23 │ (void 1) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-2.js:23:2] + 22 │ + 23 │ (void true) = 1; + · ───────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-0.js:24:2] + 23 │ + 24 │ (x ** y) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-1.js:24:2] + 23 │ + 24 │ (1 ** 2) = 1; + · ────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-2.js:24:2] + 23 │ + 24 │ (true ** false) = 1; + · ───────────── + ╰──── + + × A 'yield' expression is only allowed in a generator body. + ╭─[language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js:23:2] + 22 │ + 23 │ (yield x) = 1; + · ───── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js:23:2] + 22 │ + 23 │ (yield x) = 1; + · ─────── + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/assignmenttargettype/parenthesized-yieldexpression-1.js:23:2] + 22 │ + 23 │ (yield * x) = 1; + · ───────── + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-arrow-function/array-destructuring-param-strict-body.js:122:3] + 121 │ (async ([element]) => { + 122 │ "use strict"; + · ───────────── + 123 │ }); + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-arrow-function/await-as-binding-identifier-escaped.js:33:7] + 32 │ async () => { + 33 │ var \u0061wait; + · ────────── + 34 │ } + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-arrow-function/await-as-binding-identifier.js:33:7] + 32 │ async () => { + 33 │ var await; + · ───── + 34 │ } + ╰──── + + × Keywords cannot contain escape characters + ╭─[language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js:33:8] + 32 │ async () => { + 33 │ void \u0061wait; + · ────────── + 34 │ } + ╰──── + + × Unexpected token + ╭─[language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js:33:18] + 32 │ async () => { + 33 │ void \u0061wait; + · ─ + 34 │ } + ╰──── + + × Unexpected token + ╭─[language/expressions/async-arrow-function/await-as-identifier-reference.js:33:13] + 32 │ async () => { + 33 │ void await; + · ─ + 34 │ } + ╰──── + + × Keywords cannot contain escape characters + ╭─[language/expressions/async-arrow-function/await-as-label-identifier-escaped.js:33:3] + 32 │ async () => { + 33 │ \u0061wait: ; + · ────────── + 34 │ } + ╰──── + + × Unexpected token + ╭─[language/expressions/async-arrow-function/await-as-label-identifier-escaped.js:33:13] + 32 │ async () => { + 33 │ \u0061wait: ; + · ─ + 34 │ } + ╰──── + + × Unexpected token + ╭─[language/expressions/async-arrow-function/await-as-label-identifier.js:33:8] + 32 │ async () => { + 33 │ await: ; + · ─ + 34 │ } + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-arrow-function/await-as-param-ident-nested-arrow-parameter-position.js:16:11] + 15 │ + 16 │ async(a = await => {}) => {}; + · ───── + ╰──── + + × await expression not allowed in formal parameter + ╭─[language/expressions/async-arrow-function/await-as-param-nested-arrow-body-position.js:16:19] + 15 │ + 16 │ async() => { (a = await/r/g) => {} }; + · ────┬──── + · ╰── await expression not allowed in formal parameter ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-1.js:23:3] - 22 │ - 23 │ ((x, y = 1)) = 1; - · ──────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-arrow-function/await-as-param-nested-arrow-parameter-position.js:16:12] + 15 │ + 16 │ async(a = (await) => {}) => {}; + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-2.js:23:3] - 22 │ - 23 │ ((x, y = true)) = 1; - · ─────────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-arrow-function/await-as-param-rest-nested-arrow-parameter-position.js:16:15] + 15 │ + 16 │ async(a = (...await) => {}) => {}; + · ───── + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/async-arrow-function/dflt-params-duplicates.js:50:9] + 49 │ + 50 │ (async (x = 0, x) => { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 51 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-arrow-function/dflt-params-rest.js:54:12] + 53 │ + 54 │ (async (...x = []) => { + · ────── + 55 │ + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-arrow-function/early-errors-arrow-NSPL-with-USD.js:16:19] + 15 │ + 16 │ async (x = 1) => {"use strict"} + · ──────────── ╰──── × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/assignmenttargettype/parenthesized-identifierreference-arguments-strict.js:19:2] - 18 │ - 19 │ (arguments) = 1; - · ───────── + ╭─[language/expressions/async-arrow-function/early-errors-arrow-arguments-in-formal-parameters.js:16:7] + 15 │ + 16 │ async(arguments) => { } + · ───────── + 17 │ + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-arrow-function/early-errors-arrow-await-in-formals-default.js:14:17] + 13 │ $DONOTEVALUATE(); + 14 │ async(x = await) => { } + · ▲ + ╰──── + help: Try insert a semicolon here + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-arrow-function/early-errors-arrow-await-in-formals.js:14:7] + 13 │ $DONOTEVALUATE(); + 14 │ async(await) => { } + · ───── + ╰──── + + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-call.js:15:17] + 14 │ + 15 │ async(foo) => { super() }; + · ─────── + ╰──── + + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-property.js:15:17] + 14 │ + 15 │ async(foo) => { super.prop }; + · ───── + ╰──── + + × Identifier `a` has already been declared + ╭─[language/expressions/async-arrow-function/early-errors-arrow-duplicate-parameters.js:35:7] + 34 │ + 35 │ async(a, a) => { } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `a` has already been declared here ╰──── × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/assignmenttargettype/parenthesized-identifierreference-eval-strict.js:19:2] - 18 │ - 19 │ (eval) = 1; - · ──── + ╭─[language/expressions/async-arrow-function/early-errors-arrow-eval-in-formal-parameters.js:16:7] + 15 │ + 16 │ async(eval) => { } + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-import.meta.js:23:2] - 22 │ - 23 │ (import.meta) = 1; - · ─────────── + × Identifier `bar` has already been declared + ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-body-duplicate.js:15:7] + 14 │ + 15 │ async(bar) => { let bar; } + · ─┬─ ─┬─ + · │ ╰── It can not be redeclared here + · ╰── `bar` has already been declared here + ╰──── + + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-call.js:15:13] + 14 │ + 15 │ async(foo = super()) => {} + · ─────── + ╰──── + + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-property.js:15:14] + 14 │ + 15 │ async (foo = super.foo) => { } + · ───── + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-lineterminator.js:33:6] + 32 │ async + 33 │ (foo) => { } + · ▲ + ╰──── + help: Try insert a semicolon here + + × Keywords cannot contain escape characters + ╭─[language/expressions/async-arrow-function/escaped-async.js:24:1] + 23 │ + 24 │ \u0061sync () => {} + · ────────── + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-arrow-function/object-destructuring-param-strict-body.js:122:3] + 121 │ (async ({property}) => { + 122 │ "use strict"; + · ───────────── + 123 │ }); + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-arrow-function/rest-param-strict-body.js:122:3] + 121 │ (async (a,...rest) => { + 122 │ "use strict"; + · ───────────── + 123 │ }); + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js:46:9] + 45 │ + 46 │ (async (...a,) => { + · ──── + 47 │ + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-function/await-as-binding-identifier-escaped.js:29:7] + 28 │ var asyncFn = async function () { + 29 │ var \u0061wait; + · ────────── + 30 │ }; + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-function/await-as-binding-identifier.js:29:7] + 28 │ var asyncFn = async function () { + 29 │ var await; + · ───── + 30 │ }; + ╰──── + + × Keywords cannot contain escape characters + ╭─[language/expressions/async-function/await-as-identifier-reference-escaped.js:29:8] + 28 │ var asyncFn = async function () { + 29 │ void \u0061wait; + · ────────── + 30 │ }; ╰──── × Unexpected token - ╭─[language/expressions/assignmenttargettype/parenthesized-importcall.js:23:9] - 22 │ - 23 │ (import()) = 1; - · ─ + ╭─[language/expressions/async-function/await-as-identifier-reference-escaped.js:29:18] + 28 │ var asyncFn = async function () { + 29 │ void \u0061wait; + · ─ + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-0.js:23:3] - 22 │ - 23 │ ((x = y)) = 1; - · ───── + × Unexpected token + ╭─[language/expressions/async-function/await-as-identifier-reference.js:29:13] + 28 │ var asyncFn = async function () { + 29 │ void await; + · ─ + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-1.js:23:3] - 22 │ - 23 │ ((x = 1)) = 1; - · ───── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-function/await-as-label-identifier-escaped.js:29:3] + 28 │ var asyncFn = async function () { + 29 │ \u0061wait: ; + · ────────── + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-2.js:23:3] - 22 │ - 23 │ ((x = true)) = 1; - · ──────── + × Unexpected token + ╭─[language/expressions/async-function/await-as-label-identifier-escaped.js:29:13] + 28 │ var asyncFn = async function () { + 29 │ \u0061wait: ; + · ─ + 30 │ }; + ╰──── + + × Unexpected token + ╭─[language/expressions/async-function/await-as-label-identifier.js:29:8] + 28 │ var asyncFn = async function () { + 29 │ await: ; + · ─ + 30 │ }; + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/early-errors-expression-NSPL-with-USD.js:16:26] + 15 │ + 16 │ (async function (x = 1) {"use strict"}) + · ──────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js:23:3] - 22 │ - 23 │ ((x ??= y)) = 1; - · ─────── + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/async-function/early-errors-expression-binding-identifier-arguments.js:16:17] + 15 │ $DONOTEVALUATE(); + 16 │ (async function arguments () { }) + · ───────── + 17 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js:23:3] - 22 │ - 23 │ ((x ??= 1)) = 1; - · ─────── + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/async-function/early-errors-expression-binding-identifier-eval.js:16:17] + 15 │ $DONOTEVALUATE(); + 16 │ (async function eval () { }) + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js:23:3] - 22 │ - 23 │ ((x ??= true)) = 1; - · ────────── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/async-function/early-errors-expression-body-contains-super-call.js:15:29] + 14 │ + 15 │ (async function foo (foo) { super() }) + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js:23:3] - 22 │ - 23 │ ((x &&= y)) = 1; - · ─────── + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/async-function/early-errors-expression-body-contains-super-property.js:15:29] + 14 │ + 15 │ (async function foo (foo) { super.prop }); + · ───── + 16 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js:23:3] - 22 │ - 23 │ ((x &&= 1)) = 1; - · ─────── + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/async-function/early-errors-expression-eval-in-formal-parameters.js:16:22] + 15 │ + 16 │ (async function foo (eval) { }) + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js:23:3] - 22 │ - 23 │ ((x &&= true)) = 1; - · ────────── + × Identifier `bar` has already been declared + ╭─[language/expressions/async-function/early-errors-expression-formals-body-duplicate.js:15:22] + 14 │ + 15 │ (async function foo (bar) { let bar; }); + · ─┬─ ─┬─ + · │ ╰── It can not be redeclared here + · ╰── `bar` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js:23:3] - 22 │ - 23 │ ((x ||= y)) = 1; - · ─────── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/async-function/early-errors-expression-formals-contains-super-call.js:15:28] + 14 │ + 15 │ (async function foo (foo = super()) { var bar; }); + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js:23:3] - 22 │ - 23 │ ((x ||= 1)) = 1; - · ─────── + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/async-function/early-errors-expression-formals-contains-super-property.js:15:28] + 14 │ + 15 │ (async function foo (foo = super.foo) { var bar; }); + · ───── ╰──── × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js:23:3] - 22 │ - 23 │ ((x ||= true)) = 1; - · ────────── + ╭─[language/expressions/async-function/early-errors-expression-not-simple-assignment-target.js:16:2] + 15 │ + 16 │ (async function foo() { } = 1) + · ──────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-minus-minus.js:23:2] - 22 │ - 23 │ (x--) = 1; - · ─── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-function/escaped-async.js:24:6] + 23 │ + 24 │ void \u0061sync function f(){} + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-plus-plus.js:23:2] - 22 │ - 23 │ (x++) = 1; - · ─── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/named-array-destructuring-param-strict-body.js:108:3] + 107 │ (async function f([element]) { + 108 │ "use strict"; + · ───────────── + 109 │ }); + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-0.js:23:2] - 22 │ - 23 │ (x && y) = 1; - · ────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-function/named-await-as-binding-identifier-escaped.js:29:7] + 28 │ var asyncFn = async function asyncFn() { + 29 │ var \u0061wait; + · ────────── + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-1.js:23:2] - 22 │ - 23 │ (1 && 2) = 1; - · ────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-function/named-await-as-binding-identifier.js:29:7] + 28 │ var asyncFn = async function asyncFn() { + 29 │ var await; + · ───── + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-2.js:23:2] - 22 │ - 23 │ (true && false) = 1; - · ───────────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-function/named-await-as-identifier-reference-escaped.js:29:8] + 28 │ var asyncFn = async function asyncFn() { + 29 │ void \u0061wait; + · ────────── + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-0.js:23:2] - 22 │ - 23 │ (x || y) = 1; - · ────── + × Unexpected token + ╭─[language/expressions/async-function/named-await-as-identifier-reference-escaped.js:29:18] + 28 │ var asyncFn = async function asyncFn() { + 29 │ void \u0061wait; + · ─ + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-1.js:23:2] - 22 │ - 23 │ (1 || 2) = 1; - · ────── + × Unexpected token + ╭─[language/expressions/async-function/named-await-as-identifier-reference.js:29:13] + 28 │ var asyncFn = async function asyncFn() { + 29 │ void await; + · ─ + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-2.js:23:2] - 22 │ - 23 │ (true || false) = 1; - · ───────────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-function/named-await-as-label-identifier-escaped.js:29:3] + 28 │ var asyncFn = async function asyncFn() { + 29 │ \u0061wait: ; + · ────────── + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-memberexpression-templateliteral.js:23:2] - 22 │ - 23 │ (o.f()``) = 1; - · ─────── + × Unexpected token + ╭─[language/expressions/async-function/named-await-as-label-identifier-escaped.js:29:13] + 28 │ var asyncFn = async function asyncFn() { + 29 │ \u0061wait: ; + · ─ + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-minus-minus-unaryexpression.js:23:2] - 22 │ - 23 │ (--x) = 1; - · ─── + × Unexpected token + ╭─[language/expressions/async-function/named-await-as-label-identifier.js:29:8] + 28 │ var asyncFn = async function asyncFn() { + 29 │ await: ; + · ─ + 30 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js:23:2] - 22 │ - 23 │ (x * y) = 1; - · ───── + × Identifier `x` has already been declared + ╭─[language/expressions/async-function/named-dflt-params-duplicates.js:36:19] + 35 │ + 36 │ (async function f(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 37 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js:23:2] - 22 │ - 23 │ (1 * 2) = 1; - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-function/named-dflt-params-rest.js:40:22] + 39 │ + 40 │ (async function f(...x = []) { + · ────── + 41 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js:23:2] - 22 │ - 23 │ (true * false) = 1; - · ──────────── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/named-object-destructuring-param-strict-body.js:108:3] + 107 │ (async function f({property}) { + 108 │ "use strict"; + · ───────────── + 109 │ }); + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/named-rest-param-strict-body.js:108:3] + 107 │ (async function f(a,...rest) { + 108 │ "use strict"; + · ───────────── + 109 │ }); + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/async-function/named-rest-params-trailing-comma-early-error.js:33:19] + 32 │ + 33 │ (async function f(...a,) { + · ──── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js:23:2] - 22 │ - 23 │ (x / y) = 1; - · ───── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/nameless-array-destructuring-param-strict-body.js:108:3] + 107 │ (async function([element]) { + 108 │ "use strict"; + · ───────────── + 109 │ }); + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js:23:2] - 22 │ - 23 │ (1 / 2) = 1; - · ───── + × Identifier `x` has already been declared + ╭─[language/expressions/async-function/nameless-dflt-params-duplicates.js:36:17] + 35 │ + 36 │ (async function(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 37 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js:23:2] - 22 │ - 23 │ (true / false) = 1; - · ──────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-function/nameless-dflt-params-rest.js:40:20] + 39 │ + 40 │ (async function(...x = []) { + · ────── + 41 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-new-memberexpression-arguments.js:23:2] - 22 │ - 23 │ (new f()) = 1; - · ─────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/nameless-object-destructuring-param-strict-body.js:108:3] + 107 │ (async function({property}) { + 108 │ "use strict"; + · ───────────── + 109 │ }); + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-new-newexpression.js:23:2] - 22 │ - 23 │ (new f) = 1; - · ───── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-function/nameless-rest-param-strict-body.js:108:3] + 107 │ (async function(a,...rest) { + 108 │ "use strict"; + · ───────────── + 109 │ }); + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/async-function/nameless-rest-params-trailing-comma-early-error.js:33:17] + 32 │ + 33 │ (async function(...a,) { + · ──── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-optionalexpression.js:24:2] - 23 │ - 24 │ (x?.y) = 1; - · ──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-generator/array-destructuring-param-strict-body.js:111:3] + 110 │ 0, async function*([element]) { + 111 │ "use strict"; + · ───────────── + 112 │ }; + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-generator/await-as-binding-identifier-escaped.js:30:7] + 29 │ var gen = async function *() { + 30 │ var \u0061wait; + · ────────── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-plus-plus-unaryexpression.js:23:2] - 22 │ - 23 │ (++x) = 1; - · ─── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-generator/await-as-binding-identifier.js:30:7] + 29 │ var gen = async function *() { + 30 │ var await; + · ───── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncfunctionexpression.js:19:2] - 18 │ - 19 │ (async function () {}) = 1; - · ──────────────────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-generator/await-as-identifier-reference-escaped.js:30:8] + 29 │ var gen = async function *() { + 30 │ void \u0061wait; + · ────────── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncgeneratorexpression.js:19:2] - 18 │ - 19 │ (async function () {}) = 1; - · ──────────────────── + × Unexpected token + ╭─[language/expressions/async-generator/await-as-identifier-reference-escaped.js:30:18] + 29 │ var gen = async function *() { + 30 │ void \u0061wait; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-classexpression.js:19:2] - 18 │ - 19 │ (class {}) = 1; - · ──────── + × Unexpected token + ╭─[language/expressions/async-generator/await-as-identifier-reference.js:30:13] + 29 │ var gen = async function *() { + 30 │ void await; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-functionexpression.js:19:2] - 18 │ - 19 │ (function() {}) = 1; - · ───────────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-generator/await-as-label-identifier-escaped.js:30:3] + 29 │ var gen = async function *() { + 30 │ \u0061wait: ; + · ────────── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-generatorexpression.js:19:2] - 18 │ - 19 │ (function * () {}) = 1; - · ──────────────── + × Unexpected token + ╭─[language/expressions/async-generator/await-as-label-identifier-escaped.js:30:13] + 29 │ var gen = async function *() { + 30 │ \u0061wait: ; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-boolean.js:19:2] - 18 │ - 19 │ (true) = 1; - · ──── + × Unexpected token + ╭─[language/expressions/async-generator/await-as-label-identifier.js:30:8] + 29 │ var gen = async function *() { + 30 │ await: ; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-null.js:19:2] - 18 │ - 19 │ (null) = 1; - · ──── + × Identifier `x` has already been declared + ╭─[language/expressions/async-generator/dflt-params-duplicates.js:39:20] + 38 │ + 39 │ 0, async function*(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 40 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-numeric.js:19:2] - 18 │ - 19 │ (0) = 1; - · ─ + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dflt-params-rest.js:43:23] + 42 │ + 43 │ 0, async function*(...x = []) { + · ────── + 44 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-string.js:19:2] - 18 │ - 19 │ ('') = 1; - · ── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-init-ary.js:33:25] + 32 │ var f; + 33 │ f = async function*([...[ x ] = []]) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-objectliteral.js:19:1] - 18 │ - 19 │ ({}) = 1; - · ──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-init-id.js:33:25] + 32 │ var f; + 33 │ f = async function*([...x = []]) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-regularexpressionliteral.js:19:2] - 18 │ - 19 │ (/1/) = 1; - · ─── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-init-obj.js:33:25] + 32 │ var f; + 33 │ f = async function*([...{ x } = []]) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-templateliteral.js:19:2] - 18 │ - 19 │ (``) = 1; - · ── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-ary.js:33:22] + 32 │ var f; + 33 │ f = async function*([...[x], y]) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-primaryexpression-this.js:19:2] - 18 │ - 19 │ (this) = 1; - · ──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-id.js:33:22] + 32 │ var f; + 33 │ f = async function*([...x, y]) { + · ──── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js:23:2] - 22 │ - 23 │ (x >= y) = 1; - · ────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-obj.js:33:22] + 32 │ var f; + 33 │ f = async function*([...{ x }, y]) { + · ──────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js:23:2] - 22 │ - 23 │ (1 >= 2) = 1; - · ────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-ary.js:33:25] + 32 │ var f; + 33 │ f = async function*([...[ x ] = []] = []) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js:23:2] - 22 │ - 23 │ (true >= false) = 1; - · ───────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-id.js:33:25] + 32 │ var f; + 33 │ f = async function*([...x = []] = []) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-0.js:23:2] - 22 │ - 23 │ (x > y) = 1; - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-obj.js:33:25] + 32 │ var f; + 33 │ f = async function*([...{ x } = []] = []) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-1.js:23:2] - 22 │ - 23 │ (1 > 2) = 1; - · ───── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-ary.js:33:22] + 32 │ var f; + 33 │ f = async function*([...[x], y] = [1, 2, 3]) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-2.js:23:2] - 22 │ - 23 │ (true > false) = 1; - · ──────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-id.js:33:22] + 32 │ var f; + 33 │ f = async function*([...x, y] = [1, 2, 3]) { + · ──── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-0.js:23:2] - 22 │ - 23 │ (x in y) = 1; - · ────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-obj.js:33:22] + 32 │ var f; + 33 │ f = async function*([...{ x }, y] = [1, 2, 3]) { + · ──────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-1.js:23:2] - 22 │ - 23 │ (1 in 2) = 1; - · ────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-ary.js:33:27] + 32 │ var f; + 33 │ f = async function* h([...[ x ] = []]) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-2.js:23:2] - 22 │ - 23 │ (true in false) = 1; - · ───────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-id.js:33:27] + 32 │ var f; + 33 │ f = async function* h([...x = []]) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-0.js:23:2] - 22 │ - 23 │ (x instanceof y) = 1; - · ────────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-obj.js:33:27] + 32 │ var f; + 33 │ f = async function* h([...{ x } = []]) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-1.js:23:2] - 22 │ - 23 │ (1 instanceof 2) = 1; - · ────────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-ary.js:33:24] + 32 │ var f; + 33 │ f = async function* h([...[x], y]) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-2.js:23:2] - 22 │ - 23 │ (true instanceof false) = 1; - · ───────────────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-id.js:33:24] + 32 │ var f; + 33 │ f = async function* h([...x, y]) { + · ──── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-0.js:23:2] - 22 │ - 23 │ (x <= y) = 1; - · ────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-obj.js:33:24] + 32 │ var f; + 33 │ f = async function* h([...{ x }, y]) { + · ──────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-1.js:23:2] - 22 │ - 23 │ (1 <= 2) = 1; - · ────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-ary.js:33:27] + 32 │ var f; + 33 │ f = async function* h([...[ x ] = []] = []) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-2.js:23:2] - 22 │ - 23 │ (true <= false) = 1; - · ───────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-id.js:33:27] + 32 │ var f; + 33 │ f = async function* h([...x = []] = []) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-0.js:23:2] - 22 │ - 23 │ (x < y) = 1; - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-obj.js:33:27] + 32 │ var f; + 33 │ f = async function* h([...{ x } = []] = []) { + · ────────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-1.js:23:2] - 22 │ - 23 │ (1 < 2) = 1; - · ───── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-ary.js:33:24] + 32 │ var f; + 33 │ f = async function* h([...[x], y] = [1, 2, 3]) { + · ────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-2.js:23:2] - 22 │ - 23 │ (true < false) = 1; - · ──────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-id.js:33:24] + 32 │ var f; + 33 │ f = async function* h([...x, y] = [1, 2, 3]) { + · ──── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-0.js:23:2] - 22 │ - 23 │ (x << y) = 1; - · ────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-obj.js:33:24] + 32 │ var f; + 33 │ f = async function* h([...{ x }, y] = [1, 2, 3]) { + · ──────── + 34 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-1.js:23:2] - 22 │ - 23 │ (1 << 2) = 1; - · ────── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js:18:26] + 17 │ + 18 │ (async function*(x = 1) {"use strict"}); + · ──────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-2.js:23:2] - 22 │ - 23 │ (true << false) = 1; - · ───────────── + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js:18:18] + 17 │ + 18 │ (async function*(arguments) { }); + · ───────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-0.js:23:2] - 22 │ - 23 │ (x >> y) = 1; - · ────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js:17:18] + 16 │ + 17 │ (async function* await() { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-1.js:23:2] - 22 │ - 23 │ (1 >> 2) = 1; - · ────── + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js:19:18] + 18 │ + 19 │ (async function* arguments() { }); + · ───────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-2.js:23:2] - 22 │ - 23 │ (true >> false) = 1; - · ───────────── + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js:19:18] + 18 │ + 19 │ (async function* eval() { }); + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js:23:2] - 22 │ - 23 │ (x >>> y) = 1; - · ─────── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/async-generator/early-errors-expression-body-contains-super-call.js:17:22] + 16 │ + 17 │ (async function*() { super(); }); + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js:23:2] - 22 │ - 23 │ (1 >>> 2) = 1; - · ─────── + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/async-generator/early-errors-expression-body-contains-super-property.js:17:22] + 16 │ + 17 │ (async function*() { super.prop; }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js:23:2] - 22 │ - 23 │ (true >>> false) = 1; - · ────────────── + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js:18:18] + 17 │ + 18 │ (async function*(eval) { }); + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js:23:3] - 22 │ - 23 │ ((x ? y : z)) = 1; - · ───────── + × Identifier `a` has already been declared + ╭─[language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js:21:18] + 20 │ + 21 │ (async function*(a) { const a = 0; }); + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `a` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js:23:3] - 22 │ - 23 │ ((1 ? 2 : 3)) = 1; - · ───────── + × Identifier `a` has already been declared + ╭─[language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js:18:18] + 17 │ + 18 │ (async function*(a) { let a; }); + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `a` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js:23:3] - 22 │ - 23 │ ((true ? false : true)) = 1; - · ─────────────────── + × await expression not allowed in formal parameter + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js:17:22] + 16 │ + 17 │ (async function*(x = await 1) { }); + · ───┬─── + · ╰── await expression not allowed in formal parameter ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-delete-unaryexpression.js:23:2] - 22 │ - 23 │ (delete x.y) = 1; - · ────────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-await.js:18:18] + 17 │ + 18 │ (async function*(await) { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-0.js:23:2] - 22 │ - 23 │ (!x) = 1; - · ── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js:17:22] + 16 │ + 17 │ (async function*(a = super()) { }); + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-1.js:23:2] - 22 │ - 23 │ (!1) = 1; - · ── + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js:17:22] + 16 │ + 17 │ (async function*(a = super.prop) { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-2.js:23:2] - 22 │ - 23 │ (!true) = 1; - · ───── + × yield expression not allowed in formal parameter + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js:17:22] + 16 │ + 17 │ (async function*(x = yield) { }); + · ──┬── + · ╰── yield expression not allowed in formal parameter ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-0.js:23:2] - 22 │ - 23 │ (-x) = 1; - · ── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-yield.js:18:18] + 17 │ + 18 │ (async function*(yield) { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-1.js:23:2] - 22 │ - 23 │ (-1) = 1; - · ── + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-yield.js:18:18] + 17 │ + 18 │ (async function*(yield) { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-2.js:23:2] - 22 │ - 23 │ (-true) = 1; - · ───── + × Unexpected token + ╭─[language/expressions/async-generator/early-errors-expression-label-name-await.js:23:8] + 22 │ (async function*() { + 23 │ await: 1; + · ─ + 24 │ }); ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-0.js:23:2] - 22 │ - 23 │ (+x) = 1; - · ── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-generator/early-errors-expression-label-name-yield.js:25:8] + 24 │ (async function*() { + 25 │ yield: 1; + · ▲ + 26 │ }); ╰──── + help: Try insert a semicolon here × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-1.js:23:2] - 22 │ - 23 │ (+1) = 1; - · ── + ╭─[language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js:17:2] + 16 │ + 17 │ (async function*() { } = 1); + · ───────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-2.js:23:2] - 22 │ - 23 │ (+true) = 1; - · ───── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js:17:18] + 16 │ + 17 │ (async function* yield() { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-0.js:23:2] - 22 │ - 23 │ (~x) = 1; - · ── + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js:17:18] + 16 │ + 17 │ (async function* yield() { }); + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-1.js:23:2] - 22 │ - 23 │ (~1) = 1; - · ── + × Unexpected token + ╭─[language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js:19:3] + 18 │ yield + 19 │ * 1; + · ─ + 20 │ }); ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-2.js:23:2] - 22 │ - 23 │ (~true) = 1; - · ───── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-generator/escaped-async.js:24:6] + 23 │ + 24 │ void \u0061sync function* f(){}; + · ────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-0.js:23:2] - 22 │ - 23 │ (typeof x) = 1; - · ──────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-generator/named-array-destructuring-param-strict-body.js:111:3] + 110 │ 0, async function* g([element]) { + 111 │ "use strict"; + · ───────────── + 112 │ }; + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-1.js:23:2] - 22 │ - 23 │ (typeof 1) = 1; - · ──────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-generator/named-await-as-binding-identifier-escaped.js:30:7] + 29 │ var gen = async function *g() { + 30 │ var \u0061wait; + · ────────── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-2.js:23:2] - 22 │ - 23 │ (typeof true) = 1; - · ─────────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/async-generator/named-await-as-binding-identifier.js:30:7] + 29 │ var gen = async function *g() { + 30 │ var await; + · ───── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-0.js:23:2] - 22 │ - 23 │ (void x) = 1; - · ────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-generator/named-await-as-identifier-reference-escaped.js:30:8] + 29 │ var gen = async function *g() { + 30 │ void \u0061wait; + · ────────── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-1.js:23:2] - 22 │ - 23 │ (void 1) = 1; - · ────── + × Unexpected token + ╭─[language/expressions/async-generator/named-await-as-identifier-reference-escaped.js:30:18] + 29 │ var gen = async function *g() { + 30 │ void \u0061wait; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-2.js:23:2] - 22 │ - 23 │ (void true) = 1; - · ───────── + × Unexpected token + ╭─[language/expressions/async-generator/named-await-as-identifier-reference.js:30:13] + 29 │ var gen = async function *g() { + 30 │ void await; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-0.js:24:2] - 23 │ - 24 │ (x ** y) = 1; - · ────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-generator/named-await-as-label-identifier-escaped.js:30:3] + 29 │ var gen = async function *g() { + 30 │ \u0061wait: ; + · ────────── + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-1.js:24:2] - 23 │ - 24 │ (1 ** 2) = 1; - · ────── + × Unexpected token + ╭─[language/expressions/async-generator/named-await-as-label-identifier-escaped.js:30:13] + 29 │ var gen = async function *g() { + 30 │ \u0061wait: ; + · ─ + 31 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-2.js:24:2] - 23 │ - 24 │ (true ** false) = 1; - · ───────────── + × Unexpected token + ╭─[language/expressions/async-generator/named-await-as-label-identifier.js:30:8] + 29 │ var gen = async function *g() { + 30 │ await: ; + · ─ + 31 │ }; ╰──── - × A 'yield' expression is only allowed in a generator body. - ╭─[language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js:23:2] - 22 │ - 23 │ (yield x) = 1; - · ───── + × Identifier `x` has already been declared + ╭─[language/expressions/async-generator/named-dflt-params-duplicates.js:39:22] + 38 │ + 39 │ 0, async function* g(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 40 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js:23:2] - 22 │ - 23 │ (yield x) = 1; - · ─────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/async-generator/named-dflt-params-rest.js:43:25] + 42 │ + 43 │ 0, async function* g(...x = []) { + · ────── + 44 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/assignmenttargettype/parenthesized-yieldexpression-1.js:23:2] - 22 │ - 23 │ (yield * x) = 1; - · ───────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-generator/named-object-destructuring-param-strict-body.js:111:3] + 110 │ 0, async function* g({property}) { + 111 │ "use strict"; + · ───────────── + 112 │ }; + ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-arrow-function/array-destructuring-param-strict-body.js:122:3] - 121 │ (async ([element]) => { - 122 │ "use strict"; + ╭─[language/expressions/async-generator/named-rest-param-strict-body.js:111:3] + 110 │ 0, async function* g(a,...rest) { + 111 │ "use strict"; · ───────────── - 123 │ }); + 112 │ }; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-arrow-function/await-as-binding-identifier-escaped.js:33:7] - 32 │ async () => { - 33 │ var \u0061wait; + × A rest parameter must be last in a parameter list + ╭─[language/expressions/async-generator/named-rest-params-trailing-comma-early-error.js:36:22] + 35 │ + 36 │ 0, async function* g(...a,) { + · ──── + 37 │ + ╰──── + + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js:30:7] + 29 │ var gen = async function *g() { + 30 │ var yi\u0065ld; · ────────── - 34 │ } + 31 │ }; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-arrow-function/await-as-binding-identifier.js:33:7] - 32 │ async () => { - 33 │ var await; + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js:30:7] + 29 │ var gen = async function *g() { + 30 │ var yi\u0065ld; + · ────────── + 31 │ }; + ╰──── + + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/named-yield-as-binding-identifier.js:30:7] + 29 │ var gen = async function *g() { + 30 │ var yield; · ───── - 34 │ } + 31 │ }; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js:33:8] - 32 │ async () => { - 33 │ void \u0061wait; + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/named-yield-as-binding-identifier.js:30:7] + 29 │ var gen = async function *g() { + 30 │ var yield; + · ───── + 31 │ }; + ╰──── + + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js:30:8] + 29 │ var gen = async function *g() { + 30 │ void yi\u0065ld; · ────────── - 34 │ } + 31 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js:33:18] - 32 │ async () => { - 33 │ void \u0061wait; - · ─ - 34 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js:30:8] + 29 │ var gen = async function *g() { + 30 │ void yi\u0065ld; + · ────────── + 31 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/async-arrow-function/await-as-identifier-reference.js:33:13] - 32 │ async () => { - 33 │ void await; - · ─ - 34 │ } + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/named-yield-as-identifier-reference.js:30:8] + 29 │ var gen = async function *g() { + 30 │ void yield; + · ───── + 31 │ }; + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/named-yield-as-identifier-reference.js:30:8] + 29 │ var gen = async function *g() { + 30 │ void yield; + · ───── + 31 │ }; ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/async-arrow-function/await-as-label-identifier-escaped.js:33:3] - 32 │ async () => { - 33 │ \u0061wait: ; + ╭─[language/expressions/async-generator/named-yield-as-label-identifier-escaped.js:30:3] + 29 │ var gen = async function *g() { + 30 │ yi\u0065ld: ; · ────────── - 34 │ } + 31 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/async-arrow-function/await-as-label-identifier-escaped.js:33:13] - 32 │ async () => { - 33 │ \u0061wait: ; - · ─ - 34 │ } + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-generator/named-yield-as-label-identifier-escaped.js:30:13] + 29 │ var gen = async function *g() { + 30 │ yi\u0065ld: ; + · ▲ + 31 │ }; ╰──── + help: Try insert a semicolon here - × Unexpected token - ╭─[language/expressions/async-arrow-function/await-as-label-identifier.js:33:8] - 32 │ async () => { - 33 │ await: ; - · ─ - 34 │ } + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-generator/named-yield-as-label-identifier.js:30:8] + 29 │ var gen = async function *g() { + 30 │ yield: ; + · ▲ + 31 │ }; ╰──── + help: Try insert a semicolon here - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-arrow-function/await-as-param-ident-nested-arrow-parameter-position.js:16:11] - 15 │ - 16 │ async(a = await => {}) => {}; + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/named-yield-identifier-spread-strict.js:36:15] + 35 │ ...(function() { + 36 │ var yield; + · ───── + 37 │ throw new Test262Error(); + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/named-yield-identifier-strict.js:28:11] + 27 │ (function() { + 28 │ var yield; · ───── + 29 │ throw new Test262Error(); ╰──── - × await expression not allowed in formal parameter - ╭─[language/expressions/async-arrow-function/await-as-param-nested-arrow-body-position.js:16:19] - 15 │ - 16 │ async() => { (a = await/r/g) => {} }; - · ────┬──── - · ╰── await expression not allowed in formal parameter + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-generator/object-destructuring-param-strict-body.js:111:3] + 110 │ 0, async function*({property}) { + 111 │ "use strict"; + · ───────────── + 112 │ }; + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/async-generator/rest-param-strict-body.js:111:3] + 110 │ 0, async function*(a,...rest) { + 111 │ "use strict"; + · ───────────── + 112 │ }; + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/async-generator/rest-params-trailing-comma-early-error.js:36:20] + 35 │ + 36 │ 0, async function*(...a,) { + · ──── + 37 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-arrow-function/await-as-param-nested-arrow-parameter-position.js:16:12] - 15 │ - 16 │ async(a = (await) => {}) => {}; - · ───── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/yield-as-binding-identifier-escaped.js:30:7] + 29 │ var gen = async function *() { + 30 │ var yi\u0065ld; + · ────────── + 31 │ }; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-arrow-function/await-as-param-rest-nested-arrow-parameter-position.js:16:15] - 15 │ - 16 │ async(a = (...await) => {}) => {}; - · ───── + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/yield-as-binding-identifier-escaped.js:30:7] + 29 │ var gen = async function *() { + 30 │ var yi\u0065ld; + · ────────── + 31 │ }; ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/async-arrow-function/dflt-params-duplicates.js:50:9] - 49 │ - 50 │ (async (x = 0, x) => { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 51 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/yield-as-binding-identifier.js:30:7] + 29 │ var gen = async function *() { + 30 │ var yield; + · ───── + 31 │ }; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-arrow-function/dflt-params-rest.js:54:12] - 53 │ - 54 │ (async (...x = []) => { - · ────── - 55 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/yield-as-binding-identifier.js:30:7] + 29 │ var gen = async function *() { + 30 │ var yield; + · ───── + 31 │ }; ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-arrow-function/early-errors-arrow-NSPL-with-USD.js:16:19] - 15 │ - 16 │ async (x = 1) => {"use strict"} - · ──────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/yield-as-identifier-reference-escaped.js:30:8] + 29 │ var gen = async function *() { + 30 │ void yi\u0065ld; + · ────────── + 31 │ }; ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/async-arrow-function/early-errors-arrow-arguments-in-formal-parameters.js:16:7] - 15 │ - 16 │ async(arguments) => { } - · ───────── - 17 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/yield-as-identifier-reference-escaped.js:30:8] + 29 │ var gen = async function *() { + 30 │ void yi\u0065ld; + · ────────── + 31 │ }; ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-arrow-function/early-errors-arrow-await-in-formals-default.js:14:17] - 13 │ $DONOTEVALUATE(); - 14 │ async(x = await) => { } - · ▲ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/async-generator/yield-as-identifier-reference.js:30:8] + 29 │ var gen = async function *() { + 30 │ void yield; + · ───── + 31 │ }; ╰──── - help: Try insert a semicolon here - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-arrow-function/early-errors-arrow-await-in-formals.js:14:7] - 13 │ $DONOTEVALUATE(); - 14 │ async(await) => { } - · ───── + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/yield-as-identifier-reference.js:30:8] + 29 │ var gen = async function *() { + 30 │ void yield; + · ───── + 31 │ }; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-call.js:15:17] - 14 │ - 15 │ async(foo) => { super() }; - · ─────── + × Keywords cannot contain escape characters + ╭─[language/expressions/async-generator/yield-as-label-identifier-escaped.js:30:3] + 29 │ var gen = async function *() { + 30 │ yi\u0065ld: ; + · ────────── + 31 │ }; ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-property.js:15:17] - 14 │ - 15 │ async(foo) => { super.prop }; - · ───── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-generator/yield-as-label-identifier-escaped.js:30:13] + 29 │ var gen = async function *() { + 30 │ yi\u0065ld: ; + · ▲ + 31 │ }; ╰──── + help: Try insert a semicolon here - × Identifier `a` has already been declared - ╭─[language/expressions/async-arrow-function/early-errors-arrow-duplicate-parameters.js:35:7] - 34 │ - 35 │ async(a, a) => { } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `a` has already been declared here + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/async-generator/yield-as-label-identifier.js:30:8] + 29 │ var gen = async function *() { + 30 │ yield: ; + · ▲ + 31 │ }; ╰──── + help: Try insert a semicolon here - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/async-arrow-function/early-errors-arrow-eval-in-formal-parameters.js:16:7] - 15 │ - 16 │ async(eval) => { } - · ──── + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/yield-identifier-spread-strict.js:36:15] + 35 │ ...(function() { + 36 │ var yield; + · ───── + 37 │ throw new Test262Error(); ╰──── - × Identifier `bar` has already been declared - ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-body-duplicate.js:15:7] - 14 │ - 15 │ async(bar) => { let bar; } - · ─┬─ ─┬─ - · │ ╰── It can not be redeclared here - · ╰── `bar` has already been declared here + × The keyword 'yield' is reserved + ╭─[language/expressions/async-generator/yield-identifier-strict.js:28:11] + 27 │ (function() { + 28 │ var yield; + · ───── + 29 │ throw new Test262Error(); ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-call.js:15:13] - 14 │ - 15 │ async(foo = super()) => {} - · ─────── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/await/await-BindingIdentifier-nested.js:17:12] + 16 │ async function foo() { + 17 │ function await() { + · ───── + 18 │ } ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-property.js:15:14] - 14 │ - 15 │ async (foo = super.foo) => { } - · ───── + × Cannot assign to this expression + ╭─[language/expressions/await/early-errors-await-not-simple-assignment-target.js:17:4] + 16 │ async function foo() { + 17 │ (await 1) = 1; + · ─────── + 18 │ } ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-arrow-function/early-errors-arrow-formals-lineterminator.js:33:6] - 32 │ async - 33 │ (foo) => { } - · ▲ + × Unexpected token + ╭─[language/expressions/await/no-operand.js:17:8] + 16 │ async function foo() { + 17 │ await; + · ─ + 18 │ } ╰──── - help: Try insert a semicolon here - × Keywords cannot contain escape characters - ╭─[language/expressions/async-arrow-function/escaped-async.js:24:1] - 23 │ - 24 │ \u0061sync () => {} - · ────────── + × Unexpected token + ╭─[language/expressions/call/S11.2.4_A1.3_T1.js:20:9] + 19 │ + 20 │ f_arg(1,,2); + · ─ ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-arrow-function/object-destructuring-param-strict-body.js:122:3] - 121 │ (async ({property}) => { - 122 │ "use strict"; - · ───────────── - 123 │ }); - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-arrow-function/rest-param-strict-body.js:122:3] - 121 │ (async (a,...rest) => { - 122 │ "use strict"; - · ───────────── - 123 │ }); + ╭─[language/expressions/class/async-gen-method/array-destructuring-param-strict-body.js:135:5] + 134 │ async *method([element]) { + 135 │ "use strict"; + · ───────────── + 136 │ } ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js:46:9] - 45 │ - 46 │ (async (...a,) => { - · ──── - 47 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/async-gen-method/await-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { async *gen() { + 35 │ var \u0061wait; + · ────────── + 36 │ }}; ╰──── × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-function/await-as-binding-identifier-escaped.js:29:7] - 28 │ var asyncFn = async function () { - 29 │ var \u0061wait; - · ────────── - 30 │ }; + ╭─[language/expressions/class/async-gen-method/await-as-binding-identifier.js:35:9] + 34 │ var C = class { async *gen() { + 35 │ var await; + · ───── + 36 │ }}; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-function/await-as-binding-identifier.js:29:7] - 28 │ var asyncFn = async function () { - 29 │ var await; - · ───── - 30 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ void \u0061wait; + · ────────── + 36 │ }}; + ╰──── + + × Unexpected token + ╭─[language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js:35:20] + 34 │ var C = class { async *gen() { + 35 │ void \u0061wait; + · ─ + 36 │ }}; + ╰──── + + × Unexpected token + ╭─[language/expressions/class/async-gen-method/await-as-identifier-reference.js:35:15] + 34 │ var C = class { async *gen() { + 35 │ void await; + · ─ + 36 │ }}; ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/async-function/await-as-identifier-reference-escaped.js:29:8] - 28 │ var asyncFn = async function () { - 29 │ void \u0061wait; - · ────────── - 30 │ }; + ╭─[language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { async *gen() { + 35 │ \u0061wait: ; + · ────────── + 36 │ }}; ╰──── × Unexpected token - ╭─[language/expressions/async-function/await-as-identifier-reference-escaped.js:29:18] - 28 │ var asyncFn = async function () { - 29 │ void \u0061wait; - · ─ - 30 │ }; + ╭─[language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { async *gen() { + 35 │ \u0061wait: ; + · ─ + 36 │ }}; ╰──── × Unexpected token - ╭─[language/expressions/async-function/await-as-identifier-reference.js:29:13] - 28 │ var asyncFn = async function () { - 29 │ void await; - · ─ - 30 │ }; + ╭─[language/expressions/class/async-gen-method/await-as-label-identifier.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ await: ; + · ─ + 36 │ }}; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-function/await-as-label-identifier-escaped.js:29:3] - 28 │ var asyncFn = async function () { - 29 │ \u0061wait: ; - · ────────── - 30 │ }; + × Identifier `x` has already been declared + ╭─[language/expressions/class/async-gen-method/dflt-params-duplicates.js:63:17] + 62 │ 0, class { + 63 │ async *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 64 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-function/await-as-label-identifier-escaped.js:29:13] - 28 │ var asyncFn = async function () { - 29 │ \u0061wait: ; - · ─ - 30 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/async-gen-method/dflt-params-rest.js:67:20] + 66 │ 0, class { + 67 │ async *method(...x = []) { + · ────── + 68 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-function/await-as-label-identifier.js:29:8] - 28 │ var asyncFn = async function () { - 29 │ await: ; - · ─ - 30 │ }; - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-gen-method/object-destructuring-param-strict-body.js:135:5] + 134 │ async *method({property}) { + 135 │ "use strict"; + · ───────────── + 136 │ } + ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/early-errors-expression-NSPL-with-USD.js:16:26] - 15 │ - 16 │ (async function (x = 1) {"use strict"}) - · ──────────── - ╰──── + ╭─[language/expressions/class/async-gen-method/rest-param-strict-body.js:135:5] + 134 │ async *method(a,...rest) { + 135 │ "use strict"; + · ───────────── + 136 │ } + ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/async-function/early-errors-expression-binding-identifier-arguments.js:16:17] - 15 │ $DONOTEVALUATE(); - 16 │ (async function arguments () { }) - · ───────── - 17 │ + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/async-gen-method/rest-params-trailing-comma-early-error.js:60:17] + 59 │ 0, class { + 60 │ async *method(...a,) { + · ──── + 61 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/async-function/early-errors-expression-binding-identifier-eval.js:16:17] - 15 │ $DONOTEVALUATE(); - 16 │ (async function eval () { }) - · ──── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { async *gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/async-function/early-errors-expression-body-contains-super-call.js:15:29] - 14 │ - 15 │ (async function foo (foo) { super() }) - · ─────── + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { async *gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/async-function/early-errors-expression-body-contains-super-property.js:15:29] - 14 │ - 15 │ (async function foo (foo) { super.prop }); - · ───── - 16 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { async *gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/async-function/early-errors-expression-eval-in-formal-parameters.js:16:22] - 15 │ - 16 │ (async function foo (eval) { }) - · ──── + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { async *gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × Identifier `bar` has already been declared - ╭─[language/expressions/async-function/early-errors-expression-formals-body-duplicate.js:15:22] - 14 │ - 15 │ (async function foo (bar) { let bar; }); - · ─┬─ ─┬─ - · │ ╰── It can not be redeclared here - · ╰── `bar` has already been declared here + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/async-function/early-errors-expression-formals-contains-super-call.js:15:28] - 14 │ - 15 │ (async function foo (foo = super()) { var bar; }); - · ─────── + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/async-function/early-errors-expression-formals-contains-super-property.js:15:28] - 14 │ - 15 │ (async function foo (foo = super.foo) { var bar; }); - · ───── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/async-function/early-errors-expression-not-simple-assignment-target.js:16:2] - 15 │ - 16 │ (async function foo() { } = 1) - · ──────────────────────── + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/async-function/escaped-async.js:24:6] - 23 │ - 24 │ void \u0061sync function f(){} - · ────────── + ╭─[language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { async *gen() { + 35 │ yi\u0065ld: ; + · ────────── + 36 │ }}; ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/named-array-destructuring-param-strict-body.js:108:3] - 107 │ (async function f([element]) { - 108 │ "use strict"; - · ───────────── - 109 │ }); - ╰──── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { async *gen() { + 35 │ yi\u0065ld: ; + · ▲ + 36 │ }}; + ╰──── + help: Try insert a semicolon here - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-function/named-await-as-binding-identifier-escaped.js:29:7] - 28 │ var asyncFn = async function asyncFn() { - 29 │ var \u0061wait; - · ────────── - 30 │ }; + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/async-gen-method/yield-as-label-identifier.js:35:10] + 34 │ var C = class { async *gen() { + 35 │ yield: ; + · ▲ + 36 │ }}; + ╰──── + help: Try insert a semicolon here + + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method/yield-identifier-spread-strict.js:41:17] + 40 │ ...(function() { + 41 │ var yield; + · ───── + 42 │ throw new Test262Error(); + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method/yield-identifier-strict.js:33:13] + 32 │ (function() { + 33 │ var yield; + · ───── + 34 │ throw new Test262Error(); ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-gen-method-static/array-destructuring-param-strict-body.js:135:5] + 134 │ static async *method([element]) { + 135 │ "use strict"; + · ───────────── + 136 │ } + ╰──── + × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-function/named-await-as-binding-identifier.js:29:7] - 28 │ var asyncFn = async function asyncFn() { - 29 │ var await; - · ───── - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { static async *gen() { + 35 │ var \u0061wait; + · ────────── + 36 │ }}; + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/async-gen-method-static/await-as-binding-identifier.js:35:9] + 34 │ var C = class { static async *gen() { + 35 │ var await; + · ───── + 36 │ }}; ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/async-function/named-await-as-identifier-reference-escaped.js:29:8] - 28 │ var asyncFn = async function asyncFn() { - 29 │ void \u0061wait; - · ────────── - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ void \u0061wait; + · ────────── + 36 │ }}; ╰──── × Unexpected token - ╭─[language/expressions/async-function/named-await-as-identifier-reference-escaped.js:29:18] - 28 │ var asyncFn = async function asyncFn() { - 29 │ void \u0061wait; - · ─ - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js:35:20] + 34 │ var C = class { static async *gen() { + 35 │ void \u0061wait; + · ─ + 36 │ }}; ╰──── × Unexpected token - ╭─[language/expressions/async-function/named-await-as-identifier-reference.js:29:13] - 28 │ var asyncFn = async function asyncFn() { - 29 │ void await; - · ─ - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-identifier-reference.js:35:15] + 34 │ var C = class { static async *gen() { + 35 │ void await; + · ─ + 36 │ }}; ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/async-function/named-await-as-label-identifier-escaped.js:29:3] - 28 │ var asyncFn = async function asyncFn() { - 29 │ \u0061wait: ; - · ────────── - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { static async *gen() { + 35 │ \u0061wait: ; + · ────────── + 36 │ }}; ╰──── × Unexpected token - ╭─[language/expressions/async-function/named-await-as-label-identifier-escaped.js:29:13] - 28 │ var asyncFn = async function asyncFn() { - 29 │ \u0061wait: ; - · ─ - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { static async *gen() { + 35 │ \u0061wait: ; + · ─ + 36 │ }}; ╰──── × Unexpected token - ╭─[language/expressions/async-function/named-await-as-label-identifier.js:29:8] - 28 │ var asyncFn = async function asyncFn() { - 29 │ await: ; - · ─ - 30 │ }; + ╭─[language/expressions/class/async-gen-method-static/await-as-label-identifier.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ await: ; + · ─ + 36 │ }}; ╰──── × Identifier `x` has already been declared - ╭─[language/expressions/async-function/named-dflt-params-duplicates.js:36:19] - 35 │ - 36 │ (async function f(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 37 │ + ╭─[language/expressions/class/async-gen-method-static/dflt-params-duplicates.js:63:24] + 62 │ 0, class { + 63 │ static async *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 64 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/async-function/named-dflt-params-rest.js:40:22] - 39 │ - 40 │ (async function f(...x = []) { - · ────── - 41 │ + ╭─[language/expressions/class/async-gen-method-static/dflt-params-rest.js:67:27] + 66 │ 0, class { + 67 │ static async *method(...x = []) { + · ────── + 68 │ ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/named-object-destructuring-param-strict-body.js:108:3] - 107 │ (async function f({property}) { - 108 │ "use strict"; - · ───────────── - 109 │ }); + ╭─[language/expressions/class/async-gen-method-static/object-destructuring-param-strict-body.js:135:5] + 134 │ static async *method({property}) { + 135 │ "use strict"; + · ───────────── + 136 │ } ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/named-rest-param-strict-body.js:108:3] - 107 │ (async function f(a,...rest) { - 108 │ "use strict"; - · ───────────── - 109 │ }); + ╭─[language/expressions/class/async-gen-method-static/rest-param-strict-body.js:135:5] + 134 │ static async *method(a,...rest) { + 135 │ "use strict"; + · ───────────── + 136 │ } ╰──── × A rest parameter must be last in a parameter list - ╭─[language/expressions/async-function/named-rest-params-trailing-comma-early-error.js:33:19] - 32 │ - 33 │ (async function f(...a,) { - · ──── - 34 │ - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/nameless-array-destructuring-param-strict-body.js:108:3] - 107 │ (async function([element]) { - 108 │ "use strict"; - · ───────────── - 109 │ }); - ╰──── - - × Identifier `x` has already been declared - ╭─[language/expressions/async-function/nameless-dflt-params-duplicates.js:36:17] - 35 │ - 36 │ (async function(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 37 │ - ╰──── - - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-function/nameless-dflt-params-rest.js:40:20] - 39 │ - 40 │ (async function(...x = []) { - · ────── - 41 │ + ╭─[language/expressions/class/async-gen-method-static/rest-params-trailing-comma-early-error.js:60:24] + 59 │ 0, class { + 60 │ static async *method(...a,) { + · ──── + 61 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/nameless-object-destructuring-param-strict-body.js:108:3] - 107 │ (async function({property}) { - 108 │ "use strict"; - · ───────────── - 109 │ }); - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-function/nameless-rest-param-strict-body.js:108:3] - 107 │ (async function(a,...rest) { - 108 │ "use strict"; - · ───────────── - 109 │ }); - ╰──── - - × A rest parameter must be last in a parameter list - ╭─[language/expressions/async-function/nameless-rest-params-trailing-comma-early-error.js:33:17] - 32 │ - 33 │ (async function(...a,) { - · ──── - 34 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { static async *gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/array-destructuring-param-strict-body.js:111:3] - 110 │ 0, async function*([element]) { - 111 │ "use strict"; - · ───────────── - 112 │ }; - ╰──── - - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-generator/await-as-binding-identifier-escaped.js:30:7] - 29 │ var gen = async function *() { - 30 │ var \u0061wait; - · ────────── - 31 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { static async *gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-generator/await-as-binding-identifier.js:30:7] - 29 │ var gen = async function *() { - 30 │ var await; - · ───── - 31 │ }; + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { static async *gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/await-as-identifier-reference-escaped.js:30:8] - 29 │ var gen = async function *() { - 30 │ void \u0061wait; - · ────────── - 31 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { static async *gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/await-as-identifier-reference-escaped.js:30:18] - 29 │ var gen = async function *() { - 30 │ void \u0061wait; - · ─ - 31 │ }; + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/await-as-identifier-reference.js:30:13] - 29 │ var gen = async function *() { - 30 │ void await; - · ─ - 31 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/await-as-label-identifier-escaped.js:30:3] - 29 │ var gen = async function *() { - 30 │ \u0061wait: ; - · ────────── - 31 │ }; + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/await-as-label-identifier-escaped.js:30:13] - 29 │ var gen = async function *() { - 30 │ \u0061wait: ; - · ─ - 31 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/await-as-label-identifier.js:30:8] - 29 │ var gen = async function *() { - 30 │ await: ; - · ─ - 31 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { static async *gen() { + 35 │ yi\u0065ld: ; + · ────────── + 36 │ }}; ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/async-generator/dflt-params-duplicates.js:39:20] - 38 │ - 39 │ 0, async function*(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 40 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { static async *gen() { + 35 │ yi\u0065ld: ; + · ▲ + 36 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dflt-params-rest.js:43:23] - 42 │ - 43 │ 0, async function*(...x = []) { - · ────── - 44 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/async-gen-method-static/yield-as-label-identifier.js:35:10] + 34 │ var C = class { static async *gen() { + 35 │ yield: ; + · ▲ + 36 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-init-ary.js:33:25] - 32 │ var f; - 33 │ f = async function*([...[ x ] = []]) { - · ────────── - 34 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method-static/yield-identifier-spread-strict.js:41:17] + 40 │ ...(function() { + 41 │ var yield; + · ───── + 42 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-init-id.js:33:25] - 32 │ var f; - 33 │ f = async function*([...x = []]) { - · ────── - 34 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/async-gen-method-static/yield-identifier-strict.js:33:13] + 32 │ (function() { + 33 │ var yield; + · ───── + 34 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-init-obj.js:33:25] - 32 │ var f; - 33 │ f = async function*([...{ x } = []]) { - · ────────── - 34 │ - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-method/array-destructuring-param-strict-body.js:133:5] + 132 │ static async method([element]) { + 133 │ "use strict"; + · ───────────── + 134 │ } + ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-ary.js:33:22] - 32 │ var f; - 33 │ f = async function*([...[x], y]) { - · ────── - 34 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/async-method/await-as-binding-identifier-escaped.js:36:9] + 35 │ async method() { + 36 │ var \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-id.js:33:22] - 32 │ var f; - 33 │ f = async function*([...x, y]) { - · ──── - 34 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/async-method/await-as-binding-identifier.js:36:9] + 35 │ async method() { + 36 │ var await; + · ───── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-obj.js:33:22] - 32 │ var f; - 33 │ f = async function*([...{ x }, y]) { - · ──────── - 34 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/async-method/await-as-identifier-reference-escaped.js:36:10] + 35 │ async method() { + 36 │ void \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-ary.js:33:25] - 32 │ var f; - 33 │ f = async function*([...[ x ] = []] = []) { - · ────────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method/await-as-identifier-reference-escaped.js:36:20] + 35 │ async method() { + 36 │ void \u0061wait; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-id.js:33:25] - 32 │ var f; - 33 │ f = async function*([...x = []] = []) { - · ────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method/await-as-identifier-reference.js:36:15] + 35 │ async method() { + 36 │ void await; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-obj.js:33:25] - 32 │ var f; - 33 │ f = async function*([...{ x } = []] = []) { - · ────────── - 34 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/async-method/await-as-label-identifier-escaped.js:36:5] + 35 │ async method() { + 36 │ \u0061wait: ; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-ary.js:33:22] - 32 │ var f; - 33 │ f = async function*([...[x], y] = [1, 2, 3]) { - · ────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method/await-as-label-identifier-escaped.js:36:15] + 35 │ async method() { + 36 │ \u0061wait: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-id.js:33:22] - 32 │ var f; - 33 │ f = async function*([...x, y] = [1, 2, 3]) { - · ──── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method/await-as-label-identifier.js:36:10] + 35 │ async method() { + 36 │ await: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-obj.js:33:22] - 32 │ var f; - 33 │ f = async function*([...{ x }, y] = [1, 2, 3]) { - · ──────── - 34 │ + × Identifier `x` has already been declared + ╭─[language/expressions/class/async-method/dflt-params-duplicates.js:61:23] + 60 │ var C = class { + 61 │ static async method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 62 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-ary.js:33:27] - 32 │ var f; - 33 │ f = async function* h([...[ x ] = []]) { - · ────────── - 34 │ + ╭─[language/expressions/class/async-method/dflt-params-rest.js:65:26] + 64 │ var C = class { + 65 │ static async method(...x = []) { + · ────── + 66 │ ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-id.js:33:27] - 32 │ var f; - 33 │ f = async function* h([...x = []]) { - · ────── - 34 │ + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-method/object-destructuring-param-strict-body.js:133:5] + 132 │ static async method({property}) { + 133 │ "use strict"; + · ───────────── + 134 │ } + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-method/rest-param-strict-body.js:133:5] + 132 │ static async method(a,...rest) { + 133 │ "use strict"; + · ───────────── + 134 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/async-method/rest-params-trailing-comma-early-error.js:57:23] + 56 │ var C = class { + 57 │ static async method(...a,) { + · ──── + 58 │ ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-obj.js:33:27] - 32 │ var f; - 33 │ f = async function* h([...{ x } = []]) { - · ────────── - 34 │ + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-method-static/array-destructuring-param-strict-body.js:133:5] + 132 │ static async method([element]) { + 133 │ "use strict"; + · ───────────── + 134 │ } + ╰──── + + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/async-method-static/await-as-binding-identifier-escaped.js:36:9] + 35 │ static async method() { + 36 │ var \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-ary.js:33:24] - 32 │ var f; - 33 │ f = async function* h([...[x], y]) { - · ────── - 34 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/async-method-static/await-as-binding-identifier.js:36:9] + 35 │ static async method() { + 36 │ var await; + · ───── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-id.js:33:24] - 32 │ var f; - 33 │ f = async function* h([...x, y]) { - · ──── - 34 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js:36:10] + 35 │ static async method() { + 36 │ void \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-obj.js:33:24] - 32 │ var f; - 33 │ f = async function* h([...{ x }, y]) { - · ──────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js:36:20] + 35 │ static async method() { + 36 │ void \u0061wait; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-ary.js:33:27] - 32 │ var f; - 33 │ f = async function* h([...[ x ] = []] = []) { - · ────────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method-static/await-as-identifier-reference.js:36:15] + 35 │ static async method() { + 36 │ void await; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-id.js:33:27] - 32 │ var f; - 33 │ f = async function* h([...x = []] = []) { - · ────── - 34 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/async-method-static/await-as-label-identifier-escaped.js:36:5] + 35 │ static async method() { + 36 │ \u0061wait: ; + · ────────── + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-obj.js:33:27] - 32 │ var f; - 33 │ f = async function* h([...{ x } = []] = []) { - · ────────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method-static/await-as-label-identifier-escaped.js:36:15] + 35 │ static async method() { + 36 │ \u0061wait: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-ary.js:33:24] - 32 │ var f; - 33 │ f = async function* h([...[x], y] = [1, 2, 3]) { - · ────── - 34 │ + × Unexpected token + ╭─[language/expressions/class/async-method-static/await-as-label-identifier.js:36:10] + 35 │ static async method() { + 36 │ await: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-id.js:33:24] - 32 │ var f; - 33 │ f = async function* h([...x, y] = [1, 2, 3]) { - · ──── - 34 │ + × Identifier `x` has already been declared + ╭─[language/expressions/class/async-method-static/dflt-params-duplicates.js:61:23] + 60 │ var C = class { + 61 │ static async method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 62 │ ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-obj.js:33:24] - 32 │ var f; - 33 │ f = async function* h([...{ x }, y] = [1, 2, 3]) { - · ──────── - 34 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/async-method-static/dflt-params-rest.js:65:26] + 64 │ var C = class { + 65 │ static async method(...x = []) { + · ────── + 66 │ ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js:18:26] - 17 │ - 18 │ (async function*(x = 1) {"use strict"}); - · ──────────── - ╰──── - - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js:18:18] - 17 │ - 18 │ (async function*(arguments) { }); - · ───────── - ╰──── + ╭─[language/expressions/class/async-method-static/object-destructuring-param-strict-body.js:133:5] + 132 │ static async method({property}) { + 133 │ "use strict"; + · ───────────── + 134 │ } + ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js:17:18] - 16 │ - 17 │ (async function* await() { }); - · ───── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/async-method-static/rest-param-strict-body.js:133:5] + 132 │ static async method(a,...rest) { + 133 │ "use strict"; + · ───────────── + 134 │ } + ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js:19:18] - 18 │ - 19 │ (async function* arguments() { }); - · ───────── + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/async-method-static/rest-params-trailing-comma-early-error.js:57:23] + 56 │ var C = class { + 57 │ static async method(...a,) { + · ──── + 58 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js:19:18] - 18 │ - 19 │ (async function* eval() { }); - · ──── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/class-name-ident-await-escaped-module.js:23:15] + 22 │ + 23 │ var C = class aw\u0061it {}; + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/async-generator/early-errors-expression-body-contains-super-call.js:17:22] - 16 │ - 17 │ (async function*() { super(); }); - · ─────── + × The keyword 'await' is reserved + ╭─[language/expressions/class/class-name-ident-await-escaped-module.js:23:15] + 22 │ + 23 │ var C = class aw\u0061it {}; + · ────────── ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/async-generator/early-errors-expression-body-contains-super-property.js:17:22] - 16 │ - 17 │ (async function*() { super.prop; }); - · ───── + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/class-name-ident-await-module.js:22:15] + 21 │ + 22 │ var C = class await {}; + · ───── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js:18:18] - 17 │ - 18 │ (async function*(eval) { }); - · ──── + × The keyword 'await' is reserved + ╭─[language/expressions/class/class-name-ident-await-module.js:22:15] + 21 │ + 22 │ var C = class await {}; + · ───── ╰──── - × Identifier `a` has already been declared - ╭─[language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js:21:18] - 20 │ - 21 │ (async function*(a) { const a = 0; }); - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `a` has already been declared here + × The keyword 'let' is reserved + ╭─[language/expressions/class/class-name-ident-let-escaped.js:27:15] + 26 │ + 27 │ var C = class l\u0065t {}; + · ──────── ╰──── - × Identifier `a` has already been declared - ╭─[language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js:18:18] - 17 │ - 18 │ (async function*(a) { let a; }); - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `a` has already been declared here + × The keyword 'let' is reserved + ╭─[language/expressions/class/class-name-ident-let.js:27:15] + 26 │ + 27 │ var C = class let {}; + · ─── ╰──── - × await expression not allowed in formal parameter - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js:17:22] - 16 │ - 17 │ (async function*(x = await 1) { }); - · ───┬─── - · ╰── await expression not allowed in formal parameter + × The keyword 'static' is reserved + ╭─[language/expressions/class/class-name-ident-static-escaped.js:27:15] + 26 │ + 27 │ var C = class st\u0061tic {}; + · ─────────── ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-await.js:18:18] - 17 │ - 18 │ (async function*(await) { }); - · ───── + × The keyword 'static' is reserved + ╭─[language/expressions/class/class-name-ident-static.js:27:15] + 26 │ + 27 │ var C = class static {}; + · ────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js:17:22] - 16 │ - 17 │ (async function*(a = super()) { }); - · ─────── + × The keyword 'yield' is reserved + ╭─[language/expressions/class/class-name-ident-yield-escaped.js:27:15] + 26 │ + 27 │ var C = class yi\u0065ld {}; + · ────────── ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js:17:22] - 16 │ - 17 │ (async function*(a = super.prop) { }); - · ───── + × The keyword 'yield' is reserved + ╭─[language/expressions/class/class-name-ident-yield.js:25:15] + 24 │ + 25 │ var C = class yield {}; + · ───── ╰──── - × yield expression not allowed in formal parameter - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js:17:22] - 16 │ - 17 │ (async function*(x = yield) { }); - · ──┬── - · ╰── yield expression not allowed in formal parameter + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js:57:21] + 56 │ var C = class { + 57 │ async *method([...[ x ] = []]) { + · ────────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-yield.js:18:18] - 17 │ - 18 │ (async function*(yield) { }); - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-id.js:57:21] + 56 │ var C = class { + 57 │ async *method([...x = []]) { + · ────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/early-errors-expression-formals-contains-yield.js:18:18] - 17 │ - 18 │ (async function*(yield) { }); - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js:57:21] + 56 │ var C = class { + 57 │ async *method([...{ x } = []]) { + · ────────── + 58 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/early-errors-expression-label-name-await.js:23:8] - 22 │ (async function*() { - 23 │ await: 1; - · ─ - 24 │ }); + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js:57:18] + 56 │ var C = class { + 57 │ async *method([...[x], y]) { + · ────── + 58 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-generator/early-errors-expression-label-name-yield.js:25:8] - 24 │ (async function*() { - 25 │ yield: 1; - · ▲ - 26 │ }); + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js:57:18] + 56 │ var C = class { + 57 │ async *method([...x, y]) { + · ──── + 58 │ ╰──── - help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js:17:2] - 16 │ - 17 │ (async function*() { } = 1); - · ───────────────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js:57:18] + 56 │ var C = class { + 57 │ async *method([...{ x }, y]) { + · ──────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js:17:18] - 16 │ - 17 │ (async function* yield() { }); - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js:57:21] + 56 │ var C = class { + 57 │ async *method([...[ x ] = []] = []) { + · ────────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js:17:18] - 16 │ - 17 │ (async function* yield() { }); - · ───── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js:57:21] + 56 │ var C = class { + 57 │ async *method([...x = []] = []) { + · ────── + 58 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js:19:3] - 18 │ yield - 19 │ * 1; - · ─ - 20 │ }); + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js:57:21] + 56 │ var C = class { + 57 │ async *method([...{ x } = []] = []) { + · ────────── + 58 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/escaped-async.js:24:6] - 23 │ - 24 │ void \u0061sync function* f(){}; - · ────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:57:18] + 56 │ var C = class { + 57 │ async *method([...[x], y] = [1, 2, 3]) { + · ────── + 58 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/named-array-destructuring-param-strict-body.js:111:3] - 110 │ 0, async function* g([element]) { - 111 │ "use strict"; - · ───────────── - 112 │ }; - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:57:18] + 56 │ var C = class { + 57 │ async *method([...x, y] = [1, 2, 3]) { + · ──── + 58 │ + ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-generator/named-await-as-binding-identifier-escaped.js:30:7] - 29 │ var gen = async function *g() { - 30 │ var \u0061wait; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:57:18] + 56 │ var C = class { + 57 │ async *method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 58 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/async-generator/named-await-as-binding-identifier.js:30:7] - 29 │ var gen = async function *g() { - 30 │ var await; - · ───── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-ary.js:57:28] + 56 │ var C = class { + 57 │ static async *method([...[ x ] = []]) { + · ────────── + 58 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/named-await-as-identifier-reference-escaped.js:30:8] - 29 │ var gen = async function *g() { - 30 │ void \u0061wait; - · ────────── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-id.js:57:28] + 56 │ var C = class { + 57 │ static async *method([...x = []]) { + · ────── + 58 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/named-await-as-identifier-reference-escaped.js:30:18] - 29 │ var gen = async function *g() { - 30 │ void \u0061wait; - · ─ - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-obj.js:57:28] + 56 │ var C = class { + 57 │ static async *method([...{ x } = []]) { + · ────────── + 58 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/named-await-as-identifier-reference.js:30:13] - 29 │ var gen = async function *g() { - 30 │ void await; - · ─ - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-ary.js:57:25] + 56 │ var C = class { + 57 │ static async *method([...[x], y]) { + · ────── + 58 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/named-await-as-label-identifier-escaped.js:30:3] - 29 │ var gen = async function *g() { - 30 │ \u0061wait: ; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-id.js:57:25] + 56 │ var C = class { + 57 │ static async *method([...x, y]) { + · ──── + 58 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/named-await-as-label-identifier-escaped.js:30:13] - 29 │ var gen = async function *g() { - 30 │ \u0061wait: ; - · ─ - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-obj.js:57:25] + 56 │ var C = class { + 57 │ static async *method([...{ x }, y]) { + · ──────── + 58 │ ╰──── - × Unexpected token - ╭─[language/expressions/async-generator/named-await-as-label-identifier.js:30:8] - 29 │ var gen = async function *g() { - 30 │ await: ; - · ─ - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:57:28] + 56 │ var C = class { + 57 │ static async *method([...[ x ] = []] = []) { + · ────────── + 58 │ ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/async-generator/named-dflt-params-duplicates.js:39:22] - 38 │ - 39 │ 0, async function* g(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 40 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js:57:28] + 56 │ var C = class { + 57 │ static async *method([...x = []] = []) { + · ────── + 58 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/async-generator/named-dflt-params-rest.js:43:25] - 42 │ - 43 │ 0, async function* g(...x = []) { + ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:57:28] + 56 │ var C = class { + 57 │ static async *method([...{ x } = []] = []) { + · ────────── + 58 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:57:25] + 56 │ var C = class { + 57 │ static async *method([...[x], y] = [1, 2, 3]) { · ────── - 44 │ + 58 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/named-object-destructuring-param-strict-body.js:111:3] - 110 │ 0, async function* g({property}) { - 111 │ "use strict"; - · ───────────── - 112 │ }; - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/named-rest-param-strict-body.js:111:3] - 110 │ 0, async function* g(a,...rest) { - 111 │ "use strict"; - · ───────────── - 112 │ }; - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:57:25] + 56 │ var C = class { + 57 │ static async *method([...x, y] = [1, 2, 3]) { + · ──── + 58 │ + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/async-generator/named-rest-params-trailing-comma-early-error.js:36:22] - 35 │ - 36 │ 0, async function* g(...a,) { - · ──── - 37 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:57:25] + 56 │ var C = class { + 57 │ static async *method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js:30:7] - 29 │ var gen = async function *g() { - 30 │ var yi\u0065ld; - · ────────── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-ary.js:57:23] + 56 │ var C = class { + 57 │ async * #method([...[ x ] = []]) { + · ────────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js:30:7] - 29 │ var gen = async function *g() { - 30 │ var yi\u0065ld; - · ────────── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-id.js:57:23] + 56 │ var C = class { + 57 │ async * #method([...x = []]) { + · ────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/named-yield-as-binding-identifier.js:30:7] - 29 │ var gen = async function *g() { - 30 │ var yield; - · ───── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-obj.js:57:23] + 56 │ var C = class { + 57 │ async * #method([...{ x } = []]) { + · ────────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/named-yield-as-binding-identifier.js:30:7] - 29 │ var gen = async function *g() { - 30 │ var yield; - · ───── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-ary.js:57:20] + 56 │ var C = class { + 57 │ async * #method([...[x], y]) { + · ────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js:30:8] - 29 │ var gen = async function *g() { - 30 │ void yi\u0065ld; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-id.js:57:20] + 56 │ var C = class { + 57 │ async * #method([...x, y]) { + · ──── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js:30:8] - 29 │ var gen = async function *g() { - 30 │ void yi\u0065ld; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-obj.js:57:20] + 56 │ var C = class { + 57 │ async * #method([...{ x }, y]) { + · ──────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/named-yield-as-identifier-reference.js:30:8] - 29 │ var gen = async function *g() { - 30 │ void yield; - · ───── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-ary.js:57:23] + 56 │ var C = class { + 57 │ async * #method([...[ x ] = []] = []) { + · ────────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/named-yield-as-identifier-reference.js:30:8] - 29 │ var gen = async function *g() { - 30 │ void yield; - · ───── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-id.js:57:23] + 56 │ var C = class { + 57 │ async * #method([...x = []] = []) { + · ────── + 58 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/named-yield-as-label-identifier-escaped.js:30:3] - 29 │ var gen = async function *g() { - 30 │ yi\u0065ld: ; - · ────────── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-obj.js:57:23] + 56 │ var C = class { + 57 │ async * #method([...{ x } = []] = []) { + · ────────── + 58 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-generator/named-yield-as-label-identifier-escaped.js:30:13] - 29 │ var gen = async function *g() { - 30 │ yi\u0065ld: ; - · ▲ - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:57:20] + 56 │ var C = class { + 57 │ async * #method([...[x], y] = [1, 2, 3]) { + · ────── + 58 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-generator/named-yield-as-label-identifier.js:30:8] - 29 │ var gen = async function *g() { - 30 │ yield: ; - · ▲ - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:57:20] + 56 │ var C = class { + 57 │ async * #method([...x, y] = [1, 2, 3]) { + · ──── + 58 │ ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/named-yield-identifier-spread-strict.js:36:15] - 35 │ ...(function() { - 36 │ var yield; - · ───── - 37 │ throw new Test262Error(); + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:57:20] + 56 │ var C = class { + 57 │ async * #method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/named-yield-identifier-strict.js:28:11] - 27 │ (function() { - 28 │ var yield; - · ───── - 29 │ throw new Test262Error(); + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-ary.js:57:30] + 56 │ var C = class { + 57 │ static async * #method([...[ x ] = []]) { + · ────────── + 58 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/object-destructuring-param-strict-body.js:111:3] - 110 │ 0, async function*({property}) { - 111 │ "use strict"; - · ───────────── - 112 │ }; - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-id.js:57:30] + 56 │ var C = class { + 57 │ static async * #method([...x = []]) { + · ────── + 58 │ + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/async-generator/rest-param-strict-body.js:111:3] - 110 │ 0, async function*(a,...rest) { - 111 │ "use strict"; - · ───────────── - 112 │ }; - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-obj.js:57:30] + 56 │ var C = class { + 57 │ static async * #method([...{ x } = []]) { + · ────────── + 58 │ + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/async-generator/rest-params-trailing-comma-early-error.js:36:20] - 35 │ - 36 │ 0, async function*(...a,) { - · ──── - 37 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-ary.js:57:27] + 56 │ var C = class { + 57 │ static async * #method([...[x], y]) { + · ────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/yield-as-binding-identifier-escaped.js:30:7] - 29 │ var gen = async function *() { - 30 │ var yi\u0065ld; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-id.js:57:27] + 56 │ var C = class { + 57 │ static async * #method([...x, y]) { + · ──── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/yield-as-binding-identifier-escaped.js:30:7] - 29 │ var gen = async function *() { - 30 │ var yi\u0065ld; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-obj.js:57:27] + 56 │ var C = class { + 57 │ static async * #method([...{ x }, y]) { + · ──────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/yield-as-binding-identifier.js:30:7] - 29 │ var gen = async function *() { - 30 │ var yield; - · ───── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:57:30] + 56 │ var C = class { + 57 │ static async * #method([...[ x ] = []] = []) { + · ────────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/yield-as-binding-identifier.js:30:7] - 29 │ var gen = async function *() { - 30 │ var yield; - · ───── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js:57:30] + 56 │ var C = class { + 57 │ static async * #method([...x = []] = []) { + · ────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/yield-as-identifier-reference-escaped.js:30:8] - 29 │ var gen = async function *() { - 30 │ void yi\u0065ld; - · ────────── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:57:30] + 56 │ var C = class { + 57 │ static async * #method([...{ x } = []] = []) { + · ────────── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/yield-as-identifier-reference-escaped.js:30:8] - 29 │ var gen = async function *() { - 30 │ void yi\u0065ld; - · ────────── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:57:27] + 56 │ var C = class { + 57 │ static async * #method([...[x], y] = [1, 2, 3]) { + · ────── + 58 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/async-generator/yield-as-identifier-reference.js:30:8] - 29 │ var gen = async function *() { - 30 │ void yield; - · ───── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:57:27] + 56 │ var C = class { + 57 │ static async * #method([...x, y] = [1, 2, 3]) { + · ──── + 58 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/yield-as-identifier-reference.js:30:8] - 29 │ var gen = async function *() { - 30 │ void yield; - · ───── - 31 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:57:27] + 56 │ var C = class { + 57 │ static async * #method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 58 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/async-generator/yield-as-label-identifier-escaped.js:30:3] - 29 │ var gen = async function *() { - 30 │ yi\u0065ld: ; - · ────────── - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-ary.js:76:15] + 75 │ var C = class { + 76 │ *method([...[ x ] = []]) { + · ────────── + 77 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-generator/yield-as-label-identifier-escaped.js:30:13] - 29 │ var gen = async function *() { - 30 │ yi\u0065ld: ; - · ▲ - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-id.js:76:15] + 75 │ var C = class { + 76 │ *method([...x = []]) { + · ────── + 77 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/async-generator/yield-as-label-identifier.js:30:8] - 29 │ var gen = async function *() { - 30 │ yield: ; - · ▲ - 31 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-obj.js:76:15] + 75 │ var C = class { + 76 │ *method([...{ x } = []]) { + · ────────── + 77 │ ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/yield-identifier-spread-strict.js:36:15] - 35 │ ...(function() { - 36 │ var yield; - · ───── - 37 │ throw new Test262Error(); + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js:76:12] + 75 │ var C = class { + 76 │ *method([...[x], y]) { + · ────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/async-generator/yield-identifier-strict.js:28:11] - 27 │ (function() { - 28 │ var yield; - · ───── - 29 │ throw new Test262Error(); + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-id.js:76:12] + 75 │ var C = class { + 76 │ *method([...x, y]) { + · ──── + 77 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/await/await-BindingIdentifier-nested.js:17:12] - 16 │ async function foo() { - 17 │ function await() { - · ───── - 18 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js:76:12] + 75 │ var C = class { + 76 │ *method([...{ x }, y]) { + · ──────── + 77 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/await/early-errors-await-not-simple-assignment-target.js:17:4] - 16 │ async function foo() { - 17 │ (await 1) = 1; - · ─────── - 18 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js:76:15] + 75 │ var C = class { + 76 │ *method([...[ x ] = []] = []) { + · ────────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/await/no-operand.js:17:8] - 16 │ async function foo() { - 17 │ await; - · ─ - 18 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js:76:15] + 75 │ var C = class { + 76 │ *method([...x = []] = []) { + · ────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/call/S11.2.4_A1.3_T1.js:20:9] - 19 │ - 20 │ f_arg(1,,2); - · ─ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js:76:15] + 75 │ var C = class { + 76 │ *method([...{ x } = []] = []) { + · ────────── + 77 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-gen-method/array-destructuring-param-strict-body.js:135:5] - 134 │ async *method([element]) { - 135 │ "use strict"; - · ───────────── - 136 │ } - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:76:12] + 75 │ var C = class { + 76 │ *method([...[x], y] = [1, 2, 3]) { + · ────── + 77 │ + ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-gen-method/await-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { async *gen() { - 35 │ var \u0061wait; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js:76:12] + 75 │ var C = class { + 76 │ *method([...x, y] = [1, 2, 3]) { + · ──── + 77 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-gen-method/await-as-binding-identifier.js:35:9] - 34 │ var C = class { async *gen() { - 35 │ var await; - · ───── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:76:12] + 75 │ var C = class { + 76 │ *method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 77 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ void \u0061wait; - · ────────── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-ary.js:76:22] + 75 │ var C = class { + 76 │ static *method([...[ x ] = []]) { + · ────────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js:35:20] - 34 │ var C = class { async *gen() { - 35 │ void \u0061wait; - · ─ - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-id.js:76:22] + 75 │ var C = class { + 76 │ static *method([...x = []]) { + · ────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method/await-as-identifier-reference.js:35:15] - 34 │ var C = class { async *gen() { - 35 │ void await; - · ─ - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-obj.js:76:22] + 75 │ var C = class { + 76 │ static *method([...{ x } = []]) { + · ────────── + 77 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { async *gen() { - 35 │ \u0061wait: ; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-ary.js:76:19] + 75 │ var C = class { + 76 │ static *method([...[x], y]) { + · ────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { async *gen() { - 35 │ \u0061wait: ; - · ─ - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-id.js:76:19] + 75 │ var C = class { + 76 │ static *method([...x, y]) { + · ──── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method/await-as-label-identifier.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ await: ; - · ─ - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-obj.js:76:19] + 75 │ var C = class { + 76 │ static *method([...{ x }, y]) { + · ──────── + 77 │ ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/class/async-gen-method/dflt-params-duplicates.js:63:17] - 62 │ 0, class { - 63 │ async *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 64 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:76:22] + 75 │ var C = class { + 76 │ static *method([...[ x ] = []] = []) { + · ────────── + 77 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/class/async-gen-method/dflt-params-rest.js:67:20] - 66 │ 0, class { - 67 │ async *method(...x = []) { - · ────── - 68 │ + ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-id.js:76:22] + 75 │ var C = class { + 76 │ static *method([...x = []] = []) { + · ────── + 77 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-gen-method/object-destructuring-param-strict-body.js:135:5] - 134 │ async *method({property}) { - 135 │ "use strict"; - · ───────────── - 136 │ } - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-gen-method/rest-param-strict-body.js:135:5] - 134 │ async *method(a,...rest) { - 135 │ "use strict"; - · ───────────── - 136 │ } - ╰──── - - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/async-gen-method/rest-params-trailing-comma-early-error.js:60:17] - 59 │ 0, class { - 60 │ async *method(...a,) { - · ──── - 61 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:76:22] + 75 │ var C = class { + 76 │ static *method([...{ x } = []] = []) { + · ────────── + 77 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { async *gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:76:19] + 75 │ var C = class { + 76 │ static *method([...[x], y] = [1, 2, 3]) { + · ────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { async *gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:76:19] + 75 │ var C = class { + 76 │ static *method([...x, y] = [1, 2, 3]) { + · ──── + 77 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { async *gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:76:19] + 75 │ var C = class { + 76 │ static *method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { async *gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-init-ary.js:73:14] + 72 │ var C = class { + 73 │ method([...[ x ] = []]) { + · ────────── + 74 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-init-id.js:73:14] + 72 │ var C = class { + 73 │ method([...x = []]) { + · ────── + 74 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-init-obj.js:73:14] + 72 │ var C = class { + 73 │ method([...{ x } = []]) { + · ────────── + 74 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-ary.js:73:11] + 72 │ var C = class { + 73 │ method([...[x], y]) { + · ────── + 74 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-id.js:73:11] + 72 │ var C = class { + 73 │ method([...x, y]) { + · ──── + 74 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { async *gen() { - 35 │ yi\u0065ld: ; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-obj.js:73:11] + 72 │ var C = class { + 73 │ method([...{ x }, y]) { + · ──────── + 74 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { async *gen() { - 35 │ yi\u0065ld: ; - · ▲ - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-ary.js:73:14] + 72 │ var C = class { + 73 │ method([...[ x ] = []] = []) { + · ────────── + 74 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/async-gen-method/yield-as-label-identifier.js:35:10] - 34 │ var C = class { async *gen() { - 35 │ yield: ; - · ▲ - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-id.js:73:14] + 72 │ var C = class { + 73 │ method([...x = []] = []) { + · ────── + 74 │ ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method/yield-identifier-spread-strict.js:41:17] - 40 │ ...(function() { - 41 │ var yield; - · ───── - 42 │ throw new Test262Error(); + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-obj.js:73:14] + 72 │ var C = class { + 73 │ method([...{ x } = []] = []) { + · ────────── + 74 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method/yield-identifier-strict.js:33:13] - 32 │ (function() { - 33 │ var yield; - · ───── - 34 │ throw new Test262Error(); + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js:73:11] + 72 │ var C = class { + 73 │ method([...[x], y] = [1, 2, 3]) { + · ────── + 74 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-gen-method-static/array-destructuring-param-strict-body.js:135:5] - 134 │ static async *method([element]) { - 135 │ "use strict"; - · ───────────── - 136 │ } - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js:73:11] + 72 │ var C = class { + 73 │ method([...x, y] = [1, 2, 3]) { + · ──── + 74 │ + ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-gen-method-static/await-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { static async *gen() { - 35 │ var \u0061wait; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js:73:11] + 72 │ var C = class { + 73 │ method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 74 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-gen-method-static/await-as-binding-identifier.js:35:9] - 34 │ var C = class { static async *gen() { - 35 │ var await; - · ───── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-ary.js:73:21] + 72 │ var C = class { + 73 │ static method([...[ x ] = []]) { + · ────────── + 74 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ void \u0061wait; - · ────────── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-id.js:73:21] + 72 │ var C = class { + 73 │ static method([...x = []]) { + · ────── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js:35:20] - 34 │ var C = class { static async *gen() { - 35 │ void \u0061wait; - · ─ - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-obj.js:73:21] + 72 │ var C = class { + 73 │ static method([...{ x } = []]) { + · ────────── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method-static/await-as-identifier-reference.js:35:15] - 34 │ var C = class { static async *gen() { - 35 │ void await; - · ─ - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-ary.js:73:18] + 72 │ var C = class { + 73 │ static method([...[x], y]) { + · ────── + 74 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { static async *gen() { - 35 │ \u0061wait: ; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-id.js:73:18] + 72 │ var C = class { + 73 │ static method([...x, y]) { + · ──── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { static async *gen() { - 35 │ \u0061wait: ; - · ─ - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-obj.js:73:18] + 72 │ var C = class { + 73 │ static method([...{ x }, y]) { + · ──────── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-gen-method-static/await-as-label-identifier.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ await: ; - · ─ - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-ary.js:73:21] + 72 │ var C = class { + 73 │ static method([...[ x ] = []] = []) { + · ────────── + 74 │ ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/class/async-gen-method-static/dflt-params-duplicates.js:63:24] - 62 │ 0, class { - 63 │ static async *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 64 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-id.js:73:21] + 72 │ var C = class { + 73 │ static method([...x = []] = []) { + · ────── + 74 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/class/async-gen-method-static/dflt-params-rest.js:67:27] - 66 │ 0, class { - 67 │ static async *method(...x = []) { - · ────── - 68 │ + ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-obj.js:73:21] + 72 │ var C = class { + 73 │ static method([...{ x } = []] = []) { + · ────────── + 74 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-gen-method-static/object-destructuring-param-strict-body.js:135:5] - 134 │ static async *method({property}) { - 135 │ "use strict"; - · ───────────── - 136 │ } - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-ary.js:73:18] + 72 │ var C = class { + 73 │ static method([...[x], y] = [1, 2, 3]) { + · ────── + 74 │ + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-gen-method-static/rest-param-strict-body.js:135:5] - 134 │ static async *method(a,...rest) { - 135 │ "use strict"; - · ───────────── - 136 │ } - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-id.js:73:18] + 72 │ var C = class { + 73 │ static method([...x, y] = [1, 2, 3]) { + · ──── + 74 │ + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/async-gen-method-static/rest-params-trailing-comma-early-error.js:60:24] - 59 │ 0, class { - 60 │ static async *method(...a,) { - · ──── - 61 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-obj.js:73:18] + 72 │ var C = class { + 73 │ static method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 74 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { static async *gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-ary.js:76:17] + 75 │ var C = class { + 76 │ * #method([...[ x ] = []]) { + · ────────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { static async *gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-id.js:76:17] + 75 │ var C = class { + 76 │ * #method([...x = []]) { + · ────── + 77 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { static async *gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-obj.js:76:17] + 75 │ var C = class { + 76 │ * #method([...{ x } = []]) { + · ────────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { static async *gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-ary.js:76:14] + 75 │ var C = class { + 76 │ * #method([...[x], y]) { + · ────── + 77 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-id.js:76:14] + 75 │ var C = class { + 76 │ * #method([...x, y]) { + · ──── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-obj.js:76:14] + 75 │ var C = class { + 76 │ * #method([...{ x }, y]) { + · ──────── + 77 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-ary.js:76:17] + 75 │ var C = class { + 76 │ * #method([...[ x ] = []] = []) { + · ────────── + 77 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-id.js:76:17] + 75 │ var C = class { + 76 │ * #method([...x = []] = []) { + · ────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-obj.js:76:17] + 75 │ var C = class { + 76 │ * #method([...{ x } = []] = []) { + · ────────── + 77 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { static async *gen() { - 35 │ yi\u0065ld: ; - · ────────── - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:76:14] + 75 │ var C = class { + 76 │ * #method([...[x], y] = [1, 2, 3]) { + · ────── + 77 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { static async *gen() { - 35 │ yi\u0065ld: ; - · ▲ - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:76:14] + 75 │ var C = class { + 76 │ * #method([...x, y] = [1, 2, 3]) { + · ──── + 77 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/async-gen-method-static/yield-as-label-identifier.js:35:10] - 34 │ var C = class { static async *gen() { - 35 │ yield: ; - · ▲ - 36 │ }}; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:76:14] + 75 │ var C = class { + 76 │ * #method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 77 │ ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method-static/yield-identifier-spread-strict.js:41:17] - 40 │ ...(function() { - 41 │ var yield; - · ───── - 42 │ throw new Test262Error(); + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-ary.js:76:24] + 75 │ var C = class { + 76 │ static * #method([...[ x ] = []]) { + · ────────── + 77 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/async-gen-method-static/yield-identifier-strict.js:33:13] - 32 │ (function() { - 33 │ var yield; - · ───── - 34 │ throw new Test262Error(); + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-id.js:76:24] + 75 │ var C = class { + 76 │ static * #method([...x = []]) { + · ────── + 77 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-method/array-destructuring-param-strict-body.js:133:5] - 132 │ static async method([element]) { - 133 │ "use strict"; - · ───────────── - 134 │ } - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-obj.js:76:24] + 75 │ var C = class { + 76 │ static * #method([...{ x } = []]) { + · ────────── + 77 │ + ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-method/await-as-binding-identifier-escaped.js:36:9] - 35 │ async method() { - 36 │ var \u0061wait; - · ────────── - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-ary.js:76:21] + 75 │ var C = class { + 76 │ static * #method([...[x], y]) { + · ────── + 77 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-method/await-as-binding-identifier.js:36:9] - 35 │ async method() { - 36 │ var await; - · ───── - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-id.js:76:21] + 75 │ var C = class { + 76 │ static * #method([...x, y]) { + · ──── + 77 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-method/await-as-identifier-reference-escaped.js:36:10] - 35 │ async method() { - 36 │ void \u0061wait; - · ────────── - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-obj.js:76:21] + 75 │ var C = class { + 76 │ static * #method([...{ x }, y]) { + · ──────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method/await-as-identifier-reference-escaped.js:36:20] - 35 │ async method() { - 36 │ void \u0061wait; - · ─ - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:76:24] + 75 │ var C = class { + 76 │ static * #method([...[ x ] = []] = []) { + · ────────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method/await-as-identifier-reference.js:36:15] - 35 │ async method() { - 36 │ void await; - · ─ - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js:76:24] + 75 │ var C = class { + 76 │ static * #method([...x = []] = []) { + · ────── + 77 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-method/await-as-label-identifier-escaped.js:36:5] - 35 │ async method() { - 36 │ \u0061wait: ; - · ────────── - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:76:24] + 75 │ var C = class { + 76 │ static * #method([...{ x } = []] = []) { + · ────────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method/await-as-label-identifier-escaped.js:36:15] - 35 │ async method() { - 36 │ \u0061wait: ; - · ─ - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:76:21] + 75 │ var C = class { + 76 │ static * #method([...[x], y] = [1, 2, 3]) { + · ────── + 77 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method/await-as-label-identifier.js:36:10] - 35 │ async method() { - 36 │ await: ; - · ─ - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:76:21] + 75 │ var C = class { + 76 │ static * #method([...x, y] = [1, 2, 3]) { + · ──── + 77 │ ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/class/async-method/dflt-params-duplicates.js:61:23] - 60 │ var C = class { - 61 │ static async method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 62 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:76:21] + 75 │ var C = class { + 76 │ static * #method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 77 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/class/async-method/dflt-params-rest.js:65:26] - 64 │ var C = class { - 65 │ static async method(...x = []) { - · ────── - 66 │ + ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-ary.js:73:15] + 72 │ var C = class { + 73 │ #method([...[ x ] = []]) { + · ────────── + 74 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-method/object-destructuring-param-strict-body.js:133:5] - 132 │ static async method({property}) { - 133 │ "use strict"; - · ───────────── - 134 │ } - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-method/rest-param-strict-body.js:133:5] - 132 │ static async method(a,...rest) { - 133 │ "use strict"; - · ───────────── - 134 │ } - ╰──── - - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/async-method/rest-params-trailing-comma-early-error.js:57:23] - 56 │ var C = class { - 57 │ static async method(...a,) { - · ──── - 58 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-id.js:73:15] + 72 │ var C = class { + 73 │ #method([...x = []]) { + · ────── + 74 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-method-static/array-destructuring-param-strict-body.js:133:5] - 132 │ static async method([element]) { - 133 │ "use strict"; - · ───────────── - 134 │ } - ╰──── - - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-method-static/await-as-binding-identifier-escaped.js:36:9] - 35 │ static async method() { - 36 │ var \u0061wait; - · ────────── - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-obj.js:73:15] + 72 │ var C = class { + 73 │ #method([...{ x } = []]) { + · ────────── + 74 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/async-method-static/await-as-binding-identifier.js:36:9] - 35 │ static async method() { - 36 │ var await; - · ───── - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-ary.js:73:12] + 72 │ var C = class { + 73 │ #method([...[x], y]) { + · ────── + 74 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js:36:10] - 35 │ static async method() { - 36 │ void \u0061wait; - · ────────── - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-id.js:73:12] + 72 │ var C = class { + 73 │ #method([...x, y]) { + · ──── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js:36:20] - 35 │ static async method() { - 36 │ void \u0061wait; - · ─ - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-obj.js:73:12] + 72 │ var C = class { + 73 │ #method([...{ x }, y]) { + · ──────── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method-static/await-as-identifier-reference.js:36:15] - 35 │ static async method() { - 36 │ void await; - · ─ - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-ary.js:73:15] + 72 │ var C = class { + 73 │ #method([...[ x ] = []] = []) { + · ────────── + 74 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/async-method-static/await-as-label-identifier-escaped.js:36:5] - 35 │ static async method() { - 36 │ \u0061wait: ; - · ────────── - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-id.js:73:15] + 72 │ var C = class { + 73 │ #method([...x = []] = []) { + · ────── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method-static/await-as-label-identifier-escaped.js:36:15] - 35 │ static async method() { - 36 │ \u0061wait: ; - · ─ - 37 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-obj.js:73:15] + 72 │ var C = class { + 73 │ #method([...{ x } = []] = []) { + · ────────── + 74 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/async-method-static/await-as-label-identifier.js:36:10] - 35 │ static async method() { - 36 │ await: ; - · ─ - 37 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-ary.js:73:12] + 72 │ var C = class { + 73 │ #method([...[x], y] = [1, 2, 3]) { + · ────── + 74 │ ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/class/async-method-static/dflt-params-duplicates.js:61:23] - 60 │ var C = class { - 61 │ static async method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 62 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-id.js:73:12] + 72 │ var C = class { + 73 │ #method([...x, y] = [1, 2, 3]) { + · ──── + 74 │ ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/async-method-static/dflt-params-rest.js:65:26] - 64 │ var C = class { - 65 │ static async method(...x = []) { - · ────── - 66 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-obj.js:73:12] + 72 │ var C = class { + 73 │ #method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 74 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-method-static/object-destructuring-param-strict-body.js:133:5] - 132 │ static async method({property}) { - 133 │ "use strict"; - · ───────────── - 134 │ } - ╰──── - - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/async-method-static/rest-param-strict-body.js:133:5] - 132 │ static async method(a,...rest) { - 133 │ "use strict"; - · ───────────── - 134 │ } - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-ary.js:73:22] + 72 │ var C = class { + 73 │ static #method([...[ x ] = []]) { + · ────────── + 74 │ + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/async-method-static/rest-params-trailing-comma-early-error.js:57:23] - 56 │ var C = class { - 57 │ static async method(...a,) { - · ──── - 58 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-id.js:73:22] + 72 │ var C = class { + 73 │ static #method([...x = []]) { + · ────── + 74 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/class-name-ident-await-escaped-module.js:23:15] - 22 │ - 23 │ var C = class aw\u0061it {}; - · ────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-obj.js:73:22] + 72 │ var C = class { + 73 │ static #method([...{ x } = []]) { + · ────────── + 74 │ ╰──── - × The keyword 'await' is reserved - ╭─[language/expressions/class/class-name-ident-await-escaped-module.js:23:15] - 22 │ - 23 │ var C = class aw\u0061it {}; - · ────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-ary.js:73:19] + 72 │ var C = class { + 73 │ static #method([...[x], y]) { + · ────── + 74 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/class-name-ident-await-module.js:22:15] - 21 │ - 22 │ var C = class await {}; - · ───── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-id.js:73:19] + 72 │ var C = class { + 73 │ static #method([...x, y]) { + · ──── + 74 │ ╰──── - × The keyword 'await' is reserved - ╭─[language/expressions/class/class-name-ident-await-module.js:22:15] - 21 │ - 22 │ var C = class await {}; - · ───── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-obj.js:73:19] + 72 │ var C = class { + 73 │ static #method([...{ x }, y]) { + · ──────── + 74 │ ╰──── - × The keyword 'let' is reserved - ╭─[language/expressions/class/class-name-ident-let-escaped.js:27:15] - 26 │ - 27 │ var C = class l\u0065t {}; - · ──────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-ary.js:73:22] + 72 │ var C = class { + 73 │ static #method([...[ x ] = []] = []) { + · ────────── + 74 │ ╰──── - × The keyword 'let' is reserved - ╭─[language/expressions/class/class-name-ident-let.js:27:15] - 26 │ - 27 │ var C = class let {}; - · ─── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-id.js:73:22] + 72 │ var C = class { + 73 │ static #method([...x = []] = []) { + · ────── + 74 │ ╰──── - × The keyword 'static' is reserved - ╭─[language/expressions/class/class-name-ident-static-escaped.js:27:15] - 26 │ - 27 │ var C = class st\u0061tic {}; - · ─────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-obj.js:73:22] + 72 │ var C = class { + 73 │ static #method([...{ x } = []] = []) { + · ────────── + 74 │ ╰──── - × The keyword 'static' is reserved - ╭─[language/expressions/class/class-name-ident-static.js:27:15] - 26 │ - 27 │ var C = class static {}; - · ────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:73:19] + 72 │ var C = class { + 73 │ static #method([...[x], y] = [1, 2, 3]) { + · ────── + 74 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/class-name-ident-yield-escaped.js:27:15] - 26 │ - 27 │ var C = class yi\u0065ld {}; - · ────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-id.js:73:19] + 72 │ var C = class { + 73 │ static #method([...x, y] = [1, 2, 3]) { + · ──── + 74 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/class-name-ident-yield.js:25:15] - 24 │ - 25 │ var C = class yield {}; - · ───── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:73:19] + 72 │ var C = class { + 73 │ static #method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 74 │ + ╰──── + + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/arrow-fnc-init-err-contains-arguments.js:33:13] + 32 │ var C = class { + 33 │ x = () => arguments; + · ───────── + 34 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js:57:21] - 56 │ var C = class { - 57 │ async *method([...[ x ] = []]) { - · ────────── - 58 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/arrow-fnc-init-err-contains-super.js:26:13] + 25 │ var C = class { + 26 │ x = () => super(); + · ─────── + 27 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-id.js:57:21] - 56 │ var C = class { - 57 │ async *method([...x = []]) { - · ────── - 58 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { async *#gen() { + 35 │ var \u0061wait; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js:57:21] - 56 │ var C = class { - 57 │ async *method([...{ x } = []]) { - · ────────── - 58 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier.js:35:9] + 34 │ var C = class { async *#gen() { + 35 │ var await; + · ───── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js:57:18] - 56 │ var C = class { - 57 │ async *method([...[x], y]) { - · ────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ void \u0061wait; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js:57:18] - 56 │ var C = class { - 57 │ async *method([...x, y]) { - · ──── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js:35:20] + 34 │ var C = class { async *#gen() { + 35 │ void \u0061wait; + · ─ + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js:57:18] - 56 │ var C = class { - 57 │ async *method([...{ x }, y]) { - · ──────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference.js:35:15] + 34 │ var C = class { async *#gen() { + 35 │ void await; + · ─ + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js:57:21] - 56 │ var C = class { - 57 │ async *method([...[ x ] = []] = []) { - · ────────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { async *#gen() { + 35 │ \u0061wait: ; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js:57:21] - 56 │ var C = class { - 57 │ async *method([...x = []] = []) { - · ────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { async *#gen() { + 35 │ \u0061wait: ; + · ─ + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js:57:21] - 56 │ var C = class { - 57 │ async *method([...{ x } = []] = []) { - · ────────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method/await-as-label-identifier.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ await: ; + · ─ + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:57:18] - 56 │ var C = class { - 57 │ async *method([...[x], y] = [1, 2, 3]) { - · ────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { async *#gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:57:18] - 56 │ var C = class { - 57 │ async *method([...x, y] = [1, 2, 3]) { - · ──── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { async *#gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:57:18] - 56 │ var C = class { - 57 │ async *method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { async *#gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-ary.js:57:28] - 56 │ var C = class { - 57 │ static async *method([...[ x ] = []]) { - · ────────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { async *#gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-id.js:57:28] - 56 │ var C = class { - 57 │ static async *method([...x = []]) { - · ────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-obj.js:57:28] - 56 │ var C = class { - 57 │ static async *method([...{ x } = []]) { - · ────────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-ary.js:57:25] - 56 │ var C = class { - 57 │ static async *method([...[x], y]) { - · ────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-id.js:57:25] - 56 │ var C = class { - 57 │ static async *method([...x, y]) { - · ──── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-obj.js:57:25] - 56 │ var C = class { - 57 │ static async *method([...{ x }, y]) { - · ──────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { async *#gen() { + 35 │ yi\u0065ld: ; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:57:28] - 56 │ var C = class { - 57 │ static async *method([...[ x ] = []] = []) { - · ────────── - 58 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { async *#gen() { + 35 │ yi\u0065ld: ; + · ▲ + 36 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js:57:28] - 56 │ var C = class { - 57 │ static async *method([...x = []] = []) { - · ────── - 58 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier.js:35:10] + 34 │ var C = class { async *#gen() { + 35 │ yield: ; + · ▲ + 36 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:57:28] - 56 │ var C = class { - 57 │ static async *method([...{ x } = []] = []) { - · ────────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js:42:21] + 41 │ ...(function() { + 42 │ var yield; + · ───── + 43 │ throw new Test262Error(); ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:57:25] - 56 │ var C = class { - 57 │ static async *method([...[x], y] = [1, 2, 3]) { - · ────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js:34:17] + 33 │ (function() { + 34 │ var yield; + · ───── + 35 │ throw new Test262Error(); ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:57:25] - 56 │ var C = class { - 57 │ static async *method([...x, y] = [1, 2, 3]) { - · ──── - 58 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { static async *#gen() { + 35 │ var \u0061wait; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:57:25] - 56 │ var C = class { - 57 │ static async *method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 58 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier.js:35:9] + 34 │ var C = class { static async *#gen() { + 35 │ var await; + · ───── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-ary.js:57:23] - 56 │ var C = class { - 57 │ async * #method([...[ x ] = []]) { - · ────────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ void \u0061wait; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-id.js:57:23] - 56 │ var C = class { - 57 │ async * #method([...x = []]) { - · ────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js:35:20] + 34 │ var C = class { static async *#gen() { + 35 │ void \u0061wait; + · ─ + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-obj.js:57:23] - 56 │ var C = class { - 57 │ async * #method([...{ x } = []]) { - · ────────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference.js:35:15] + 34 │ var C = class { static async *#gen() { + 35 │ void await; + · ─ + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-ary.js:57:20] - 56 │ var C = class { - 57 │ async * #method([...[x], y]) { - · ────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { static async *#gen() { + 35 │ \u0061wait: ; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-id.js:57:20] - 56 │ var C = class { - 57 │ async * #method([...x, y]) { - · ──── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { static async *#gen() { + 35 │ \u0061wait: ; + · ─ + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-obj.js:57:20] - 56 │ var C = class { - 57 │ async * #method([...{ x }, y]) { - · ──────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ await: ; + · ─ + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-ary.js:57:23] - 56 │ var C = class { - 57 │ async * #method([...[ x ] = []] = []) { - · ────────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { static async *#gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-id.js:57:23] - 56 │ var C = class { - 57 │ async * #method([...x = []] = []) { - · ────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js:35:9] + 34 │ var C = class { static async *#gen() { + 35 │ var yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-obj.js:57:23] - 56 │ var C = class { - 57 │ async * #method([...{ x } = []] = []) { - · ────────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { static async *#gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:57:20] - 56 │ var C = class { - 57 │ async * #method([...[x], y] = [1, 2, 3]) { - · ────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js:35:9] + 34 │ var C = class { static async *#gen() { + 35 │ var yield; + · ───── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:57:20] - 56 │ var C = class { - 57 │ async * #method([...x, y] = [1, 2, 3]) { - · ──── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:57:20] - 56 │ var C = class { - 57 │ async * #method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ void yi\u0065ld; + · ────────── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-ary.js:57:30] - 56 │ var C = class { - 57 │ static async * #method([...[ x ] = []]) { - · ────────── - 58 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-id.js:57:30] - 56 │ var C = class { - 57 │ static async * #method([...x = []]) { - · ────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ void yield; + · ───── + 36 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-obj.js:57:30] - 56 │ var C = class { - 57 │ static async * #method([...{ x } = []]) { - · ────────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js:35:5] + 34 │ var C = class { static async *#gen() { + 35 │ yi\u0065ld: ; + · ────────── + 36 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-ary.js:57:27] - 56 │ var C = class { - 57 │ static async * #method([...[x], y]) { - · ────── - 58 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js:35:15] + 34 │ var C = class { static async *#gen() { + 35 │ yi\u0065ld: ; + · ▲ + 36 │ }}; ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-id.js:57:27] - 56 │ var C = class { - 57 │ static async * #method([...x, y]) { - · ──── - 58 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier.js:35:10] + 34 │ var C = class { static async *#gen() { + 35 │ yield: ; + · ▲ + 36 │ }}; ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-obj.js:57:27] - 56 │ var C = class { - 57 │ static async * #method([...{ x }, y]) { - · ──────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js:42:21] + 41 │ ...(function() { + 42 │ var yield; + · ───── + 43 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:57:30] - 56 │ var C = class { - 57 │ static async * #method([...[ x ] = []] = []) { - · ────────── - 58 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js:34:17] + 33 │ (function() { + 34 │ var yield; + · ───── + 35 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js:57:30] - 56 │ var C = class { - 57 │ static async * #method([...x = []] = []) { - · ────── - 58 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-private-method/await-as-binding-identifier-escaped.js:36:9] + 35 │ async #method() { + 36 │ var \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:57:30] - 56 │ var C = class { - 57 │ static async * #method([...{ x } = []] = []) { - · ────────── - 58 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-private-method/await-as-binding-identifier.js:36:9] + 35 │ async #method() { + 36 │ var await; + · ───── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:57:27] - 56 │ var C = class { - 57 │ static async * #method([...[x], y] = [1, 2, 3]) { - · ────── - 58 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js:36:10] + 35 │ async #method() { + 36 │ void \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:57:27] - 56 │ var C = class { - 57 │ static async * #method([...x, y] = [1, 2, 3]) { - · ──── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js:36:20] + 35 │ async #method() { + 36 │ void \u0061wait; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:57:27] - 56 │ var C = class { - 57 │ static async * #method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 58 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method/await-as-identifier-reference.js:36:15] + 35 │ async #method() { + 36 │ void await; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-ary.js:76:15] - 75 │ var C = class { - 76 │ *method([...[ x ] = []]) { - · ────────── - 77 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js:36:5] + 35 │ async #method() { + 36 │ \u0061wait: ; + · ────────── + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-id.js:76:15] - 75 │ var C = class { - 76 │ *method([...x = []]) { - · ────── - 77 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js:36:15] + 35 │ async #method() { + 36 │ \u0061wait: ; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-obj.js:76:15] - 75 │ var C = class { - 76 │ *method([...{ x } = []]) { - · ────────── - 77 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method/await-as-label-identifier.js:36:10] + 35 │ async #method() { + 36 │ await: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js:76:12] - 75 │ var C = class { - 76 │ *method([...[x], y]) { - · ────── - 77 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-private-method-static/await-as-binding-identifier-escaped.js:36:9] + 35 │ static async #method() { + 36 │ var \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-id.js:76:12] - 75 │ var C = class { - 76 │ *method([...x, y]) { - · ──── - 77 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/elements/async-private-method-static/await-as-binding-identifier.js:36:9] + 35 │ static async #method() { + 36 │ var await; + · ───── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js:76:12] - 75 │ var C = class { - 76 │ *method([...{ x }, y]) { - · ──────── - 77 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js:36:10] + 35 │ static async #method() { + 36 │ void \u0061wait; + · ────────── + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js:76:15] - 75 │ var C = class { - 76 │ *method([...[ x ] = []] = []) { - · ────────── - 77 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js:36:20] + 35 │ static async #method() { + 36 │ void \u0061wait; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js:76:15] - 75 │ var C = class { - 76 │ *method([...x = []] = []) { - · ────── - 77 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method-static/await-as-identifier-reference.js:36:15] + 35 │ static async #method() { + 36 │ void await; + · ─ + 37 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js:76:15] - 75 │ var C = class { - 76 │ *method([...{ x } = []] = []) { - · ────────── - 77 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js:36:5] + 35 │ static async #method() { + 36 │ \u0061wait: ; + · ────────── + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:76:12] - 75 │ var C = class { - 76 │ *method([...[x], y] = [1, 2, 3]) { - · ────── - 77 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js:36:15] + 35 │ static async #method() { + 36 │ \u0061wait: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js:76:12] - 75 │ var C = class { - 76 │ *method([...x, y] = [1, 2, 3]) { - · ──── - 77 │ + × Unexpected token + ╭─[language/expressions/class/elements/async-private-method-static/await-as-label-identifier.js:36:10] + 35 │ static async #method() { + 36 │ await: ; + · ─ + 37 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:76:12] - 75 │ var C = class { - 76 │ *method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/comp-name-init-err-contains-arguments.js:34:9] + 33 │ var C = class { + 34 │ [x] = arguments; + · ───────── + 35 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-ary.js:76:22] - 75 │ var C = class { - 76 │ static *method([...[ x ] = []]) { - · ────────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/comp-name-init-err-contains-super.js:27:9] + 26 │ var C = class { + 27 │ [x] = super(); + · ─────── + 28 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-id.js:76:22] - 75 │ var C = class { - 76 │ static *method([...x = []]) { - · ────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/equality-init-err-contains-arguments.js:33:13] + 32 │ var C = class { + 33 │ x = {} == arguments; + · ───────── + 34 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-obj.js:76:22] - 75 │ var C = class { - 76 │ static *method([...{ x } = []]) { - · ────────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/equality-init-err-contains-super.js:26:13] + 25 │ var C = class { + 26 │ x = {} == super(); + · ─────── + 27 │ } + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/fields-asi-3.js:17:8] + 16 │ x = "string" + 17 │ [0]() {} + · ▲ + 18 │ } ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-ary.js:76:19] - 75 │ var C = class { - 76 │ static *method([...[x], y]) { - · ────── - 77 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/fields-asi-4.js:17:9] + 16 │ x = 42 + 17 │ *gen() {} + · ▲ + 18 │ } ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-id.js:76:19] - 75 │ var C = class { - 76 │ static *method([...x, y]) { - · ──── - 77 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/fields-asi-same-line-1.js:16:8] + 15 │ var C = class { + 16 │ field /* no ASI here */ method(){} + · ▲ + 17 │ } ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-obj.js:76:19] - 75 │ var C = class { - 76 │ static *method([...{ x }, y]) { - · ──────── - 77 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/fields-asi-same-line-2.js:16:12] + 15 │ var C = class { + 16 │ field = 1 /* no ASI here */ method(){} + · ▲ + 17 │ } ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:76:22] - 75 │ var C = class { - 76 │ static *method([...[ x ] = []] = []) { - · ────────── - 77 │ + × Identifier `x` has already been declared + ╭─[language/expressions/class/elements/fields-duplicate-privatenames.js:22:3] + 21 │ var C = class { + 22 │ #x; + · ─┬ + · ╰── `x` has already been declared here + 23 │ #x; + · ─┬ + · ╰── It can not be redeclared here + 24 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-id.js:76:22] - 75 │ var C = class { - 76 │ static *method([...x = []] = []) { - · ────── - 77 │ + × Classes can't have a field named 'constructor' + ╭─[language/expressions/class/elements/fields-literal-name-propname-constructor.js:28:3] + 27 │ var C = class { + 28 │ constructor; + · ─────────── + 29 │ }; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:76:22] - 75 │ var C = class { - 76 │ static *method([...{ x } = []] = []) { - · ────────── - 77 │ + × Classes can't have a field named 'constructor' + ╭─[language/expressions/class/elements/fields-literal-name-static-propname-constructor.js:28:10] + 27 │ var C = class { + 28 │ static constructor; + · ─────────── + 29 │ }; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:76:19] - 75 │ var C = class { - 76 │ static *method([...[x], y] = [1, 2, 3]) { - · ────── - 77 │ + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/fields-literal-name-static-propname-prototype.js:28:10] + 27 │ var C = class { + 28 │ static prototype; + · ───────── + 29 │ }; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:76:19] - 75 │ var C = class { - 76 │ static *method([...x, y] = [1, 2, 3]) { - · ──── - 77 │ + × Classes can't have a field named 'constructor' + ╭─[language/expressions/class/elements/fields-string-name-propname-constructor.js:29:3] + 28 │ var C = class { + 29 │ 'constructor'; + · ───────────── + 30 │ }; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:76:19] - 75 │ var C = class { - 76 │ static *method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 77 │ + × Classes can't have a field named 'constructor' + ╭─[language/expressions/class/elements/fields-string-name-static-propname-constructor.js:29:10] + 28 │ var C = class { + 29 │ static 'constructor'; + · ───────────── + 30 │ }; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-init-ary.js:73:14] - 72 │ var C = class { - 73 │ method([...[ x ] = []]) { - · ────────── - 74 │ + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/fields-string-name-static-propname-prototype.js:29:10] + 28 │ var C = class { + 29 │ static 'prototype'; + · ─────────── + 30 │ }; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-init-id.js:73:14] - 72 │ var C = class { - 73 │ method([...x = []]) { - · ────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class {*#gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-init-obj.js:73:14] - 72 │ var C = class { - 73 │ method([...{ x } = []]) { - · ────────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class {*#gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-ary.js:73:11] - 72 │ var C = class { - 73 │ method([...[x], y]) { - · ────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js:34:9] + 33 │ var C = class {*#gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-id.js:73:11] - 72 │ var C = class { - 73 │ method([...x, y]) { - · ──── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js:34:9] + 33 │ var C = class {*#gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-obj.js:73:11] - 72 │ var C = class { - 73 │ method([...{ x }, y]) { - · ──────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class {*#gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-ary.js:73:14] - 72 │ var C = class { - 73 │ method([...[ x ] = []] = []) { - · ────────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class {*#gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-id.js:73:14] - 72 │ var C = class { - 73 │ method([...x = []] = []) { - · ────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js:34:10] + 33 │ var C = class {*#gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-obj.js:73:14] - 72 │ var C = class { - 73 │ method([...{ x } = []] = []) { - · ────────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js:34:10] + 33 │ var C = class {*#gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js:73:11] - 72 │ var C = class { - 73 │ method([...[x], y] = [1, 2, 3]) { - · ────── - 74 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js:34:5] + 33 │ var C = class {*#gen() { + 34 │ yi\u0065ld: ; + · ────────── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js:73:11] - 72 │ var C = class { - 73 │ method([...x, y] = [1, 2, 3]) { - · ──── - 74 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js:34:15] + 33 │ var C = class {*#gen() { + 34 │ yi\u0065ld: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js:73:11] - 72 │ var C = class { - 73 │ method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 74 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/gen-private-method/yield-as-label-identifier.js:34:10] + 33 │ var C = class {*#gen() { + 34 │ yield: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-ary.js:73:21] - 72 │ var C = class { - 73 │ static method([...[ x ] = []]) { - · ────────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js:41:21] + 40 │ ...(function() { + 41 │ var yield; + · ───── + 42 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-id.js:73:21] - 72 │ var C = class { - 73 │ static method([...x = []]) { - · ────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method/yield-identifier-strict.js:33:17] + 32 │ (function() { + 33 │ var yield; + · ───── + 34 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-obj.js:73:21] - 72 │ var C = class { - 73 │ static method([...{ x } = []]) { - · ────────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class { static *#gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-ary.js:73:18] - 72 │ var C = class { - 73 │ static method([...[x], y]) { - · ────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class { static *#gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-id.js:73:18] - 72 │ var C = class { - 73 │ static method([...x, y]) { - · ──── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js:34:9] + 33 │ var C = class { static *#gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-obj.js:73:18] - 72 │ var C = class { - 73 │ static method([...{ x }, y]) { - · ──────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js:34:9] + 33 │ var C = class { static *#gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-ary.js:73:21] - 72 │ var C = class { - 73 │ static method([...[ x ] = []] = []) { - · ────────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class { static *#gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-id.js:73:21] - 72 │ var C = class { - 73 │ static method([...x = []] = []) { - · ────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class { static *#gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-obj.js:73:21] - 72 │ var C = class { - 73 │ static method([...{ x } = []] = []) { - · ────────── - 74 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js:34:10] + 33 │ var C = class { static *#gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-ary.js:73:18] - 72 │ var C = class { - 73 │ static method([...[x], y] = [1, 2, 3]) { - · ────── - 74 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js:34:10] + 33 │ var C = class { static *#gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-id.js:73:18] - 72 │ var C = class { - 73 │ static method([...x, y] = [1, 2, 3]) { - · ──── - 74 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js:34:5] + 33 │ var C = class { static *#gen() { + 34 │ yi\u0065ld: ; + · ────────── + 35 │ }}; ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-obj.js:73:18] - 72 │ var C = class { - 73 │ static method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 74 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js:34:15] + 33 │ var C = class { static *#gen() { + 34 │ yi\u0065ld: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-ary.js:76:17] - 75 │ var C = class { - 76 │ * #method([...[ x ] = []]) { - · ────────── - 77 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier.js:34:10] + 33 │ var C = class { static *#gen() { + 34 │ yield: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-id.js:76:17] - 75 │ var C = class { - 76 │ * #method([...x = []]) { - · ────── - 77 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js:41:21] + 40 │ ...(function() { + 41 │ var yield; + · ───── + 42 │ throw new Test262Error(); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-obj.js:76:17] - 75 │ var C = class { - 76 │ * #method([...{ x } = []]) { - · ────────── - 77 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js:33:17] + 32 │ (function() { + 33 │ var yield; + · ───── + 34 │ throw new Test262Error(); ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-ary.js:76:14] - 75 │ var C = class { - 76 │ * #method([...[x], y]) { - · ────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/literal-name-init-err-contains-arguments.js:33:7] + 32 │ var C = class { + 33 │ x = arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-id.js:76:14] - 75 │ var C = class { - 76 │ * #method([...x, y]) { - · ──── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/literal-name-init-err-contains-super.js:26:7] + 25 │ var C = class { + 26 │ x = super(); + · ─────── + 27 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-obj.js:76:14] - 75 │ var C = class { - 76 │ * #method([...{ x }, y]) { - · ──────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-arrow-fnc-init-err-contains-arguments.js:34:19] + 33 │ x = () => { + 34 │ var t = () => arguments; + · ───────── + 35 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-ary.js:76:17] - 75 │ var C = class { - 76 │ * #method([...[ x ] = []] = []) { - · ────────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-arrow-fnc-init-err-contains-super.js:27:19] + 26 │ x = () => { + 27 │ var t = () => super(); + · ─────── + 28 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-id.js:76:17] - 75 │ var C = class { - 76 │ * #method([...x = []] = []) { - · ────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-comp-name-init-err-contains-arguments.js:33:15] + 32 │ var C = class { + 33 │ [x] = () => arguments; + · ───────── + 34 │ } + ╰──── + + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-comp-name-init-err-contains-super.js:26:15] + 25 │ var C = class { + 26 │ [x] = () => super(); + · ─────── + 27 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-obj.js:76:17] - 75 │ var C = class { - 76 │ * #method([...{ x } = []] = []) { - · ────────── - 77 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/nested-equality-init-err-contains-arguments.js:32:15] + 31 │ var C = class { + 32 │ x = () => {} == arguments; + · ▲ + 33 │ } ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:76:14] - 75 │ var C = class { - 76 │ * #method([...[x], y] = [1, 2, 3]) { - · ────── - 77 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/nested-equality-init-err-contains-super.js:25:15] + 24 │ var C = class { + 25 │ x = () => {} == super(); + · ▲ + 26 │ } ╰──── + help: Try insert a semicolon here - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:76:14] - 75 │ var C = class { - 76 │ * #method([...x, y] = [1, 2, 3]) { - · ──── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-literal-name-init-err-contains-arguments.js:32:13] + 31 │ var C = class { + 32 │ x = () => arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:76:14] - 75 │ var C = class { - 76 │ * #method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-literal-name-init-err-contains-super.js:25:13] + 24 │ var C = class { + 25 │ x = () => super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-ary.js:76:24] - 75 │ var C = class { - 76 │ static * #method([...[ x ] = []]) { - · ────────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-arguments.js:34:19] + 33 │ #x = () => { + 34 │ var t = () => arguments; + · ───────── + 35 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-id.js:76:24] - 75 │ var C = class { - 76 │ static * #method([...x = []]) { - · ────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-super.js:27:19] + 26 │ #x = () => { + 27 │ var t = () => super(); + · ─────── + 28 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-obj.js:76:24] - 75 │ var C = class { - 76 │ static * #method([...{ x } = []]) { - · ────────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-private-literal-name-init-err-contains-arguments.js:32:14] + 31 │ var C = class { + 32 │ #x = () => arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-ary.js:76:21] - 75 │ var C = class { - 76 │ static * #method([...[x], y]) { - · ────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-private-literal-name-init-err-contains-super.js:25:14] + 24 │ var C = class { + 25 │ #x = () => super(); + · ─────── + 26 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-id.js:76:21] - 75 │ var C = class { - 76 │ static * #method([...x, y]) { - · ──── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-private-ternary-init-err-contains-arguments.js:32:26] + 31 │ var C = class { + 32 │ #x = () => true ? {} : arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-obj.js:76:21] - 75 │ var C = class { - 76 │ static * #method([...{ x }, y]) { - · ──────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-private-ternary-init-err-contains-super.js:25:26] + 24 │ var C = class { + 25 │ #x = () => true ? {} : super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js:76:24] - 75 │ var C = class { - 76 │ static * #method([...[ x ] = []] = []) { - · ────────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-private-typeof-init-err-contains-arguments.js:32:21] + 31 │ var C = class { + 32 │ #x = () => typeof arguments; + · ───────── + 33 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js:76:24] - 75 │ var C = class { - 76 │ static * #method([...x = []] = []) { - · ────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-private-typeof-init-err-contains-super.js:25:21] + 24 │ var C = class { + 25 │ #x = () => typeof super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js:76:24] - 75 │ var C = class { - 76 │ static * #method([...{ x } = []] = []) { - · ────────── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-static-comp-name-init-err-contains-arguments.js:33:22] + 32 │ var C = class { + 33 │ static [x] = () => arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:76:21] - 75 │ var C = class { - 76 │ static * #method([...[x], y] = [1, 2, 3]) { - · ────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-static-comp-name-init-err-contains-super.js:26:22] + 25 │ var C = class { + 26 │ static [x] = () => super(); + · ─────── + 27 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js:76:21] - 75 │ var C = class { - 76 │ static * #method([...x, y] = [1, 2, 3]) { - · ──── - 77 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-static-literal-init-err-contains-arguments.js:32:20] + 31 │ var C = class { + 32 │ static x = () => arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:76:21] - 75 │ var C = class { - 76 │ static * #method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 77 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-static-literal-init-err-contains-super.js:25:20] + 24 │ var C = class { + 25 │ static x = () => super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-ary.js:73:15] - 72 │ var C = class { - 73 │ #method([...[ x ] = []]) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-static-private-init-err-contains-arguments.js:32:21] + 31 │ var C = class { + 32 │ static #x = () => arguments; + · ───────── + 33 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-id.js:73:15] - 72 │ var C = class { - 73 │ #method([...x = []]) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-static-private-init-err-contains-super.js:25:21] + 24 │ var C = class { + 25 │ static #x = () => super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-obj.js:73:15] - 72 │ var C = class { - 73 │ #method([...{ x } = []]) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-arguments.js:32:22] + 31 │ var C = class { + 32 │ static 'x' = () => arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-ary.js:73:12] - 72 │ var C = class { - 73 │ #method([...[x], y]) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-super.js:25:22] + 24 │ var C = class { + 25 │ static 'x' = () => super(); + · ─────── + 26 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-id.js:73:12] - 72 │ var C = class { - 73 │ #method([...x, y]) { - · ──── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-string-literal-name-init-err-contains-arguments.js:32:15] + 31 │ var C = class { + 32 │ 'x' = () => arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-obj.js:73:12] - 72 │ var C = class { - 73 │ #method([...{ x }, y]) { - · ──────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-string-literal-name-init-err-contains-super.js:25:15] + 24 │ var C = class { + 25 │ 'x' = () => super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-ary.js:73:15] - 72 │ var C = class { - 73 │ #method([...[ x ] = []] = []) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-ternary-init-err-contains-arguments.js:32:25] + 31 │ var C = class { + 32 │ x = () => true ? {} : arguments; + · ───────── + 33 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-id.js:73:15] - 72 │ var C = class { - 73 │ #method([...x = []] = []) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-ternary-init-err-contains-super.js:25:25] + 24 │ var C = class { + 25 │ x = () => true ? {} : super(); + · ─────── + 26 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-obj.js:73:15] - 72 │ var C = class { - 73 │ #method([...{ x } = []] = []) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/nested-typeof-init-err-contains-arguments.js:32:20] + 31 │ var C = class { + 32 │ x = () => typeof arguments; + · ───────── + 33 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-ary.js:73:12] - 72 │ var C = class { - 73 │ #method([...[x], y] = [1, 2, 3]) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/nested-typeof-init-err-contains-super.js:25:20] + 24 │ var C = class { + 25 │ x = () => typeof super(); + · ─────── + 26 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-id.js:73:12] - 72 │ var C = class { - 73 │ #method([...x, y] = [1, 2, 3]) { - · ──── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/private-arrow-fnc-init-err-contains-arguments.js:33:14] + 32 │ var C = class { + 33 │ #x = () => arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-obj.js:73:12] - 72 │ var C = class { - 73 │ #method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/private-arrow-fnc-init-err-contains-super.js:26:14] + 25 │ var C = class { + 26 │ #x = () => super(); + · ─────── + 27 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-ary.js:73:22] - 72 │ var C = class { - 73 │ static #method([...[ x ] = []]) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/private-literal-name-init-err-contains-arguments.js:33:8] + 32 │ var C = class { + 33 │ #x = arguments; + · ───────── + 34 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-id.js:73:22] - 72 │ var C = class { - 73 │ static #method([...x = []]) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/private-literal-name-init-err-contains-super.js:26:8] + 25 │ var C = class { + 26 │ #x = super(); + · ─────── + 27 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-obj.js:73:22] - 72 │ var C = class { - 73 │ static #method([...{ x } = []]) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/private-ternary-init-err-contains-arguments.js:33:20] + 32 │ var C = class { + 33 │ #x = true ? {} : arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-ary.js:73:19] - 72 │ var C = class { - 73 │ static #method([...[x], y]) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/private-ternary-init-err-contains-super.js:26:20] + 25 │ var C = class { + 26 │ #x = true ? {} : super(); + · ─────── + 27 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-id.js:73:19] - 72 │ var C = class { - 73 │ static #method([...x, y]) { - · ──── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/private-typeof-init-err-contains-arguments.js:33:15] + 32 │ var C = class { + 33 │ #x = typeof arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-obj.js:73:19] - 72 │ var C = class { - 73 │ static #method([...{ x }, y]) { - · ──────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/private-typeof-init-err-contains-super.js:26:15] + 25 │ var C = class { + 26 │ #x = typeof super(); + · ─────── + 27 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-ary.js:73:22] - 72 │ var C = class { - 73 │ static #method([...[ x ] = []] = []) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/static-comp-name-init-err-contains-arguments.js:34:16] + 33 │ var C = class { + 34 │ static [x] = arguments; + · ───────── + 35 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-id.js:73:22] - 72 │ var C = class { - 73 │ static #method([...x = []] = []) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/static-comp-name-init-err-contains-super.js:27:16] + 26 │ var C = class { + 27 │ static [x] = super(); + · ─────── + 28 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-obj.js:73:22] - 72 │ var C = class { - 73 │ static #method([...{ x } = []] = []) { - · ────────── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/static-literal-init-err-contains-arguments.js:33:14] + 32 │ var C = class { + 33 │ static x = arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-ary.js:73:19] - 72 │ var C = class { - 73 │ static #method([...[x], y] = [1, 2, 3]) { - · ────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/static-literal-init-err-contains-super.js:26:14] + 25 │ var C = class { + 26 │ static x = super(); + · ─────── + 27 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-id.js:73:19] - 72 │ var C = class { - 73 │ static #method([...x, y] = [1, 2, 3]) { - · ──── - 74 │ + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/static-private-init-err-contains-arguments.js:33:15] + 32 │ var C = class { + 33 │ static #x = arguments; + · ───────── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-obj.js:73:19] - 72 │ var C = class { - 73 │ static #method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 74 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/static-private-init-err-contains-super.js:26:15] + 25 │ var C = class { + 26 │ static #x = super(); + · ─────── + 27 │ } ╰──── × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/arrow-fnc-init-err-contains-arguments.js:33:13] + ╭─[language/expressions/class/elements/static-string-literal-name-init-err-contains-arguments.js:33:16] 32 │ var C = class { - 33 │ x = () => arguments; - · ───────── + 33 │ static 'x' = arguments; + · ───────── 34 │ } ╰──── × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/arrow-fnc-init-err-contains-super.js:26:13] + ╭─[language/expressions/class/elements/static-string-literal-name-init-err-contains-super.js:26:16] 25 │ var C = class { - 26 │ x = () => super(); - · ─────── + 26 │ static 'x' = super(); + · ─────── 27 │ } ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { async *#gen() { - 35 │ var \u0061wait; - · ────────── - 36 │ }}; + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/string-literal-name-init-err-contains-arguments.js:33:9] + 32 │ var C = class { + 33 │ 'x' = arguments; + · ───────── + 34 │ } ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier.js:35:9] - 34 │ var C = class { async *#gen() { - 35 │ var await; - · ───── - 36 │ }}; + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/string-literal-name-init-err-contains-super.js:26:9] + 25 │ var C = class { + 26 │ 'x' = super(); + · ─────── + 27 │ } ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ void \u0061wait; - · ────────── - 36 │ }}; + × Empty parenthesized expression + ╭─[language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-arrow-heritage.js:23:23] + 22 │ + 23 │ var C = class extends () => {} { + · ── + 24 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js:35:20] - 34 │ var C = class { async *#gen() { - 35 │ void \u0061wait; - · ─ - 36 │ }}; + × Expected `{` but found `=>` + ╭─[language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-async-arrow-heritage.js:23:32] + 22 │ + 23 │ var C = class extends async () => {} { + · ─┬ + · ╰── `{` expected + 24 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference.js:35:15] - 34 │ var C = class { async *#gen() { - 35 │ void await; - · ─ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-get.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { async *#gen() { - 35 │ \u0061wait: ; - · ────────── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-get.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { async *#gen() { - 35 │ \u0061wait: ; - · ─ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-set.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method/await-as-label-identifier.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ await: ; - · ─ - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-set.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { async *#gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { async *#gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { async *#gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { async *#gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { async *#gen() { - 35 │ yi\u0065ld: ; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ────── + 41 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { async *#gen() { - 35 │ yi\u0065ld: ; - · ▲ - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js:40:19] + 39 │ g = this.f; + 40 │ x = delete (g().#m); + · ── + 41 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier.js:35:10] - 34 │ var C = class { async *#gen() { - 35 │ yield: ; - · ▲ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-privatename.js:40:15] + 39 │ g = this.f; + 40 │ x = delete (g().#x); + · ────── + 41 │ ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js:42:21] - 41 │ ...(function() { - 42 │ var yield; - · ───── - 43 │ throw new Test262Error(); + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-get.js:40:15] + 39 │ + 40 │ x = delete (this.#m + · ─────── + 41 │ ); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js:34:17] - 33 │ (function() { - 34 │ var yield; - · ───── - 35 │ throw new Test262Error(); + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-get.js:40:20] + 39 │ + 40 │ x = delete (this.#m + · ── + 41 │ ); ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { static async *#gen() { - 35 │ var \u0061wait; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-set.js:40:15] + 39 │ + 40 │ x = delete (this.#m + · ─────── + 41 │ ); ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier.js:35:9] - 34 │ var C = class { static async *#gen() { - 35 │ var await; - · ───── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-set.js:40:20] + 39 │ + 40 │ x = delete (this.#m + · ── + 41 │ ); ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ void \u0061wait; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async-gen.js:40:15] + 39 │ + 40 │ x = delete (this.#m + · ─────── + 41 │ ); ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js:35:20] - 34 │ var C = class { static async *#gen() { - 35 │ void \u0061wait; - · ─ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async.js:40:15] + 39 │ + 40 │ x = delete (this.#m + · ─────── + 41 │ ); ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference.js:35:15] - 34 │ var C = class { static async *#gen() { - 35 │ void await; - · ─ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-gen.js:40:15] + 39 │ + 40 │ x = delete (this.#m + · ─────── + 41 │ ); ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { static async *#gen() { - 35 │ \u0061wait: ; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js:40:15] + 39 │ + 40 │ x = delete (this.#m + · ─────── + 41 │ ); ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { static async *#gen() { - 35 │ \u0061wait: ; - · ─ - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js:40:20] + 39 │ + 40 │ x = delete (this.#m + · ── + 41 │ ); ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ await: ; - · ─ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js:40:15] + 39 │ + 40 │ x = delete (this.#m); + · ─────── + 41 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { static async *#gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js:40:20] + 39 │ + 40 │ x = delete (this.#m); + · ── + 41 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js:35:9] - 34 │ var C = class { static async *#gen() { - 35 │ var yi\u0065ld; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-privatename.js:40:15] + 39 │ + 40 │ x = delete (this.#x); + · ─────── + 41 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { static async *#gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js:35:9] - 34 │ var C = class { static async *#gen() { - 35 │ var yield; - · ───── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ void yi\u0065ld; - · ────────── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ void yield; - · ───── - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js:35:5] - 34 │ var C = class { static async *#gen() { - 35 │ yi\u0065ld: ; - · ────────── - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js:35:15] - 34 │ var C = class { static async *#gen() { - 35 │ yi\u0065ld: ; - · ▲ - 36 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier.js:35:10] - 34 │ var C = class { static async *#gen() { - 35 │ yield: ; - · ▲ - 36 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js:42:21] - 41 │ ...(function() { - 42 │ var yield; - · ───── - 43 │ throw new Test262Error(); + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js:34:17] - 33 │ (function() { - 34 │ var yield; - · ───── - 35 │ throw new Test262Error(); + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-private-method/await-as-binding-identifier-escaped.js:36:9] - 35 │ async #method() { - 36 │ var \u0061wait; - · ────────── - 37 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ + ╰──── + + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ────── + 35 │ ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-private-method/await-as-binding-identifier.js:36:9] - 35 │ async #method() { - 36 │ var await; - · ───── - 37 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js:34:18] + 33 │ g = this.f; + 34 │ x = delete g().#m; + · ── + 35 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js:36:10] - 35 │ async #method() { - 36 │ void \u0061wait; - · ────────── - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-privatename.js:34:14] + 33 │ g = this.f; + 34 │ x = delete g().#x; + · ────── + 35 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js:36:20] - 35 │ async #method() { - 36 │ void \u0061wait; - · ─ - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js:34:14] + 33 │ + 34 │ x = delete this.#m + · ─────── + 35 │ ; ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method/await-as-identifier-reference.js:36:15] - 35 │ async #method() { - 36 │ void await; - · ─ - 37 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js:34:19] + 33 │ + 34 │ x = delete this.#m + · ── + 35 │ ; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js:36:5] - 35 │ async #method() { - 36 │ \u0061wait: ; - · ────────── - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js:34:14] + 33 │ + 34 │ x = delete this.#m + · ─────── + 35 │ ; ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js:36:15] - 35 │ async #method() { - 36 │ \u0061wait: ; - · ─ - 37 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js:34:19] + 33 │ + 34 │ x = delete this.#m + · ── + 35 │ ; ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method/await-as-label-identifier.js:36:10] - 35 │ async #method() { - 36 │ await: ; - · ─ - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async-gen.js:34:14] + 33 │ + 34 │ x = delete this.#m + · ─────── + 35 │ ; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-private-method-static/await-as-binding-identifier-escaped.js:36:9] - 35 │ static async #method() { - 36 │ var \u0061wait; - · ────────── - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async.js:34:14] + 33 │ + 34 │ x = delete this.#m + · ─────── + 35 │ ; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/elements/async-private-method-static/await-as-binding-identifier.js:36:9] - 35 │ static async #method() { - 36 │ var await; - · ───── - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-gen.js:34:14] + 33 │ + 34 │ x = delete this.#m + · ─────── + 35 │ ; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js:36:10] - 35 │ static async #method() { - 36 │ void \u0061wait; - · ────────── - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js:34:14] + 33 │ + 34 │ x = delete this.#m + · ─────── + 35 │ ; ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js:36:20] - 35 │ static async #method() { - 36 │ void \u0061wait; - · ─ - 37 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js:34:19] + 33 │ + 34 │ x = delete this.#m + · ── + 35 │ ; ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method-static/await-as-identifier-reference.js:36:15] - 35 │ static async #method() { - 36 │ void await; - · ─ - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js:34:14] + 33 │ + 34 │ x = delete this.#m; + · ─────── + 35 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js:36:5] - 35 │ static async #method() { - 36 │ \u0061wait: ; - · ────────── - 37 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js:34:19] + 33 │ + 34 │ x = delete this.#m; + · ── + 35 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js:36:15] - 35 │ static async #method() { - 36 │ \u0061wait: ; - · ─ - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-privatename.js:34:14] + 33 │ + 34 │ x = delete this.#x; + · ─────── + 35 │ ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/async-private-method-static/await-as-label-identifier.js:36:10] - 35 │ static async #method() { - 36 │ await: ; - · ─ - 37 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/comp-name-init-err-contains-arguments.js:34:9] - 33 │ var C = class { - 34 │ [x] = arguments; - · ───────── - 35 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/comp-name-init-err-contains-super.js:27:9] - 26 │ var C = class { - 27 │ [x] = super(); - · ─────── - 28 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/equality-init-err-contains-arguments.js:33:13] - 32 │ var C = class { - 33 │ x = {} == arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/equality-init-err-contains-super.js:26:13] - 25 │ var C = class { - 26 │ x = {} == super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/fields-asi-3.js:17:8] - 16 │ x = "string" - 17 │ [0]() {} - · ▲ - 18 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/fields-asi-4.js:17:9] - 16 │ x = 42 - 17 │ *gen() {} - · ▲ - 18 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/fields-asi-same-line-1.js:16:8] - 15 │ var C = class { - 16 │ field /* no ASI here */ method(){} - · ▲ - 17 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/fields-asi-same-line-2.js:16:12] - 15 │ var C = class { - 16 │ field = 1 /* no ASI here */ method(){} - · ▲ - 17 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - help: Try insert a semicolon here - × Identifier `x` has already been declared - ╭─[language/expressions/class/elements/fields-duplicate-privatenames.js:22:3] - 21 │ var C = class { - 22 │ #x; - · ─┬ - · ╰── `x` has already been declared here - 23 │ #x; - · ─┬ - · ╰── It can not be redeclared here - 24 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - × Classes can't have a field named 'constructor' - ╭─[language/expressions/class/elements/fields-literal-name-propname-constructor.js:28:3] - 27 │ var C = class { - 28 │ constructor; - · ─────────── - 29 │ }; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - × Classes can't have a field named 'constructor' - ╭─[language/expressions/class/elements/fields-literal-name-static-propname-constructor.js:28:10] - 27 │ var C = class { - 28 │ static constructor; - · ─────────── - 29 │ }; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/fields-literal-name-static-propname-prototype.js:28:10] - 27 │ var C = class { - 28 │ static prototype; - · ───────── - 29 │ }; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-no-reference.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ────── + 41 │ ╰──── - × Classes can't have a field named 'constructor' - ╭─[language/expressions/class/elements/fields-string-name-propname-constructor.js:29:3] - 28 │ var C = class { - 29 │ 'constructor'; - · ───────────── - 30 │ }; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-no-reference.js:40:20] + 39 │ g = this.f; + 40 │ x = delete ((g().#m)); + · ── + 41 │ ╰──── - × Classes can't have a field named 'constructor' - ╭─[language/expressions/class/elements/fields-string-name-static-propname-constructor.js:29:10] - 28 │ var C = class { - 29 │ static 'constructor'; - · ───────────── - 30 │ }; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-privatename.js:40:16] + 39 │ g = this.f; + 40 │ x = delete ((g().#x)); + · ────── + 41 │ ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/fields-string-name-static-propname-prototype.js:29:10] - 28 │ var C = class { - 29 │ static 'prototype'; - · ─────────── - 30 │ }; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:40:16] + 39 │ + 40 │ x = delete ((this.#m + · ─────── + 41 │ )); ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class {*#gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:40:21] + 39 │ + 40 │ x = delete ((this.#m + · ── + 41 │ )); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class {*#gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:40:16] + 39 │ + 40 │ x = delete ((this.#m + · ─────── + 41 │ )); ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js:34:9] - 33 │ var C = class {*#gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:40:21] + 39 │ + 40 │ x = delete ((this.#m + · ── + 41 │ )); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js:34:9] - 33 │ var C = class {*#gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js:40:16] + 39 │ + 40 │ x = delete ((this.#m + · ─────── + 41 │ )); ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class {*#gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-async.js:40:16] + 39 │ + 40 │ x = delete ((this.#m + · ─────── + 41 │ )); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class {*#gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-gen.js:40:16] + 39 │ + 40 │ x = delete ((this.#m + · ─────── + 41 │ )); ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js:34:10] - 33 │ var C = class {*#gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js:40:16] + 39 │ + 40 │ x = delete ((this.#m + · ─────── + 41 │ )); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js:34:10] - 33 │ var C = class {*#gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js:40:21] + 39 │ + 40 │ x = delete ((this.#m + · ── + 41 │ )); ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js:34:5] - 33 │ var C = class {*#gen() { - 34 │ yi\u0065ld: ; - · ────────── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-no-reference.js:40:16] + 39 │ + 40 │ x = delete ((this.#m)); + · ─────── + 41 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js:34:15] - 33 │ var C = class {*#gen() { - 34 │ yi\u0065ld: ; - · ▲ - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-no-reference.js:40:21] + 39 │ + 40 │ x = delete ((this.#m)); + · ── + 41 │ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/gen-private-method/yield-as-label-identifier.js:34:10] - 33 │ var C = class {*#gen() { - 34 │ yield: ; - · ▲ - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-privatename.js:40:16] + 39 │ + 40 │ x = delete ((this.#x)); + · ─────── + 41 │ + ╰──── + + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-get.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js:41:21] - 40 │ ...(function() { - 41 │ var yield; - · ───── - 42 │ throw new Test262Error(); + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-get.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method/yield-identifier-strict.js:33:17] - 32 │ (function() { - 33 │ var yield; - · ───── - 34 │ throw new Test262Error(); + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-set.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class { static *#gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-set.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class { static *#gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js:34:9] - 33 │ var C = class { static *#gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js:34:9] - 33 │ var C = class { static *#gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class { static *#gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class { static *#gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js:34:10] - 33 │ var C = class { static *#gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js:34:10] - 33 │ var C = class { static *#gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js:34:5] - 33 │ var C = class { static *#gen() { - 34 │ yi\u0065ld: ; - · ────────── - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js:34:15] - 33 │ var C = class { static *#gen() { - 34 │ yi\u0065ld: ; - · ▲ - 35 │ }}; + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ────── + 43 │ } ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier.js:34:10] - 33 │ var C = class { static *#gen() { - 34 │ yield: ; - · ▲ - 35 │ }}; + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js:42:17] + 41 │ var g = this.f; + 42 │ delete (g().#m); + · ── + 43 │ } ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js:41:21] - 40 │ ...(function() { - 41 │ var yield; - · ───── - 42 │ throw new Test262Error(); + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-privatename.js:42:13] + 41 │ var g = this.f; + 42 │ delete (g().#x); + · ────── + 43 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js:33:17] - 32 │ (function() { - 33 │ var yield; - · ───── - 34 │ throw new Test262Error(); + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-get.js:42:13] + 41 │ + 42 │ delete (this.#m + · ─────── + 43 │ ); ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/literal-name-init-err-contains-arguments.js:33:7] - 32 │ var C = class { - 33 │ x = arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-get.js:42:18] + 41 │ + 42 │ delete (this.#m + · ── + 43 │ ); ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/literal-name-init-err-contains-super.js:26:7] - 25 │ var C = class { - 26 │ x = super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-set.js:42:13] + 41 │ + 42 │ delete (this.#m + · ─────── + 43 │ ); ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-arrow-fnc-init-err-contains-arguments.js:34:19] - 33 │ x = () => { - 34 │ var t = () => arguments; - · ───────── - 35 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-set.js:42:18] + 41 │ + 42 │ delete (this.#m + · ── + 43 │ ); ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-arrow-fnc-init-err-contains-super.js:27:19] - 26 │ x = () => { - 27 │ var t = () => super(); - · ─────── - 28 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async-gen.js:42:13] + 41 │ + 42 │ delete (this.#m + · ─────── + 43 │ ); ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-comp-name-init-err-contains-arguments.js:33:15] - 32 │ var C = class { - 33 │ [x] = () => arguments; - · ───────── - 34 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async.js:42:13] + 41 │ + 42 │ delete (this.#m + · ─────── + 43 │ ); ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-comp-name-init-err-contains-super.js:26:15] - 25 │ var C = class { - 26 │ [x] = () => super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-gen.js:42:13] + 41 │ + 42 │ delete (this.#m + · ─────── + 43 │ ); ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/nested-equality-init-err-contains-arguments.js:32:15] - 31 │ var C = class { - 32 │ x = () => {} == arguments; - · ▲ - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js:42:13] + 41 │ + 42 │ delete (this.#m + · ─────── + 43 │ ); ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/nested-equality-init-err-contains-super.js:25:15] - 24 │ var C = class { - 25 │ x = () => {} == super(); - · ▲ - 26 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js:42:18] + 41 │ + 42 │ delete (this.#m + · ── + 43 │ ); ╰──── - help: Try insert a semicolon here - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-literal-name-init-err-contains-arguments.js:32:13] - 31 │ var C = class { - 32 │ x = () => arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js:42:13] + 41 │ + 42 │ delete (this.#m); + · ─────── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-literal-name-init-err-contains-super.js:25:13] - 24 │ var C = class { - 25 │ x = () => super(); + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js:42:18] + 41 │ + 42 │ delete (this.#m); + · ── + 43 │ } + ╰──── + + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-privatename.js:42:13] + 41 │ + 42 │ delete (this.#x); · ─────── - 26 │ } + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-arguments.js:34:19] - 33 │ #x = () => { - 34 │ var t = () => arguments; - · ───────── - 35 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-super.js:27:19] - 26 │ #x = () => { - 27 │ var t = () => super(); - · ─────── - 28 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-private-literal-name-init-err-contains-arguments.js:32:14] - 31 │ var C = class { - 32 │ #x = () => arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-private-literal-name-init-err-contains-super.js:25:14] - 24 │ var C = class { - 25 │ #x = () => super(); - · ─────── - 26 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-private-ternary-init-err-contains-arguments.js:32:26] - 31 │ var C = class { - 32 │ #x = () => true ? {} : arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-private-ternary-init-err-contains-super.js:25:26] - 24 │ var C = class { - 25 │ #x = () => true ? {} : super(); - · ─────── - 26 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-private-typeof-init-err-contains-arguments.js:32:21] - 31 │ var C = class { - 32 │ #x = () => typeof arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-private-typeof-init-err-contains-super.js:25:21] - 24 │ var C = class { - 25 │ #x = () => typeof super(); - · ─────── - 26 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-static-comp-name-init-err-contains-arguments.js:33:22] - 32 │ var C = class { - 33 │ static [x] = () => arguments; - · ───────── - 34 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-static-comp-name-init-err-contains-super.js:26:22] - 25 │ var C = class { - 26 │ static [x] = () => super(); - · ─────── - 27 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-static-literal-init-err-contains-arguments.js:32:20] - 31 │ var C = class { - 32 │ static x = () => arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-static-literal-init-err-contains-super.js:25:20] - 24 │ var C = class { - 25 │ static x = () => super(); - · ─────── - 26 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-static-private-init-err-contains-arguments.js:32:21] - 31 │ var C = class { - 32 │ static #x = () => arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-static-private-init-err-contains-super.js:25:21] - 24 │ var C = class { - 25 │ static #x = () => super(); - · ─────── - 26 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js:36:16] + 35 │ var g = this.f; + 36 │ delete g().#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-arguments.js:32:22] - 31 │ var C = class { - 32 │ static 'x' = () => arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-privatename.js:36:12] + 35 │ var g = this.f; + 36 │ delete g().#x; + · ────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-super.js:25:22] - 24 │ var C = class { - 25 │ static 'x' = () => super(); - · ─────── - 26 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js:36:12] + 35 │ + 36 │ delete this.#m + · ─────── + 37 │ ; ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-string-literal-name-init-err-contains-arguments.js:32:15] - 31 │ var C = class { - 32 │ 'x' = () => arguments; - · ───────── - 33 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js:36:17] + 35 │ + 36 │ delete this.#m + · ── + 37 │ ; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-string-literal-name-init-err-contains-super.js:25:15] - 24 │ var C = class { - 25 │ 'x' = () => super(); - · ─────── - 26 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js:36:12] + 35 │ + 36 │ delete this.#m + · ─────── + 37 │ ; ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-ternary-init-err-contains-arguments.js:32:25] - 31 │ var C = class { - 32 │ x = () => true ? {} : arguments; - · ───────── - 33 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js:36:17] + 35 │ + 36 │ delete this.#m + · ── + 37 │ ; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-ternary-init-err-contains-super.js:25:25] - 24 │ var C = class { - 25 │ x = () => true ? {} : super(); - · ─────── - 26 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async-gen.js:36:12] + 35 │ + 36 │ delete this.#m + · ─────── + 37 │ ; ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/nested-typeof-init-err-contains-arguments.js:32:20] - 31 │ var C = class { - 32 │ x = () => typeof arguments; - · ───────── - 33 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async.js:36:12] + 35 │ + 36 │ delete this.#m + · ─────── + 37 │ ; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/nested-typeof-init-err-contains-super.js:25:20] - 24 │ var C = class { - 25 │ x = () => typeof super(); - · ─────── - 26 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-gen.js:36:12] + 35 │ + 36 │ delete this.#m + · ─────── + 37 │ ; ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/private-arrow-fnc-init-err-contains-arguments.js:33:14] - 32 │ var C = class { - 33 │ #x = () => arguments; - · ───────── - 34 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js:36:12] + 35 │ + 36 │ delete this.#m + · ─────── + 37 │ ; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/private-arrow-fnc-init-err-contains-super.js:26:14] - 25 │ var C = class { - 26 │ #x = () => super(); - · ─────── - 27 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js:36:17] + 35 │ + 36 │ delete this.#m + · ── + 37 │ ; ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/private-literal-name-init-err-contains-arguments.js:33:8] - 32 │ var C = class { - 33 │ #x = arguments; - · ───────── - 34 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js:36:12] + 35 │ + 36 │ delete this.#m; + · ─────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/private-literal-name-init-err-contains-super.js:26:8] - 25 │ var C = class { - 26 │ #x = super(); - · ─────── - 27 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js:36:17] + 35 │ + 36 │ delete this.#m; + · ── + 37 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/private-ternary-init-err-contains-arguments.js:33:20] - 32 │ var C = class { - 33 │ #x = true ? {} : arguments; - · ───────── - 34 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-privatename.js:36:12] + 35 │ + 36 │ delete this.#x; + · ─────── + 37 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/private-ternary-init-err-contains-super.js:26:20] - 25 │ var C = class { - 26 │ #x = true ? {} : super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/private-typeof-init-err-contains-arguments.js:33:15] - 32 │ var C = class { - 33 │ #x = typeof arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/private-typeof-init-err-contains-super.js:26:15] - 25 │ var C = class { - 26 │ #x = typeof super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/static-comp-name-init-err-contains-arguments.js:34:16] - 33 │ var C = class { - 34 │ static [x] = arguments; - · ───────── - 35 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/static-comp-name-init-err-contains-super.js:27:16] - 26 │ var C = class { - 27 │ static [x] = super(); - · ─────── - 28 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/static-literal-init-err-contains-arguments.js:33:14] - 32 │ var C = class { - 33 │ static x = arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/static-literal-init-err-contains-super.js:26:14] - 25 │ var C = class { - 26 │ static x = super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/static-private-init-err-contains-arguments.js:33:15] - 32 │ var C = class { - 33 │ static #x = arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/static-private-init-err-contains-super.js:26:15] - 25 │ var C = class { - 26 │ static #x = super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/static-string-literal-name-init-err-contains-arguments.js:33:16] - 32 │ var C = class { - 33 │ static 'x' = arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/static-string-literal-name-init-err-contains-super.js:26:16] - 25 │ var C = class { - 26 │ static 'x' = super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/string-literal-name-init-err-contains-arguments.js:33:9] - 32 │ var C = class { - 33 │ 'x' = arguments; - · ───────── - 34 │ } + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/string-literal-name-init-err-contains-super.js:26:9] - 25 │ var C = class { - 26 │ 'x' = super(); - · ─────── - 27 │ } + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-no-reference.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ────── + 43 │ } ╰──── - × Empty parenthesized expression - ╭─[language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-arrow-heritage.js:23:23] - 22 │ - 23 │ var C = class extends () => {} { - · ── - 24 │ + × Private field 'm' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-no-reference.js:42:18] + 41 │ var g = this.f; + 42 │ delete ((g().#m)); + · ── + 43 │ } ╰──── - × Expected `{` but found `=>` - ╭─[language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-async-arrow-heritage.js:23:32] - 22 │ - 23 │ var C = class extends async () => {} { - · ─┬ - · ╰── `{` expected - 24 │ + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-privatename.js:42:14] + 41 │ var g = this.f; + 42 │ delete ((g().#x)); + · ────── + 43 │ } ╰──── × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-get.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:42:14] + 41 │ + 42 │ delete ((this.#m + · ─────── + 43 │ )); ╰──── × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-get.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:42:19] + 41 │ + 42 │ delete ((this.#m · ── - 41 │ + 43 │ )); ╰──── × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-set.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:42:14] + 41 │ + 42 │ delete ((this.#m + · ─────── + 43 │ )); ╰──── × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-accessor-set.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:42:19] + 41 │ + 42 │ delete ((this.#m · ── - 41 │ + 43 │ )); ╰──── × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js:42:14] + 41 │ + 42 │ delete ((this.#m + · ─────── + 43 │ )); ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ── - 41 │ + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-async.js:42:14] + 41 │ + 42 │ delete ((this.#m + · ─────── + 43 │ )); ╰──── × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-gen.js:42:14] + 41 │ + 42 │ delete ((this.#m + · ─────── + 43 │ )); + ╰──── + + × Private fields can not be deleted + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js:42:14] + 41 │ + 42 │ delete ((this.#m + · ─────── + 43 │ )); ╰──── × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js:42:19] + 41 │ + 42 │ delete ((this.#m · ── - 41 │ + 43 │ )); ╰──── × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-no-reference.js:42:14] + 41 │ + 42 │ delete ((this.#m)); + · ─────── + 43 │ } ╰──── × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-no-reference.js:42:19] + 41 │ + 42 │ delete ((this.#m)); · ── - 41 │ + 43 │ } ╰──── × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-privatename.js:42:14] + 41 │ + 42 │ delete ((this.#x)); + · ─────── + 43 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ── - 41 │ + × Multiple constructor implementations are not allowed. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-class-body-ctor-duplicate.js:23:3] + 22 │ var C = class { + 23 │ constructor() {} + · ─────┬───── + · ╰── constructor has already been declared here + 24 │ constructor() {} + · ─────┬───── + · ╰── it cannot be redeclared here + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ────── - 41 │ + × 'super' can only be referenced in a derived class. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-ctor-super-no-heritage.js:25:9] + 24 │ + 25 │ ╭─▶ var C = class { + 26 │ │ constructor() { + 27 │ │ super(); + · │ ───── + 28 │ │ } + 29 │ ├─▶ }; + · ╰──── class does not have `extends` ╰──── + help: either remove this super, or extend the class - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js:40:19] - 39 │ g = this.f; - 40 │ x = delete (g().#m); - · ── - 41 │ + × Invalid Character `` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-ues-error.js:69:9] + 68 │ var C = class { + 69 │ \u0000; + · ▲ + 70 │ }; + ╰──── + + × Invalid Character `‍` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwj-error.js:69:9] + 68 │ var C = class { + 69 │ \u200D_ZWJ; + · ▲ + 70 │ }; + ╰──── + + × Invalid Character `‌` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwnj-error.js:69:9] + 68 │ var C = class { + 69 │ \u200C_ZWNJ; + · ▲ + 70 │ }; + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-fields-same-line-error.js:32:4] + 31 │ var C = class { + 32 │ x y + · ▲ + 33 │ }; + ╰──── + help: Try insert a semicolon here + + × Expected `{` but found `=>` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-array-literal.js:36:27] + 35 │ + 36 │ var C = class extends (o) => [o.#foo] + · ─┬ + · ╰── `{` expected + 37 │ { + ╰──── + + × Private field 'foo' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js:36:68] + 35 │ + 36 │ var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } + · ──── + 37 │ { + ╰──── + + × Private field 'bar' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js:36:93] + 35 │ + 36 │ var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } + · ──── + 37 │ { ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-privatename.js:40:15] - 39 │ g = this.f; - 40 │ x = delete (g().#x); - · ────── - 41 │ + × Private field 'fuz' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js:36:118] + 35 │ + 36 │ var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } + · ──── + 37 │ { ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-get.js:40:15] - 39 │ - 40 │ x = delete (this.#m - · ─────── - 41 │ ); + × Private identifier '#foo' is not allowed outside class bodies + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-function-expression.js:36:45] + 35 │ + 36 │ var C = class extends function() { x = this.#foo; } + · ──── + 37 │ { ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-get.js:40:20] - 39 │ - 40 │ x = delete (this.#m - · ── - 41 │ ); + × Expected `{` but found `=>` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-obj-literal.js:36:27] + 35 │ + 36 │ var C = class extends (o) => {x: o.#foo} + · ─┬ + · ╰── `{` expected + 37 │ { ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-set.js:40:15] - 39 │ - 40 │ x = delete (this.#m - · ─────── - 41 │ ); + × Private field 'foo' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-recursive.js:36:54] + 35 │ + 36 │ var C = class extends class extends class { x = this.#foo; } {} + · ──── + 37 │ { ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-accessor-set.js:40:20] - 39 │ - 40 │ x = delete (this.#m - · ── - 41 │ ); + × Private field 'foo' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage.js:36:40] + 35 │ + 36 │ var C = class extends class { x = this.#foo; } + · ──── + 37 │ { ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async-gen.js:40:15] - 39 │ - 40 │ x = delete (this.#m - · ─────── - 41 │ ); + × Unexpected token + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-field-on-object-destructuring.js:30:13] + 29 │ destructureX() { + 30 │ const { #x: x } = this; + · ── + 31 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async.js:40:15] - 39 │ - 40 │ x = delete (this.#m - · ─────── - 41 │ ); + × Private fields cannot be accessed on super + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js:28:14] + 27 │ access() { + 28 │ return super.#m; + · ──────── + 29 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-gen.js:40:15] - 39 │ - 40 │ x = delete (this.#m - · ─────── - 41 │ ); + × Private fields cannot be accessed on super + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js:32:14] + 31 │ method() { + 32 │ return super.#m(); + · ──────── + 33 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js:40:15] - 39 │ - 40 │ x = delete (this.#m - · ─────── - 41 │ ); + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async-gen.js:24:3] + 23 │ var C = class { + 24 │ #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ async * #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js:40:20] - 39 │ - 40 │ x = delete (this.#m - · ── - 41 │ ); + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async.js:24:3] + 23 │ var C = class { + 24 │ #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ async #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js:40:15] - 39 │ - 40 │ x = delete (this.#m); - · ─────── - 41 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-gen.js:24:3] + 23 │ var C = class { + 24 │ #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ * #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js:40:20] - 39 │ - 40 │ x = delete (this.#m); - · ── - 41 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-field.js:24:3] + 23 │ var C = class { + 24 │ #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ get #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-privatename.js:40:15] - 39 │ - 40 │ x = delete (this.#x); - · ─────── - 41 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-get.js:24:7] + 23 │ var C = class { + 24 │ get #m() {} + · ─┬ + · ╰── `m` has already been declared here + 25 │ get #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-field.js:24:3] + 23 │ var C = class { + 24 │ #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-get.js:24:7] + 23 │ var C = class { + 24 │ get #m() {} + · ─┬ + · ╰── `m` has already been declared here + 25 │ #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-meth.js:24:3] + 23 │ var C = class { + 24 │ #m() {} + · ─┬ + · ╰── `m` has already been declared here + 25 │ #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-set.js:24:7] + 23 │ var C = class { + 24 │ set #m(_) {} + · ─┬ + · ╰── `m` has already been declared here + 25 │ #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticfield.js:24:10] + 23 │ var C = class { + 24 │ static #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticmeth.js:24:10] + 23 │ var C = class { + 24 │ static #m() {} + · ─┬ + · ╰── `m` has already been declared here + 25 │ #m() {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-field.js:24:3] + 23 │ var C = class { + 24 │ #m; + · ─┬ + · ╰── `m` has already been declared here + 25 │ set #m(_) {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Identifier `m` has already been declared + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-set.js:24:7] + 23 │ var C = class { + 24 │ set #m(_) {} + · ─┬ + · ╰── `m` has already been declared here + 25 │ set #m(_) {} + · ─┬ + · ╰── It can not be redeclared here + 26 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Classes can't have an element named '#constructor' + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-constructor.js:24:3] + 23 │ var C = class { + 24 │ #constructor + · ──────────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-error.js:35:4] + 34 │ var C = class { + 35 │ # x + · ─ + 36 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Invalid Character `` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-ues.js:63:10] + 62 │ var C = class { + 63 │ #\u0000; + · ▲ + 64 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Invalid Character `‍` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwj-error.js:63:10] + 62 │ var C = class { + 63 │ #\u200D_ZWJ; + · ▲ + 64 │ ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ────── - 35 │ + × Invalid Character `‌` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwnj-error.js:63:10] + 62 │ var C = class { + 63 │ #\u200C_ZWNJ; + · ▲ + 64 │ ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js:34:18] - 33 │ g = this.f; - 34 │ x = delete g().#m; - · ── - 35 │ + × Private field 'f' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-in-computed-property-missing.js:51:9] + 50 │ var C = class { + 51 │ [this.#f] = 'Test262' + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-privatename.js:34:14] - 33 │ g = this.f; - 34 │ x = delete g().#x; - · ────── - 35 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js:28:8] + 27 │ var C = class { + 28 │ get # m() {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js:34:14] - 33 │ - 34 │ x = delete this.#m - · ─────── - 35 │ ; + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js:28:6] + 27 │ var C = class { + 28 │ get # m() {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js:34:19] - 33 │ - 34 │ x = delete this.#m - · ── - 35 │ ; + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js:28:8] + 27 │ var C = class { + 28 │ set # m(_) {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js:34:14] - 33 │ - 34 │ x = delete this.#m - · ─────── - 35 │ ; + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js:28:6] + 27 │ var C = class { + 28 │ set # m(_) {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js:34:19] - 33 │ - 34 │ x = delete this.#m - · ── - 35 │ ; + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-gen-meth.js:28:12] + 27 │ var C = class { + 28 │ async * # m() {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async-gen.js:34:14] - 33 │ - 34 │ x = delete this.#m - · ─────── - 35 │ ; + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js:28:10] + 27 │ var C = class { + 28 │ async # m() {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async.js:34:14] - 33 │ - 34 │ x = delete this.#m - · ─────── - 35 │ ; + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js:28:8] + 27 │ var C = class { + 28 │ async # m() {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-gen.js:34:14] - 33 │ - 34 │ x = delete this.#m - · ─────── - 35 │ ; + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-call-expr.js:37:15] + 36 │ m() { + 37 │ this.f().# x; + · ─ + 38 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js:34:14] - 33 │ - 34 │ x = delete this.#m - · ─────── - 35 │ ; + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field-init.js:28:4] + 27 │ var C = class { + 28 │ # x = 1; + · ─ + 29 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js:34:19] - 33 │ - 34 │ x = delete this.#m - · ── - 35 │ ; + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field.js:28:4] + 27 │ var C = class { + 28 │ # x; + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js:34:14] - 33 │ - 34 │ x = delete this.#m; - · ─────── - 35 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-gen-meth.js:28:6] + 27 │ var C = class { + 28 │ * # m() {} + · ─ + 29 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js:34:19] - 33 │ - 34 │ x = delete this.#m; - · ── - 35 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-member-expr.js:32:11] + 31 │ m() { + 32 │ this.# x; + · ─ + 33 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-privatename.js:34:14] - 33 │ - 34 │ x = delete this.#x; - · ─────── - 35 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-meth.case.js:28:4] + 27 │ var C = class { + 28 │ # m() {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js:28:15] + 27 │ var C = class { + 28 │ static get # m() {} + · ─ + 29 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js:28:13] + 27 │ var C = class { + 28 │ static get # m() {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js:28:15] + 27 │ var C = class { + 28 │ static set # m(_) {} + · ─ + 29 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js:28:13] + 27 │ var C = class { + 28 │ static set # m(_) {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-gen-meth.js:28:19] + 27 │ var C = class { + 28 │ static async * # m() {} + · ─ + 29 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js:28:17] + 27 │ var C = class { + 28 │ static async # m() {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js:28:15] + 27 │ var C = class { + 28 │ static async # m() {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-async.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js:28:11] + 27 │ var C = class { + 28 │ static # x = 1; + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js:28:9] + 27 │ var C = class { + 28 │ static # x = 1; + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js:28:11] + 27 │ var C = class { + 28 │ static # x; + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js:28:9] + 27 │ var C = class { + 28 │ static # x; + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-gen-meth.js:28:13] + 27 │ var C = class { + 28 │ static * # m() {} + · ─ + 29 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-no-reference.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ────── - 41 │ + × Invalid Character ` ` + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js:28:11] + 27 │ var C = class { + 28 │ static # m() {} + · ─ + 29 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-no-reference.js:40:20] - 39 │ g = this.f; - 40 │ x = delete ((g().#m)); - · ── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js:28:9] + 27 │ var C = class { + 28 │ static # m() {} + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-privatename.js:40:16] - 39 │ g = this.f; - 40 │ x = delete ((g().#x)); - · ────── - 41 │ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatenames-same-line-error.js:35:5] + 34 │ var C = class { + 35 │ #x #y + · ▲ + 36 │ }; ╰──── + help: Try insert a semicolon here - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:40:16] - 39 │ - 40 │ x = delete ((this.#m - · ─────── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async-gen.js:25:7] + 24 │ async * method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:40:21] - 39 │ - 40 │ x = delete ((this.#m - · ── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async.js:25:7] + 24 │ async method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:40:16] - 39 │ - 40 │ x = delete ((this.#m - · ─────── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-gen.js:25:7] + 24 │ * method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:40:21] - 39 │ - 40 │ x = delete ((this.#m - · ── - 41 │ )); + + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-get.js:25:7] + 24 │ get method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js:40:16] - 39 │ - 40 │ x = delete ((this.#m - · ─────── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-method.js:25:7] + 24 │ method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-async.js:40:16] - 39 │ - 40 │ x = delete ((this.#m - · ─────── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async-gen.js:25:7] + 24 │ async * #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method-gen.js:40:16] - 39 │ - 40 │ x = delete ((this.#m - · ─────── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async.js:25:7] + 24 │ async #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js:40:16] - 39 │ - 40 │ x = delete ((this.#m - · ─────── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-gen.js:25:7] + 24 │ * #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js:40:21] - 39 │ - 40 │ x = delete ((this.#m - · ── - 41 │ )); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-method.js:25:7] + 24 │ #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-no-reference.js:40:16] - 39 │ - 40 │ x = delete ((this.#m)); - · ─────── - 41 │ + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-set.js:25:7] + 24 │ set method(_) { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-no-reference.js:40:21] - 39 │ - 40 │ x = delete ((this.#m)); - · ── - 41 │ + × Constructor can't be an async method + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js:24:11] + 23 │ var C = class { + 24 │ async * constructor() {} + · ─────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-privatename.js:40:16] - 39 │ - 40 │ x = delete ((this.#x)); - · ─────── - 41 │ + × Constructor can't be a generator + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js:24:11] + 23 │ var C = class { + 24 │ async * constructor() {} + · ─────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-get.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Constructor can't be an async method + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-meth.js:24:9] + 23 │ var C = class { + 24 │ async constructor() {} + · ─────────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-get.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Constructor can't be a generator + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-gen.js:24:5] + 23 │ var C = class { + 24 │ * constructor() {} + · ─────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-set.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Constructor can't have get/set modifier + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-get.js:24:7] + 23 │ var C = class { + 24 │ get constructor() {} + · ─────────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-accessor-set.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Constructor can't have get/set modifier + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-set.js:24:7] + 23 │ var C = class { + 24 │ set constructor(_) {} + · ─────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-prototype.js:24:18] + 23 │ var C = class { + 24 │ static async * prototype() {} + · ───────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-super.js:25:7] + 24 │ static async * method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-prototype.js:24:16] + 23 │ var C = class { + 24 │ static async prototype() {} + · ───────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-super.js:25:7] + 24 │ static async method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-prototype.js:24:12] + 23 │ var C = class { + 24 │ static * prototype() {} + · ───────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-super.js:25:7] + 24 │ static * method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-prototype.js:24:14] + 23 │ var C = class { + 24 │ static get prototype() {} + · ───────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-super.js:25:7] + 24 │ static get method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ────── - 43 │ } + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-meth-prototype.js:24:10] + 23 │ var C = class { + 24 │ static prototype() {} + · ───────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js:42:17] - 41 │ var g = this.f; - 42 │ delete (g().#m); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-meth-super.js:25:7] + 24 │ static method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-privatename.js:42:13] - 41 │ var g = this.f; - 42 │ delete (g().#x); - · ────── - 43 │ } + × Classes can't have an element named '#constructor' + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-constructor.js:24:18] + 23 │ var C = class { + 24 │ static async * #constructor() {} + · ──────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-get.js:42:13] - 41 │ - 42 │ delete (this.#m - · ─────── - 43 │ ); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-super.js:25:7] + 24 │ static async * #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-get.js:42:18] - 41 │ - 42 │ delete (this.#m - · ── - 43 │ ); + × Classes can't have an element named '#constructor' + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-constructor.js:24:16] + 23 │ var C = class { + 24 │ static async #constructor() {} + · ──────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-set.js:42:13] - 41 │ - 42 │ delete (this.#m - · ─────── - 43 │ ); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-super.js:25:7] + 24 │ static async #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-accessor-set.js:42:18] - 41 │ - 42 │ delete (this.#m - · ── - 43 │ ); + × Classes can't have an element named '#constructor' + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-constructor.js:24:12] + 23 │ var C = class { + 24 │ static * #constructor() {} + · ──────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async-gen.js:42:13] - 41 │ - 42 │ delete (this.#m - · ─────── - 43 │ ); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-super.js:25:7] + 24 │ static * #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async.js:42:13] - 41 │ - 42 │ delete (this.#m - · ─────── - 43 │ ); + × Classes can't have an element named '#constructor' + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-constructor.js:24:10] + 23 │ var C = class { + 24 │ static #constructor() {} + · ──────────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-gen.js:42:13] - 41 │ - 42 │ delete (this.#m - · ─────── - 43 │ ); + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-super.js:25:7] + 24 │ static #method() { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js:42:13] - 41 │ - 42 │ delete (this.#m - · ─────── - 43 │ ); + × Classes can't have an element named '#constructor' + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-privatename-constructor.js:24:10] + 23 │ var C = class { + 24 │ static #constructor + · ──────────── + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js:42:18] - 41 │ - 42 │ delete (this.#m - · ── - 43 │ ); + × Classes may not have a static property named prototype + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-prototype.js:24:14] + 23 │ var C = class { + 24 │ static set prototype(_) {} + · ───────── + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js:42:13] - 41 │ - 42 │ delete (this.#m); - · ─────── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-super.js:25:7] + 24 │ static set method(_) { + 25 │ super(); + · ─────── + 26 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js:42:18] - 41 │ - 42 │ delete (this.#m); - · ── - 43 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-bad-reference.js:51:20] + 50 │ var C = class { + 51 │ f = (() => {})().#x + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-privatename.js:42:13] - 41 │ - 42 │ delete (this.#x); - · ─────── - 43 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-this.js:51:22] + 50 │ var C = class { + 51 │ f = (() => this)().#x + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-bad-reference.js:51:33] + 50 │ var C = class { + 51 │ f = function() { (() => {})().#x } + · ── + 52 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-this.js:51:35] + 50 │ var C = class { + 51 │ f = function() { (() => this)().#x } + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-bad-reference.js:51:30] + 50 │ var C = class { + 51 │ f = function() { something.#x } + · ── + 52 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-this.js:51:25] + 50 │ var C = class { + 51 │ f = function() { this.#x } + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-bad-reference.js:55:20] + 54 │ var C = class extends Parent { + 55 │ f = (() => {})().#x + · ── + 56 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-this.js:55:22] + 54 │ var C = class extends Parent { + 55 │ f = (() => this)().#x + · ── + 56 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-bad-reference.js:55:17] + 54 │ var C = class extends Parent { + 55 │ f = something.#x + · ── + 56 │ }; + ╰──── + + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-this.js:55:12] + 54 │ var C = class extends Parent { + 55 │ f = this.#x + · ── + 56 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-bad-reference.js:51:17] + 50 │ var C = class { + 51 │ f = something.#x + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-this.js:51:12] + 50 │ var C = class { + 51 │ f = this.#x + · ── + 52 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-bad-reference.js:51:22] + 50 │ var C = class { + 51 │ m() { (() => {})().#x } + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-this.js:51:24] + 50 │ var C = class { + 51 │ m() { (() => this)().#x } + · ── + 52 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-bad-reference.js:52:34] + 51 │ m() { + 52 │ function fn() { (() => {})().#x } + · ── + 53 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-this.js:52:36] + 51 │ m() { + 52 │ function fn() { (() => this)().#x } + · ── + 53 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js:36:16] - 35 │ var g = this.f; - 36 │ delete g().#m; - · ── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-bad-reference.js:52:31] + 51 │ m() { + 52 │ function fn() { something.#x } + · ── + 53 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-privatename.js:36:12] - 35 │ var g = this.f; - 36 │ delete g().#x; - · ────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-this.js:52:26] + 51 │ m() { + 52 │ function fn() { this.#x } + · ── + 53 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js:36:12] - 35 │ - 36 │ delete this.#m - · ─────── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-bad-reference.js:56:18] + 55 │ m() { + 56 │ (() => {})().#x + · ── + 57 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js:36:17] - 35 │ - 36 │ delete this.#m - · ── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-this.js:56:20] + 55 │ m() { + 56 │ (() => this)().#x + · ── + 57 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js:36:12] - 35 │ - 36 │ delete this.#m - · ─────── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-bad-reference.js:56:15] + 55 │ m() { + 56 │ something.#x + · ── + 57 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js:36:17] - 35 │ - 36 │ delete this.#m - · ── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-this.js:56:10] + 55 │ m() { + 56 │ this.#x + · ── + 57 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async-gen.js:36:12] - 35 │ - 36 │ delete this.#m - · ─────── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-bad-reference.js:51:19] + 50 │ var C = class { + 51 │ m() { something.#x } + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async.js:36:12] - 35 │ - 36 │ delete this.#m - · ─────── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-this.js:51:14] + 50 │ var C = class { + 51 │ m() { this.#x } + · ── + 52 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-gen.js:36:12] - 35 │ - 36 │ delete this.#m - · ─────── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-bad-reference.js:56:10] + 55 │ + 56 │ this.#x; + · ── + 57 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js:36:12] - 35 │ - 36 │ delete this.#m - · ─────── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-this.js:56:10] + 55 │ + 56 │ this.#x; + · ── + 57 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js:36:17] - 35 │ - 36 │ delete this.#m - · ── - 37 │ ; + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-bad-reference.js:56:10] + 55 │ + 56 │ this.#x; + · ── + 57 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js:36:12] - 35 │ - 36 │ delete this.#m; - · ─────── - 37 │ } + × Private field 'x' must be declared in an enclosing class + ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-this.js:56:10] + 55 │ + 56 │ this.#x; + · ── + 57 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js:36:17] - 35 │ - 36 │ delete this.#m; - · ── - 37 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-async-generator-cannot-escape-token.js:24:17] + 23 │ var C = class { + 24 │ async * \u0023m() { return 42; } + · ▲ + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-privatename.js:36:12] - 35 │ - 36 │ delete this.#x; - · ─────── - 37 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-async-method-cannot-escape-token.js:24:15] + 23 │ var C = class { + 24 │ async \u0023m() { return 42; } + · ▲ + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ────── - 43 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-call-exp-cannot-escape-token.js:31:17] + 30 │ method() { + 31 │ foo().\u0023field; + · ▲ + 32 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-get.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-field-cannot-escape-token.js:24:9] + 23 │ var C = class { + 24 │ \u0023field; + · ▲ + 25 │ }; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ────── - 43 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-generator-cannot-escape-token.js:24:11] + 23 │ var C = class { + 24 │ * \u0023m() { return 42; } + · ▲ + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-accessor-set.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-member-exp-cannot-escape-token.js:31:16] + 30 │ method() { + 31 │ this.\u0023field; + · ▲ + 32 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ────── - 43 │ } + × Invalid Character `#` + ╭─[language/expressions/class/elements/syntax/early-errors/private-method-cannot-escape-token.js:24:9] + 23 │ var C = class { + 24 │ \u0023m() { return 42; } + · ▲ + 25 │ }; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async-gen.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Private fields cannot be accessed on super + ╭─[language/expressions/class/elements/syntax/early-errors/super-private-access-invalid.js:34:5] + 33 │ method() { + 34 │ super.#x(); + · ──────── + 35 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ────── - 43 │ } + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/ternary-init-err-contains-arguments.js:33:19] + 32 │ var C = class { + 33 │ x = true ? {} : arguments; + · ───────── + 34 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-async.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/ternary-init-err-contains-super.js:26:19] + 25 │ var C = class { + 26 │ x = true ? {} : super(); + · ─────── + 27 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ────── - 43 │ } + × 'arguments' is not allowed in class field initializer + ╭─[language/expressions/class/elements/typeof-init-err-contains-arguments.js:33:14] + 32 │ var C = class { + 33 │ x = typeof arguments; + · ───────── + 34 │ } ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/class/elements/typeof-init-err-contains-super.js:26:14] + 25 │ var C = class { + 26 │ x = typeof super(); + · ─────── + 27 │ } ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ────── - 43 │ } - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/gen-method/array-destructuring-param-strict-body.js:156:5] + 155 │ *method([element]) { + 156 │ "use strict"; + · ───────────── + 157 │ } + ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Identifier `x` has already been declared + ╭─[language/expressions/class/gen-method/dflt-params-duplicates.js:84:11] + 83 │ 0, class { + 84 │ *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 85 │ ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-no-reference.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/gen-method/dflt-params-rest.js:88:14] + 87 │ 0, class { + 88 │ *method(...x = []) { · ────── - 43 │ } + 89 │ ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-no-reference.js:42:18] - 41 │ var g = this.f; - 42 │ delete ((g().#m)); - · ── - 43 │ } + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/gen-method/object-destructuring-param-strict-body.js:156:5] + 155 │ *method({property}) { + 156 │ "use strict"; + · ───────────── + 157 │ } + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/gen-method/rest-param-strict-body.js:156:5] + 155 │ *method(a,...rest) { + 156 │ "use strict"; + · ───────────── + 157 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/gen-method/rest-params-trailing-comma-early-error.js:81:11] + 80 │ 0, class { + 81 │ *method(...a,) { + · ──── + 82 │ ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-privatename.js:42:14] - 41 │ var g = this.f; - 42 │ delete ((g().#x)); - · ────── - 43 │ } + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class {*gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:42:14] - 41 │ - 42 │ delete ((this.#m - · ─────── - 43 │ )); + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class {*gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-get.js:42:19] - 41 │ - 42 │ delete ((this.#m - · ── - 43 │ )); + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method/yield-as-binding-identifier.js:34:9] + 33 │ var C = class {*gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:42:14] - 41 │ - 42 │ delete ((this.#m - · ─────── - 43 │ )); + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method/yield-as-binding-identifier.js:34:9] + 33 │ var C = class {*gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-accessor-set.js:42:19] - 41 │ - 42 │ delete ((this.#m - · ── - 43 │ )); + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class {*gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-async-gen.js:42:14] - 41 │ - 42 │ delete ((this.#m - · ─────── - 43 │ )); + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class {*gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-async.js:42:14] - 41 │ - 42 │ delete ((this.#m - · ─────── - 43 │ )); + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method/yield-as-identifier-reference.js:34:10] + 33 │ var C = class {*gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method-gen.js:42:14] - 41 │ - 42 │ delete ((this.#m - · ─────── - 43 │ )); + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method/yield-as-identifier-reference.js:34:10] + 33 │ var C = class {*gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js:42:14] - 41 │ - 42 │ delete ((this.#m - · ─────── - 43 │ )); + × Keywords cannot contain escape characters + ╭─[language/expressions/class/gen-method/yield-as-label-identifier-escaped.js:34:5] + 33 │ var C = class {*gen() { + 34 │ yi\u0065ld: ; + · ────────── + 35 │ }}; ╰──── - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js:42:19] - 41 │ - 42 │ delete ((this.#m - · ── - 43 │ )); + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/gen-method/yield-as-label-identifier-escaped.js:34:15] + 33 │ var C = class {*gen() { + 34 │ yi\u0065ld: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-no-reference.js:42:14] - 41 │ - 42 │ delete ((this.#m)); - · ─────── - 43 │ } + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/gen-method/yield-as-label-identifier.js:34:10] + 33 │ var C = class {*gen() { + 34 │ yield: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × Private field 'm' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-no-reference.js:42:19] - 41 │ - 42 │ delete ((this.#m)); - · ── - 43 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method/yield-identifier-spread-strict.js:40:17] + 39 │ ...(function() { + 40 │ var yield; + · ───── + 41 │ throw new Test262Error(); ╰──── - × Private fields can not be deleted - ╭─[language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-privatename.js:42:14] - 41 │ - 42 │ delete ((this.#x)); - · ─────── - 43 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method/yield-identifier-strict.js:32:13] + 31 │ (function() { + 32 │ var yield; + · ───── + 33 │ throw new Test262Error(); ╰──── - × Multiple constructor implementations are not allowed. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-class-body-ctor-duplicate.js:23:3] - 22 │ var C = class { - 23 │ constructor() {} - · ─────┬───── - · ╰── constructor has already been declared here - 24 │ constructor() {} - · ─────┬───── - · ╰── it cannot be redeclared here - 25 │ }; + × yield expression not allowed in formal parameter + ╭─[language/expressions/class/gen-method-param-dflt-yield.js:26:10] + 25 │ 0, class { + 26 │ *g(x = yield) {} + · ──┬── + · ╰── yield expression not allowed in formal parameter + 27 │ }; ╰──── - × 'super' can only be referenced in a derived class. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-ctor-super-no-heritage.js:25:9] - 24 │ - 25 │ ╭─▶ var C = class { - 26 │ │ constructor() { - 27 │ │ super(); - · │ ───── - 28 │ │ } - 29 │ ├─▶ }; - · ╰──── class does not have `extends` - ╰──── - help: either remove this super, or extend the class + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/gen-method-static/array-destructuring-param-strict-body.js:156:5] + 155 │ static *method([element]) { + 156 │ "use strict"; + · ───────────── + 157 │ } + ╰──── - × Invalid Character `` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-ues-error.js:69:9] - 68 │ var C = class { - 69 │ \u0000; - · ▲ - 70 │ }; + × Identifier `x` has already been declared + ╭─[language/expressions/class/gen-method-static/dflt-params-duplicates.js:84:18] + 83 │ 0, class { + 84 │ static *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 85 │ ╰──── - × Invalid Character `‍` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwj-error.js:69:9] - 68 │ var C = class { - 69 │ \u200D_ZWJ; - · ▲ - 70 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/gen-method-static/dflt-params-rest.js:88:21] + 87 │ 0, class { + 88 │ static *method(...x = []) { + · ────── + 89 │ ╰──── - × Invalid Character `‌` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwnj-error.js:69:9] - 68 │ var C = class { - 69 │ \u200C_ZWNJ; - · ▲ - 70 │ }; + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/gen-method-static/object-destructuring-param-strict-body.js:156:5] + 155 │ static *method({property}) { + 156 │ "use strict"; + · ───────────── + 157 │ } + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/gen-method-static/rest-param-strict-body.js:156:5] + 155 │ static *method(a,...rest) { + 156 │ "use strict"; + · ───────────── + 157 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/gen-method-static/rest-params-trailing-comma-early-error.js:81:18] + 80 │ 0, class { + 81 │ static *method(...a,) { + · ──── + 82 │ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-fields-same-line-error.js:32:4] - 31 │ var C = class { - 32 │ x y - · ▲ - 33 │ }; + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class { static *gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - help: Try insert a semicolon here - × Expected `{` but found `=>` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-array-literal.js:36:27] - 35 │ - 36 │ var C = class extends (o) => [o.#foo] - · ─┬ - · ╰── `{` expected - 37 │ { + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js:34:9] + 33 │ var C = class { static *gen() { + 34 │ var yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Private field 'foo' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js:36:68] - 35 │ - 36 │ var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } - · ──── - 37 │ { + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier.js:34:9] + 33 │ var C = class { static *gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × Private field 'bar' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js:36:93] - 35 │ - 36 │ var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } - · ──── - 37 │ { + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier.js:34:9] + 33 │ var C = class { static *gen() { + 34 │ var yield; + · ───── + 35 │ }}; ╰──── - × Private field 'fuz' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js:36:118] - 35 │ - 36 │ var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } - · ──── - 37 │ { + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class { static *gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Private identifier '#foo' is not allowed outside class bodies - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-function-expression.js:36:45] - 35 │ - 36 │ var C = class extends function() { x = this.#foo; } - · ──── - 37 │ { + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js:34:10] + 33 │ var C = class { static *gen() { + 34 │ void yi\u0065ld; + · ────────── + 35 │ }}; ╰──── - × Expected `{` but found `=>` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-obj-literal.js:36:27] - 35 │ - 36 │ var C = class extends (o) => {x: o.#foo} - · ─┬ - · ╰── `{` expected - 37 │ { + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference.js:34:10] + 33 │ var C = class { static *gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × Private field 'foo' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-recursive.js:36:54] - 35 │ - 36 │ var C = class extends class extends class { x = this.#foo; } {} - · ──── - 37 │ { + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference.js:34:10] + 33 │ var C = class { static *gen() { + 34 │ void yield; + · ───── + 35 │ }}; ╰──── - × Private field 'foo' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage.js:36:40] - 35 │ - 36 │ var C = class extends class { x = this.#foo; } - · ──── - 37 │ { + × Keywords cannot contain escape characters + ╭─[language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js:34:5] + 33 │ var C = class { static *gen() { + 34 │ yi\u0065ld: ; + · ────────── + 35 │ }}; ╰──── - × Unexpected token - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-field-on-object-destructuring.js:30:13] - 29 │ destructureX() { - 30 │ const { #x: x } = this; - · ── - 31 │ } + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js:34:15] + 33 │ var C = class { static *gen() { + 34 │ yi\u0065ld: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × Private fields cannot be accessed on super - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js:28:14] - 27 │ access() { - 28 │ return super.#m; - · ──────── - 29 │ } + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/class/gen-method-static/yield-as-label-identifier.js:34:10] + 33 │ var C = class { static *gen() { + 34 │ yield: ; + · ▲ + 35 │ }}; ╰──── + help: Try insert a semicolon here - × Private fields cannot be accessed on super - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js:32:14] - 31 │ method() { - 32 │ return super.#m(); - · ──────── - 33 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method-static/yield-identifier-spread-strict.js:40:17] + 39 │ ...(function() { + 40 │ var yield; + · ───── + 41 │ throw new Test262Error(); ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async-gen.js:24:3] - 23 │ var C = class { - 24 │ #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ async * #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/gen-method-static/yield-identifier-strict.js:32:13] + 31 │ (function() { + 32 │ var yield; + · ───── + 33 │ throw new Test262Error(); ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async.js:24:3] - 23 │ var C = class { - 24 │ #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ async #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × A 'get' accessor must not have any formal parameters. + ╭─[language/expressions/class/getter-param-dflt.js:23:17] + 22 │ + 23 │ 0, class { get a(param = null) {} }; + · ────────────── ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-gen.js:24:3] - 23 │ var C = class { - 24 │ #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ * #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/method/array-destructuring-param-strict-body.js:152:5] + 151 │ method([element]) { + 152 │ "use strict"; + · ───────────── + 153 │ } + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/class/method/dflt-params-duplicates.js:80:10] + 79 │ 0, class { + 80 │ method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 81 │ ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-field.js:24:3] - 23 │ var C = class { - 24 │ #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ get #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/method/dflt-params-rest.js:84:13] + 83 │ 0, class { + 84 │ method(...x = []) { + · ────── + 85 │ ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-get.js:24:7] - 23 │ var C = class { - 24 │ get #m() {} - · ─┬ - · ╰── `m` has already been declared here - 25 │ get #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/method/object-destructuring-param-strict-body.js:152:5] + 151 │ method({property}) { + 152 │ "use strict"; + · ───────────── + 153 │ } + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/method/rest-param-strict-body.js:152:5] + 151 │ method(a,...rest) { + 152 │ "use strict"; + · ───────────── + 153 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/method/rest-params-trailing-comma-early-error.js:76:10] + 75 │ 0, class { + 76 │ method(...a,) { + · ──── + 77 │ ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-field.js:24:3] - 23 │ var C = class { - 24 │ #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/method-param-dflt-yield.js:21:9] + 20 │ 0, class { + 21 │ m(x = yield) {} + · ───── + 22 │ }; ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-get.js:24:7] - 23 │ var C = class { - 24 │ get #m() {} - · ─┬ - · ╰── `m` has already been declared here - 25 │ #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/method-static/array-destructuring-param-strict-body.js:152:5] + 151 │ static method([element]) { + 152 │ "use strict"; + · ───────────── + 153 │ } + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/class/method-static/dflt-params-duplicates.js:80:17] + 79 │ 0, class { + 80 │ static method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 81 │ ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-meth.js:24:3] - 23 │ var C = class { - 24 │ #m() {} - · ─┬ - · ╰── `m` has already been declared here - 25 │ #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/class/method-static/dflt-params-rest.js:84:20] + 83 │ 0, class { + 84 │ static method(...x = []) { + · ────── + 85 │ ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-set.js:24:7] - 23 │ var C = class { - 24 │ set #m(_) {} - · ─┬ - · ╰── `m` has already been declared here - 25 │ #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/method-static/object-destructuring-param-strict-body.js:152:5] + 151 │ static method({property}) { + 152 │ "use strict"; + · ───────────── + 153 │ } + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/class/method-static/rest-param-strict-body.js:152:5] + 151 │ static method(a,...rest) { + 152 │ "use strict"; + · ───────────── + 153 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/class/method-static/rest-params-trailing-comma-early-error.js:76:17] + 75 │ 0, class { + 76 │ static method(...a,) { + · ──── + 77 │ ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticfield.js:24:10] - 23 │ var C = class { - 24 │ static #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × yield expression not allowed in formal parameter + ╭─[language/expressions/class/static-gen-method-param-dflt-yield.js:26:17] + 25 │ 0, class { + 26 │ static *g(x = yield) {} + · ──┬── + · ╰── yield expression not allowed in formal parameter + 27 │ }; ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticmeth.js:24:10] - 23 │ var C = class { - 24 │ static #m() {} - · ─┬ - · ╰── `m` has already been declared here - 25 │ #m() {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/class/static-init-await-binding.js:21:12] + 20 │ static { + 21 │ (class await {}); + · ───── + 22 │ } ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-field.js:24:3] - 23 │ var C = class { - 24 │ #m; - · ─┬ - · ╰── `m` has already been declared here - 25 │ set #m(_) {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × Cannot use await in class static initialization block + ╭─[language/expressions/class/static-init-await-binding.js:21:12] + 20 │ static { + 21 │ (class await {}); + · ───── + 22 │ } ╰──── - × Identifier `m` has already been declared - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-set.js:24:7] - 23 │ var C = class { - 24 │ set #m(_) {} - · ─┬ - · ╰── `m` has already been declared here - 25 │ set #m(_) {} - · ─┬ - · ╰── It can not be redeclared here - 26 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/class/static-method-param-dflt-yield.js:21:16] + 20 │ 0, class { + 21 │ static m(x = yield) {} + · ───── + 22 │ }; ╰──── - × Classes can't have an element named '#constructor' - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-constructor.js:24:3] - 23 │ var C = class { - 24 │ #constructor - · ──────────── - 25 │ }; + × Logical expressions and coalesce expressions cannot be mixed + ╭─[language/expressions/coalesce/cannot-chain-head-with-logical-and.js:31:1] + 30 │ + 31 │ 0 && 0 ?? true; + · ────────────── ╰──── + help: Wrap either expression by parentheses - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-error.js:35:4] - 34 │ var C = class { - 35 │ # x - · ─ - 36 │ }; + × Logical expressions and coalesce expressions cannot be mixed + ╭─[language/expressions/coalesce/cannot-chain-head-with-logical-or.js:31:1] + 30 │ + 31 │ 0 || 0 ?? true; + · ────────────── ╰──── + help: Wrap either expression by parentheses - × Invalid Character `` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-ues.js:63:10] - 62 │ var C = class { - 63 │ #\u0000; - · ▲ - 64 │ }; + × Logical expressions and coalesce expressions cannot be mixed + ╭─[language/expressions/coalesce/cannot-chain-tail-with-logical-and.js:32:1] + 31 │ + 32 │ 0 ?? 0 && true; + · ────────────── ╰──── + help: Wrap either expression by parentheses - × Invalid Character `‍` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwj-error.js:63:10] - 62 │ var C = class { - 63 │ #\u200D_ZWJ; - · ▲ - 64 │ + × Logical expressions and coalesce expressions cannot be mixed + ╭─[language/expressions/coalesce/cannot-chain-tail-with-logical-or.js:32:1] + 31 │ + 32 │ 0 ?? 0 || true; + · ────────────── ╰──── + help: Wrap either expression by parentheses - × Invalid Character `‌` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwnj-error.js:63:10] - 62 │ var C = class { - 63 │ #\u200C_ZWNJ; - · ▲ - 64 │ + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/11.13.2-6-1gs.js:17:1] + 16 │ + 17 │ eval *= 20; + · ──── ╰──── - × Private field 'f' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-in-computed-property-missing.js:51:9] - 50 │ var C = class { - 51 │ [this.#f] = 'Test262' - · ── - 52 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/add-arguments-strict.js:19:1] + 18 │ + 19 │ arguments += 20; + · ───────── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js:28:8] - 27 │ var C = class { - 28 │ get # m() {} - · ─ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/add-eval-strict.js:18:1] + 17 │ + 18 │ eval += 20; + · ──── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js:28:6] - 27 │ var C = class { - 28 │ get # m() {} - · ▲ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/add-non-simple.js:17:1] + 16 │ + 17 │ 1 += 1; + · ─ ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js:28:8] - 27 │ var C = class { - 28 │ set # m(_) {} - · ─ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/and-arguments-strict.js:19:1] + 18 │ + 19 │ arguments &= 20; + · ───────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js:28:6] - 27 │ var C = class { - 28 │ set # m(_) {} - · ▲ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/and-eval-strict.js:18:1] + 17 │ + 18 │ eval &= 20; + · ──── ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-gen-meth.js:28:12] - 27 │ var C = class { - 28 │ async * # m() {} - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/btws-and-non-simple.js:17:1] + 16 │ + 17 │ 1 &= 1; + · ─ ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js:28:10] - 27 │ var C = class { - 28 │ async # m() {} - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/btws-or-non-simple.js:17:1] + 16 │ + 17 │ 1 |= 1; + · ─ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js:28:8] - 27 │ var C = class { - 28 │ async # m() {} - · ▲ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/btws-xor-non-simple.js:17:1] + 16 │ + 17 │ 1 ^= 1; + · ─ ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-call-expr.js:37:15] - 36 │ m() { - 37 │ this.f().# x; - · ─ - 38 │ } + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/div-arguments-strict.js:19:1] + 18 │ + 19 │ arguments /= 20; + · ───────── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field-init.js:28:4] - 27 │ var C = class { - 28 │ # x = 1; - · ─ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/div-eval-strict.js:18:1] + 17 │ + 18 │ eval /= 20; + · ──── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field.js:28:4] - 27 │ var C = class { - 28 │ # x; - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/div-non-simple.js:17:1] + 16 │ + 17 │ 1 /= 1; + · ─ + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/left-shift-non-simple.js:17:1] + 16 │ + 17 │ 1 <<= 1; + · ─ ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-gen-meth.js:28:6] - 27 │ var C = class { - 28 │ * # m() {} - · ─ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/lshift-arguments-strict.js:19:1] + 18 │ + 19 │ arguments <<= 20; + · ───────── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-member-expr.js:32:11] - 31 │ m() { - 32 │ this.# x; - · ─ - 33 │ } + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/lshift-eval-strict.js:19:1] + 18 │ + 19 │ eval <<= 20; + · ──── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-meth.case.js:28:4] - 27 │ var C = class { - 28 │ # m() {} - · ─ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/mod-arguments-strict.js:19:1] + 18 │ + 19 │ arguments %= 20; + · ───────── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js:28:15] - 27 │ var C = class { - 28 │ static get # m() {} - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/mod-div-non-simple.js:17:1] + 16 │ + 17 │ 1 %= 1; + · ─ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js:28:13] - 27 │ var C = class { - 28 │ static get # m() {} - · ▲ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/mod-eval-strict.js:18:1] + 17 │ + 18 │ eval %= 20; + · ──── ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js:28:15] - 27 │ var C = class { - 28 │ static set # m(_) {} - · ─ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/mult-arguments-strict.js:19:1] + 18 │ + 19 │ arguments *= 20; + · ───────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js:28:13] - 27 │ var C = class { - 28 │ static set # m(_) {} - · ▲ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/mult-eval-strict.js:18:1] + 17 │ + 18 │ eval *= 20; + · ──── ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-gen-meth.js:28:19] - 27 │ var C = class { - 28 │ static async * # m() {} - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/mult-non-simple.js:17:1] + 16 │ + 17 │ 1 *= 1; + · ─ ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js:28:17] - 27 │ var C = class { - 28 │ static async # m() {} - · ─ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/or-arguments-strict.js:19:1] + 18 │ + 19 │ arguments |= 20; + · ───────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js:28:15] - 27 │ var C = class { - 28 │ static async # m() {} - · ▲ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/or-eval-strict.js:18:1] + 17 │ + 18 │ eval |= 20; + · ──── ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js:28:11] - 27 │ var C = class { - 28 │ static # x = 1; - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/right-shift-non-simple.js:17:1] + 16 │ + 17 │ 1 >>= 1; + · ─ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js:28:9] - 27 │ var C = class { - 28 │ static # x = 1; - · ▲ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/srshift-arguments-strict.js:19:1] + 18 │ + 19 │ arguments >>= 20; + · ───────── ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js:28:11] - 27 │ var C = class { - 28 │ static # x; - · ─ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/srshift-eval-strict.js:19:1] + 18 │ + 19 │ eval >>= 20; + · ──── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js:28:9] - 27 │ var C = class { - 28 │ static # x; - · ▲ - 29 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/sub-arguments-strict.js:19:1] + 18 │ + 19 │ arguments -= 20; + · ───────── ╰──── - help: Try insert a semicolon here - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-gen-meth.js:28:13] - 27 │ var C = class { - 28 │ static * # m() {} - · ─ - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/sub-eval-strict.js:18:1] + 17 │ + 18 │ eval -= 20; + · ──── ╰──── - × Invalid Character ` ` - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js:28:11] - 27 │ var C = class { - 28 │ static # m() {} - · ─ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/subtract-non-simple.js:17:1] + 16 │ + 17 │ 1 -= 1; + · ─ ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js:28:9] - 27 │ var C = class { - 28 │ static # m() {} - · ▲ - 29 │ }; + × Cannot assign to this expression + ╭─[language/expressions/compound-assignment/u-right-shift-non-simple.js:17:1] + 16 │ + 17 │ 1 >>>= 1; + · ─ ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-privatenames-same-line-error.js:35:5] - 34 │ var C = class { - 35 │ #x #y - · ▲ - 36 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/urshift-arguments-strict.js:19:1] + 18 │ + 19 │ arguments >>>= 20; + · ───────── ╰──── - help: Try insert a semicolon here - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async-gen.js:25:7] - 24 │ async * method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/urshift-eval-strict.js:19:1] + 18 │ + 19 │ eval >>>= 20; + · ──── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async.js:25:7] - 24 │ async method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/compound-assignment/xor-arguments-strict.js:19:1] + 18 │ + 19 │ arguments ^= 20; + · ───────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-gen.js:25:7] - 24 │ * method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/compound-assignment/xor-eval-strict.js:18:1] + 17 │ + 18 │ eval ^= 20; + · ──── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-get.js:25:7] - 24 │ get method() { - 25 │ super(); - · ─────── - 26 │ } + × Unexpected token + ╭─[language/expressions/conditional/in-branch-2.js:22:6] + 21 │ + 22 │ for (true ? 0 : 0 in {}; false; ) ; + · ──────────── + ╰──── + + × Unexpected token + ╭─[language/expressions/conditional/in-condition.js:22:6] + 21 │ + 22 │ for ('' in {} ? 0 : 0; false; ) ; + · ── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-method.js:25:7] - 24 │ method() { - 25 │ super(); - · ─────── - 26 │ } + × Delete of an unqualified identifier in strict mode. + ╭─[language/expressions/delete/identifier-strict-recursive.js:18:10] + 17 │ + 18 │ delete ((identifier)); + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async-gen.js:25:7] - 24 │ async * #method() { - 25 │ super(); - · ─────── - 26 │ } + × Delete of an unqualified identifier in strict mode. + ╭─[language/expressions/delete/identifier-strict.js:17:8] + 16 │ + 17 │ delete test262identifier; + · ───────────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async.js:25:7] - 24 │ async #method() { - 25 │ super(); - · ─────── - 26 │ } + × Keywords cannot contain escape characters + ╭─[language/expressions/dynamic-import/escape-sequence-import.js:35:1] + 34 │ + 35 │ im\u0070ort('./empty_FIXTURE.js'); + · ─────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-gen.js:25:7] - 24 │ * #method() { - 25 │ super(); - · ─────── - 26 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/dynamic-import/import-assertions/2nd-param-yield-ident-invalid.js:19:30] + 18 │ + 19 │ import('./empty_FIXTURE.js', yield); + · ───── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-method.js:25:7] - 24 │ #method() { - 25 │ super(); - · ─────── - 26 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/dynamic-import/import-attributes/2nd-param-yield-ident-invalid.js:19:30] + 18 │ + 19 │ import('./empty_FIXTURE.js', yield); + · ───── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-set.js:25:7] - 24 │ set method(_) { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-1-update-expression.js:46:1] + 45 │ + 46 │ import('')++ + · ────────── ╰──── - × Constructor can't be an async method - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js:24:11] - 23 │ var C = class { - 24 │ async * constructor() {} - · ─────────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-10-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') -= 1; + · ────────── ╰──── - × Constructor can't be a generator - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js:24:11] - 23 │ var C = class { - 24 │ async * constructor() {} - · ─────────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-11-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') <<= 1; + · ────────── ╰──── - × Constructor can't be an async method - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-meth.js:24:9] - 23 │ var C = class { - 24 │ async constructor() {} - · ─────────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-12-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') >>= 1; + · ────────── ╰──── - × Constructor can't be a generator - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-gen.js:24:5] - 23 │ var C = class { - 24 │ * constructor() {} - · ─────────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-13-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') >>>= 1; + · ────────── ╰──── - × Constructor can't have get/set modifier - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-get.js:24:7] - 23 │ var C = class { - 24 │ get constructor() {} - · ─────────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-14-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') &= 1; + · ────────── ╰──── - × Constructor can't have get/set modifier - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-set.js:24:7] - 23 │ var C = class { - 24 │ set constructor(_) {} - · ─────────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-15-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') ^= 1; + · ────────── ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-prototype.js:24:18] - 23 │ var C = class { - 24 │ static async * prototype() {} - · ───────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-16-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') |= 1; + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-super.js:25:7] - 24 │ static async * method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-17-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') **= 1; + · ────────── ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-prototype.js:24:16] - 23 │ var C = class { - 24 │ static async prototype() {} - · ───────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-2-update-expression.js:46:1] + 45 │ + 46 │ import('')-- + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-super.js:25:7] - 24 │ static async method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-3-update-expression.js:46:3] + 45 │ + 46 │ ++import('') + · ────────── ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-prototype.js:24:12] - 23 │ var C = class { - 24 │ static * prototype() {} - · ───────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-4-update-expression.js:46:3] + 45 │ + 46 │ --import('') + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-super.js:25:7] - 24 │ static * method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-5-lhs-equals-assignment-expression.js:48:1] + 47 │ + 48 │ import('') = 1; + · ────────── ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-prototype.js:24:14] - 23 │ var C = class { - 24 │ static get prototype() {} - · ───────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-6-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') *= 1; + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-super.js:25:7] - 24 │ static get method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-7-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') /= 1; + · ────────── ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-meth-prototype.js:24:10] - 23 │ var C = class { - 24 │ static prototype() {} - · ───────── - 25 │ }; + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-8-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') %= 1; + · ────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-meth-super.js:25:7] - 24 │ static method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot assign to this expression + ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-9-lhs-assignment-operator-assignment-expression.js:48:1] + 47 │ + 48 │ import('') += 1; + · ────────── ╰──── - × Classes can't have an element named '#constructor' - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-constructor.js:24:18] - 23 │ var C = class { - 24 │ static async * #constructor() {} - · ──────────── - 25 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expr-not-optional.js:34:10] + 33 │ let f = () => { + 34 │ import(); + · ─ + 35 │ }; + ╰──── + + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-assignment-expr-not-optional.js:33:22] + 32 │ + 33 │ let f = () => import(); + · ─ + 34 │ ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-super.js:25:7] - 24 │ static async * #method() { - 25 │ super(); - · ─────── - 26 │ } + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-new-call-expression.js:36:19] + 35 │ + 36 │ let f = () => new import(''); + · ────────── ╰──── - × Classes can't have an element named '#constructor' - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-constructor.js:24:16] - 23 │ var C = class { - 24 │ static async #constructor() {} - · ──────────── - 25 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-rest-param.js:41:22] + 40 │ + 41 │ let f = () => import(...['']); + · ─── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-super.js:25:7] - 24 │ static async #method() { - 25 │ super(); - · ─────── - 26 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-not-extensible-args.js:38:48] + 37 │ + 38 │ let f = () => import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected ╰──── - × Classes can't have an element named '#constructor' - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-constructor.js:24:12] - 23 │ var C = class { - 24 │ static * #constructor() {} - · ──────────── - 25 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-new-call-expression.js:37:7] + 36 │ let f = () => { + 37 │ new import(''); + · ────────── + 38 │ }; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-super.js:25:7] - 24 │ static * #method() { - 25 │ super(); - · ─────── - 26 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-rest-param.js:42:10] + 41 │ let f = () => { + 42 │ import(...['']); + · ─── + 43 │ }; ╰──── - × Classes can't have an element named '#constructor' - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-constructor.js:24:10] - 23 │ var C = class { - 24 │ static #constructor() {} - · ──────────── - 25 │ }; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-not-extensible-args.js:39:36] + 38 │ let f = () => { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ }; ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-super.js:25:7] - 24 │ static #method() { - 25 │ super(); - · ─────── - 26 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-assignment-expr-not-optional.js:34:16] + 33 │ (async () => { + 34 │ await import() + · ─ + 35 │ }); ╰──── - × Classes can't have an element named '#constructor' - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-privatename-constructor.js:24:10] - 23 │ var C = class { - 24 │ static #constructor - · ──────────── - 25 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-new-call-expression.js:37:13] + 36 │ (async () => { + 37 │ await new import('') + · ────────── + 38 │ }); ╰──── - × Classes may not have a static property named prototype - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-prototype.js:24:14] - 23 │ var C = class { - 24 │ static set prototype(_) {} - · ───────── - 25 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-rest-param.js:42:16] + 41 │ (async () => { + 42 │ await import(...['']) + · ─── + 43 │ }); ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-super.js:25:7] - 24 │ static set method(_) { - 25 │ super(); - · ─────── - 26 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-not-extensible-args.js:39:42] + 38 │ (async () => { + 39 │ await import('./empty_FIXTURE.js', {}, '') + · ─┬ + · ╰── `)` expected + 40 │ }); ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-bad-reference.js:51:20] - 50 │ var C = class { - 51 │ f = (() => {})().#x - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-assignment-expr-not-optional.js:33:27] + 32 │ + 33 │ (async () => await import()) + · ─ + 34 │ ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-this.js:51:22] - 50 │ var C = class { - 51 │ f = (() => this)().#x - · ── - 52 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-new-call-expression.js:36:24] + 35 │ + 36 │ (async () => await new import('')) + · ────────── ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-bad-reference.js:51:33] - 50 │ var C = class { - 51 │ f = function() { (() => {})().#x } - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-rest-param.js:41:27] + 40 │ + 41 │ (async () => await import(...[''])) + · ─── ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-this.js:51:35] - 50 │ var C = class { - 51 │ f = function() { (() => this)().#x } - · ── - 52 │ }; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-not-extensible-args.js:38:53] + 37 │ + 38 │ (async () => await import('./empty_FIXTURE.js', {}, '')) + · ─┬ + · ╰── `)` expected ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-bad-reference.js:51:30] - 50 │ var C = class { - 51 │ f = function() { something.#x } - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-assignment-expr-not-optional.js:34:10] + 33 │ async function f() { + 34 │ import(); + · ─ + 35 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-this.js:51:25] - 50 │ var C = class { - 51 │ f = function() { this.#x } - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-assignment-expr-not-optional.js:34:16] + 33 │ async function f() { + 34 │ await import(); + · ─ + 35 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-bad-reference.js:55:20] - 54 │ var C = class extends Parent { - 55 │ f = (() => {})().#x - · ── - 56 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-new-call-expression.js:37:13] + 36 │ async function f() { + 37 │ await new import(''); + · ────────── + 38 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-this.js:55:22] - 54 │ var C = class extends Parent { - 55 │ f = (() => this)().#x - · ── - 56 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-rest-param.js:42:16] + 41 │ async function f() { + 42 │ await import(...['']); + · ─── + 43 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-bad-reference.js:55:17] - 54 │ var C = class extends Parent { - 55 │ f = something.#x - · ── - 56 │ }; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-not-extensible-args.js:39:42] + 38 │ async function f() { + 39 │ await import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-this.js:55:12] - 54 │ var C = class extends Parent { - 55 │ f = this.#x - · ── - 56 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-new-call-expression.js:37:7] + 36 │ async function f() { + 37 │ new import(''); + · ────────── + 38 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-bad-reference.js:51:17] - 50 │ var C = class { - 51 │ f = something.#x - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-rest-param.js:42:10] + 41 │ async function f() { + 42 │ import(...['']); + · ─── + 43 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-this.js:51:12] - 50 │ var C = class { - 51 │ f = this.#x - · ── - 52 │ }; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-not-extensible-args.js:39:36] + 38 │ async function f() { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-bad-reference.js:51:22] - 50 │ var C = class { - 51 │ m() { (() => {})().#x } - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-assignment-expr-not-optional.js:34:23] + 33 │ async function f() { + 34 │ return await import(); + · ─ + 35 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-this.js:51:24] - 50 │ var C = class { - 51 │ m() { (() => this)().#x } - · ── - 52 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-new-call-expression.js:37:20] + 36 │ async function f() { + 37 │ return await new import(''); + · ────────── + 38 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-bad-reference.js:52:34] - 51 │ m() { - 52 │ function fn() { (() => {})().#x } - · ── - 53 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-rest-param.js:42:23] + 41 │ async function f() { + 42 │ return await import(...['']); + · ─── + 43 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-this.js:52:36] - 51 │ m() { - 52 │ function fn() { (() => this)().#x } - · ── - 53 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-not-extensible-args.js:39:49] + 38 │ async function f() { + 39 │ return await import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-bad-reference.js:52:31] - 51 │ m() { - 52 │ function fn() { something.#x } - · ── - 53 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-assignment-expr-not-optional.js:34:16] + 33 │ async function * f() { + 34 │ await import() + · ─ + 35 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-this.js:52:26] - 51 │ m() { - 52 │ function fn() { this.#x } - · ── - 53 │ } + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-new-call-expression.js:37:13] + 36 │ async function * f() { + 37 │ await new import('') + · ────────── + 38 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-bad-reference.js:56:18] - 55 │ m() { - 56 │ (() => {})().#x - · ── - 57 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-rest-param.js:42:16] + 41 │ async function * f() { + 42 │ await import(...['']) + · ─── + 43 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-this.js:56:20] - 55 │ m() { - 56 │ (() => this)().#x - · ── - 57 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-not-extensible-args.js:39:42] + 38 │ async function * f() { + 39 │ await import('./empty_FIXTURE.js', {}, '') + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-bad-reference.js:56:15] - 55 │ m() { - 56 │ something.#x - · ── - 57 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-assignment-expr-not-optional.js:34:10] + 33 │ { + 34 │ import(); + · ─ + 35 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-this.js:56:10] - 55 │ m() { - 56 │ this.#x - · ── - 57 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-assignment-expr-not-optional.js:34:10] + 33 │ label: { + 34 │ import(); + · ─ + 35 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-bad-reference.js:51:19] - 50 │ var C = class { - 51 │ m() { something.#x } - · ── - 52 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-new-call-expression.js:37:7] + 36 │ label: { + 37 │ new import(''); + · ────────── + 38 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-this.js:51:14] - 50 │ var C = class { - 51 │ m() { this.#x } - · ── - 52 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-rest-param.js:42:10] + 41 │ label: { + 42 │ import(...['']); + · ─── + 43 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-bad-reference.js:56:10] - 55 │ - 56 │ this.#x; - · ── - 57 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-not-extensible-args.js:39:36] + 38 │ label: { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-this.js:56:10] - 55 │ - 56 │ this.#x; - · ── - 57 │ } + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-no-new-call-expression.js:37:7] + 36 │ { + 37 │ new import(''); + · ────────── + 38 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-bad-reference.js:56:10] - 55 │ - 56 │ this.#x; - · ── - 57 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-no-rest-param.js:42:10] + 41 │ { + 42 │ import(...['']); + · ─── + 43 │ }; ╰──── - × Private field 'x' must be declared in an enclosing class - ╭─[language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-this.js:56:10] - 55 │ - 56 │ this.#x; - · ── - 57 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-not-extensible-args.js:39:36] + 38 │ { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ }; ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-async-generator-cannot-escape-token.js:24:17] - 23 │ var C = class { - 24 │ async * \u0023m() { return 42; } - · ▲ - 25 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-assignment-expr-not-optional.js:34:10] + 33 │ do { + 34 │ import(); + · ─ + 35 │ } while (false); ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-async-method-cannot-escape-token.js:24:15] - 23 │ var C = class { - 24 │ async \u0023m() { return 42; } - · ▲ - 25 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-new-call-expression.js:37:7] + 36 │ do { + 37 │ new import(''); + · ────────── + 38 │ } while (false); ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-call-exp-cannot-escape-token.js:31:17] - 30 │ method() { - 31 │ foo().\u0023field; - · ▲ - 32 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-rest-param.js:42:10] + 41 │ do { + 42 │ import(...['']); + · ─── + 43 │ } while (false); ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-field-cannot-escape-token.js:24:9] - 23 │ var C = class { - 24 │ \u0023field; - · ▲ - 25 │ }; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-not-extensible-args.js:39:36] + 38 │ do { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } while (false); ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-generator-cannot-escape-token.js:24:11] - 23 │ var C = class { - 24 │ * \u0023m() { return 42; } - · ▲ - 25 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-assignment-expr-not-optional.js:36:10] + 35 │ } else { + 36 │ import(); + · ─ + 37 │ } ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-member-exp-cannot-escape-token.js:31:16] - 30 │ method() { - 31 │ this.\u0023field; - · ▲ - 32 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-assignment-expr-not-optional.js:35:15] + 34 │ + 35 │ } else import(); + · ─ + 36 │ ╰──── - × Invalid Character `#` - ╭─[language/expressions/class/elements/syntax/early-errors/private-method-cannot-escape-token.js:24:9] - 23 │ var C = class { - 24 │ \u0023m() { return 42; } - · ▲ - 25 │ }; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-new-call-expression.js:38:12] + 37 │ + 38 │ } else new import(''); + · ────────── ╰──── - × Private fields cannot be accessed on super - ╭─[language/expressions/class/elements/syntax/early-errors/super-private-access-invalid.js:34:5] - 33 │ method() { - 34 │ super.#x(); - · ──────── - 35 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-rest-param.js:43:15] + 42 │ + 43 │ } else import(...['']); + · ─── ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/ternary-init-err-contains-arguments.js:33:19] - 32 │ var C = class { - 33 │ x = true ? {} : arguments; - · ───────── - 34 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-not-extensible-args.js:40:41] + 39 │ + 40 │ } else import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/ternary-init-err-contains-super.js:26:19] - 25 │ var C = class { - 26 │ x = true ? {} : super(); - · ─────── - 27 │ } + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-no-new-call-expression.js:39:7] + 38 │ } else { + 39 │ new import(''); + · ────────── + 40 │ } ╰──── - × 'arguments' is not allowed in class field initializer - ╭─[language/expressions/class/elements/typeof-init-err-contains-arguments.js:33:14] - 32 │ var C = class { - 33 │ x = typeof arguments; - · ───────── - 34 │ } + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-no-rest-param.js:44:10] + 43 │ } else { + 44 │ import(...['']); + · ─── + 45 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/class/elements/typeof-init-err-contains-super.js:26:14] - 25 │ var C = class { - 26 │ x = typeof super(); - · ─────── - 27 │ } + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-not-extensible-args.js:41:36] + 40 │ } else { + 41 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 42 │ } ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/gen-method/array-destructuring-param-strict-body.js:156:5] - 155 │ *method([element]) { - 156 │ "use strict"; - · ───────────── - 157 │ } - ╰──── - - × Identifier `x` has already been declared - ╭─[language/expressions/class/gen-method/dflt-params-duplicates.js:84:11] - 83 │ 0, class { - 84 │ *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 85 │ + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-assignment-expr-not-optional.js:34:10] + 33 │ function fn() { + 34 │ import(); + · ─ + 35 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/gen-method/dflt-params-rest.js:88:14] - 87 │ 0, class { - 88 │ *method(...x = []) { - · ────── - 89 │ + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-no-new-call-expression.js:37:7] + 36 │ function fn() { + 37 │ new import(''); + · ────────── + 38 │ } ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/gen-method/object-destructuring-param-strict-body.js:156:5] - 155 │ *method({property}) { - 156 │ "use strict"; - · ───────────── - 157 │ } - ╰──── + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-no-rest-param.js:42:10] + 41 │ function fn() { + 42 │ import(...['']); + · ─── + 43 │ } + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/gen-method/rest-param-strict-body.js:156:5] - 155 │ *method(a,...rest) { - 156 │ "use strict"; - · ───────────── - 157 │ } - ╰──── + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-not-extensible-args.js:39:36] + 38 │ function fn() { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/gen-method/rest-params-trailing-comma-early-error.js:81:11] - 80 │ 0, class { - 81 │ *method(...a,) { - · ──── - 82 │ + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-assignment-expr-not-optional.js:34:17] + 33 │ function fn() { + 34 │ return import(); + · ─ + 35 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class {*gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-new-call-expression.js:37:14] + 36 │ function fn() { + 37 │ return new import(''); + · ────────── + 38 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class {*gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-rest-param.js:42:17] + 41 │ function fn() { + 42 │ return import(...['']); + · ─── + 43 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method/yield-as-binding-identifier.js:34:9] - 33 │ var C = class {*gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-not-extensible-args.js:39:43] + 38 │ function fn() { + 39 │ return import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method/yield-as-binding-identifier.js:34:9] - 33 │ var C = class {*gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-assignment-expr-not-optional.js:34:10] + 33 │ if (true) { + 34 │ import(); + · ─ + 35 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class {*gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-assignment-expr-not-optional.js:33:18] + 32 │ + 33 │ if (true) import(); + · ─ + 34 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class {*gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-new-call-expression.js:36:15] + 35 │ + 36 │ if (true) new import(''); + · ────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method/yield-as-identifier-reference.js:34:10] - 33 │ var C = class {*gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-rest-param.js:41:18] + 40 │ + 41 │ if (true) import(...['']); + · ─── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method/yield-as-identifier-reference.js:34:10] - 33 │ var C = class {*gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-not-extensible-args.js:38:44] + 37 │ + 38 │ if (true) import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/class/gen-method/yield-as-label-identifier-escaped.js:34:5] - 33 │ var C = class {*gen() { - 34 │ yi\u0065ld: ; - · ────────── - 35 │ }}; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-no-new-call-expression.js:37:7] + 36 │ if (true) { + 37 │ new import(''); + · ────────── + 38 │ } ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/gen-method/yield-as-label-identifier-escaped.js:34:15] - 33 │ var C = class {*gen() { - 34 │ yi\u0065ld: ; - · ▲ - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-no-rest-param.js:42:10] + 41 │ if (true) { + 42 │ import(...['']); + · ─── + 43 │ } ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/gen-method/yield-as-label-identifier.js:34:10] - 33 │ var C = class {*gen() { - 34 │ yield: ; - · ▲ - 35 │ }}; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-not-extensible-args.js:39:36] + 38 │ if (true) { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method/yield-identifier-spread-strict.js:40:17] - 39 │ ...(function() { - 40 │ var yield; - · ───── - 41 │ throw new Test262Error(); + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-assignment-expr-not-optional.js:36:10] + 35 │ x++; + 36 │ import(); + · ─ + 37 │ }; ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method/yield-identifier-strict.js:32:13] - 31 │ (function() { - 32 │ var yield; - · ───── - 33 │ throw new Test262Error(); + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-no-new-call-expression.js:39:7] + 38 │ x++; + 39 │ new import(''); + · ────────── + 40 │ }; ╰──── - × yield expression not allowed in formal parameter - ╭─[language/expressions/class/gen-method-param-dflt-yield.js:26:10] - 25 │ 0, class { - 26 │ *g(x = yield) {} - · ──┬── - · ╰── yield expression not allowed in formal parameter - 27 │ }; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-no-rest-param.js:44:10] + 43 │ x++; + 44 │ import(...['']); + · ─── + 45 │ }; ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/gen-method-static/array-destructuring-param-strict-body.js:156:5] - 155 │ static *method([element]) { - 156 │ "use strict"; - · ───────────── - 157 │ } - ╰──── + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-not-extensible-args.js:41:36] + 40 │ x++; + 41 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 42 │ }; + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/class/gen-method-static/dflt-params-duplicates.js:84:18] - 83 │ 0, class { - 84 │ static *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 85 │ + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-assignment-expr-not-optional.js:34:10] + 33 │ with ({}) { + 34 │ import(); + · ─ + 35 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/class/gen-method-static/dflt-params-rest.js:88:21] - 87 │ 0, class { - 88 │ static *method(...x = []) { - · ────── - 89 │ + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-assignment-expr-not-optional.js:33:14] + 32 │ + 33 │ with (import()) {} + · ─ + 34 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/gen-method-static/object-destructuring-param-strict-body.js:156:5] - 155 │ static *method({property}) { - 156 │ "use strict"; - · ───────────── - 157 │ } - ╰──── + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-new-call-expression.js:36:11] + 35 │ + 36 │ with (new import('')) {} + · ────────── + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/gen-method-static/rest-param-strict-body.js:156:5] - 155 │ static *method(a,...rest) { - 156 │ "use strict"; - · ───────────── - 157 │ } - ╰──── + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-rest-param.js:41:14] + 40 │ + 41 │ with (import(...[''])) {} + · ─── + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/gen-method-static/rest-params-trailing-comma-early-error.js:81:18] - 80 │ 0, class { - 81 │ static *method(...a,) { - · ──── - 82 │ + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-not-extensible-args.js:38:40] + 37 │ + 38 │ with (import('./empty_FIXTURE.js', {}, '')) {} + · ─┬ + · ╰── `)` expected ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class { static *gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-no-new-call-expression.js:37:7] + 36 │ with ({}) { + 37 │ new import(''); + · ────────── + 38 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js:34:9] - 33 │ var C = class { static *gen() { - 34 │ var yi\u0065ld; - · ────────── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-no-rest-param.js:42:10] + 41 │ with ({}) { + 42 │ import(...['']); + · ─── + 43 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier.js:34:9] - 33 │ var C = class { static *gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-not-extensible-args.js:39:36] + 38 │ with ({}) { + 39 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected + 40 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method-static/yield-as-binding-identifier.js:34:9] - 33 │ var C = class { static *gen() { - 34 │ var yield; - · ───── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-assignment-expr-not-optional.js:23:8] + 22 │ + 23 │ import(); + · ─ + 24 │ ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class { static *gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Cannot use new with dynamic import + ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-no-new-call-expression.js:26:5] + 25 │ + 26 │ new import(''); + · ────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js:34:10] - 33 │ var C = class { static *gen() { - 34 │ void yi\u0065ld; - · ────────── - 35 │ }}; + × Unexpected token + ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-no-rest-param.js:31:8] + 30 │ + 31 │ import(...['']); + · ─── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference.js:34:10] - 33 │ var C = class { static *gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Expected `)` but found `string` + ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-not-extensible-args.js:28:34] + 27 │ + 28 │ import('./empty_FIXTURE.js', {}, ''); + · ─┬ + · ╰── `)` expected ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method-static/yield-as-identifier-reference.js:34:10] - 33 │ var C = class { static *gen() { - 34 │ void yield; - · ───── - 35 │ }}; + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-bitnot-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ ~3 ** 2; + · ─────── ╰──── + help: Wrap unary expression in parentheses to enforce operator precedence - × Keywords cannot contain escape characters - ╭─[language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js:34:5] - 33 │ var C = class { static *gen() { - 34 │ yi\u0065ld: ; - · ────────── - 35 │ }}; + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-delete-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ delete o.p ** 2; + · ─────────────── ╰──── + help: Wrap unary expression in parentheses to enforce operator precedence - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js:34:15] - 33 │ var C = class { static *gen() { - 34 │ yi\u0065ld: ; - · ▲ - 35 │ }}; + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-logical-not-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ !1 ** 2; + · ─────── ╰──── - help: Try insert a semicolon here + help: Wrap unary expression in parentheses to enforce operator precedence - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/class/gen-method-static/yield-as-label-identifier.js:34:10] - 33 │ var C = class { static *gen() { - 34 │ yield: ; - · ▲ - 35 │ }}; + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-negate-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ -3 ** 2; + · ─────── ╰──── - help: Try insert a semicolon here + help: Wrap unary expression in parentheses to enforce operator precedence - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method-static/yield-identifier-spread-strict.js:40:17] - 39 │ ...(function() { - 40 │ var yield; - · ───── - 41 │ throw new Test262Error(); + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-plus-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ +1 ** 2; + · ─────── ╰──── + help: Wrap unary expression in parentheses to enforce operator precedence - × The keyword 'yield' is reserved - ╭─[language/expressions/class/gen-method-static/yield-identifier-strict.js:32:13] - 31 │ (function() { - 32 │ var yield; - · ───── - 33 │ throw new Test262Error(); + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-typeof-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ typeof 1 ** 2; + · ───────────── ╰──── + help: Wrap unary expression in parentheses to enforce operator precedence - × A 'get' accessor must not have any formal parameters. - ╭─[language/expressions/class/getter-param-dflt.js:23:17] - 22 │ - 23 │ 0, class { get a(param = null) {} }; - · ────────────── + × Unexpected exponentiation expression + ╭─[language/expressions/exponentiation/exp-operator-syntax-error-void-unary-expression-base.js:25:1] + 24 │ $DONOTEVALUATE(); + 25 │ void 1 ** 2; + · ─────────── ╰──── + help: Wrap unary expression in parentheses to enforce operator precedence × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/method/array-destructuring-param-strict-body.js:152:5] - 151 │ method([element]) { - 152 │ "use strict"; - · ───────────── - 153 │ } + ╭─[language/expressions/function/array-destructuring-param-strict-body.js:131:3] + 130 │ 0, function([element]) { + 131 │ "use strict"; + · ───────────── + 132 │ }; ╰──── × Identifier `x` has already been declared - ╭─[language/expressions/class/method/dflt-params-duplicates.js:80:10] - 79 │ 0, class { - 80 │ method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 81 │ + ╭─[language/expressions/function/dflt-params-duplicates.js:59:13] + 58 │ + 59 │ 0, function(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 60 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/class/method/dflt-params-rest.js:84:13] - 83 │ 0, class { - 84 │ method(...x = []) { - · ────── - 85 │ + ╭─[language/expressions/function/dflt-params-rest.js:63:16] + 62 │ + 63 │ 0, function(...x = []) { + · ────── + 64 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/method/object-destructuring-param-strict-body.js:152:5] - 151 │ method({property}) { - 152 │ "use strict"; - · ───────────── - 153 │ } - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/function/dstr/ary-ptrn-rest-init-ary.js:53:18] + 52 │ var f; + 53 │ f = function([...[ x ] = []]) { + · ────────── + 54 │ + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/method/rest-param-strict-body.js:152:5] - 151 │ method(a,...rest) { - 152 │ "use strict"; - · ───────────── - 153 │ } - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/function/dstr/ary-ptrn-rest-init-id.js:53:18] + 52 │ var f; + 53 │ f = function([...x = []]) { + · ────── + 54 │ + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/method/rest-params-trailing-comma-early-error.js:76:10] - 75 │ 0, class { - 76 │ method(...a,) { - · ──── - 77 │ + × A rest parameter cannot have an initializer + ╭─[language/expressions/function/dstr/ary-ptrn-rest-init-obj.js:53:18] + 52 │ var f; + 53 │ f = function([...{ x } = []]) { + · ────────── + 54 │ ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/method-param-dflt-yield.js:21:9] - 20 │ 0, class { - 21 │ m(x = yield) {} - · ───── - 22 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/function/dstr/ary-ptrn-rest-not-final-ary.js:53:15] + 52 │ var f; + 53 │ f = function([...[x], y]) { + · ────── + 54 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/method-static/array-destructuring-param-strict-body.js:152:5] - 151 │ static method([element]) { - 152 │ "use strict"; - · ───────────── - 153 │ } - ╰──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/function/dstr/ary-ptrn-rest-not-final-id.js:53:15] + 52 │ var f; + 53 │ f = function([...x, y]) { + · ──── + 54 │ + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/class/method-static/dflt-params-duplicates.js:80:17] - 79 │ 0, class { - 80 │ static method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 81 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/function/dstr/ary-ptrn-rest-not-final-obj.js:53:15] + 52 │ var f; + 53 │ f = function([...{ x }, y]) { + · ──────── + 54 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/class/method-static/dflt-params-rest.js:84:20] - 83 │ 0, class { - 84 │ static method(...x = []) { - · ────── - 85 │ + ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-init-ary.js:53:18] + 52 │ var f; + 53 │ f = function([...[ x ] = []] = []) { + · ────────── + 54 │ ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/method-static/object-destructuring-param-strict-body.js:152:5] - 151 │ static method({property}) { - 152 │ "use strict"; - · ───────────── - 153 │ } - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-init-id.js:53:18] + 52 │ var f; + 53 │ f = function([...x = []] = []) { + · ────── + 54 │ + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/class/method-static/rest-param-strict-body.js:152:5] - 151 │ static method(a,...rest) { - 152 │ "use strict"; - · ───────────── - 153 │ } - ╰──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-init-obj.js:53:18] + 52 │ var f; + 53 │ f = function([...{ x } = []] = []) { + · ────────── + 54 │ + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/class/method-static/rest-params-trailing-comma-early-error.js:76:17] - 75 │ 0, class { - 76 │ static method(...a,) { - · ──── - 77 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-ary.js:53:15] + 52 │ var f; + 53 │ f = function([...[x], y] = [1, 2, 3]) { + · ────── + 54 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-id.js:53:15] + 52 │ var f; + 53 │ f = function([...x, y] = [1, 2, 3]) { + · ──── + 54 │ + ╰──── + + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-obj.js:53:15] + 52 │ var f; + 53 │ f = function([...{ x }, y] = [1, 2, 3]) { + · ──────── + 54 │ ╰──── - × yield expression not allowed in formal parameter - ╭─[language/expressions/class/static-gen-method-param-dflt-yield.js:26:17] - 25 │ 0, class { - 26 │ static *g(x = yield) {} - · ──┬── - · ╰── yield expression not allowed in formal parameter - 27 │ }; + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/function/early-body-super-call.js:17:3] + 16 │ 0, function() { + 17 │ super(); + · ─────── + 18 │ }; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/class/static-init-await-binding.js:21:12] - 20 │ static { - 21 │ (class await {}); - · ───── - 22 │ } + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/function/early-body-super-prop.js:17:3] + 16 │ 0, function() { + 17 │ super.x; + · ───── + 18 │ }; ╰──── - × Cannot use await in class static initialization block - ╭─[language/expressions/class/static-init-await-binding.js:21:12] - 20 │ static { - 21 │ (class await {}); - · ───── - 22 │ } + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/expressions/function/early-errors/invalid-names-call-expression-bad-reference.js:40:36] + 39 │ + 40 │ var fn = function() { (() => {})().#x }; + · ── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/class/static-method-param-dflt-yield.js:21:16] - 20 │ 0, class { - 21 │ static m(x = yield) {} - · ───── - 22 │ }; + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/expressions/function/early-errors/invalid-names-call-expression-this.js:40:38] + 39 │ + 40 │ var fn = function() { (() => this)().#x }; + · ── ╰──── - × Logical expressions and coalesce expressions cannot be mixed - ╭─[language/expressions/coalesce/cannot-chain-head-with-logical-and.js:31:1] - 30 │ - 31 │ 0 && 0 ?? true; - · ────────────── + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/expressions/function/early-errors/invalid-names-member-expression-bad-reference.js:40:33] + 39 │ + 40 │ var fn = function() { something.#x }; + · ── ╰──── - help: Wrap either expression by parentheses - × Logical expressions and coalesce expressions cannot be mixed - ╭─[language/expressions/coalesce/cannot-chain-head-with-logical-or.js:31:1] - 30 │ - 31 │ 0 || 0 ?? true; - · ────────────── + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/expressions/function/early-errors/invalid-names-member-expression-this.js:40:28] + 39 │ + 40 │ var fn = function() { this.#x }; + · ── ╰──── - help: Wrap either expression by parentheses - × Logical expressions and coalesce expressions cannot be mixed - ╭─[language/expressions/coalesce/cannot-chain-tail-with-logical-and.js:32:1] - 31 │ - 32 │ 0 ?? 0 && true; - · ────────────── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/function/early-params-super-call.js:16:17] + 15 │ + 16 │ 0, function(x = super()) {}; + · ─────── ╰──── - help: Wrap either expression by parentheses - × Logical expressions and coalesce expressions cannot be mixed - ╭─[language/expressions/coalesce/cannot-chain-tail-with-logical-or.js:32:1] - 31 │ - 32 │ 0 ?? 0 || true; - · ────────────── + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/expressions/function/early-params-super-prop.js:16:17] + 15 │ + 16 │ 0, function(x = super.x) {}; + · ───── ╰──── - help: Wrap either expression by parentheses - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/11.13.2-6-1gs.js:17:1] - 16 │ - 17 │ eval *= 20; - · ──── + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/function/name-arguments-strict-body.js:18:11] + 17 │ + 18 │ (function arguments() {'use strict';}); + · ───────── ╰──── × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/add-arguments-strict.js:19:1] - 18 │ - 19 │ arguments += 20; - · ───────── + ╭─[language/expressions/function/name-arguments-strict.js:17:11] + 16 │ + 17 │ (function arguments() {}); + · ───────── ╰──── × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/add-eval-strict.js:18:1] + ╭─[language/expressions/function/name-eval-strict-body.js:18:11] 17 │ - 18 │ eval += 20; - · ──── + 18 │ (function eval() {'use strict';}); + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/add-non-simple.js:17:1] + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/function/name-eval-strict.js:17:11] 16 │ - 17 │ 1 += 1; - · ─ + 17 │ (function eval() {}); + · ──── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/and-arguments-strict.js:19:1] - 18 │ - 19 │ arguments &= 20; - · ───────── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/function/object-destructuring-param-strict-body.js:131:3] + 130 │ 0, function({property}) { + 131 │ "use strict"; + · ───────────── + 132 │ }; + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/function/param-dflt-yield-strict.js:22:19] + 21 │ function *g() { + 22 │ 0, function(x = yield) { + · ───── + 23 │ paramValue = x; ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/and-eval-strict.js:18:1] - 17 │ - 18 │ eval &= 20; - · ──── + × Identifier `param` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-1.js:22:12] + 21 │ + 22 │ (function (param, param) { }); + · ──┬── ──┬── + · │ ╰── It can not be redeclared here + · ╰── `param` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/btws-and-non-simple.js:17:1] - 16 │ - 17 │ 1 &= 1; - · ─ + × Identifier `param1` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-2.js:23:12] + 22 │ + 23 │ (function (param1, param2, param1) { }); + · ───┬── ───┬── + · │ ╰── It can not be redeclared here + · ╰── `param1` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/btws-or-non-simple.js:17:1] - 16 │ - 17 │ 1 |= 1; - · ─ + × Identifier `param` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-3.js:22:12] + 21 │ + 22 │ (function (param, param, param) { }); + · ──┬── ──┬── + · │ ╰── It can not be redeclared here + · ╰── `param` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/btws-xor-non-simple.js:17:1] - 16 │ - 17 │ 1 ^= 1; - · ─ + × Identifier `param` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-3.js:22:12] + 21 │ + 22 │ (function (param, param, param) { }); + · ──┬── ──┬── + · │ ╰── It can not be redeclared here + · ╰── `param` has already been declared here ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/div-arguments-strict.js:19:1] - 18 │ - 19 │ arguments /= 20; - · ───────── + × Identifier `param` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-body-1.js:22:12] + 21 │ + 22 │ (function (param, param) { 'use strict'; }); + · ──┬── ──┬── + · │ ╰── It can not be redeclared here + · ╰── `param` has already been declared here + ╰──── + + × Identifier `param1` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-body-2.js:23:12] + 22 │ + 23 │ (function (param1, param2, param1) { 'use strict'; }); + · ───┬── ───┬── + · │ ╰── It can not be redeclared here + · ╰── `param1` has already been declared here + ╰──── + + × Identifier `param` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-body-3.js:21:12] + 20 │ + 21 │ (function (param, param, param) { 'use strict'; }); + · ──┬── ──┬── + · │ ╰── It can not be redeclared here + · ╰── `param` has already been declared here + ╰──── + + × Identifier `param` has already been declared + ╭─[language/expressions/function/param-duplicated-strict-body-3.js:21:12] + 20 │ + 21 │ (function (param, param, param) { 'use strict'; }); + · ──┬── ──┬── + · │ ╰── It can not be redeclared here + · ╰── `param` has already been declared here ╰──── × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/div-eval-strict.js:18:1] - 17 │ - 18 │ eval /= 20; - · ──── + ╭─[language/expressions/function/param-eval-strict-body.js:22:12] + 21 │ + 22 │ (function (eval) { 'use strict'; }); + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/div-non-simple.js:17:1] - 16 │ - 17 │ 1 /= 1; - · ─ + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/function/rest-param-strict-body.js:131:3] + 130 │ 0, function(a,...rest) { + 131 │ "use strict"; + · ───────────── + 132 │ }; + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/function/rest-params-trailing-comma-early-error.js:55:13] + 54 │ + 55 │ 0, function(...a,) { + · ──── + 56 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/left-shift-non-simple.js:17:1] - 16 │ - 17 │ 1 <<= 1; - · ─ + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/function/use-strict-with-non-simple-param.js:20:3] + 19 │ var f = function(a = 0) { + 20 │ "use strict"; + · ───────────── + 21 │ } ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/lshift-arguments-strict.js:19:1] - 18 │ - 19 │ arguments <<= 20; - · ───────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/generators/array-destructuring-param-strict-body.js:132:3] + 131 │ 0, function*([element]) { + 132 │ "use strict"; + · ───────────── + 133 │ }; + ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/lshift-eval-strict.js:19:1] - 18 │ - 19 │ eval <<= 20; - · ──── + × Identifier `x` has already been declared + ╭─[language/expressions/generators/dflt-params-duplicates.js:60:14] + 59 │ + 60 │ 0, function*(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 61 │ ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/mod-arguments-strict.js:19:1] - 18 │ - 19 │ arguments %= 20; - · ───────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dflt-params-rest.js:64:17] + 63 │ + 64 │ 0, function*(...x = []) { + · ────── + 65 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/mod-div-non-simple.js:17:1] - 16 │ - 17 │ 1 %= 1; - · ─ + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dstr/ary-ptrn-rest-init-ary.js:53:19] + 52 │ var f; + 53 │ f = function*([...[ x ] = []]) { + · ────────── + 54 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/mod-eval-strict.js:18:1] - 17 │ - 18 │ eval %= 20; - · ──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dstr/ary-ptrn-rest-init-id.js:53:19] + 52 │ var f; + 53 │ f = function*([...x = []]) { + · ────── + 54 │ ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/mult-arguments-strict.js:19:1] - 18 │ - 19 │ arguments *= 20; - · ───────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dstr/ary-ptrn-rest-init-obj.js:53:19] + 52 │ var f; + 53 │ f = function*([...{ x } = []]) { + · ────────── + 54 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/mult-eval-strict.js:18:1] - 17 │ - 18 │ eval *= 20; - · ──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/generators/dstr/ary-ptrn-rest-not-final-ary.js:53:16] + 52 │ var f; + 53 │ f = function*([...[x], y]) { + · ────── + 54 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/mult-non-simple.js:17:1] - 16 │ - 17 │ 1 *= 1; - · ─ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/generators/dstr/ary-ptrn-rest-not-final-id.js:53:16] + 52 │ var f; + 53 │ f = function*([...x, y]) { + · ──── + 54 │ ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/or-arguments-strict.js:19:1] - 18 │ - 19 │ arguments |= 20; - · ───────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/generators/dstr/ary-ptrn-rest-not-final-obj.js:53:16] + 52 │ var f; + 53 │ f = function*([...{ x }, y]) { + · ──────── + 54 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/or-eval-strict.js:18:1] - 17 │ - 18 │ eval |= 20; - · ──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-ary.js:53:19] + 52 │ var f; + 53 │ f = function*([...[ x ] = []] = []) { + · ────────── + 54 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/right-shift-non-simple.js:17:1] - 16 │ - 17 │ 1 >>= 1; - · ─ + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-id.js:53:19] + 52 │ var f; + 53 │ f = function*([...x = []] = []) { + · ────── + 54 │ ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/srshift-arguments-strict.js:19:1] - 18 │ - 19 │ arguments >>= 20; - · ───────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-obj.js:53:19] + 52 │ var f; + 53 │ f = function*([...{ x } = []] = []) { + · ────────── + 54 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/srshift-eval-strict.js:19:1] - 18 │ - 19 │ eval >>= 20; - · ──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-ary.js:53:16] + 52 │ var f; + 53 │ f = function*([...[x], y] = [1, 2, 3]) { + · ────── + 54 │ ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/sub-arguments-strict.js:19:1] - 18 │ - 19 │ arguments -= 20; - · ───────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-id.js:53:16] + 52 │ var f; + 53 │ f = function*([...x, y] = [1, 2, 3]) { + · ──── + 54 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/sub-eval-strict.js:18:1] - 17 │ - 18 │ eval -= 20; - · ──── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-obj.js:53:16] + 52 │ var f; + 53 │ f = function*([...{ x }, y] = [1, 2, 3]) { + · ──────── + 54 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/subtract-non-simple.js:17:1] - 16 │ - 17 │ 1 -= 1; - · ─ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/named-yield-as-binding-identifier-escaped.js:28:7] + 27 │ var gen = function *g() { + 28 │ var yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/compound-assignment/u-right-shift-non-simple.js:17:1] - 16 │ - 17 │ 1 >>>= 1; - · ─ + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/named-yield-as-binding-identifier-escaped.js:28:7] + 27 │ var gen = function *g() { + 28 │ var yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/urshift-arguments-strict.js:19:1] - 18 │ - 19 │ arguments >>>= 20; - · ───────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/named-yield-as-binding-identifier.js:28:7] + 27 │ var gen = function *g() { + 28 │ var yield; + · ───── + 29 │ }; ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/urshift-eval-strict.js:19:1] - 18 │ - 19 │ eval >>>= 20; - · ──── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/named-yield-as-binding-identifier.js:28:7] + 27 │ var gen = function *g() { + 28 │ var yield; + · ───── + 29 │ }; ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/compound-assignment/xor-arguments-strict.js:19:1] - 18 │ - 19 │ arguments ^= 20; - · ───────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/named-yield-as-identifier-reference-escaped.js:28:8] + 27 │ var gen = function *g() { + 28 │ void yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/compound-assignment/xor-eval-strict.js:18:1] - 17 │ - 18 │ eval ^= 20; - · ──── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/named-yield-as-identifier-reference-escaped.js:28:8] + 27 │ var gen = function *g() { + 28 │ void yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/conditional/in-branch-2.js:22:6] - 21 │ - 22 │ for (true ? 0 : 0 in {}; false; ) ; - · ──────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/named-yield-as-identifier-reference.js:28:8] + 27 │ var gen = function *g() { + 28 │ void yield; + · ───── + 29 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/conditional/in-condition.js:22:6] - 21 │ - 22 │ for ('' in {} ? 0 : 0; false; ) ; - · ── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/named-yield-as-identifier-reference.js:28:8] + 27 │ var gen = function *g() { + 28 │ void yield; + · ───── + 29 │ }; ╰──── - × Delete of an unqualified identifier in strict mode. - ╭─[language/expressions/delete/identifier-strict-recursive.js:18:10] - 17 │ - 18 │ delete ((identifier)); - · ────────── + × Keywords cannot contain escape characters + ╭─[language/expressions/generators/named-yield-as-label-identifier-escaped.js:28:3] + 27 │ var gen = function *g() { + 28 │ yi\u0065ld: ; + · ────────── + 29 │ }; ╰──── - × Delete of an unqualified identifier in strict mode. - ╭─[language/expressions/delete/identifier-strict.js:17:8] - 16 │ - 17 │ delete test262identifier; - · ───────────────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/generators/named-yield-as-label-identifier-escaped.js:28:13] + 27 │ var gen = function *g() { + 28 │ yi\u0065ld: ; + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Keywords cannot contain escape characters - ╭─[language/expressions/dynamic-import/escape-sequence-import.js:35:1] - 34 │ - 35 │ im\u0070ort('./empty_FIXTURE.js'); - · ─────────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/generators/named-yield-as-label-identifier.js:28:8] + 27 │ var gen = function *g() { + 28 │ yield: ; + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here × The keyword 'yield' is reserved - ╭─[language/expressions/dynamic-import/import-assertions/2nd-param-yield-ident-invalid.js:19:30] - 18 │ - 19 │ import('./empty_FIXTURE.js', yield); - · ───── + ╭─[language/expressions/generators/named-yield-identifier-spread-strict.js:34:15] + 33 │ ...(function() { + 34 │ var yield; + · ───── + 35 │ throw new Test262Error(); ╰──── × The keyword 'yield' is reserved - ╭─[language/expressions/dynamic-import/import-attributes/2nd-param-yield-ident-invalid.js:19:30] - 18 │ - 19 │ import('./empty_FIXTURE.js', yield); - · ───── + ╭─[language/expressions/generators/named-yield-identifier-strict.js:26:11] + 25 │ (function() { + 26 │ var yield; + · ───── + 27 │ throw new Test262Error(); ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-1-update-expression.js:46:1] - 45 │ - 46 │ import('')++ - · ────────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/generators/object-destructuring-param-strict-body.js:132:3] + 131 │ 0, function*({property}) { + 132 │ "use strict"; + · ───────────── + 133 │ }; + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-10-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') -= 1; - · ────────── + × yield expression not allowed in formal parameter + ╭─[language/expressions/generators/param-dflt-yield.js:25:18] + 24 │ + 25 │ 0, function*(x = yield) {}; + · ──┬── + · ╰── yield expression not allowed in formal parameter ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-11-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') <<= 1; - · ────────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/generators/rest-param-strict-body.js:132:3] + 131 │ 0, function*(a,...rest) { + 132 │ "use strict"; + · ───────────── + 133 │ }; + ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-12-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') >>= 1; - · ────────── + × A rest parameter must be last in a parameter list + ╭─[language/expressions/generators/rest-params-trailing-comma-early-error.js:57:14] + 56 │ + 57 │ 0, function*(...a,) { + · ──── + 58 │ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-13-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') >>>= 1; - · ────────── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/generators/use-strict-with-non-simple-param.js:21:3] + 20 │ var f = function*(a = 0) { + 21 │ "use strict"; + · ───────────── + 22 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-14-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') &= 1; - · ────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-as-binding-identifier-escaped.js:28:7] + 27 │ var gen = function *() { + 28 │ var yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-15-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') ^= 1; - · ────────── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-as-binding-identifier-escaped.js:28:7] + 27 │ var gen = function *() { + 28 │ var yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-16-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') |= 1; - · ────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-as-binding-identifier.js:28:7] + 27 │ var gen = function *() { + 28 │ var yield; + · ───── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-17-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') **= 1; - · ────────── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-as-binding-identifier.js:28:7] + 27 │ var gen = function *() { + 28 │ var yield; + · ───── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-2-update-expression.js:46:1] - 45 │ - 46 │ import('')-- - · ────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-as-generator-expression-binding-identifier.js:17:19] + 16 │ + 17 │ var g = function* yield() {}; + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-3-update-expression.js:46:3] - 45 │ - 46 │ ++import('') - · ────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-as-identifier-reference-escaped.js:28:8] + 27 │ var gen = function *() { + 28 │ void yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-4-update-expression.js:46:3] - 45 │ - 46 │ --import('') - · ────────── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-as-identifier-reference-escaped.js:28:8] + 27 │ var gen = function *() { + 28 │ void yi\u0065ld; + · ────────── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-5-lhs-equals-assignment-expression.js:48:1] - 47 │ - 48 │ import('') = 1; - · ────────── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-as-identifier-reference.js:28:8] + 27 │ var gen = function *() { + 28 │ void yield; + · ───── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-6-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') *= 1; - · ────────── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-as-identifier-reference.js:28:8] + 27 │ var gen = function *() { + 28 │ void yield; + · ───── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-7-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') /= 1; - · ────────── + × Keywords cannot contain escape characters + ╭─[language/expressions/generators/yield-as-label-identifier-escaped.js:28:3] + 27 │ var gen = function *() { + 28 │ yi\u0065ld: ; + · ────────── + 29 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-8-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') %= 1; - · ────────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/generators/yield-as-label-identifier-escaped.js:28:13] + 27 │ var gen = function *() { + 28 │ yi\u0065ld: ; + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here - × Cannot assign to this expression - ╭─[language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-9-lhs-assignment-operator-assignment-expression.js:48:1] - 47 │ - 48 │ import('') += 1; - · ────────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/generators/yield-as-label-identifier.js:28:8] + 27 │ var gen = function *() { + 28 │ yield: ; + · ▲ + 29 │ }; ╰──── + help: Try insert a semicolon here × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expr-not-optional.js:34:10] - 33 │ let f = () => { - 34 │ import(); - · ─ - 35 │ }; + ╭─[language/expressions/generators/yield-as-logical-or-expression.js:18:9] + 17 │ var g = function*() { + 18 │ yield ? yield : yield; + · ─ + 19 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-assignment-expr-not-optional.js:33:22] - 32 │ - 33 │ let f = () => import(); - · ─ - 34 │ + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-as-parameter.js:17:19] + 16 │ + 17 │ var g = function*(yield) {}; + · ───── ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-new-call-expression.js:36:19] - 35 │ - 36 │ let f = () => new import(''); - · ────────── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-as-parameter.js:17:19] + 16 │ + 17 │ var g = function*(yield) {}; + · ───── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-rest-param.js:41:22] - 40 │ - 41 │ let f = () => import(...['']); - · ─── + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-identifier-spread-strict.js:34:15] + 33 │ ...(function() { + 34 │ var yield; + · ───── + 35 │ throw new Test262Error(); ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-not-extensible-args.js:38:48] - 37 │ - 38 │ let f = () => import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected + × The keyword 'yield' is reserved + ╭─[language/expressions/generators/yield-identifier-strict.js:26:11] + 25 │ (function() { + 26 │ var yield; + · ───── + 27 │ throw new Test262Error(); ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-new-call-expression.js:37:7] - 36 │ let f = () => { - 37 │ new import(''); - · ────────── - 38 │ }; + × Unexpected token + ╭─[language/expressions/generators/yield-star-after-newline.js:18:3] + 17 │ yield + 18 │ * 1 + · ─ + 19 │ }; ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-rest-param.js:42:10] - 41 │ let f = () => { - 42 │ import(...['']); - · ─── - 43 │ }; + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/generators/yield-weak-binding.js:16:33] + 15 │ + 16 │ var g = function*() { yield 3 + yield 4; }; + · ───── ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-arrow-not-extensible-args.js:39:36] - 38 │ let f = () => { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ }; + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/generators/yield-weak-binding.js:16:38] + 15 │ + 16 │ var g = function*() { yield 3 + yield 4; }; + · ▲ ╰──── + help: Try insert a semicolon here - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-assignment-expr-not-optional.js:34:16] - 33 │ (async () => { - 34 │ await import() - · ─ - 35 │ }); + × Keywords cannot contain escape characters + ╭─[language/expressions/import.meta/syntax/escape-sequence-import.js:34:1] + 33 │ + 34 │ im\u0070ort.meta; + · ─────────── ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-new-call-expression.js:37:13] - 36 │ (async () => { - 37 │ await new import('') - · ────────── - 38 │ }); + × Keywords cannot contain escape characters + ╭─[language/expressions/import.meta/syntax/escape-sequence-meta.js:34:8] + 33 │ + 34 │ import.m\u0065ta; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-rest-param.js:42:16] - 41 │ (async () => { - 42 │ await import(...['']) - · ─── - 43 │ }); + × Unexpected import.meta expression + ╭─[language/expressions/import.meta/syntax/goal-script.js:18:1] + 17 │ + 18 │ import.meta; + · ─────────── ╰──── + help: import.meta is only allowed in module code - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-not-extensible-args.js:39:42] - 38 │ (async () => { - 39 │ await import('./empty_FIXTURE.js', {}, '') - · ─┬ - · ╰── `)` expected - 40 │ }); + × Cannot assign to this expression + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-array-destructuring-expr.js:31:2] + 30 │ + 31 │ [import.meta] = []; + · ─────────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-assignment-expr-not-optional.js:33:27] - 32 │ - 33 │ (async () => await import()) - · ─ - 34 │ + × Cannot assign to this expression + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-array-rest-destructuring-expr.js:31:5] + 30 │ + 31 │ [...import.meta] = []; + · ─────────── ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-new-call-expression.js:36:24] - 35 │ - 36 │ (async () => await new import('')) - · ────────── + × Cannot assign to this expression + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-assignment-expr.js:31:1] + 30 │ + 31 │ import.meta = 0; + · ─────────── ╰──── × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-rest-param.js:41:27] - 40 │ - 41 │ (async () => await import(...[''])) - · ─── + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-for-await-of-loop.js:31:16] + 30 │ async function* f() { + 31 │ for await (import.meta of null) ; + · ─────────── + 32 │ } ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-not-extensible-args.js:38:53] - 37 │ - 38 │ (async () => await import('./empty_FIXTURE.js', {}, '')) - · ─┬ - · ╰── `)` expected + × Unexpected token + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-for-in-loop.js:30:6] + 29 │ + 30 │ for (import.meta in null) ; + · ─────────── ╰──── × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-assignment-expr-not-optional.js:34:10] - 33 │ async function f() { - 34 │ import(); - · ─ - 35 │ } + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-for-of-loop.js:30:6] + 29 │ + 30 │ for (import.meta of null) ; + · ─────────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-assignment-expr-not-optional.js:34:16] - 33 │ async function f() { - 34 │ await import(); - · ─ - 35 │ } + × Cannot assign to this expression + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-object-destructuring-expr.js:31:6] + 30 │ + 31 │ ({a: import.meta} = {}); + · ─────────── ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-new-call-expression.js:37:13] - 36 │ async function f() { - 37 │ await new import(''); - · ────────── - 38 │ } + × Cannot assign to this expression + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-object-rest-destructuring-expr.js:31:6] + 30 │ + 31 │ ({...import.meta} = {}); + · ─────────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-rest-param.js:42:16] - 41 │ async function f() { - 42 │ await import(...['']); - · ─── - 43 │ } + × Cannot assign to this expression + ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-update-expr.js:32:1] + 31 │ + 32 │ import.meta++; + · ─────────── ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-not-extensible-args.js:39:42] - 38 │ async function f() { - 39 │ await import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × Unexpected token + ╭─[language/expressions/in/private-field-in-nested.js:25:15] + 24 │ constructor() { + 25 │ #field in #field in this; + · ────── + 26 │ } ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-new-call-expression.js:37:7] - 36 │ async function f() { - 37 │ new import(''); - · ────────── - 38 │ } + × Unexpected token + ╭─[language/expressions/in/private-field-in.js:24:10] + 23 │ constructor() { + 24 │ for (#field in value;;) break; + · ────── + 25 │ } ╰──── × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-rest-param.js:42:10] - 41 │ async function f() { - 42 │ import(...['']); - · ─── - 43 │ } + ╭─[language/expressions/in/private-field-invalid-assignment-reference.js:23:10] + 22 │ m() { + 23 │ for (#field in []) ; + · ────── + 24 │ } ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-not-extensible-args.js:39:36] - 38 │ async function f() { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × Cannot assign to this expression + ╭─[language/expressions/in/private-field-invalid-assignment-target.js:29:5] + 28 │ constructor() { + 29 │ #field in {} = 0; + · ──────────── + 30 │ } ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-assignment-expr-not-optional.js:34:23] - 33 │ async function f() { - 34 │ return await import(); - · ─ - 35 │ } + × Private field 'b' must be declared in an enclosing class + ╭─[language/expressions/in/private-field-invalid-identifier-complex.js:29:5] + 28 │ constructor() { + 29 │ #b in {}; + · ── + 30 │ } ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-new-call-expression.js:37:20] - 36 │ async function f() { - 37 │ return await new import(''); - · ────────── - 38 │ } + × Private identifier '#name' is not allowed outside class bodies + ╭─[language/expressions/in/private-field-invalid-identifier-simple.js:25:1] + 24 │ + 25 │ #name in {}; + · ───── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-rest-param.js:42:23] - 41 │ async function f() { - 42 │ return await import(...['']); - · ─── - 43 │ } + × Empty parenthesized expression + ╭─[language/expressions/in/private-field-invalid-rhs.js:24:15] + 23 │ constructor() { + 24 │ #field in () => {}; + · ── + 25 │ } ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-not-extensible-args.js:39:49] - 38 │ async function f() { - 39 │ return await import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/in/private-field-rhs-yield-absent.js:31:15] + 30 │ static method() { + 31 │ #field in yield; + · ───── + 32 │ } ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-assignment-expr-not-optional.js:34:16] - 33 │ async function * f() { - 34 │ await import() - · ─ - 35 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/in/rhs-yield-absent-strict.js:20:8] + 19 │ + 20 │ '' in (yield); + · ───── ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-new-call-expression.js:37:13] - 36 │ async function * f() { - 37 │ await new import('') - · ────────── - 38 │ } + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/logical-assignment/lgcl-and-arguments-strict.js:18:1] + 17 │ + 18 │ arguments &&= 20; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-rest-param.js:42:16] - 41 │ async function * f() { - 42 │ await import(...['']) - · ─── - 43 │ } + × Cannot assign to this expression + ╭─[language/expressions/logical-assignment/lgcl-and-assignment-operator-non-simple-lhs.js:19:1] + 18 │ function test() {} + 19 │ test() &&= 1; + · ────── ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-not-extensible-args.js:39:42] - 38 │ async function * f() { - 39 │ await import('./empty_FIXTURE.js', {}, '') - · ─┬ - · ╰── `)` expected - 40 │ } + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/logical-assignment/lgcl-and-eval-strict.js:17:1] + 16 │ + 17 │ eval &&= 20; + · ──── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-assignment-expr-not-optional.js:34:10] - 33 │ { - 34 │ import(); - · ─ - 35 │ }; + × Cannot assign to this expression + ╭─[language/expressions/logical-assignment/lgcl-and-non-simple.js:17:1] + 16 │ + 17 │ 1 &&= 1; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-assignment-expr-not-optional.js:34:10] - 33 │ label: { - 34 │ import(); - · ─ - 35 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/logical-assignment/lgcl-nullish-arguments-strict.js:18:1] + 17 │ + 18 │ arguments ??= 20; + · ───────── ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-new-call-expression.js:37:7] - 36 │ label: { - 37 │ new import(''); - · ────────── - 38 │ }; + × Cannot assign to this expression + ╭─[language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-simple-lhs.js:19:1] + 18 │ function test() {} + 19 │ test() ??= 1; + · ────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-rest-param.js:42:10] - 41 │ label: { - 42 │ import(...['']); - · ─── - 43 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/logical-assignment/lgcl-nullish-eval-strict.js:17:1] + 16 │ + 17 │ eval ??= 20; + · ──── ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-not-extensible-args.js:39:36] - 38 │ label: { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ }; + × Cannot assign to this expression + ╭─[language/expressions/logical-assignment/lgcl-nullish-non-simple.js:17:1] + 16 │ + 17 │ 1 ??= 1; + · ─ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-no-new-call-expression.js:37:7] - 36 │ { - 37 │ new import(''); - · ────────── - 38 │ }; + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/logical-assignment/lgcl-or-arguments-strict.js:18:1] + 17 │ + 18 │ arguments ||= 20; + · ───────── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-no-rest-param.js:42:10] - 41 │ { - 42 │ import(...['']); - · ─── - 43 │ }; + × Cannot assign to this expression + ╭─[language/expressions/logical-assignment/lgcl-or-assignment-operator-non-simple-lhs.js:19:1] + 18 │ function test() {} + 19 │ test() ||= 1; + · ────── ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-block-not-extensible-args.js:39:36] - 38 │ { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/logical-assignment/lgcl-or-eval-strict.js:17:1] + 16 │ + 17 │ eval ||= 20; + · ──── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-assignment-expr-not-optional.js:34:10] - 33 │ do { - 34 │ import(); - · ─ - 35 │ } while (false); + × Cannot assign to this expression + ╭─[language/expressions/logical-assignment/lgcl-or-non-simple.js:17:1] + 16 │ + 17 │ 1 ||= 1; + · ─ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-new-call-expression.js:37:7] - 36 │ do { - 37 │ new import(''); - · ────────── - 38 │ } while (false); + × Keywords cannot contain escape characters + ╭─[language/expressions/new.target/escaped-new.js:24:5] + 23 │ function f() { + 24 │ n\u0065w.target; + · ──────── + 25 │ } ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-rest-param.js:42:10] - 41 │ do { - 42 │ import(...['']); - · ─── - 43 │ } while (false); + × Keywords cannot contain escape characters + ╭─[language/expressions/new.target/escaped-target.js:24:9] + 23 │ function f() { + 24 │ new.t\u0061rget; + · ─────────── + 25 │ } ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-do-while-not-extensible-args.js:39:36] - 38 │ do { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } while (false); + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/object/11.1.5-1gs.js:18:31] + 17 │ + 18 │ var obj = { set _11_1_5_1_fun(eval) {}}; + · ──── ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-assignment-expr-not-optional.js:36:10] - 35 │ } else { - 36 │ import(); - · ─ - 37 │ } + × Identifier `__proto__` has already been declared + ╭─[language/expressions/object/__proto__-duplicate.js:20:3] + 19 │ ({ + 20 │ __proto__: null, + · ────┬──── + · ╰── `__proto__` has already been declared here + 21 │ other: null, + 22 │ '__proto__': null + · ─────┬───── + · ╰── It can not be redeclared here + 23 │ }); ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-assignment-expr-not-optional.js:35:15] - 34 │ - 35 │ } else import(); - · ─ - 36 │ + × Invalid assignment in object literal + ╭─[language/expressions/object/cover-initialized-name.js:32:4] + 31 │ + 32 │ ({ a = 1 }); + · ───── ╰──── + help: Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern. - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-new-call-expression.js:38:12] - 37 │ - 38 │ } else new import(''); - · ────────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js:38:21] + 37 │ var obj = { + 38 │ async *method([...[ x ] = []]) { + · ────────── + 39 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-rest-param.js:43:15] - 42 │ - 43 │ } else import(...['']); - · ─── + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-id.js:38:21] + 37 │ var obj = { + 38 │ async *method([...x = []]) { + · ────── + 39 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-not-extensible-args.js:40:41] - 39 │ - 40 │ } else import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js:38:21] + 37 │ var obj = { + 38 │ async *method([...{ x } = []]) { + · ────────── + 39 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-no-new-call-expression.js:39:7] - 38 │ } else { - 39 │ new import(''); - · ────────── - 40 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js:38:18] + 37 │ var obj = { + 38 │ async *method([...[x], y]) { + · ────── + 39 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-no-rest-param.js:44:10] - 43 │ } else { - 44 │ import(...['']); - · ─── - 45 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js:38:18] + 37 │ var obj = { + 38 │ async *method([...x, y]) { + · ──── + 39 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-else-not-extensible-args.js:41:36] - 40 │ } else { - 41 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 42 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js:38:18] + 37 │ var obj = { + 38 │ async *method([...{ x }, y]) { + · ──────── + 39 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-assignment-expr-not-optional.js:34:10] - 33 │ function fn() { - 34 │ import(); - · ─ - 35 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js:38:21] + 37 │ var obj = { + 38 │ async *method([...[ x ] = []] = []) { + · ────────── + 39 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-no-new-call-expression.js:37:7] - 36 │ function fn() { - 37 │ new import(''); - · ────────── - 38 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js:38:21] + 37 │ var obj = { + 38 │ async *method([...x = []] = []) { + · ────── + 39 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-no-rest-param.js:42:10] - 41 │ function fn() { - 42 │ import(...['']); - · ─── - 43 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js:38:21] + 37 │ var obj = { + 38 │ async *method([...{ x } = []] = []) { + · ────────── + 39 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-not-extensible-args.js:39:36] - 38 │ function fn() { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:38:18] + 37 │ var obj = { + 38 │ async *method([...[x], y] = [1, 2, 3]) { + · ────── + 39 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-assignment-expr-not-optional.js:34:17] - 33 │ function fn() { - 34 │ return import(); - · ─ - 35 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:38:18] + 37 │ var obj = { + 38 │ async *method([...x, y] = [1, 2, 3]) { + · ──── + 39 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-new-call-expression.js:37:14] - 36 │ function fn() { - 37 │ return new import(''); - · ────────── - 38 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:38:18] + 37 │ var obj = { + 38 │ async *method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 39 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-rest-param.js:42:17] - 41 │ function fn() { - 42 │ return import(...['']); - · ─── - 43 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-ary.js:58:15] + 57 │ var obj = { + 58 │ *method([...[ x ] = []]) { + · ────────── + 59 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-function-return-not-extensible-args.js:39:43] - 38 │ function fn() { - 39 │ return import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-id.js:58:15] + 57 │ var obj = { + 58 │ *method([...x = []]) { + · ────── + 59 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-assignment-expr-not-optional.js:34:10] - 33 │ if (true) { - 34 │ import(); - · ─ - 35 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-obj.js:58:15] + 57 │ var obj = { + 58 │ *method([...{ x } = []]) { + · ────────── + 59 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-assignment-expr-not-optional.js:33:18] - 32 │ - 33 │ if (true) import(); - · ─ - 34 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js:58:12] + 57 │ var obj = { + 58 │ *method([...[x], y]) { + · ────── + 59 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-new-call-expression.js:36:15] - 35 │ - 36 │ if (true) new import(''); - · ────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-id.js:58:12] + 57 │ var obj = { + 58 │ *method([...x, y]) { + · ──── + 59 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-rest-param.js:41:18] - 40 │ - 41 │ if (true) import(...['']); - · ─── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js:58:12] + 57 │ var obj = { + 58 │ *method([...{ x }, y]) { + · ──────── + 59 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-not-extensible-args.js:38:44] - 37 │ - 38 │ if (true) import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js:58:15] + 57 │ var obj = { + 58 │ *method([...[ x ] = []] = []) { + · ────────── + 59 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-no-new-call-expression.js:37:7] - 36 │ if (true) { - 37 │ new import(''); - · ────────── - 38 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js:58:15] + 57 │ var obj = { + 58 │ *method([...x = []] = []) { + · ────── + 59 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-no-rest-param.js:42:10] - 41 │ if (true) { - 42 │ import(...['']); - · ─── - 43 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js:58:15] + 57 │ var obj = { + 58 │ *method([...{ x } = []] = []) { + · ────────── + 59 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-if-not-extensible-args.js:39:36] - 38 │ if (true) { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:58:12] + 57 │ var obj = { + 58 │ *method([...[x], y] = [1, 2, 3]) { + · ────── + 59 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-assignment-expr-not-optional.js:36:10] - 35 │ x++; - 36 │ import(); - · ─ - 37 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js:58:12] + 57 │ var obj = { + 58 │ *method([...x, y] = [1, 2, 3]) { + · ──── + 59 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-no-new-call-expression.js:39:7] - 38 │ x++; - 39 │ new import(''); - · ────────── - 40 │ }; + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:58:12] + 57 │ var obj = { + 58 │ *method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 59 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-no-rest-param.js:44:10] - 43 │ x++; - 44 │ import(...['']); - · ─── - 45 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-init-ary.js:55:14] + 54 │ var obj = { + 55 │ method([...[ x ] = []]) { + · ────────── + 56 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-while-not-extensible-args.js:41:36] - 40 │ x++; - 41 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 42 │ }; + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-init-id.js:55:14] + 54 │ var obj = { + 55 │ method([...x = []]) { + · ────── + 56 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-assignment-expr-not-optional.js:34:10] - 33 │ with ({}) { - 34 │ import(); - · ─ - 35 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-init-obj.js:55:14] + 54 │ var obj = { + 55 │ method([...{ x } = []]) { + · ────────── + 56 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-assignment-expr-not-optional.js:33:14] - 32 │ - 33 │ with (import()) {} - · ─ - 34 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-ary.js:55:11] + 54 │ var obj = { + 55 │ method([...[x], y]) { + · ────── + 56 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-new-call-expression.js:36:11] - 35 │ - 36 │ with (new import('')) {} - · ────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-id.js:55:11] + 54 │ var obj = { + 55 │ method([...x, y]) { + · ──── + 56 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-rest-param.js:41:14] - 40 │ - 41 │ with (import(...[''])) {} - · ─── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-obj.js:55:11] + 54 │ var obj = { + 55 │ method([...{ x }, y]) { + · ──────── + 56 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-expression-not-extensible-args.js:38:40] - 37 │ - 38 │ with (import('./empty_FIXTURE.js', {}, '')) {} - · ─┬ - · ╰── `)` expected + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-ary.js:55:14] + 54 │ var obj = { + 55 │ method([...[ x ] = []] = []) { + · ────────── + 56 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-no-new-call-expression.js:37:7] - 36 │ with ({}) { - 37 │ new import(''); - · ────────── - 38 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-id.js:55:14] + 54 │ var obj = { + 55 │ method([...x = []] = []) { + · ────── + 56 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-no-rest-param.js:42:10] - 41 │ with ({}) { - 42 │ import(...['']); - · ─── - 43 │ } + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-obj.js:55:14] + 54 │ var obj = { + 55 │ method([...{ x } = []] = []) { + · ────────── + 56 │ ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/nested-with-not-extensible-args.js:39:36] - 38 │ with ({}) { - 39 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected - 40 │ } + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js:55:11] + 54 │ var obj = { + 55 │ method([...[x], y] = [1, 2, 3]) { + · ────── + 56 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-assignment-expr-not-optional.js:23:8] - 22 │ - 23 │ import(); - · ─ - 24 │ + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js:55:11] + 54 │ var obj = { + 55 │ method([...x, y] = [1, 2, 3]) { + · ──── + 56 │ ╰──── - × Cannot use new with dynamic import - ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-no-new-call-expression.js:26:5] - 25 │ - 26 │ new import(''); - · ────────── + × A rest element must be last in a destructuring pattern + ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js:55:11] + 54 │ var obj = { + 55 │ method([...{ x }, y] = [1, 2, 3]) { + · ──────── + 56 │ ╰──── - × Unexpected token - ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-no-rest-param.js:31:8] - 30 │ - 31 │ import(...['']); - · ─── + × The keyword 'public' is reserved + ╭─[language/expressions/object/getter-body-strict-inside.js:20:5] + 19 │ "use strict"; + 20 │ public = 42; + · ────── + 21 │ } ╰──── - × Expected `)` but found `string` - ╭─[language/expressions/dynamic-import/syntax/invalid/top-level-not-extensible-args.js:28:34] - 27 │ - 28 │ import('./empty_FIXTURE.js', {}, ''); - · ─┬ - · ╰── `)` expected + × The keyword 'public' is reserved + ╭─[language/expressions/object/getter-body-strict-outside.js:18:5] + 17 │ get x() { + 18 │ public = 42; + · ────── + 19 │ } ╰──── - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-bitnot-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ ~3 ** 2; - · ─────── + × A 'get' accessor must not have any formal parameters. + ╭─[language/expressions/object/getter-param-dflt.js:23:11] + 22 │ + 23 │ 0, { get a(param = null) {} }; + · ────────────── ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-delete-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ delete o.p ** 2; - · ─────────────── + × The keyword 'implements' is reserved + ╭─[language/expressions/object/identifier-shorthand-implements-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ implements + · ────────── + 32 │ }); ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-logical-not-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ !1 ** 2; - · ─────── + × The keyword 'interface' is reserved + ╭─[language/expressions/object/identifier-shorthand-interface-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ interface + · ───────── + 32 │ }); ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-negate-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ -3 ** 2; - · ─────── + × Unexpected token + ╭─[language/expressions/object/identifier-shorthand-invalid-computed-name.js:29:6] + 28 │ + 29 │ ({[x]}); + · ─ ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-plus-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ +1 ** 2; - · ─────── + × Unexpected token + ╭─[language/expressions/object/identifier-shorthand-invalid-zero.js:22:4] + 21 │ + 22 │ ({0}); + · ─ ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-typeof-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ typeof 1 ** 2; - · ───────────── + × The keyword 'let' is reserved + ╭─[language/expressions/object/identifier-shorthand-let-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ let + · ─── + 32 │ }); ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Unexpected exponentiation expression - ╭─[language/expressions/exponentiation/exp-operator-syntax-error-void-unary-expression-base.js:25:1] - 24 │ $DONOTEVALUATE(); - 25 │ void 1 ** 2; - · ─────────── + × The keyword 'package' is reserved + ╭─[language/expressions/object/identifier-shorthand-package-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ package + · ─────── + 32 │ }); ╰──── - help: Wrap unary expression in parentheses to enforce operator precedence - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/function/array-destructuring-param-strict-body.js:131:3] - 130 │ 0, function([element]) { - 131 │ "use strict"; - · ───────────── - 132 │ }; - ╰──── + × The keyword 'private' is reserved + ╭─[language/expressions/object/identifier-shorthand-private-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ private + · ─────── + 32 │ }); + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/function/dflt-params-duplicates.js:59:13] - 58 │ - 59 │ 0, function(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 60 │ + × The keyword 'protected' is reserved + ╭─[language/expressions/object/identifier-shorthand-protected-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ protected + · ───────── + 32 │ }); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dflt-params-rest.js:63:16] - 62 │ - 63 │ 0, function(...x = []) { - · ────── - 64 │ + × The keyword 'public' is reserved + ╭─[language/expressions/object/identifier-shorthand-public-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ public + · ────── + 32 │ }); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dstr/ary-ptrn-rest-init-ary.js:53:18] - 52 │ var f; - 53 │ f = function([...[ x ] = []]) { - · ────────── - 54 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/object/identifier-shorthand-static-init-await-invalid.js:23:8] + 22 │ static { + 23 │ ({ await }); + · ───── + 24 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dstr/ary-ptrn-rest-init-id.js:53:18] - 52 │ var f; - 53 │ f = function([...x = []]) { - · ────── - 54 │ + × Cannot use await in class static initialization block + ╭─[language/expressions/object/identifier-shorthand-static-init-await-invalid.js:23:8] + 22 │ static { + 23 │ ({ await }); + · ───── + 24 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dstr/ary-ptrn-rest-init-obj.js:53:18] - 52 │ var f; - 53 │ f = function([...{ x } = []]) { - · ────────── - 54 │ + × The keyword 'static' is reserved + ╭─[language/expressions/object/identifier-shorthand-static-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ static + · ────── + 32 │ }); ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/function/dstr/ary-ptrn-rest-not-final-ary.js:53:15] - 52 │ var f; - 53 │ f = function([...[x], y]) { - · ────── - 54 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/object/identifier-shorthand-yield-invalid-strict-mode.js:31:5] + 30 │ ({ + 31 │ yield + · ───── + 32 │ }); ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/function/dstr/ary-ptrn-rest-not-final-id.js:53:15] - 52 │ var f; - 53 │ f = function([...x, y]) { - · ──── - 54 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/object/method-definition/async-await-as-binding-identifier-escaped.js:30:9] + 29 │ async method() { + 30 │ var \u0061wait; + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/function/dstr/ary-ptrn-rest-not-final-obj.js:53:15] - 52 │ var f; - 53 │ f = function([...{ x }, y]) { - · ──────── - 54 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/object/method-definition/async-await-as-binding-identifier.js:30:9] + 29 │ async method() { + 30 │ var await; + · ───── + 31 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-init-ary.js:53:18] - 52 │ var f; - 53 │ f = function([...[ x ] = []] = []) { - · ────────── - 54 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js:30:10] + 29 │ async method() { + 30 │ void \u0061wait; + · ────────── + 31 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-init-id.js:53:18] - 52 │ var f; - 53 │ f = function([...x = []] = []) { - · ────── - 54 │ + × Unexpected token + ╭─[language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js:30:20] + 29 │ async method() { + 30 │ void \u0061wait; + · ─ + 31 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-init-obj.js:53:18] - 52 │ var f; - 53 │ f = function([...{ x } = []] = []) { - · ────────── - 54 │ + × Unexpected token + ╭─[language/expressions/object/method-definition/async-await-as-identifier-reference.js:30:15] + 29 │ async method() { + 30 │ void await; + · ─ + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-ary.js:53:15] - 52 │ var f; - 53 │ f = function([...[x], y] = [1, 2, 3]) { - · ────── - 54 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js:30:5] + 29 │ async method() { + 30 │ \u0061wait: ; + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-id.js:53:15] - 52 │ var f; - 53 │ f = function([...x, y] = [1, 2, 3]) { - · ──── - 54 │ + × Unexpected token + ╭─[language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js:30:15] + 29 │ async method() { + 30 │ \u0061wait: ; + · ─ + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-obj.js:53:15] - 52 │ var f; - 53 │ f = function([...{ x }, y] = [1, 2, 3]) { - · ──────── - 54 │ + × Unexpected token + ╭─[language/expressions/object/method-definition/async-await-as-label-identifier.js:30:10] + 29 │ async method() { + 30 │ await: ; + · ─ + 31 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/function/early-body-super-call.js:17:3] - 16 │ 0, function() { - 17 │ super(); - · ─────── - 18 │ }; + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/object/method-definition/async-gen-await-as-binding-identifier-escaped.js:29:9] + 28 │ async *method() { + 29 │ var \u0061wait; + · ────────── + 30 │ } ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/function/early-body-super-prop.js:17:3] - 16 │ 0, function() { - 17 │ super.x; - · ───── - 18 │ }; + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/object/method-definition/async-gen-await-as-binding-identifier.js:29:9] + 28 │ async *method() { + 29 │ var await; + · ───── + 30 │ } ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/expressions/function/early-errors/invalid-names-call-expression-bad-reference.js:40:36] - 39 │ - 40 │ var fn = function() { (() => {})().#x }; - · ── + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js:29:10] + 28 │ async *method() { + 29 │ void \u0061wait; + · ────────── + 30 │ } ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/expressions/function/early-errors/invalid-names-call-expression-this.js:40:38] - 39 │ - 40 │ var fn = function() { (() => this)().#x }; - · ── + × Unexpected token + ╭─[language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js:29:20] + 28 │ async *method() { + 29 │ void \u0061wait; + · ─ + 30 │ } ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/expressions/function/early-errors/invalid-names-member-expression-bad-reference.js:40:33] - 39 │ - 40 │ var fn = function() { something.#x }; - · ── + × Unexpected token + ╭─[language/expressions/object/method-definition/async-gen-await-as-identifier-reference.js:29:15] + 28 │ async *method() { + 29 │ void await; + · ─ + 30 │ } ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/expressions/function/early-errors/invalid-names-member-expression-this.js:40:28] - 39 │ - 40 │ var fn = function() { this.#x }; - · ── + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js:29:5] + 28 │ async *method() { + 29 │ \u0061wait: ; + · ────────── + 30 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/function/early-params-super-call.js:16:17] - 15 │ - 16 │ 0, function(x = super()) {}; - · ─────── + × Unexpected token + ╭─[language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js:29:15] + 28 │ async *method() { + 29 │ \u0061wait: ; + · ─ + 30 │ } ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/expressions/function/early-params-super-prop.js:16:17] - 15 │ - 16 │ 0, function(x = super.x) {}; - · ───── + × Unexpected token + ╭─[language/expressions/object/method-definition/async-gen-await-as-label-identifier.js:29:10] + 28 │ async *method() { + 29 │ await: ; + · ─ + 30 │ } ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/function/name-arguments-strict-body.js:18:11] - 17 │ - 18 │ (function arguments() {'use strict';}); - · ───────── - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/async-gen-meth-array-destructuring-param-strict-body.js:116:5] + 115 │ async *method([element]) { + 116 │ "use strict"; + · ───────────── + 117 │ } + ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/function/name-arguments-strict.js:17:11] - 16 │ - 17 │ (function arguments() {}); - · ───────── + × Identifier `x` has already been declared + ╭─[language/expressions/object/method-definition/async-gen-meth-dflt-params-duplicates.js:44:17] + 43 │ 0, { + 44 │ async *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 45 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/function/name-eval-strict-body.js:18:11] - 17 │ - 18 │ (function eval() {'use strict';}); - · ──── + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/method-definition/async-gen-meth-dflt-params-rest.js:48:20] + 47 │ 0, { + 48 │ async *method(...x = []) { + · ────── + 49 │ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/function/name-eval-strict.js:17:11] - 16 │ - 17 │ (function eval() {}); - · ──── + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-gen-meth-escaped-async.js:25:5] + 24 │ ({ + 25 │ \u0061sync* m(){} + · ────────── + 26 │ }); ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/function/object-destructuring-param-strict-body.js:131:3] - 130 │ 0, function({property}) { - 131 │ "use strict"; - · ───────────── - 132 │ }; + ╭─[language/expressions/object/method-definition/async-gen-meth-object-destructuring-param-strict-body.js:116:5] + 115 │ async *method({property}) { + 116 │ "use strict"; + · ───────────── + 117 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/function/param-dflt-yield-strict.js:22:19] - 21 │ function *g() { - 22 │ 0, function(x = yield) { - · ───── - 23 │ paramValue = x; + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/async-gen-meth-rest-param-strict-body.js:116:5] + 115 │ async *method(a,...rest) { + 116 │ "use strict"; + · ───────────── + 117 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/object/method-definition/async-gen-meth-rest-params-trailing-comma-early-error.js:41:17] + 40 │ 0, { + 41 │ async *method(...a,) { + · ──── + 42 │ ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-1.js:22:12] - 21 │ - 22 │ (function (param, param) { }); - · ──┬── ──┬── - · │ ╰── It can not be redeclared here - · ╰── `param` has already been declared here + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js:29:9] + 28 │ async *method() { + 29 │ var yi\u0065ld; + · ────────── + 30 │ } ╰──── - × Identifier `param1` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-2.js:23:12] - 22 │ - 23 │ (function (param1, param2, param1) { }); - · ───┬── ───┬── - · │ ╰── It can not be redeclared here - · ╰── `param1` has already been declared here + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js:29:9] + 28 │ async *method() { + 29 │ var yi\u0065ld; + · ────────── + 30 │ } ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-3.js:22:12] - 21 │ - 22 │ (function (param, param, param) { }); - · ──┬── ──┬── - · │ ╰── It can not be redeclared here - · ╰── `param` has already been declared here + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js:29:9] + 28 │ async *method() { + 29 │ var yield; + · ───── + 30 │ } ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-3.js:22:12] - 21 │ - 22 │ (function (param, param, param) { }); - · ──┬── ──┬── - · │ ╰── It can not be redeclared here - · ╰── `param` has already been declared here + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js:29:9] + 28 │ async *method() { + 29 │ var yield; + · ───── + 30 │ } ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-body-1.js:22:12] - 21 │ - 22 │ (function (param, param) { 'use strict'; }); - · ──┬── ──┬── - · │ ╰── It can not be redeclared here - · ╰── `param` has already been declared here + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js:29:10] + 28 │ async *method() { + 29 │ void yi\u0065ld; + · ────────── + 30 │ } ╰──── - × Identifier `param1` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-body-2.js:23:12] - 22 │ - 23 │ (function (param1, param2, param1) { 'use strict'; }); - · ───┬── ───┬── - · │ ╰── It can not be redeclared here - · ╰── `param1` has already been declared here + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js:29:10] + 28 │ async *method() { + 29 │ void yi\u0065ld; + · ────────── + 30 │ } ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-body-3.js:21:12] - 20 │ - 21 │ (function (param, param, param) { 'use strict'; }); - · ──┬── ──┬── - · │ ╰── It can not be redeclared here - · ╰── `param` has already been declared here + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js:29:10] + 28 │ async *method() { + 29 │ void yield; + · ───── + 30 │ } ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/function/param-duplicated-strict-body-3.js:21:12] - 20 │ - 21 │ (function (param, param, param) { 'use strict'; }); - · ──┬── ──┬── - · │ ╰── It can not be redeclared here - · ╰── `param` has already been declared here + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js:29:10] + 28 │ async *method() { + 29 │ void yield; + · ───── + 30 │ } ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/function/param-eval-strict-body.js:22:12] - 21 │ - 22 │ (function (eval) { 'use strict'; }); - · ──── + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js:29:5] + 28 │ async *method() { + 29 │ yi\u0065ld: ; + · ────────── + 30 │ } + ╰──── + + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js:29:15] + 28 │ async *method() { + 29 │ yi\u0065ld: ; + · ▲ + 30 │ } ╰──── + help: Try insert a semicolon here - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/function/rest-param-strict-body.js:131:3] - 130 │ 0, function(a,...rest) { - 131 │ "use strict"; - · ───────────── - 132 │ }; - ╰──── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/object/method-definition/async-gen-yield-as-label-identifier.js:29:10] + 28 │ async *method() { + 29 │ yield: ; + · ▲ + 30 │ } + ╰──── + help: Try insert a semicolon here - × A rest parameter must be last in a parameter list - ╭─[language/expressions/function/rest-params-trailing-comma-early-error.js:55:13] - 54 │ - 55 │ 0, function(...a,) { - · ──── - 56 │ + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js:35:17] + 34 │ ...(function() { + 35 │ var yield; + · ───── + 36 │ throw new Test262Error(); ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/function/use-strict-with-non-simple-param.js:20:3] - 19 │ var f = function(a = 0) { - 20 │ "use strict"; - · ───────────── - 21 │ } + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/async-gen-yield-identifier-strict.js:27:13] + 26 │ (function() { + 27 │ var yield; + · ───── + 28 │ throw new Test262Error(); ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/generators/array-destructuring-param-strict-body.js:132:3] - 131 │ 0, function*([element]) { - 132 │ "use strict"; - · ───────────── - 133 │ }; + ╭─[language/expressions/object/method-definition/async-meth-array-destructuring-param-strict-body.js:109:5] + 108 │ async *method([element]) { + 109 │ "use strict"; + · ───────────── + 110 │ } ╰──── × Identifier `x` has already been declared - ╭─[language/expressions/generators/dflt-params-duplicates.js:60:14] - 59 │ - 60 │ 0, function*(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 61 │ - ╰──── - - × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dflt-params-rest.js:64:17] - 63 │ - 64 │ 0, function*(...x = []) { - · ────── - 65 │ - ╰──── - - × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dstr/ary-ptrn-rest-init-ary.js:53:19] - 52 │ var f; - 53 │ f = function*([...[ x ] = []]) { - · ────────── - 54 │ + ╭─[language/expressions/object/method-definition/async-meth-dflt-params-duplicates.js:37:17] + 36 │ ({ + 37 │ async *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 38 │ ╰──── × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dstr/ary-ptrn-rest-init-id.js:53:19] - 52 │ var f; - 53 │ f = function*([...x = []]) { - · ────── - 54 │ + ╭─[language/expressions/object/method-definition/async-meth-dflt-params-rest.js:41:20] + 40 │ ({ + 41 │ async *method(...x = []) { + · ────── + 42 │ ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dstr/ary-ptrn-rest-init-obj.js:53:19] - 52 │ var f; - 53 │ f = function*([...{ x } = []]) { - · ────────── - 54 │ + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/async-meth-escaped-async.js:25:5] + 24 │ ({ + 25 │ \u0061sync m(){} + · ────────── + 26 │ }); ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/generators/dstr/ary-ptrn-rest-not-final-ary.js:53:16] - 52 │ var f; - 53 │ f = function*([...[x], y]) { - · ────── - 54 │ - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/async-meth-object-destructuring-param-strict-body.js:109:5] + 108 │ async *method({property}) { + 109 │ "use strict"; + · ───────────── + 110 │ } + ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/generators/dstr/ary-ptrn-rest-not-final-id.js:53:16] - 52 │ var f; - 53 │ f = function*([...x, y]) { - · ──── - 54 │ - ╰──── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/async-meth-rest-param-strict-body.js:109:5] + 108 │ async *method(a,...rest) { + 109 │ "use strict"; + · ───────────── + 110 │ } + ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/generators/dstr/ary-ptrn-rest-not-final-obj.js:53:16] - 52 │ var f; - 53 │ f = function*([...{ x }, y]) { - · ──────── - 54 │ + × A rest parameter must be last in a parameter list + ╭─[language/expressions/object/method-definition/async-meth-rest-params-trailing-comma-early-error.js:34:17] + 33 │ ({ + 34 │ async *method(...a,) { + · ──── + 35 │ ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-ary.js:53:19] - 52 │ var f; - 53 │ f = function*([...[ x ] = []] = []) { - · ────────── - 54 │ + × Identifier `a` has already been declared + ╭─[language/expressions/object/method-definition/early-errors-object-async-method-duplicate-parameters.js:27:13] + 26 │ ({ + 27 │ async foo(a, a) { } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `a` has already been declared here + 28 │ }) ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-id.js:53:19] - 52 │ var f; - 53 │ f = function*([...x = []] = []) { - · ────── - 54 │ + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/early-errors-object-method-NSPL-with-USD.js:16:15] + 15 │ ({ + 16 │ foo(x = 1) {"use strict"} + · ──────────── + 17 │ }); ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-obj.js:53:19] - 52 │ var f; - 53 │ f = function*([...{ x } = []] = []) { - · ────────── - 54 │ + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/object/method-definition/early-errors-object-method-arguments-in-formal-parameters.js:17:14] + 16 │ ({ + 17 │ async foo (arguments) { } + · ───────── + 18 │ }) ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-ary.js:53:16] - 52 │ var f; - 53 │ f = function*([...[x], y] = [1, 2, 3]) { - · ────── - 54 │ + × Expected `,` but found `Identifier` + ╭─[language/expressions/object/method-definition/early-errors-object-method-async-lineterminator.js:21:3] + 20 │ async + 21 │ foo() { } + · ─┬─ + · ╰── `,` expected + 22 │ }) ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-id.js:53:16] - 52 │ var f; - 53 │ f = function*([...x, y] = [1, 2, 3]) { - · ──── - 54 │ + × Unexpected token + ╭─[language/expressions/object/method-definition/early-errors-object-method-await-in-formals-default.js:16:23] + 15 │ ({ + 16 │ async foo (x = await) { } + · ─ + 17 │ }) ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-obj.js:53:16] - 52 │ var f; - 53 │ f = function*([...{ x }, y] = [1, 2, 3]) { - · ──────── - 54 │ + × Cannot use `await` as an identifier in an async context + ╭─[language/expressions/object/method-definition/early-errors-object-method-await-in-formals.js:16:14] + 15 │ ({ + 16 │ async foo (await) { } + · ───── + 17 │ }) ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/named-yield-as-binding-identifier-escaped.js:28:7] - 27 │ var gen = function *g() { - 28 │ var yi\u0065ld; - · ────────── - 29 │ }; + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/object/method-definition/early-errors-object-method-body-contains-super-call.js:16:18] + 15 │ ({ + 16 │ async foo () { super() } + · ─────── + 17 │ }) ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/named-yield-as-binding-identifier-escaped.js:28:7] - 27 │ var gen = function *g() { - 28 │ var yi\u0065ld; - · ────────── - 29 │ }; + × Identifier `a` has already been declared + ╭─[language/expressions/object/method-definition/early-errors-object-method-duplicate-parameters.js:26:7] + 25 │ ({ + 26 │ foo(a, a) { } + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `a` has already been declared here + 27 │ }) ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/named-yield-as-binding-identifier.js:28:7] - 27 │ var gen = function *g() { - 28 │ var yield; - · ───── - 29 │ }; + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/object/method-definition/early-errors-object-method-eval-in-formal-parameters.js:17:13] + 16 │ ({ + 17 │ async foo(eval) { } + · ──── + 18 │ }) ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/named-yield-as-binding-identifier.js:28:7] - 27 │ var gen = function *g() { - 28 │ var yield; - · ───── - 29 │ }; + × Expected `(` but found `Identifier` + ╭─[language/expressions/object/method-definition/early-errors-object-method-formals-body-duplicate.js:17:18] + 16 │ ({ + 17 │ async function foo(bar) { let bar; } + · ─┬─ + · ╰── `(` expected + 18 │ }) ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/named-yield-as-identifier-reference-escaped.js:28:8] - 27 │ var gen = function *g() { - 28 │ void yi\u0065ld; - · ────────── - 29 │ }; + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/object/method-definition/early-errors-object-method-formals-contains-super-call.js:15:19] + 14 │ ({ + 15 │ async foo(foo = super()) { } + · ─────── + 16 │ }) ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/named-yield-as-identifier-reference-escaped.js:28:8] - 27 │ var gen = function *g() { - 28 │ void yi\u0065ld; - · ────────── - 29 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-get-e.js:24:3] + 23 │ ({ + 24 │ g\u0065t m() {} + · ──────── + 25 │ }); ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/named-yield-as-identifier-reference.js:28:8] - 27 │ var gen = function *g() { - 28 │ void yield; - · ───── - 29 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-get-g.js:24:3] + 23 │ ({ + 24 │ \u0067et m() {} + · ──────── + 25 │ }); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/named-yield-as-identifier-reference.js:28:8] - 27 │ var gen = function *g() { - 28 │ void yield; - · ───── - 29 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-get-t.js:24:3] + 23 │ ({ + 24 │ ge\u0074 m() {} + · ──────── + 25 │ }); ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/generators/named-yield-as-label-identifier-escaped.js:28:3] - 27 │ var gen = function *g() { - 28 │ yi\u0065ld: ; - · ────────── - 29 │ }; + ╭─[language/expressions/object/method-definition/escaped-get.js:24:3] + 23 │ ({ + 24 │ \u0067\u0065\u0074 m() {} + · ────────────────── + 25 │ }); ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/generators/named-yield-as-label-identifier-escaped.js:28:13] - 27 │ var gen = function *g() { - 28 │ yi\u0065ld: ; - · ▲ - 29 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-set-e.js:24:3] + 23 │ ({ + 24 │ s\u0065t m(v) {} + · ──────── + 25 │ }); ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/generators/named-yield-as-label-identifier.js:28:8] - 27 │ var gen = function *g() { - 28 │ yield: ; - · ▲ - 29 │ }; + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-set-s.js:24:3] + 23 │ ({ + 24 │ \u0073et m(v) {} + · ──────── + 25 │ }); ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/named-yield-identifier-spread-strict.js:34:15] - 33 │ ...(function() { - 34 │ var yield; - · ───── - 35 │ throw new Test262Error(); + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-set-t.js:24:3] + 23 │ ({ + 24 │ se\u0074 m(v) {} + · ──────── + 25 │ }); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/named-yield-identifier-strict.js:26:11] - 25 │ (function() { - 26 │ var yield; - · ───── - 27 │ throw new Test262Error(); + × Keywords cannot contain escape characters + ╭─[language/expressions/object/method-definition/escaped-set.js:24:3] + 23 │ ({ + 24 │ \u0073\u0065\u0074 m(v) {} + · ────────────────── + 25 │ }); ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/generators/object-destructuring-param-strict-body.js:132:3] - 131 │ 0, function*({property}) { - 132 │ "use strict"; - · ───────────── - 133 │ }; + ╭─[language/expressions/object/method-definition/gen-meth-array-destructuring-param-strict-body.js:138:5] + 137 │ *method([element]) { + 138 │ "use strict"; + · ───────────── + 139 │ } ╰──── - × yield expression not allowed in formal parameter - ╭─[language/expressions/generators/param-dflt-yield.js:25:18] - 24 │ - 25 │ 0, function*(x = yield) {}; - · ──┬── - · ╰── yield expression not allowed in formal parameter + × Identifier `x` has already been declared + ╭─[language/expressions/object/method-definition/gen-meth-dflt-params-duplicates.js:66:11] + 65 │ 0, { + 66 │ *method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 67 │ + ╰──── + + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/method-definition/gen-meth-dflt-params-rest.js:70:14] + 69 │ 0, { + 70 │ *method(...x = []) { + · ────── + 71 │ ╰──── × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/generators/rest-param-strict-body.js:132:3] - 131 │ 0, function*(a,...rest) { - 132 │ "use strict"; - · ───────────── - 133 │ }; + ╭─[language/expressions/object/method-definition/gen-meth-object-destructuring-param-strict-body.js:138:5] + 137 │ *method({property}) { + 138 │ "use strict"; + · ───────────── + 139 │ } ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/generators/rest-params-trailing-comma-early-error.js:57:14] - 56 │ - 57 │ 0, function*(...a,) { - · ──── - 58 │ - ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/generators/use-strict-with-non-simple-param.js:21:3] - 20 │ var f = function*(a = 0) { - 21 │ "use strict"; - · ───────────── - 22 │ } + ╭─[language/expressions/object/method-definition/gen-meth-rest-param-strict-body.js:138:5] + 137 │ *method(a,...rest) { + 138 │ "use strict"; + · ───────────── + 139 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/object/method-definition/gen-meth-rest-params-trailing-comma-early-error.js:63:11] + 62 │ 0, { + 63 │ *method(...a,) { + · ──── + 64 │ ╰──── × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-as-binding-identifier-escaped.js:28:7] - 27 │ var gen = function *() { - 28 │ var yi\u0065ld; - · ────────── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js:29:9] + 28 │ *method() { + 29 │ var yi\u0065ld; + · ────────── + 30 │ } ╰──── × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-as-binding-identifier-escaped.js:28:7] - 27 │ var gen = function *() { - 28 │ var yi\u0065ld; - · ────────── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js:29:9] + 28 │ *method() { + 29 │ var yi\u0065ld; + · ────────── + 30 │ } ╰──── × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-as-binding-identifier.js:28:7] - 27 │ var gen = function *() { - 28 │ var yield; - · ───── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier.js:29:9] + 28 │ *method() { + 29 │ var yield; + · ───── + 30 │ } ╰──── × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-as-binding-identifier.js:28:7] - 27 │ var gen = function *() { - 28 │ var yield; - · ───── - 29 │ }; - ╰──── - - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-as-generator-expression-binding-identifier.js:17:19] - 16 │ - 17 │ var g = function* yield() {}; - · ───── + ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier.js:29:9] + 28 │ *method() { + 29 │ var yield; + · ───── + 30 │ } ╰──── × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-as-identifier-reference-escaped.js:28:8] - 27 │ var gen = function *() { - 28 │ void yi\u0065ld; - · ────────── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js:29:10] + 28 │ *method() { + 29 │ void yi\u0065ld; + · ────────── + 30 │ } ╰──── × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-as-identifier-reference-escaped.js:28:8] - 27 │ var gen = function *() { - 28 │ void yi\u0065ld; - · ────────── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js:29:10] + 28 │ *method() { + 29 │ void yi\u0065ld; + · ────────── + 30 │ } ╰──── × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-as-identifier-reference.js:28:8] - 27 │ var gen = function *() { - 28 │ void yield; - · ───── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference.js:29:10] + 28 │ *method() { + 29 │ void yield; + · ───── + 30 │ } ╰──── × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-as-identifier-reference.js:28:8] - 27 │ var gen = function *() { - 28 │ void yield; - · ───── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference.js:29:10] + 28 │ *method() { + 29 │ void yield; + · ───── + 30 │ } ╰──── × Keywords cannot contain escape characters - ╭─[language/expressions/generators/yield-as-label-identifier-escaped.js:28:3] - 27 │ var gen = function *() { - 28 │ yi\u0065ld: ; - · ────────── - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js:29:5] + 28 │ *method() { + 29 │ yi\u0065ld: ; + · ────────── + 30 │ } ╰──── × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/generators/yield-as-label-identifier-escaped.js:28:13] - 27 │ var gen = function *() { - 28 │ yi\u0065ld: ; - · ▲ - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js:29:15] + 28 │ *method() { + 29 │ yi\u0065ld: ; + · ▲ + 30 │ } ╰──── help: Try insert a semicolon here × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/generators/yield-as-label-identifier.js:28:8] - 27 │ var gen = function *() { - 28 │ yield: ; - · ▲ - 29 │ }; + ╭─[language/expressions/object/method-definition/gen-yield-as-label-identifier.js:29:10] + 28 │ *method() { + 29 │ yield: ; + · ▲ + 30 │ } ╰──── help: Try insert a semicolon here - × Unexpected token - ╭─[language/expressions/generators/yield-as-logical-or-expression.js:18:9] - 17 │ var g = function*() { - 18 │ yield ? yield : yield; - · ─ - 19 │ }; + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js:35:17] + 34 │ ...(function() { + 35 │ var yield; + · ───── + 36 │ throw new Test262Error(); + ╰──── + + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/gen-yield-identifier-strict.js:27:13] + 26 │ (function() { + 27 │ var yield; + · ───── + 28 │ throw new Test262Error(); ╰──── × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-as-parameter.js:17:19] - 16 │ - 17 │ var g = function*(yield) {}; - · ───── + ╭─[language/expressions/object/method-definition/generator-param-id-yield.js:19:11] + 18 │ ({ + 19 │ *method(yield) {} + · ───── + 20 │ }); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-as-parameter.js:17:19] - 16 │ - 17 │ var g = function*(yield) {}; - · ───── + × yield expression not allowed in formal parameter + ╭─[language/expressions/object/method-definition/generator-param-init-yield.js:20:17] + 19 │ ({ + 20 │ *method(x = yield) {} + · ──┬── + · ╰── yield expression not allowed in formal parameter + 21 │ }); ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-identifier-spread-strict.js:34:15] - 33 │ ...(function() { - 34 │ var yield; - · ───── - 35 │ throw new Test262Error(); + × Identifier `a` has already been declared + ╭─[language/expressions/object/method-definition/generator-param-redecl-const.js:20:10] + 19 │ var obj = { + 20 │ *foo(a) { + · ┬ + · ╰── `a` has already been declared here + 21 │ const a = 3; + · ┬ + · ╰── It can not be redeclared here + 22 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/generators/yield-identifier-strict.js:26:11] - 25 │ (function() { - 26 │ var yield; - · ───── - 27 │ throw new Test262Error(); + × Identifier `a` has already been declared + ╭─[language/expressions/object/method-definition/generator-param-redecl-let.js:20:10] + 19 │ var obj = { + 20 │ *foo(a) { + · ┬ + · ╰── `a` has already been declared here + 21 │ let a = 3; + · ┬ + · ╰── It can not be redeclared here + 22 │ } ╰──── - × Unexpected token - ╭─[language/expressions/generators/yield-star-after-newline.js:18:3] - 17 │ yield - 18 │ * 1 - · ─ - 19 │ }; + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/object/method-definition/generator-super-call-body.js:21:9] + 20 │ *foo(a) { + 21 │ super(); + · ─────── + 22 │ } ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/generators/yield-weak-binding.js:16:33] - 15 │ - 16 │ var g = function*() { yield 3 + yield 4; }; - · ───── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/object/method-definition/generator-super-call-param.js:20:14] + 19 │ var obj = { + 20 │ *foo(a = super()) { + · ─────── + 21 │ } ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/generators/yield-weak-binding.js:16:38] - 15 │ - 16 │ var g = function*() { yield 3 + yield 4; }; - · ▲ + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/generator-use-strict-with-non-simple-param.js:22:5] + 21 │ *m(a = 0) { + 22 │ "use strict"; + · ───────────── + 23 │ } ╰──── - help: Try insert a semicolon here - × Keywords cannot contain escape characters - ╭─[language/expressions/import.meta/syntax/escape-sequence-import.js:34:1] - 33 │ - 34 │ im\u0070ort.meta; - · ─────────── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/meth-array-destructuring-param-strict-body.js:134:5] + 133 │ method([element]) { + 134 │ "use strict"; + · ───────────── + 135 │ } + ╰──── + + × Identifier `x` has already been declared + ╭─[language/expressions/object/method-definition/meth-dflt-params-duplicates.js:62:10] + 61 │ 0, { + 62 │ method(x = 0, x) { + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here + 63 │ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/import.meta/syntax/escape-sequence-meta.js:34:8] - 33 │ - 34 │ import.m\u0065ta; - · ───────── + × A rest parameter cannot have an initializer + ╭─[language/expressions/object/method-definition/meth-dflt-params-rest.js:66:13] + 65 │ 0, { + 66 │ method(...x = []) { + · ────── + 67 │ ╰──── - × Unexpected import.meta expression - ╭─[language/expressions/import.meta/syntax/goal-script.js:18:1] - 17 │ - 18 │ import.meta; - · ─────────── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/meth-object-destructuring-param-strict-body.js:134:5] + 133 │ method({property}) { + 134 │ "use strict"; + · ───────────── + 135 │ } + ╰──── + + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/meth-rest-param-strict-body.js:134:5] + 133 │ method(a,...rest) { + 134 │ "use strict"; + · ───────────── + 135 │ } + ╰──── + + × A rest parameter must be last in a parameter list + ╭─[language/expressions/object/method-definition/meth-rest-params-trailing-comma-early-error.js:58:10] + 57 │ 0, { + 58 │ method(...a,) { + · ──── + 59 │ ╰──── - help: import.meta is only allowed in module code - × Cannot assign to this expression - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-array-destructuring-expr.js:31:2] - 30 │ - 31 │ [import.meta] = []; - · ─────────── + × Identifier `param` has already been declared + ╭─[language/expressions/object/method-definition/name-param-redecl.js:18:10] + 17 │ var obj = { + 18 │ method(param) { + · ──┬── + · ╰── `param` has already been declared here + 19 │ let param; + · ──┬── + · ╰── It can not be redeclared here + 20 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-array-rest-destructuring-expr.js:31:5] - 30 │ - 31 │ [...import.meta] = []; - · ─────────── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/object/method-definition/name-super-call-body.js:17:5] + 16 │ method() { + 17 │ super(); + · ─────── + 18 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-assignment-expr.js:31:1] - 30 │ - 31 │ import.meta = 0; - · ─────────── + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/expressions/object/method-definition/name-super-call-param.js:16:18] + 15 │ ({ + 16 │ method(param = super()) {} + · ─────── + 17 │ }); ╰──── × Unexpected token - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-for-await-of-loop.js:31:16] - 30 │ async function* f() { - 31 │ for await (import.meta of null) ; - · ─────────── - 32 │ } + ╭─[language/expressions/object/method-definition/private-name-early-error-async-fn-inside-class.js:24:11] + 23 │ field = { + 24 │ async #m() {} + · ── + 25 │ } ╰──── × Unexpected token - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-for-in-loop.js:30:6] - 29 │ - 30 │ for (import.meta in null) ; - · ─────────── + ╭─[language/expressions/object/method-definition/private-name-early-error-async-fn.js:23:9] + 22 │ var o = { + 23 │ async #m() {} + · ── + 24 │ }; ╰──── × Unexpected token - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-for-of-loop.js:30:6] - 29 │ - 30 │ for (import.meta of null) ; - · ─────────── + ╭─[language/expressions/object/method-definition/private-name-early-error-async-gen-inside-class.js:24:13] + 23 │ field = { + 24 │ async * #m() {} + · ── + 25 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-object-destructuring-expr.js:31:6] - 30 │ - 31 │ ({a: import.meta} = {}); - · ─────────── + × Unexpected token + ╭─[language/expressions/object/method-definition/private-name-early-error-async-gen.js:23:11] + 22 │ var o = { + 23 │ async * #m() {} + · ── + 24 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-object-rest-destructuring-expr.js:31:6] - 30 │ - 31 │ ({...import.meta} = {}); - · ─────────── + × Unexpected token + ╭─[language/expressions/object/method-definition/private-name-early-error-gen-inside-class.js:24:7] + 23 │ field = { + 24 │ * #m() {} + · ── + 25 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/import.meta/syntax/invalid-assignment-target-update-expr.js:32:1] - 31 │ - 32 │ import.meta++; - · ─────────── + × Unexpected token + ╭─[language/expressions/object/method-definition/private-name-early-error-gen.js:23:5] + 22 │ var o = { + 23 │ * #m() {} + · ── + 24 │ }; ╰──── × Unexpected token - ╭─[language/expressions/in/private-field-in-nested.js:25:15] - 24 │ constructor() { - 25 │ #field in #field in this; - · ────── - 26 │ } + ╭─[language/expressions/object/method-definition/private-name-early-error-get-method-inside-class.js:24:9] + 23 │ field = { + 24 │ get #m() {} + · ── + 25 │ } ╰──── × Unexpected token - ╭─[language/expressions/in/private-field-in.js:24:10] - 23 │ constructor() { - 24 │ for (#field in value;;) break; - · ────── + ╭─[language/expressions/object/method-definition/private-name-early-error-get-method.js:23:7] + 22 │ var o = { + 23 │ get #m() {} + · ── + 24 │ }; + ╰──── + + × Unexpected token + ╭─[language/expressions/object/method-definition/private-name-early-error-method-inside-class.js:24:5] + 23 │ field = { + 24 │ #m() {} + · ── 25 │ } ╰──── × Unexpected token - ╭─[language/expressions/in/private-field-invalid-assignment-reference.js:23:10] - 22 │ m() { - 23 │ for (#field in []) ; - · ────── - 24 │ } + ╭─[language/expressions/object/method-definition/private-name-early-error-method.js:23:3] + 22 │ var o = { + 23 │ #m() {} + · ── + 24 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/in/private-field-invalid-assignment-target.js:29:5] - 28 │ constructor() { - 29 │ #field in {} = 0; - · ──────────── - 30 │ } + × Unexpected token + ╭─[language/expressions/object/method-definition/private-name-early-error-set-method-inside-class.js:24:9] + 23 │ field = { + 24 │ set #m(x) {} + · ── + 25 │ } ╰──── - × Private field 'b' must be declared in an enclosing class - ╭─[language/expressions/in/private-field-invalid-identifier-complex.js:29:5] - 28 │ constructor() { - 29 │ #b in {}; - · ── - 30 │ } + × Unexpected token + ╭─[language/expressions/object/method-definition/private-name-early-error-set-method.js:23:7] + 22 │ var o = { + 23 │ set #m(x) {} + · ── + 24 │ }; ╰──── - × Private identifier '#name' is not allowed outside class bodies - ╭─[language/expressions/in/private-field-invalid-identifier-simple.js:25:1] - 24 │ - 25 │ #name in {}; - · ───── + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/setter-use-strict-with-non-simple-param.js:21:5] + 20 │ set m(a = 0) { + 21 │ "use strict"; + · ───────────── + 22 │ } ╰──── - × Empty parenthesized expression - ╭─[language/expressions/in/private-field-invalid-rhs.js:24:15] - 23 │ constructor() { - 24 │ #field in () => {}; - · ── - 25 │ } + × Illegal 'use strict' directive in function with non-simple parameter list + ╭─[language/expressions/object/method-definition/use-strict-with-non-simple-param.js:21:5] + 20 │ m(a = 0) { + 21 │ "use strict"; + · ───────────── + 22 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/in/private-field-rhs-yield-absent.js:31:15] - 30 │ static method() { - 31 │ #field in yield; - · ───── - 32 │ } + × Unexpected token + ╭─[language/expressions/object/method-definition/yield-as-logical-or-expression.js:18:11] + 17 │ *g() { + 18 │ yield ? yield : yield; + · ─ + 19 │ } ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/in/rhs-yield-absent-strict.js:20:8] - 19 │ - 20 │ '' in (yield); - · ───── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/object/method-definition/yield-as-parameter.js:18:6] + 17 │ var obj = { + 18 │ *g(yield) {} + · ───── + 19 │ }; ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/logical-assignment/lgcl-and-arguments-strict.js:18:1] - 17 │ - 18 │ arguments &&= 20; - · ───────── + × The keyword 'yield' is reserved + ╭─[language/expressions/object/method-definition/yield-as-parameter.js:18:6] + 17 │ var obj = { + 18 │ *g(yield) {} + · ───── + 19 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/logical-assignment/lgcl-and-assignment-operator-non-simple-lhs.js:19:1] - 18 │ function test() {} - 19 │ test() &&= 1; - · ────── + × Unexpected token + ╭─[language/expressions/object/method-definition/yield-star-after-newline.js:19:5] + 18 │ yield + 19 │ * 1 + · ─ + 20 │ } ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/logical-assignment/lgcl-and-eval-strict.js:17:1] - 16 │ - 17 │ eval &&= 20; - · ──── + × Cannot use `yield` as an identifier in a generator context + ╭─[language/expressions/object/method-definition/yield-weak-binding.js:17:20] + 16 │ var obj = { + 17 │ *g() { yield 3 + yield 4; } + · ───── + 18 │ }; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/logical-assignment/lgcl-and-non-simple.js:17:1] - 16 │ - 17 │ 1 &&= 1; - · ─ + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/expressions/object/method-definition/yield-weak-binding.js:17:25] + 16 │ var obj = { + 17 │ *g() { yield 3 + yield 4; } + · ▲ + 18 │ }; ╰──── + help: Try insert a semicolon here - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/logical-assignment/lgcl-nullish-arguments-strict.js:18:1] - 17 │ - 18 │ arguments ??= 20; - · ───────── + × Expected `(` but found `}` + ╭─[language/expressions/object/prop-def-invalid-async-prefix.js:35:14] + 34 │ + 35 │ ({async async}); + · ┬ + · ╰── `(` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-simple-lhs.js:19:1] - 18 │ function test() {} - 19 │ test() ??= 1; - · ────── + × Expected `(` but found `}` + ╭─[language/expressions/object/prop-def-invalid-star-prefix.js:21:8] + 20 │ + 21 │ ({* foo}); + · ┬ + · ╰── `(` expected ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/logical-assignment/lgcl-nullish-eval-strict.js:17:1] - 16 │ - 17 │ eval ??= 20; - · ──── + × The keyword 'public' is reserved + ╭─[language/expressions/object/setter-body-strict-inside.js:20:5] + 19 │ "use strict"; + 20 │ public = 42; + · ────── + 21 │ } ╰──── - × Cannot assign to this expression - ╭─[language/expressions/logical-assignment/lgcl-nullish-non-simple.js:17:1] - 16 │ - 17 │ 1 ??= 1; - · ─ + × The keyword 'public' is reserved + ╭─[language/expressions/object/setter-body-strict-outside.js:18:5] + 17 │ set x(value) { + 18 │ public = 42; + · ────── + 19 │ } ╰──── × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/logical-assignment/lgcl-or-arguments-strict.js:18:1] - 17 │ - 18 │ arguments ||= 20; - · ───────── + ╭─[language/expressions/object/setter-param-arguments-strict-inside.js:18:9] + 17 │ void { + 18 │ set x(arguments) { + · ───────── + 19 │ "use strict"; ╰──── - × Cannot assign to this expression - ╭─[language/expressions/logical-assignment/lgcl-or-assignment-operator-non-simple-lhs.js:19:1] - 18 │ function test() {} - 19 │ test() ||= 1; - · ────── + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/object/setter-param-arguments-strict-outside.js:18:9] + 17 │ void { + 18 │ set x(arguments) {} + · ───────── + 19 │ }; ╰──── × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/logical-assignment/lgcl-or-eval-strict.js:17:1] - 16 │ - 17 │ eval ||= 20; - · ──── - ╰──── - - × Cannot assign to this expression - ╭─[language/expressions/logical-assignment/lgcl-or-non-simple.js:17:1] - 16 │ - 17 │ 1 ||= 1; - · ─ + ╭─[language/expressions/object/setter-param-eval-strict-inside.js:18:9] + 17 │ void { + 18 │ set x(eval) { + · ──── + 19 │ "use strict"; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/new.target/escaped-new.js:24:5] - 23 │ function f() { - 24 │ n\u0065w.target; - · ──────── - 25 │ } + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/object/setter-param-eval-strict-outside.js:18:9] + 17 │ void { + 18 │ set x(eval) {} + · ──── + 19 │ }; ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/new.target/escaped-target.js:24:9] - 23 │ function f() { - 24 │ new.t\u0061rget; - · ─────────── - 25 │ } + × 'super' can only be referenced in a derived class. + ╭─[language/expressions/optional-chaining/call-expression-super-no-base.js:19:1] + 18 │ + 19 │ ╭─▶ class C { + 20 │ │ constructor () { + 21 │ │ super()?.a; + · │ ───── + 22 │ │ } + 23 │ ├─▶ } + · ╰──── class does not have `extends` ╰──── + help: either remove this super, or extend the class - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/object/11.1.5-1gs.js:18:31] - 17 │ - 18 │ var obj = { set _11_1_5_1_fun(eval) {}}; - · ──── + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string-esi.js:25:3] + 24 │ null?. + 25 │ `hello` + · ─────── ╰──── - × Identifier `__proto__` has already been declared - ╭─[language/expressions/object/__proto__-duplicate.js:20:3] - 19 │ ({ - 20 │ __proto__: null, - · ────┬──── - · ╰── `__proto__` has already been declared here - 21 │ other: null, - 22 │ '__proto__': null - · ─────┬───── - · ╰── It can not be redeclared here - 23 │ }); + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string.js:22:7] + 21 │ + 22 │ null?.`hello`; + · ─────── ╰──── - × Invalid assignment in object literal - ╭─[language/expressions/object/cover-initialized-name.js:32:4] - 31 │ - 32 │ ({ a = 1 }); - · ───── + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string-esi.js:25:3] + 24 │ null?.fn + 25 │ `hello` + · ─────── ╰──── - help: Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern. - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js:38:21] - 37 │ var obj = { - 38 │ async *method([...[ x ] = []]) { - · ────────── - 39 │ + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string.js:22:9] + 21 │ + 22 │ null?.fn`hello`; + · ─────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-id.js:38:21] - 37 │ var obj = { - 38 │ async *method([...x = []]) { - · ────── - 39 │ + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-op-template-string-esi.js:27:3] + 26 │ a?. + 27 │ `hello` + · ─────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js:38:21] - 37 │ var obj = { - 38 │ async *method([...{ x } = []]) { - · ────────── - 39 │ + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-op-template-string.js:24:4] + 23 │ + 24 │ a?.`hello`; + · ─────── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js:38:18] - 37 │ var obj = { - 38 │ async *method([...[x], y]) { - · ────── - 39 │ + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string-esi.js:27:3] + 26 │ a?.fn + 27 │ `hello` + · ─────── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js:38:18] - 37 │ var obj = { - 38 │ async *method([...x, y]) { - · ──── - 39 │ + × Tagged template expressions are not permitted in an optional chain + ╭─[language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string.js:24:6] + 23 │ + 24 │ a?.fn`hello`; + · ─────── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js:38:18] - 37 │ var obj = { - 38 │ async *method([...{ x }, y]) { - · ──────── - 39 │ + × Cannot assign to this expression + ╭─[language/expressions/optional-chaining/static-semantics-simple-assignment.js:23:1] + 22 │ + 23 │ obj?.a = 33; + · ────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js:38:21] - 37 │ var obj = { - 38 │ async *method([...[ x ] = []] = []) { - · ────────── - 39 │ + × Cannot assign to this expression + ╭─[language/expressions/optional-chaining/update-expression-postfix.js:23:1] + 22 │ const a = {}; + 23 │ a?.b++; + · ──── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js:38:21] - 37 │ var obj = { - 38 │ async *method([...x = []] = []) { - · ────── - 39 │ + × Cannot assign to this expression + ╭─[language/expressions/optional-chaining/update-expression-prefix.js:23:3] + 22 │ const a = {}; + 23 │ --a?.b; + · ──── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js:38:21] - 37 │ var obj = { - 38 │ async *method([...{ x } = []] = []) { - · ────────── - 39 │ + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/postfix-decrement/arguments.js:26:1] + 25 │ + 26 │ arguments--; + · ───────── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:38:18] - 37 │ var obj = { - 38 │ async *method([...[x], y] = [1, 2, 3]) { - · ────── - 39 │ + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/postfix-decrement/eval.js:26:1] + 25 │ + 26 │ eval--; + · ──── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js:38:18] - 37 │ var obj = { - 38 │ async *method([...x, y] = [1, 2, 3]) { - · ──── - 39 │ + × Unexpected token + ╭─[language/expressions/postfix-decrement/line-terminator-carriage-return.js:17:3] + 16 │ x + 17 │ --; + · ─ + 18 │ // The preceding line contains an unprintable CARRIAGE RETURN character (U+000D) ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:38:18] - 37 │ var obj = { - 38 │ async *method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 39 │ + × Unexpected token + ╭─[language/expressions/postfix-decrement/line-terminator-line-feed.js:17:3] + 16 │ x + 17 │ --; + · ─ ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-ary.js:58:15] - 57 │ var obj = { - 58 │ *method([...[ x ] = []]) { - · ────────── - 59 │ + × Unexpected token + ╭─[language/expressions/postfix-decrement/line-terminator-line-separator.js:16:7] + 15 │ + 16 │ x
--; + · ─ + 17 │ // The preceding line contains an unprintable LINE SEPARATOR character (U+2028) ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-id.js:58:15] - 57 │ var obj = { - 58 │ *method([...x = []]) { - · ────── - 59 │ + × Unexpected token + ╭─[language/expressions/postfix-decrement/line-terminator-paragraph-separator.js:16:7] + 15 │ + 16 │ x
--; + · ─ + 17 │ // The preceding line contains an unprintable PARAGRAPH SEPARATOR character ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-obj.js:58:15] - 57 │ var obj = { - 58 │ *method([...{ x } = []]) { - · ────────── - 59 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-decrement/target-cover-newtarget.js:30:4] + 29 │ function f() { + 30 │ (new.target)--; + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js:58:12] - 57 │ var obj = { - 58 │ *method([...[x], y]) { - · ────── - 59 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-decrement/target-cover-yieldexpr.js:33:4] + 32 │ function* g() { + 33 │ (yield)--; + · ───── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-id.js:58:12] - 57 │ var obj = { - 58 │ *method([...x, y]) { - · ──── - 59 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-decrement/target-newtarget.js:30:3] + 29 │ function f() { + 30 │ new.target--; + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js:58:12] - 57 │ var obj = { - 58 │ *method([...{ x }, y]) { - · ──────── - 59 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-decrement/this.js:27:1] + 26 │ + 27 │ this--; + · ──── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js:58:15] - 57 │ var obj = { - 58 │ *method([...[ x ] = []] = []) { - · ────────── - 59 │ + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/postfix-increment/11.3.1-2-1gs.js:17:1] + 16 │ + 17 │ arguments++; + · ───────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js:58:15] - 57 │ var obj = { - 58 │ *method([...x = []] = []) { - · ────── - 59 │ + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/postfix-increment/arguments.js:22:1] + 21 │ + 22 │ arguments++; + · ───────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js:58:15] - 57 │ var obj = { - 58 │ *method([...{ x } = []] = []) { - · ────────── - 59 │ + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/postfix-increment/eval.js:22:1] + 21 │ + 22 │ eval++; + · ──── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js:58:12] - 57 │ var obj = { - 58 │ *method([...[x], y] = [1, 2, 3]) { - · ────── - 59 │ + × Unexpected token + ╭─[language/expressions/postfix-increment/line-terminator-carriage-return.js:17:3] + 16 │ x + 17 │ ++; + · ─ + 18 │ // The preceding line contains an unprintable CARRIAGE RETURN character (U+000D) ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js:58:12] - 57 │ var obj = { - 58 │ *method([...x, y] = [1, 2, 3]) { - · ──── - 59 │ + × Unexpected token + ╭─[language/expressions/postfix-increment/line-terminator-line-feed.js:17:3] + 16 │ x + 17 │ ++; + · ─ ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js:58:12] - 57 │ var obj = { - 58 │ *method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 59 │ + × Unexpected token + ╭─[language/expressions/postfix-increment/line-terminator-line-separator.js:16:7] + 15 │ + 16 │ x
++; + · ─ + 17 │ // The preceding line contains an unprintable LINE SEPARATOR character (U+2028) ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-init-ary.js:55:14] - 54 │ var obj = { - 55 │ method([...[ x ] = []]) { - · ────────── - 56 │ + × Unexpected token + ╭─[language/expressions/postfix-increment/line-terminator-paragraph-separator.js:16:7] + 15 │ + 16 │ x
++; + · ─ + 17 │ // The preceding line contains an unprintable PARAGRAPH SEPARATOR character ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-init-id.js:55:14] - 54 │ var obj = { - 55 │ method([...x = []]) { - · ────── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-increment/target-cover-newtarget.js:30:4] + 29 │ function f() { + 30 │ (new.target)++; + · ────────── + 31 │ } ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-init-obj.js:55:14] - 54 │ var obj = { - 55 │ method([...{ x } = []]) { - · ────────── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-increment/target-cover-yieldexpr.js:33:4] + 32 │ function* g() { + 33 │ (yield)++; + · ───── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-ary.js:55:11] - 54 │ var obj = { - 55 │ method([...[x], y]) { - · ────── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-increment/target-newtarget.js:30:3] + 29 │ function f() { + 30 │ new.target++; + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-id.js:55:11] - 54 │ var obj = { - 55 │ method([...x, y]) { - · ──── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/postfix-increment/this.js:27:1] + 26 │ + 27 │ this++; + · ──── ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-obj.js:55:11] - 54 │ var obj = { - 55 │ method([...{ x }, y]) { - · ──────── - 56 │ + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/prefix-decrement/11.4.5-2-2gs.js:17:3] + 16 │ + 17 │ --arguments; + · ───────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-ary.js:55:14] - 54 │ var obj = { - 55 │ method([...[ x ] = []] = []) { - · ────────── - 56 │ + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/prefix-decrement/arguments.js:26:3] + 25 │ + 26 │ --arguments; + · ───────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-id.js:55:14] - 54 │ var obj = { - 55 │ method([...x = []] = []) { - · ────── - 56 │ + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/prefix-decrement/eval.js:26:3] + 25 │ + 26 │ --eval; + · ──── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-obj.js:55:14] - 54 │ var obj = { - 55 │ method([...{ x } = []] = []) { - · ────────── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/prefix-decrement/target-cover-newtarget.js:30:6] + 29 │ function f() { + 30 │ --(new.target); + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js:55:11] - 54 │ var obj = { - 55 │ method([...[x], y] = [1, 2, 3]) { - · ────── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/prefix-decrement/target-cover-yieldexpr.js:33:6] + 32 │ function* g() { + 33 │ --(yield); + · ───── + 34 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js:55:11] - 54 │ var obj = { - 55 │ method([...x, y] = [1, 2, 3]) { - · ──── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/prefix-decrement/target-newtarget.js:30:5] + 29 │ function f() { + 30 │ --new.target; + · ────────── + 31 │ } ╰──── - × A rest element must be last in a destructuring pattern - ╭─[language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js:55:11] - 54 │ var obj = { - 55 │ method([...{ x }, y] = [1, 2, 3]) { - · ──────── - 56 │ + × Cannot assign to this expression + ╭─[language/expressions/prefix-decrement/this.js:27:3] + 26 │ + 27 │ --this; + · ──── ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/object/getter-body-strict-inside.js:20:5] - 19 │ "use strict"; - 20 │ public = 42; - · ────── - 21 │ } + × Cannot assign to 'arguments' in strict mode + ╭─[language/expressions/prefix-increment/arguments.js:26:3] + 25 │ + 26 │ ++arguments; + · ───────── ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/object/getter-body-strict-outside.js:18:5] - 17 │ get x() { - 18 │ public = 42; - · ────── - 19 │ } + × Cannot assign to 'eval' in strict mode + ╭─[language/expressions/prefix-increment/eval.js:27:3] + 26 │ + 27 │ ++eval; + · ──── ╰──── - × A 'get' accessor must not have any formal parameters. - ╭─[language/expressions/object/getter-param-dflt.js:23:11] - 22 │ - 23 │ 0, { get a(param = null) {} }; - · ────────────── + × Cannot assign to this expression + ╭─[language/expressions/prefix-increment/target-cover-newtarget.js:30:6] + 29 │ function f() { + 30 │ ++(new.target); + · ────────── + 31 │ } ╰──── - × The keyword 'implements' is reserved - ╭─[language/expressions/object/identifier-shorthand-implements-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ implements + × Cannot assign to this expression + ╭─[language/expressions/prefix-increment/target-cover-yieldexpr.js:33:6] + 32 │ function* g() { + 33 │ ++(yield); + · ───── + 34 │ } + ╰──── + + × Cannot assign to this expression + ╭─[language/expressions/prefix-increment/target-newtarget.js:30:5] + 29 │ function f() { + 30 │ ++new.target; · ────────── - 32 │ }); + 31 │ } ╰──── - × The keyword 'interface' is reserved - ╭─[language/expressions/object/identifier-shorthand-interface-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ interface - · ───────── - 32 │ }); + × Cannot assign to this expression + ╭─[language/expressions/prefix-increment/this.js:27:3] + 26 │ + 27 │ ++this; + · ──── ╰──── × Unexpected token - ╭─[language/expressions/object/identifier-shorthand-invalid-computed-name.js:29:6] - 28 │ - 29 │ ({[x]}); - · ─ + ╭─[language/expressions/property-accessors/non-identifier-name.js:20:23] + 19 │ + 20 │ unresolvableReference.""; + · ── ╰──── - × Unexpected token - ╭─[language/expressions/object/identifier-shorthand-invalid-zero.js:22:4] - 21 │ - 22 │ ({0}); - · ─ + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-1.js:13:2] + 12 │ + 13 │ `\x0`; + · ─── ╰──── - × The keyword 'let' is reserved - ╭─[language/expressions/object/identifier-shorthand-let-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ let - · ─── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-2.js:13:2] + 12 │ + 13 │ `\x0G`; + · ──── ╰──── - × The keyword 'package' is reserved - ╭─[language/expressions/object/identifier-shorthand-package-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ package - · ─────── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-3.js:13:2] + 12 │ + 13 │ `\xG`; + · ─── ╰──── - × The keyword 'private' is reserved - ╭─[language/expressions/object/identifier-shorthand-private-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ private - · ─────── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-legacy-octal-escape-sequence-8.js:27:2] + 26 │ + 27 │ `\8`; + · ── ╰──── - × The keyword 'protected' is reserved - ╭─[language/expressions/object/identifier-shorthand-protected-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ protected - · ───────── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-legacy-octal-escape-sequence-9.js:27:2] + 26 │ + 27 │ `\9`; + · ── ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/object/identifier-shorthand-public-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ public - · ────── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-legacy-octal-escape-sequence.js:26:2] + 25 │ + 26 │ `\00`; + · ─── ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/object/identifier-shorthand-static-init-await-invalid.js:23:8] - 22 │ static { - 23 │ ({ await }); - · ───── - 24 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-1.js:13:2] + 12 │ + 13 │ `\u0`; + · ─── ╰──── - × Cannot use await in class static initialization block - ╭─[language/expressions/object/identifier-shorthand-static-init-await-invalid.js:23:8] - 22 │ static { - 23 │ ({ await }); - · ───── - 24 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-2.js:13:2] + 12 │ + 13 │ `\u0g`; + · ──── ╰──── - × The keyword 'static' is reserved - ╭─[language/expressions/object/identifier-shorthand-static-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ static - · ────── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-3.js:13:2] + 12 │ + 13 │ `\u00g`; + · ───── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/identifier-shorthand-yield-invalid-strict-mode.js:31:5] - 30 │ ({ - 31 │ yield - · ───── - 32 │ }); + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-4.js:13:2] + 12 │ + 13 │ `\u000g`; + · ────── ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/object/method-definition/async-await-as-binding-identifier-escaped.js:30:9] - 29 │ async method() { - 30 │ var \u0061wait; - · ────────── - 31 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-5.js:13:2] + 12 │ + 13 │ `\u{g`; + · ──── ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/object/method-definition/async-await-as-binding-identifier.js:30:9] - 29 │ async method() { - 30 │ var await; - · ───── - 31 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-6.js:13:2] + 12 │ + 13 │ `\u{0`; + · ──── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js:30:10] - 29 │ async method() { - 30 │ void \u0061wait; - · ────────── - 31 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-7.js:13:2] + 12 │ + 13 │ `\u{10FFFFF}`; + · ─────────── ╰──── - × Unexpected token - ╭─[language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js:30:20] - 29 │ async method() { - 30 │ void \u0061wait; - · ─ - 31 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-8.js:13:2] + 12 │ + 13 │ `\u{10FFFFF}${'inner'}right`; + · ─────────── ╰──── - × Unexpected token - ╭─[language/expressions/object/method-definition/async-await-as-identifier-reference.js:30:15] - 29 │ async method() { - 30 │ void await; - · ─ - 31 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/unicode-escape-nls-err.js:55:2] + 54 │ + 55 │ `\u{1F_639}`; + · ────────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js:30:5] - 29 │ async method() { - 30 │ \u0061wait: ; - · ────────── - 31 │ } + × Bad escape sequence in untagged template literal + ╭─[language/expressions/template-literal/unicode-escape-no-hex-err.js:50:2] + 49 │ + 50 │ `\u` + · ── ╰──── - × Unexpected token - ╭─[language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js:30:15] - 29 │ async method() { - 30 │ \u0061wait: ; - · ─ - 31 │ } + × Cannot assign to this expression + ╭─[language/expressions/this/S11.1.1_A1.js:15:1] + 14 │ + 15 │ this = 1; + · ──── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/async-await-as-label-identifier.js:30:10] - 29 │ async method() { - 30 │ await: ; - · ─ - 31 │ } + ╭─[language/expressions/yield/in-iteration-stmt.js:22:8] + 21 │ function* g() { + 22 │ for (yield '' in {}; ; ) ; + · ──────── + 23 │ } ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/object/method-definition/async-gen-await-as-binding-identifier-escaped.js:29:9] - 28 │ async *method() { - 29 │ var \u0061wait; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/expressions/yield/invalid-left-hand-side.js:27:9] + 26 │ function* g() { + 27 │ yield = 1; + · ─ + 28 │ } ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/object/method-definition/async-gen-await-as-binding-identifier.js:29:9] - 28 │ async *method() { - 29 │ var await; - · ───── - 30 │ } + × Unexpected token + ╭─[language/expressions/yield/star-in-iteration-stmt.js:22:8] + 21 │ function* g() { + 22 │ for (yield * '' in {}; ; ) ; + · ────────── + 23 │ } ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js:29:10] - 28 │ async *method() { - 29 │ void \u0061wait; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/future-reserved-words/class.js:20:5] + 19 │ + 20 │ var class = 1; + · ───── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js:29:20] - 28 │ async *method() { - 29 │ void \u0061wait; - · ─ - 30 │ } + ╭─[language/future-reserved-words/const.js:20:5] + 19 │ + 20 │ var const = 1; + · ───── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/async-gen-await-as-identifier-reference.js:29:15] - 28 │ async *method() { - 29 │ void await; - · ─ - 30 │ } + ╭─[language/future-reserved-words/debugger.js:20:5] + 19 │ + 20 │ var debugger = 1; + · ──────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js:29:5] - 28 │ async *method() { - 29 │ \u0061wait: ; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/future-reserved-words/enum.js:20:5] + 19 │ + 20 │ var enum = 1; + · ──── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js:29:15] - 28 │ async *method() { - 29 │ \u0061wait: ; - · ─ - 30 │ } + ╭─[language/future-reserved-words/export.js:20:5] + 19 │ + 20 │ var export = 1; + · ────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/async-gen-await-as-label-identifier.js:29:10] - 28 │ async *method() { - 29 │ await: ; - · ─ - 30 │ } + ╭─[language/future-reserved-words/extends.js:20:5] + 19 │ + 20 │ var extends = 1; + · ─────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/async-gen-meth-array-destructuring-param-strict-body.js:116:5] - 115 │ async *method([element]) { - 116 │ "use strict"; - · ───────────── - 117 │ } - ╰──── + × The keyword 'implements' is reserved + ╭─[language/future-reserved-words/implements-strict-escaped.js:24:5] + 23 │ + 24 │ var \u0069mplements = 123; + · ─────────────── + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/object/method-definition/async-gen-meth-dflt-params-duplicates.js:44:17] - 43 │ 0, { - 44 │ async *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 45 │ + × The keyword 'implements' is reserved + ╭─[language/future-reserved-words/implements-strict.js:23:5] + 22 │ + 23 │ var implements = 1; + · ────────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/method-definition/async-gen-meth-dflt-params-rest.js:48:20] - 47 │ 0, { - 48 │ async *method(...x = []) { - · ────── - 49 │ + × Unexpected token + ╭─[language/future-reserved-words/import.js:20:5] + 19 │ + 20 │ var import = 1; + · ────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-gen-meth-escaped-async.js:25:5] - 24 │ ({ - 25 │ \u0061sync* m(){} - · ────────── - 26 │ }); + × The keyword 'interface' is reserved + ╭─[language/future-reserved-words/interface-strict-escaped.js:24:5] + 23 │ + 24 │ var inte\u0072face = 123; + · ────────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/async-gen-meth-object-destructuring-param-strict-body.js:116:5] - 115 │ async *method({property}) { - 116 │ "use strict"; - · ───────────── - 117 │ } - ╰──── + × The keyword 'interface' is reserved + ╭─[language/future-reserved-words/interface-strict.js:23:5] + 22 │ + 23 │ var interface = 1; + · ───────── + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/async-gen-meth-rest-param-strict-body.js:116:5] - 115 │ async *method(a,...rest) { - 116 │ "use strict"; - · ───────────── - 117 │ } - ╰──── + × The keyword 'let' is reserved + ╭─[language/future-reserved-words/let-strict-escaped.js:24:5] + 23 │ + 24 │ var l\u0065t = 123; + · ──────── + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/object/method-definition/async-gen-meth-rest-params-trailing-comma-early-error.js:41:17] - 40 │ 0, { - 41 │ async *method(...a,) { - · ──── - 42 │ + × The keyword 'let' is reserved + ╭─[language/future-reserved-words/let-strict.js:23:5] + 22 │ + 23 │ var let = 1; + · ─── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js:29:9] - 28 │ async *method() { - 29 │ var yi\u0065ld; - · ────────── - 30 │ } + × The keyword 'package' is reserved + ╭─[language/future-reserved-words/package-strict-escaped.js:24:5] + 23 │ + 24 │ var packag\u0065 = 123; + · ──────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js:29:9] - 28 │ async *method() { - 29 │ var yi\u0065ld; - · ────────── - 30 │ } + × The keyword 'package' is reserved + ╭─[language/future-reserved-words/package-strict.js:23:5] + 22 │ + 23 │ var package = 1; + · ─────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js:29:9] - 28 │ async *method() { - 29 │ var yield; - · ───── - 30 │ } + × The keyword 'private' is reserved + ╭─[language/future-reserved-words/private-strict-escaped.js:24:5] + 23 │ + 24 │ var privat\u0065 = 123; + · ──────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js:29:9] - 28 │ async *method() { - 29 │ var yield; - · ───── - 30 │ } + × The keyword 'private' is reserved + ╭─[language/future-reserved-words/private-strict.js:23:5] + 22 │ + 23 │ var private = 1; + · ─────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js:29:10] - 28 │ async *method() { - 29 │ void yi\u0065ld; - · ────────── - 30 │ } + × The keyword 'protected' is reserved + ╭─[language/future-reserved-words/protected-strict-escaped.js:25:5] + 24 │ + 25 │ var \u0070\u0072\u006f\u0074\u0065\u0063\u0074\u0065\u0064 = 123; + · ────────────────────────────────────────────────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js:29:10] - 28 │ async *method() { - 29 │ void yi\u0065ld; - · ────────── - 30 │ } + × The keyword 'protected' is reserved + ╭─[language/future-reserved-words/protected-strict.js:23:5] + 22 │ + 23 │ var protected = 1; + · ───────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js:29:10] - 28 │ async *method() { - 29 │ void yield; - · ───── - 30 │ } + × The keyword 'public' is reserved + ╭─[language/future-reserved-words/public-strict-escaped.js:24:5] + 23 │ + 24 │ var \u0070\u0075\u0062\u006c\u0069\u0063 = 123; + · ──────────────────────────────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js:29:10] - 28 │ async *method() { - 29 │ void yield; - · ───── - 30 │ } + × The keyword 'public' is reserved + ╭─[language/future-reserved-words/public-strict.js:23:5] + 22 │ + 23 │ var public = 1; + · ────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js:29:5] - 28 │ async *method() { - 29 │ yi\u0065ld: ; - · ────────── - 30 │ } + × The keyword 'static' is reserved + ╭─[language/future-reserved-words/static-strict-escaped.js:24:5] + 23 │ + 24 │ var \u0073\u0074\u0061\u0074\u0069\u0063 = 123; + · ──────────────────────────────────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js:29:15] - 28 │ async *method() { - 29 │ yi\u0065ld: ; - · ▲ - 30 │ } + × The keyword 'static' is reserved + ╭─[language/future-reserved-words/static-strict.js:23:5] + 22 │ + 23 │ var static = 1; + · ────── ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/object/method-definition/async-gen-yield-as-label-identifier.js:29:10] - 28 │ async *method() { - 29 │ yield: ; - · ▲ - 30 │ } + × Unexpected token + ╭─[language/future-reserved-words/super.js:20:5] + 19 │ + 20 │ var super = 1; + · ───── ╰──── - help: Try insert a semicolon here × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js:35:17] - 34 │ ...(function() { - 35 │ var yield; - · ───── - 36 │ throw new Test262Error(); + ╭─[language/future-reserved-words/yield-strict-escaped.js:24:5] + 23 │ + 24 │ var \u0079ield = 123; + · ────────── ╰──── × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/async-gen-yield-identifier-strict.js:27:13] - 26 │ (function() { - 27 │ var yield; - · ───── - 28 │ throw new Test262Error(); + ╭─[language/future-reserved-words/yield-strict.js:22:5] + 21 │ + 22 │ var yield = 1; + · ───── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/async-meth-array-destructuring-param-strict-body.js:109:5] - 108 │ async *method([element]) { - 109 │ "use strict"; - · ───────────── - 110 │ } - ╰──── + × Cannot use export statement outside a module + ╭─[language/global-code/export.js:21:1] + 20 │ + 21 │ export default null; + · ────── + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/object/method-definition/async-meth-dflt-params-duplicates.js:37:17] - 36 │ ({ - 37 │ async *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 38 │ + × Cannot use import statement outside a module + ╭─[language/global-code/import.js:21:1] + 20 │ + 21 │ import v from './import.js'; + · ────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/method-definition/async-meth-dflt-params-rest.js:41:20] - 40 │ ({ - 41 │ async *method(...x = []) { - · ────── - 42 │ + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/global-code/invalid-private-names-call-expression-bad-reference.js:40:14] + 39 │ + 40 │ (() => {})().#x + · ── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/async-meth-escaped-async.js:25:5] - 24 │ ({ - 25 │ \u0061sync m(){} - · ────────── - 26 │ }); + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/global-code/invalid-private-names-call-expression-this.js:40:16] + 39 │ + 40 │ (() => this)().#x + · ── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/async-meth-object-destructuring-param-strict-body.js:109:5] - 108 │ async *method({property}) { - 109 │ "use strict"; - · ───────────── - 110 │ } - ╰──── + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/global-code/invalid-private-names-member-expression-bad-reference.js:40:11] + 39 │ + 40 │ something.#x + · ── + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/async-meth-rest-param-strict-body.js:109:5] - 108 │ async *method(a,...rest) { - 109 │ "use strict"; - · ───────────── - 110 │ } - ╰──── + × Private identifier '#x' is not allowed outside class bodies + ╭─[language/global-code/invalid-private-names-member-expression-this.js:40:6] + 39 │ + 40 │ this.#x + · ── + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/object/method-definition/async-meth-rest-params-trailing-comma-early-error.js:34:17] - 33 │ ({ - 34 │ async *method(...a,) { - · ──── - 35 │ + × Unexpected new.target expression + ╭─[language/global-code/new.target-arrow.js:36:3] + 35 │ () => { + 36 │ new.target; + · ────────── + 37 │ }; ╰──── + help: new.target is only allowed in constructors and functions invoked using thew `new` operator - × Identifier `a` has already been declared - ╭─[language/expressions/object/method-definition/early-errors-object-async-method-duplicate-parameters.js:27:13] - 26 │ ({ - 27 │ async foo(a, a) { } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `a` has already been declared here - 28 │ }) + × Unexpected new.target expression + ╭─[language/global-code/new.target.js:20:1] + 19 │ + 20 │ new.target; + · ────────── ╰──── + help: new.target is only allowed in constructors and functions invoked using thew `new` operator - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/early-errors-object-method-NSPL-with-USD.js:16:15] - 15 │ ({ - 16 │ foo(x = 1) {"use strict"} - · ──────────── - 17 │ }); + × TS(1108): A 'return' statement can only be used within a function body. + ╭─[language/global-code/return.js:22:1] + 21 │ + 22 │ return; + · ────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/object/method-definition/early-errors-object-method-arguments-in-formal-parameters.js:17:14] - 16 │ ({ - 17 │ async foo (arguments) { } - · ───────── - 18 │ }) + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/global-code/super-call-arrow.js:36:3] + 35 │ () => { + 36 │ super(); + · ─────── + 37 │ }; ╰──── - × Expected `,` but found `Identifier` - ╭─[language/expressions/object/method-definition/early-errors-object-method-async-lineterminator.js:21:3] - 20 │ async - 21 │ foo() { } - · ─┬─ - · ╰── `,` expected - 22 │ }) + × Super calls are not permitted outside constructors or in nested functions inside constructors. + ╭─[language/global-code/super-call.js:20:1] + 19 │ + 20 │ super(); + · ─────── ╰──── - × Unexpected token - ╭─[language/expressions/object/method-definition/early-errors-object-method-await-in-formals-default.js:16:23] - 15 │ ({ - 16 │ async foo (x = await) { } - · ─ - 17 │ }) + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/global-code/super-prop-arrow.js:36:3] + 35 │ () => { + 36 │ super.property; + · ───── + 37 │ }; ╰──── - × Cannot use `await` as an identifier in an async context - ╭─[language/expressions/object/method-definition/early-errors-object-method-await-in-formals.js:16:14] - 15 │ ({ - 16 │ async foo (await) { } - · ───── - 17 │ }) + × 'super' can only be referenced in members of derived classes or object literal expressions. + ╭─[language/global-code/super-prop.js:20:1] + 19 │ + 20 │ super.property; + · ───── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/object/method-definition/early-errors-object-method-body-contains-super-call.js:16:18] - 15 │ ({ - 16 │ async foo () { super() } - · ─────── - 17 │ }) + × The keyword 'yield' is reserved + ╭─[language/global-code/yield-strict.js:25:1] + 24 │ + 25 │ yield; + · ───── ╰──── - × Identifier `a` has already been declared - ╭─[language/expressions/object/method-definition/early-errors-object-method-duplicate-parameters.js:26:7] - 25 │ ({ - 26 │ foo(a, a) { } - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `a` has already been declared here - 27 │ }) + × Unexpected token + ╭─[language/identifier-resolution/static-init-invalid-await.js:23:10] + 22 │ static { + 23 │ await; + · ─ + 24 │ } + ╰──── + + × Invalid Character `‍` + ╭─[language/identifiers/start-zwj-escaped.js:15:11] + 14 │ + 15 │ var \u200D; + · ▲ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/object/method-definition/early-errors-object-method-eval-in-formal-parameters.js:17:13] - 16 │ ({ - 17 │ async foo(eval) { } - · ──── - 18 │ }) + × Invalid Character `‌` + ╭─[language/identifiers/start-zwnj-escaped.js:15:11] + 14 │ + 15 │ var \u200C; + · ▲ ╰──── - × Expected `(` but found `Identifier` - ╭─[language/expressions/object/method-definition/early-errors-object-method-formals-body-duplicate.js:17:18] - 16 │ ({ - 17 │ async function foo(bar) { let bar; } - · ─┬─ - · ╰── `(` expected - 18 │ }) + × Invalid Unicode escape sequence + ╭─[language/identifiers/unicode-escape-nls-err.js:48:6] + 47 │ + 48 │ var \u{00_76} = 1; + · ──── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/object/method-definition/early-errors-object-method-formals-contains-super-call.js:15:19] - 14 │ ({ - 15 │ async foo(foo = super()) { } - · ─────── - 16 │ }) + × Unexpected token + ╭─[language/identifiers/unicode-escape-nls-err.js:48:13] + 47 │ + 48 │ var \u{00_76} = 1; + · ─ ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-get-e.js:24:3] - 23 │ ({ - 24 │ g\u0065t m() {} - · ──────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-break-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{62}\u{72}\u{65}\u{61}\u{6b} = 123;; + · ────────────────────────────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-get-g.js:24:3] - 23 │ ({ - 24 │ \u0067et m() {} - · ──────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-break-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0062\u0072\u0065\u0061\u006b = 123;; + · ────────────────────────────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-get-t.js:24:3] - 23 │ ({ - 24 │ ge\u0074 m() {} - · ──────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-break.js:15:5] + 14 │ + 15 │ var break = 123;; + · ───── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-get.js:24:3] - 23 │ ({ - 24 │ \u0067\u0065\u0074 m() {} - · ────────────────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-case-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{63}ase = 123; + · ───────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-set-e.js:24:3] - 23 │ ({ - 24 │ s\u0065t m(v) {} - · ──────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-case-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0063ase = 123; + · ───────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-set-s.js:24:3] - 23 │ ({ - 24 │ \u0073et m(v) {} - · ──────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-case.js:15:5] + 14 │ + 15 │ var case = 123; + · ──── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-set-t.js:24:3] - 23 │ ({ - 24 │ se\u0074 m(v) {} - · ──────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-catch-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{63}atch = 123; + · ────────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/escaped-set.js:24:3] - 23 │ ({ - 24 │ \u0073\u0065\u0074 m(v) {} - · ────────────────── - 25 │ }); + × Unexpected token + ╭─[language/identifiers/val-catch-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0063atch = 123; + · ────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/gen-meth-array-destructuring-param-strict-body.js:138:5] - 137 │ *method([element]) { - 138 │ "use strict"; - · ───────────── - 139 │ } - ╰──── - - × Identifier `x` has already been declared - ╭─[language/expressions/object/method-definition/gen-meth-dflt-params-duplicates.js:66:11] - 65 │ 0, { - 66 │ *method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 67 │ + × Unexpected token + ╭─[language/identifiers/val-catch.js:15:5] + 14 │ + 15 │ var catch = 123; + · ───── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/method-definition/gen-meth-dflt-params-rest.js:70:14] - 69 │ 0, { - 70 │ *method(...x = []) { - · ────── - 71 │ + × Unexpected token + ╭─[language/identifiers/val-class-via-escape-hex.js:16:5] + 15 │ + 16 │ var cla\u{73}s = 123; + · ────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/gen-meth-object-destructuring-param-strict-body.js:138:5] - 137 │ *method({property}) { - 138 │ "use strict"; - · ───────────── - 139 │ } - ╰──── + × Unexpected token + ╭─[language/identifiers/val-class-via-escape-hex4.js:16:5] + 15 │ + 16 │ var cla\u0073s = 123; + · ────────── + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/gen-meth-rest-param-strict-body.js:138:5] - 137 │ *method(a,...rest) { - 138 │ "use strict"; - · ───────────── - 139 │ } - ╰──── + × Unexpected token + ╭─[language/identifiers/val-class.js:15:5] + 14 │ + 15 │ var class = 123; + · ───── + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/object/method-definition/gen-meth-rest-params-trailing-comma-early-error.js:63:11] - 62 │ 0, { - 63 │ *method(...a,) { - · ──── - 64 │ + × Unexpected token + ╭─[language/identifiers/val-const-via-escape-hex.js:16:5] + 15 │ + 16 │ var co\u{6e}st = 123; + · ────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js:29:9] - 28 │ *method() { - 29 │ var yi\u0065ld; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-const-via-escape-hex4.js:16:5] + 15 │ + 16 │ var co\u006est = 123; + · ────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js:29:9] - 28 │ *method() { - 29 │ var yi\u0065ld; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-const.js:15:5] + 14 │ + 15 │ var const = 123; + · ───── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier.js:29:9] - 28 │ *method() { - 29 │ var yield; - · ───── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-continue-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{63}ontinue = 123; + · ───────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/gen-yield-as-binding-identifier.js:29:9] - 28 │ *method() { - 29 │ var yield; - · ───── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-continue-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0063ontinue = 123; + · ───────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js:29:10] - 28 │ *method() { - 29 │ void yi\u0065ld; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-continue.js:15:5] + 14 │ + 15 │ var continue = 123; + · ──────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js:29:10] - 28 │ *method() { - 29 │ void yi\u0065ld; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-debugger-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{64}ebugger = 123; + · ───────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference.js:29:10] - 28 │ *method() { - 29 │ void yield; - · ───── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-debugger-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0064ebugger = 123; + · ───────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/gen-yield-as-identifier-reference.js:29:10] - 28 │ *method() { - 29 │ void yield; - · ───── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-debugger.js:15:5] + 14 │ + 15 │ var debugger = 123; + · ──────── ╰──── - × Keywords cannot contain escape characters - ╭─[language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js:29:5] - 28 │ *method() { - 29 │ yi\u0065ld: ; - · ────────── - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-default-via-escape-hex.js:16:5] + 15 │ + 16 │ var def\u{61}ult = 123; + · ──────────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js:29:15] - 28 │ *method() { - 29 │ yi\u0065ld: ; - · ▲ - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-default-via-escape-hex4.js:16:5] + 15 │ + 16 │ var def\u0061ult = 123; + · ──────────── ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/object/method-definition/gen-yield-as-label-identifier.js:29:10] - 28 │ *method() { - 29 │ yield: ; - · ▲ - 30 │ } + × Unexpected token + ╭─[language/identifiers/val-default.js:15:5] + 14 │ + 15 │ var default = 123; + · ─────── ╰──── - help: Try insert a semicolon here - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js:35:17] - 34 │ ...(function() { - 35 │ var yield; - · ───── - 36 │ throw new Test262Error(); + × Unexpected token + ╭─[language/identifiers/val-delete-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{64}elete = 123; + · ─────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/gen-yield-identifier-strict.js:27:13] - 26 │ (function() { - 27 │ var yield; - · ───── - 28 │ throw new Test262Error(); + × Unexpected token + ╭─[language/identifiers/val-delete-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0064elete = 123; + · ─────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/generator-param-id-yield.js:19:11] - 18 │ ({ - 19 │ *method(yield) {} - · ───── - 20 │ }); + × Unexpected token + ╭─[language/identifiers/val-delete.js:15:5] + 14 │ + 15 │ var delete = 123; + · ────── ╰──── - × yield expression not allowed in formal parameter - ╭─[language/expressions/object/method-definition/generator-param-init-yield.js:20:17] - 19 │ ({ - 20 │ *method(x = yield) {} - · ──┬── - · ╰── yield expression not allowed in formal parameter - 21 │ }); + × Unexpected token + ╭─[language/identifiers/val-do-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{64}\u{6f} = 123; + · ──────────── ╰──── - × Identifier `a` has already been declared - ╭─[language/expressions/object/method-definition/generator-param-redecl-const.js:20:10] - 19 │ var obj = { - 20 │ *foo(a) { - · ┬ - · ╰── `a` has already been declared here - 21 │ const a = 3; - · ┬ - · ╰── It can not be redeclared here - 22 │ } + × Unexpected token + ╭─[language/identifiers/val-do-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0064\u006f = 123; + · ──────────── ╰──── - × Identifier `a` has already been declared - ╭─[language/expressions/object/method-definition/generator-param-redecl-let.js:20:10] - 19 │ var obj = { - 20 │ *foo(a) { - · ┬ - · ╰── `a` has already been declared here - 21 │ let a = 3; - · ┬ - · ╰── It can not be redeclared here - 22 │ } + × Unexpected token + ╭─[language/identifiers/val-do.js:15:5] + 14 │ + 15 │ var do = 123; + · ── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/object/method-definition/generator-super-call-body.js:21:9] - 20 │ *foo(a) { - 21 │ super(); - · ─────── - 22 │ } + × Unexpected token + ╭─[language/identifiers/val-else-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{65}lse = 123; + · ───────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/object/method-definition/generator-super-call-param.js:20:14] - 19 │ var obj = { - 20 │ *foo(a = super()) { - · ─────── - 21 │ } + × Unexpected token + ╭─[language/identifiers/val-else-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0065lse = 123; + · ───────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/generator-use-strict-with-non-simple-param.js:22:5] - 21 │ *m(a = 0) { - 22 │ "use strict"; - · ───────────── - 23 │ } + × Unexpected token + ╭─[language/identifiers/val-else.js:15:5] + 14 │ + 15 │ var else = 123; + · ──── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/meth-array-destructuring-param-strict-body.js:134:5] - 133 │ method([element]) { - 134 │ "use strict"; - · ───────────── - 135 │ } - ╰──── + × Unexpected token + ╭─[language/identifiers/val-enum-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{65}\u{6e}\u{75}\u{6d} = 123; + · ──────────────────────── + ╰──── - × Identifier `x` has already been declared - ╭─[language/expressions/object/method-definition/meth-dflt-params-duplicates.js:62:10] - 61 │ 0, { - 62 │ method(x = 0, x) { - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here - 63 │ + × Unexpected token + ╭─[language/identifiers/val-enum-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0065\u006e\u0075\u006d = 123; + · ──────────────────────── ╰──── - × A rest parameter cannot have an initializer - ╭─[language/expressions/object/method-definition/meth-dflt-params-rest.js:66:13] - 65 │ 0, { - 66 │ method(...x = []) { - · ────── - 67 │ + × Unexpected token + ╭─[language/identifiers/val-enum.js:15:5] + 14 │ + 15 │ var enum = 123; + · ──── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/meth-object-destructuring-param-strict-body.js:134:5] - 133 │ method({property}) { - 134 │ "use strict"; - · ───────────── - 135 │ } - ╰──── + × Unexpected token + ╭─[language/identifiers/val-export-via-escape-hex.js:16:5] + 15 │ + 16 │ var expor\u{74} = 123; + · ─────────── + ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/meth-rest-param-strict-body.js:134:5] - 133 │ method(a,...rest) { - 134 │ "use strict"; - · ───────────── - 135 │ } - ╰──── + × Unexpected token + ╭─[language/identifiers/val-export-via-escape-hex4.js:16:5] + 15 │ + 16 │ var expor\u0074 = 123; + · ─────────── + ╰──── - × A rest parameter must be last in a parameter list - ╭─[language/expressions/object/method-definition/meth-rest-params-trailing-comma-early-error.js:58:10] - 57 │ 0, { - 58 │ method(...a,) { - · ──── - 59 │ + × Unexpected token + ╭─[language/identifiers/val-export.js:15:5] + 14 │ + 15 │ var export = 123; + · ────── ╰──── - × Identifier `param` has already been declared - ╭─[language/expressions/object/method-definition/name-param-redecl.js:18:10] - 17 │ var obj = { - 18 │ method(param) { - · ──┬── - · ╰── `param` has already been declared here - 19 │ let param; - · ──┬── - · ╰── It can not be redeclared here - 20 │ } + × Unexpected token + ╭─[language/identifiers/val-extends-via-escape-hex.js:16:5] + 15 │ + 16 │ var extend\u{73} = 123; + · ──────────── + ╰──── + + × Unexpected token + ╭─[language/identifiers/val-extends-via-escape-hex4.js:16:5] + 15 │ + 16 │ var extend\u0073 = 123; + · ──────────── ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/object/method-definition/name-super-call-body.js:17:5] - 16 │ method() { - 17 │ super(); + × Unexpected token + ╭─[language/identifiers/val-extends.js:15:5] + 14 │ + 15 │ var extends = 123; · ─────── - 18 │ } ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/expressions/object/method-definition/name-super-call-param.js:16:18] - 15 │ ({ - 16 │ method(param = super()) {} - · ─────── - 17 │ }); + × Unexpected token + ╭─[language/identifiers/val-false-via-escape-hex.js:16:5] + 15 │ + 16 │ var fals\u{65} = 123; + · ────────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-async-fn-inside-class.js:24:11] - 23 │ field = { - 24 │ async #m() {} - · ── - 25 │ } + ╭─[language/identifiers/val-false-via-escape-hex4.js:16:5] + 15 │ + 16 │ var fals\u0065 = 123; + · ────────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-async-fn.js:23:9] - 22 │ var o = { - 23 │ async #m() {} - · ── - 24 │ }; + ╭─[language/identifiers/val-false.js:15:5] + 14 │ + 15 │ var false = 123; + · ───── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-async-gen-inside-class.js:24:13] - 23 │ field = { - 24 │ async * #m() {} - · ── - 25 │ } + ╭─[language/identifiers/val-finally-via-escape-hex.js:16:5] + 15 │ + 16 │ var fina\u{6c}ly = 123; + · ──────────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-async-gen.js:23:11] - 22 │ var o = { - 23 │ async * #m() {} - · ── - 24 │ }; + ╭─[language/identifiers/val-finally-via-escape-hex4.js:16:5] + 15 │ + 16 │ var fina\u006cly = 123; + · ──────────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-gen-inside-class.js:24:7] - 23 │ field = { - 24 │ * #m() {} - · ── - 25 │ } + ╭─[language/identifiers/val-finally.js:15:5] + 14 │ + 15 │ var finally = 123; + · ─────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-gen.js:23:5] - 22 │ var o = { - 23 │ * #m() {} - · ── - 24 │ }; + ╭─[language/identifiers/val-for-via-escape-hex.js:16:5] + 15 │ + 16 │ var f\u{6f}r = 123; + · ──────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-get-method-inside-class.js:24:9] - 23 │ field = { - 24 │ get #m() {} - · ── - 25 │ } + ╭─[language/identifiers/val-for-via-escape-hex4.js:16:5] + 15 │ + 16 │ var f\u006fr = 123; + · ──────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-get-method.js:23:7] - 22 │ var o = { - 23 │ get #m() {} - · ── - 24 │ }; + ╭─[language/identifiers/val-for.js:15:5] + 14 │ + 15 │ var for = 123; + · ─── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-method-inside-class.js:24:5] - 23 │ field = { - 24 │ #m() {} - · ── - 25 │ } + ╭─[language/identifiers/val-function-via-escape-hex.js:16:5] + 15 │ + 16 │ var func\u{74}ion = 123; + · ───────────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-method.js:23:3] - 22 │ var o = { - 23 │ #m() {} - · ── - 24 │ }; + ╭─[language/identifiers/val-function-via-escape-hex4.js:16:5] + 15 │ + 16 │ var func\u0074ion = 123; + · ───────────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-set-method-inside-class.js:24:9] - 23 │ field = { - 24 │ set #m(x) {} - · ── - 25 │ } + ╭─[language/identifiers/val-function.js:15:5] + 14 │ + 15 │ var function = 123; + · ──────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/private-name-early-error-set-method.js:23:7] - 22 │ var o = { - 23 │ set #m(x) {} - · ── - 24 │ }; + ╭─[language/identifiers/val-if-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{69}\u{66} = 123; + · ──────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/setter-use-strict-with-non-simple-param.js:21:5] - 20 │ set m(a = 0) { - 21 │ "use strict"; - · ───────────── - 22 │ } + × Unexpected token + ╭─[language/identifiers/val-if-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0069\u0066 = 123; + · ──────────── ╰──── - × Illegal 'use strict' directive in function with non-simple parameter list - ╭─[language/expressions/object/method-definition/use-strict-with-non-simple-param.js:21:5] - 20 │ m(a = 0) { - 21 │ "use strict"; - · ───────────── - 22 │ } + × Unexpected token + ╭─[language/identifiers/val-if.js:15:5] + 14 │ + 15 │ var if = 123; + · ── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/yield-as-logical-or-expression.js:18:11] - 17 │ *g() { - 18 │ yield ? yield : yield; - · ─ - 19 │ } + ╭─[language/identifiers/val-import-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{69}\u{6d}\u{70}\u{6f}\u{72}\u{74} = 123; + · ──────────────────────────────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/yield-as-parameter.js:18:6] - 17 │ var obj = { - 18 │ *g(yield) {} - · ───── - 19 │ }; + × Unexpected token + ╭─[language/identifiers/val-import-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0069\u006d\u0070\u006f\u0072\u0074 = 123; + · ──────────────────────────────────── ╰──── - × The keyword 'yield' is reserved - ╭─[language/expressions/object/method-definition/yield-as-parameter.js:18:6] - 17 │ var obj = { - 18 │ *g(yield) {} - · ───── - 19 │ }; + × Unexpected token + ╭─[language/identifiers/val-import.js:15:5] + 14 │ + 15 │ var import = 123; + · ────── ╰──── × Unexpected token - ╭─[language/expressions/object/method-definition/yield-star-after-newline.js:19:5] - 18 │ yield - 19 │ * 1 - · ─ - 20 │ } + ╭─[language/identifiers/val-in-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{69}\u{6e} = 123; + · ──────────── ╰──── - × Cannot use `yield` as an identifier in a generator context - ╭─[language/expressions/object/method-definition/yield-weak-binding.js:17:20] - 16 │ var obj = { - 17 │ *g() { yield 3 + yield 4; } - · ───── - 18 │ }; + × Unexpected token + ╭─[language/identifiers/val-in-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0069\u006e = 123; + · ──────────── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/expressions/object/method-definition/yield-weak-binding.js:17:25] - 16 │ var obj = { - 17 │ *g() { yield 3 + yield 4; } - · ▲ - 18 │ }; + × Unexpected token + ╭─[language/identifiers/val-in.js:15:5] + 14 │ + 15 │ var in = 123; + · ── ╰──── - help: Try insert a semicolon here - × Expected `(` but found `}` - ╭─[language/expressions/object/prop-def-invalid-async-prefix.js:35:14] - 34 │ - 35 │ ({async async}); - · ┬ - · ╰── `(` expected + × Unexpected token + ╭─[language/identifiers/val-instanceof-via-escape-hex.js:16:5] + 15 │ + 16 │ var insta\u{6e}ceof = 123; + · ─────────────── ╰──── - × Expected `(` but found `}` - ╭─[language/expressions/object/prop-def-invalid-star-prefix.js:21:8] - 20 │ - 21 │ ({* foo}); - · ┬ - · ╰── `(` expected + × Unexpected token + ╭─[language/identifiers/val-instanceof-via-escape-hex4.js:16:5] + 15 │ + 16 │ var insta\u006eceof = 123; + · ─────────────── ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/object/setter-body-strict-inside.js:20:5] - 19 │ "use strict"; - 20 │ public = 42; - · ────── - 21 │ } + × Unexpected token + ╭─[language/identifiers/val-instanceof.js:15:5] + 14 │ + 15 │ var instanceof = 123; + · ────────── + ╰──── + + × Unexpected token + ╭─[language/identifiers/val-new-via-escape-hex.js:16:5] + 15 │ + 16 │ var n\u{65}w = 123; + · ──────── ╰──── - × The keyword 'public' is reserved - ╭─[language/expressions/object/setter-body-strict-outside.js:18:5] - 17 │ set x(value) { - 18 │ public = 42; - · ────── - 19 │ } + × Unexpected token + ╭─[language/identifiers/val-new-via-escape-hex4.js:16:5] + 15 │ + 16 │ var n\u0065w = 123; + · ──────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/object/setter-param-arguments-strict-inside.js:18:9] - 17 │ void { - 18 │ set x(arguments) { - · ───────── - 19 │ "use strict"; + × Unexpected token + ╭─[language/identifiers/val-new.js:15:5] + 14 │ + 15 │ var new = 123; + · ─── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/object/setter-param-arguments-strict-outside.js:18:9] - 17 │ void { - 18 │ set x(arguments) {} - · ───────── - 19 │ }; + × Unexpected token + ╭─[language/identifiers/val-null-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{6e}ull = 123; + · ───────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/object/setter-param-eval-strict-inside.js:18:9] - 17 │ void { - 18 │ set x(eval) { - · ──── - 19 │ "use strict"; + × Unexpected token + ╭─[language/identifiers/val-null-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u006eull = 123; + · ───────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/object/setter-param-eval-strict-outside.js:18:9] - 17 │ void { - 18 │ set x(eval) {} - · ──── - 19 │ }; + × Unexpected token + ╭─[language/identifiers/val-null.js:15:5] + 14 │ + 15 │ var null = 123; + · ──── ╰──── - × 'super' can only be referenced in a derived class. - ╭─[language/expressions/optional-chaining/call-expression-super-no-base.js:19:1] - 18 │ - 19 │ ╭─▶ class C { - 20 │ │ constructor () { - 21 │ │ super()?.a; - · │ ───── - 22 │ │ } - 23 │ ├─▶ } - · ╰──── class does not have `extends` + × Unexpected token + ╭─[language/identifiers/val-return-via-escape-hex.js:16:5] + 15 │ + 16 │ var retur\u{6e} = 123; + · ─────────── ╰──── - help: either remove this super, or extend the class - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string-esi.js:25:3] - 24 │ null?. - 25 │ `hello` - · ─────── + × Unexpected token + ╭─[language/identifiers/val-return-via-escape-hex4.js:16:5] + 15 │ + 16 │ var retur\u006e = 123; + · ─────────── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string.js:22:7] - 21 │ - 22 │ null?.`hello`; - · ─────── + × Unexpected token + ╭─[language/identifiers/val-return.js:15:5] + 14 │ + 15 │ var return = 123; + · ────── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string-esi.js:25:3] - 24 │ null?.fn - 25 │ `hello` - · ─────── + × Unexpected token + ╭─[language/identifiers/val-super-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{73}uper = 123; + · ────────── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string.js:22:9] - 21 │ - 22 │ null?.fn`hello`; - · ─────── + × Unexpected token + ╭─[language/identifiers/val-super-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0073uper = 123; + · ────────── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-op-template-string-esi.js:27:3] - 26 │ a?. - 27 │ `hello` - · ─────── + × Unexpected token + ╭─[language/identifiers/val-super.js:15:5] + 14 │ + 15 │ var super = 123; + · ───── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-op-template-string.js:24:4] - 23 │ - 24 │ a?.`hello`; - · ─────── + × Unexpected token + ╭─[language/identifiers/val-switch-via-escape-hex.js:16:5] + 15 │ + 16 │ var switc\u{68} = 123; + · ─────────── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string-esi.js:27:3] - 26 │ a?.fn - 27 │ `hello` - · ─────── + × Unexpected token + ╭─[language/identifiers/val-switch-via-escape-hex4.js:16:5] + 15 │ + 16 │ var switc\u0068 = 123; + · ─────────── ╰──── - × Tagged template expressions are not permitted in an optional chain - ╭─[language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string.js:24:6] - 23 │ - 24 │ a?.fn`hello`; - · ─────── + × Unexpected token + ╭─[language/identifiers/val-switch.js:15:5] + 14 │ + 15 │ var switch = 123; + · ────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/optional-chaining/static-semantics-simple-assignment.js:23:1] - 22 │ - 23 │ obj?.a = 33; - · ────── + × Unexpected token + ╭─[language/identifiers/val-this-via-escape-hex.js:16:5] + 15 │ + 16 │ var thi\u{73} = 123; + · ───────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/optional-chaining/update-expression-postfix.js:23:1] - 22 │ const a = {}; - 23 │ a?.b++; - · ──── + × Unexpected token + ╭─[language/identifiers/val-this-via-escape-hex4.js:16:5] + 15 │ + 16 │ var thi\u0073 = 123; + · ───────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/optional-chaining/update-expression-prefix.js:23:3] - 22 │ const a = {}; - 23 │ --a?.b; - · ──── + × Unexpected token + ╭─[language/identifiers/val-this.js:15:5] + 14 │ + 15 │ var this = 123; + · ──── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/postfix-decrement/arguments.js:26:1] - 25 │ - 26 │ arguments--; - · ───────── + × Unexpected token + ╭─[language/identifiers/val-throw-via-escape-hex.js:16:5] + 15 │ + 16 │ var thro\u{77} = 123; + · ────────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/postfix-decrement/eval.js:26:1] - 25 │ - 26 │ eval--; - · ──── + × Unexpected token + ╭─[language/identifiers/val-throw-via-escape-hex4.js:16:5] + 15 │ + 16 │ var thro\u0077 = 123; + · ────────── ╰──── × Unexpected token - ╭─[language/expressions/postfix-decrement/line-terminator-carriage-return.js:17:3] - 16 │ x - 17 │ --; - · ─ - 18 │ // The preceding line contains an unprintable CARRIAGE RETURN character (U+000D) + ╭─[language/identifiers/val-throw.js:15:5] + 14 │ + 15 │ var throw = 123; + · ───── ╰──── × Unexpected token - ╭─[language/expressions/postfix-decrement/line-terminator-line-feed.js:17:3] - 16 │ x - 17 │ --; - · ─ + ╭─[language/identifiers/val-true-via-escape-hex.js:16:5] + 15 │ + 16 │ var tr\u{75}e = 123; + · ───────── ╰──── × Unexpected token - ╭─[language/expressions/postfix-decrement/line-terminator-line-separator.js:16:7] + ╭─[language/identifiers/val-true-via-escape-hex4.js:16:5] 15 │ - 16 │ x
--; - · ─ - 17 │ // The preceding line contains an unprintable LINE SEPARATOR character (U+2028) + 16 │ var tr\u0075e = 123; + · ───────── ╰──── × Unexpected token - ╭─[language/expressions/postfix-decrement/line-terminator-paragraph-separator.js:16:7] - 15 │ - 16 │ x
--; - · ─ - 17 │ // The preceding line contains an unprintable PARAGRAPH SEPARATOR character + ╭─[language/identifiers/val-true.js:15:5] + 14 │ + 15 │ var true = 123; + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-decrement/target-cover-newtarget.js:30:4] - 29 │ function f() { - 30 │ (new.target)--; - · ────────── - 31 │ } + × Unexpected token + ╭─[language/identifiers/val-try-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{74}\u{72}\u{79} = 123; + · ────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-decrement/target-cover-yieldexpr.js:33:4] - 32 │ function* g() { - 33 │ (yield)--; - · ───── - 34 │ } + × Unexpected token + ╭─[language/identifiers/val-try-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0074\u0072\u0079 = 123; + · ────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-decrement/target-newtarget.js:30:3] - 29 │ function f() { - 30 │ new.target--; - · ────────── - 31 │ } + × Unexpected token + ╭─[language/identifiers/val-try.js:15:5] + 14 │ + 15 │ var try = 123; + · ─── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-decrement/this.js:27:1] - 26 │ - 27 │ this--; - · ──── + × Unexpected token + ╭─[language/identifiers/val-typeof-via-escape-hex.js:16:5] + 15 │ + 16 │ var typeo\u{66} = 123; + · ─────────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/postfix-increment/11.3.1-2-1gs.js:17:1] - 16 │ - 17 │ arguments++; - · ───────── + × Unexpected token + ╭─[language/identifiers/val-typeof-via-escape-hex4.js:16:5] + 15 │ + 16 │ var typeo\u0066 = 123; + · ─────────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/postfix-increment/arguments.js:22:1] - 21 │ - 22 │ arguments++; - · ───────── + × Unexpected token + ╭─[language/identifiers/val-typeof.js:15:5] + 14 │ + 15 │ var typeof = 123; + · ────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/postfix-increment/eval.js:22:1] - 21 │ - 22 │ eval++; - · ──── + × Unexpected token + ╭─[language/identifiers/val-var-via-escape-hex.js:16:5] + 15 │ + 16 │ var va\u{72} = 123; + · ──────── ╰──── × Unexpected token - ╭─[language/expressions/postfix-increment/line-terminator-carriage-return.js:17:3] - 16 │ x - 17 │ ++; - · ─ - 18 │ // The preceding line contains an unprintable CARRIAGE RETURN character (U+000D) + ╭─[language/identifiers/val-var-via-escape-hex4.js:16:5] + 15 │ + 16 │ var va\u0072 = 123; + · ──────── ╰──── × Unexpected token - ╭─[language/expressions/postfix-increment/line-terminator-line-feed.js:17:3] - 16 │ x - 17 │ ++; - · ─ + ╭─[language/identifiers/val-var.js:15:5] + 14 │ + 15 │ var var = 123; + · ─── ╰──── × Unexpected token - ╭─[language/expressions/postfix-increment/line-terminator-line-separator.js:16:7] + ╭─[language/identifiers/val-void-via-escape-hex.js:16:5] 15 │ - 16 │ x
++; - · ─ - 17 │ // The preceding line contains an unprintable LINE SEPARATOR character (U+2028) + 16 │ var \u{76}\u{6f}\u{69}\u{64} = 123; + · ──────────────────────── ╰──── × Unexpected token - ╭─[language/expressions/postfix-increment/line-terminator-paragraph-separator.js:16:7] + ╭─[language/identifiers/val-void-via-escape-hex4.js:16:5] 15 │ - 16 │ x
++; - · ─ - 17 │ // The preceding line contains an unprintable PARAGRAPH SEPARATOR character + 16 │ var \u0076\u006f\u0069\u0064 = 123; + · ──────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-increment/target-cover-newtarget.js:30:4] - 29 │ function f() { - 30 │ (new.target)++; - · ────────── - 31 │ } + × Unexpected token + ╭─[language/identifiers/val-void.js:15:5] + 14 │ + 15 │ var void = 123; + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-increment/target-cover-yieldexpr.js:33:4] - 32 │ function* g() { - 33 │ (yield)++; - · ───── - 34 │ } + × Unexpected token + ╭─[language/identifiers/val-while-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{77}\u{68}\u{69}\u{6c}\u{65} = 123; + · ────────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-increment/target-newtarget.js:30:3] - 29 │ function f() { - 30 │ new.target++; - · ────────── - 31 │ } + × Unexpected token + ╭─[language/identifiers/val-while-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0077\u0068\u0069\u006c\u0065 = 123; + · ────────────────────────────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/postfix-increment/this.js:27:1] - 26 │ - 27 │ this++; - · ──── + × Unexpected token + ╭─[language/identifiers/val-while.js:15:5] + 14 │ + 15 │ var while = 123; + · ───── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/prefix-decrement/11.4.5-2-2gs.js:17:3] - 16 │ - 17 │ --arguments; - · ───────── + × Unexpected token + ╭─[language/identifiers/val-with-via-escape-hex.js:16:5] + 15 │ + 16 │ var \u{77}ith = 123; + · ───────── ╰──── - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/prefix-decrement/arguments.js:26:3] - 25 │ - 26 │ --arguments; - · ───────── + × Unexpected token + ╭─[language/identifiers/val-with-via-escape-hex4.js:16:5] + 15 │ + 16 │ var \u0077ith = 123; + · ───────── ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/prefix-decrement/eval.js:26:3] - 25 │ - 26 │ --eval; - · ──── + × Unexpected token + ╭─[language/identifiers/val-with.js:15:5] + 14 │ + 15 │ var with = 123; + · ──── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-decrement/target-cover-newtarget.js:30:6] - 29 │ function f() { - 30 │ --(new.target); - · ────────── - 31 │ } + × The keyword 'yield' is reserved + ╭─[language/identifiers/val-yield-strict.js:17:5] + 16 │ + 17 │ var yield = 13; + · ───── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-decrement/target-cover-yieldexpr.js:33:6] - 32 │ function* g() { - 33 │ --(yield); - · ───── - 34 │ } + × Invalid Character `ⸯ` + ╭─[language/identifiers/vertical-tilde-continue-escaped.js:16:12] + 15 │ + 16 │ var a\u2E2F; + · ▲ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-decrement/target-newtarget.js:30:5] - 29 │ function f() { - 30 │ --new.target; - · ────────── - 31 │ } + × Invalid Character `ⸯ` + ╭─[language/identifiers/vertical-tilde-continue.js:16:6] + 15 │ + 16 │ var aⸯ; // U+2E2F + · ─ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-decrement/this.js:27:3] - 26 │ - 27 │ --this; - · ──── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/identifiers/vertical-tilde-continue.js:16:6] + 15 │ + 16 │ var aⸯ; // U+2E2F + · ▲ ╰──── + help: Try insert a semicolon here - × Cannot assign to 'arguments' in strict mode - ╭─[language/expressions/prefix-increment/arguments.js:26:3] - 25 │ - 26 │ ++arguments; - · ───────── + × Invalid Character `ⸯ` + ╭─[language/identifiers/vertical-tilde-start-escaped.js:16:11] + 15 │ + 16 │ var \u2E2F; + · ▲ ╰──── - × Cannot assign to 'eval' in strict mode - ╭─[language/expressions/prefix-increment/eval.js:27:3] - 26 │ - 27 │ ++eval; - · ──── + × Invalid Character `ⸯ` + ╭─[language/identifiers/vertical-tilde-start.js:16:5] + 15 │ + 16 │ var ⸯ; // U+2E2F + · ─ ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-increment/target-cover-newtarget.js:30:6] - 29 │ function f() { - 30 │ ++(new.target); - · ────────── - 31 │ } + × Identifier `x` has already been declared + ╭─[language/import/dup-bound-names.js:16:10] + 15 │ + 16 │ import { x, y as x } from 'z'; + · ┬ ┬ + · │ ╰── It can not be redeclared here + · ╰── `x` has already been declared here ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-increment/target-cover-yieldexpr.js:33:6] - 32 │ function* g() { - 33 │ ++(yield); - · ───── - 34 │ } + × Keywords cannot contain escape characters + ╭─[language/import/escaped-as-import-specifier.js:26:11] + 25 │ + 26 │ import {a \u0061s b} from "./escaped-as-import-specifier.js"; + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-increment/target-newtarget.js:30:5] - 29 │ function f() { - 30 │ ++new.target; - · ────────── - 31 │ } + × Keywords cannot contain escape characters + ╭─[language/import/escaped-as-namespace-import.js:24:9] + 23 │ + 24 │ import* \u0061s self from "./escaped-as-namespace-import.js"; + · ─────── ╰──── - × Cannot assign to this expression - ╭─[language/expressions/prefix-increment/this.js:27:3] - 26 │ - 27 │ ++this; - · ──── + × Keywords cannot contain escape characters + ╭─[language/import/escaped-from.js:24:11] + 23 │ + 24 │ import {} \u0066rom "./escaped-from.js"; + · ───────── ╰──── × Unexpected token - ╭─[language/expressions/property-accessors/non-identifier-name.js:20:23] + ╭─[language/keywords/ident-ref-break.js:20:7] 19 │ - 20 │ unresolvableReference.""; - · ── + 20 │ break = 1; + · ─ ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-1.js:13:2] - 12 │ - 13 │ `\x0`; - · ─── + × Unexpected token + ╭─[language/keywords/ident-ref-case.js:20:1] + 19 │ + 20 │ case = 1; + · ──── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-2.js:13:2] - 12 │ - 13 │ `\x0G`; - · ──── + × Unexpected token + ╭─[language/keywords/ident-ref-catch.js:20:1] + 19 │ + 20 │ catch = 1; + · ───── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-3.js:13:2] - 12 │ - 13 │ `\xG`; - · ─── + × Unexpected token + ╭─[language/keywords/ident-ref-continue.js:20:10] + 19 │ + 20 │ continue = 1; + · ─ ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-legacy-octal-escape-sequence-8.js:27:2] - 26 │ - 27 │ `\8`; - · ── + × Unexpected token + ╭─[language/keywords/ident-ref-default.js:20:1] + 19 │ + 20 │ default = 1; + · ─────── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-legacy-octal-escape-sequence-9.js:27:2] - 26 │ - 27 │ `\9`; - · ── + × Unexpected token + ╭─[language/keywords/ident-ref-delete.js:20:8] + 19 │ + 20 │ delete = 1; + · ─ ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-legacy-octal-escape-sequence.js:26:2] - 25 │ - 26 │ `\00`; - · ─── + × Unexpected token + ╭─[language/keywords/ident-ref-do.js:20:4] + 19 │ + 20 │ do = 1; + · ─ ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-1.js:13:2] - 12 │ - 13 │ `\u0`; - · ─── + × Unexpected token + ╭─[language/keywords/ident-ref-else.js:20:1] + 19 │ + 20 │ else = 1; + · ──── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-2.js:13:2] - 12 │ - 13 │ `\u0g`; - · ──── + × Unexpected token + ╭─[language/keywords/ident-ref-finally.js:20:1] + 19 │ + 20 │ finally = 1; + · ─────── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-3.js:13:2] - 12 │ - 13 │ `\u00g`; - · ───── + × Expected `(` but found `=` + ╭─[language/keywords/ident-ref-for.js:20:5] + 19 │ + 20 │ for = 1; + · ┬ + · ╰── `(` expected ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-4.js:13:2] - 12 │ - 13 │ `\u000g`; - · ────── + × Expected `(` but found `=` + ╭─[language/keywords/ident-ref-function.js:20:10] + 19 │ + 20 │ function = 1; + · ┬ + · ╰── `(` expected ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-5.js:13:2] - 12 │ - 13 │ `\u{g`; - · ──── + × Expected `(` but found `=` + ╭─[language/keywords/ident-ref-if.js:20:4] + 19 │ + 20 │ if = 1; + · ┬ + · ╰── `(` expected ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-6.js:13:2] - 12 │ - 13 │ `\u{0`; - · ──── + × Unexpected token + ╭─[language/keywords/ident-ref-in.js:20:1] + 19 │ + 20 │ in = 1; + · ── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-7.js:13:2] - 12 │ - 13 │ `\u{10FFFFF}`; - · ─────────── + × Unexpected token + ╭─[language/keywords/ident-ref-instanceof.js:20:1] + 19 │ + 20 │ instanceof = 1; + · ────────── ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/invalid-unicode-escape-sequence-8.js:13:2] - 12 │ - 13 │ `\u{10FFFFF}${'inner'}right`; - · ─────────── + × Unexpected token + ╭─[language/keywords/ident-ref-new.js:20:5] + 19 │ + 20 │ new = 1; + · ─ ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/unicode-escape-nls-err.js:55:2] - 54 │ - 55 │ `\u{1F_639}`; - · ────────── + × Unexpected token + ╭─[language/keywords/ident-ref-return.js:20:8] + 19 │ + 20 │ return = 1; + · ─ ╰──── - × Bad escape sequence in untagged template literal - ╭─[language/expressions/template-literal/unicode-escape-no-hex-err.js:50:2] - 49 │ - 50 │ `\u` - · ── + × Expected `(` but found `=` + ╭─[language/keywords/ident-ref-switch.js:20:8] + 19 │ + 20 │ switch = 1; + · ┬ + · ╰── `(` expected ╰──── - × Cannot assign to this expression - ╭─[language/expressions/this/S11.1.1_A1.js:15:1] - 14 │ - 15 │ this = 1; - · ──── + × Unexpected token + ╭─[language/keywords/ident-ref-this.js:23:7] + 22 │ // Also see: sec-semantics-static-semantics-isvalidsimpleassignmenttarget + 23 │ ({this}); + · ─ ╰──── × Unexpected token - ╭─[language/expressions/yield/in-iteration-stmt.js:22:8] - 21 │ function* g() { - 22 │ for (yield '' in {}; ; ) ; - · ──────── - 23 │ } + ╭─[language/keywords/ident-ref-throw.js:20:7] + 19 │ + 20 │ throw = 1; + · ─ ╰──── - × Unexpected token - ╭─[language/expressions/yield/invalid-left-hand-side.js:27:9] - 26 │ function* g() { - 27 │ yield = 1; - · ─ - 28 │ } + × Expected `{` but found `=` + ╭─[language/keywords/ident-ref-try.js:20:5] + 19 │ + 20 │ try = 1; + · ┬ + · ╰── `{` expected ╰──── × Unexpected token - ╭─[language/expressions/yield/star-in-iteration-stmt.js:22:8] - 21 │ function* g() { - 22 │ for (yield * '' in {}; ; ) ; - · ────────── - 23 │ } + ╭─[language/keywords/ident-ref-typeof.js:20:8] + 19 │ + 20 │ typeof = 1; + · ─ ╰──── × Unexpected token - ╭─[language/future-reserved-words/class.js:20:5] + ╭─[language/keywords/ident-ref-var.js:20:5] 19 │ - 20 │ var class = 1; - · ───── + 20 │ var = 1; + · ─ ╰──── × Unexpected token - ╭─[language/future-reserved-words/const.js:20:5] + ╭─[language/keywords/ident-ref-void.js:20:6] 19 │ - 20 │ var const = 1; - · ───── + 20 │ void = 1; + · ─ ╰──── - × Unexpected token - ╭─[language/future-reserved-words/debugger.js:20:5] + × Expected `(` but found `=` + ╭─[language/keywords/ident-ref-while.js:20:7] 19 │ - 20 │ var debugger = 1; - · ──────── + 20 │ while = 1; + · ┬ + · ╰── `(` expected ╰──── - × Unexpected token - ╭─[language/future-reserved-words/enum.js:20:5] + × Expected `(` but found `=` + ╭─[language/keywords/ident-ref-with.js:20:6] 19 │ - 20 │ var enum = 1; - · ──── + 20 │ with = 1; + · ┬ + · ╰── `(` expected + ╰──── + + × Unterminated string + ╭─[language/line-terminators/S7.3_A2.1_T2.js:16:1] + 15 │ //CHECK#1 + 16 │ " + · ── + 17 │ str + 18 │ ing ╰──── - × Unexpected token - ╭─[language/future-reserved-words/export.js:20:5] - 19 │ - 20 │ var export = 1; - · ────── + × Unterminated string + ╭─[language/line-terminators/S7.3_A2.2_T2.js:16:1] + 15 │ //CHECK#1 + 16 │ " + · ── + 17 │ str + 18 │ ing ╰──── × Unexpected token - ╭─[language/future-reserved-words/extends.js:20:5] - 19 │ - 20 │ var extends = 1; - · ─────── + ╭─[language/line-terminators/S7.3_A3.2_T1.js:16:2] + 15 │ // single line comment + 16 │ ??? (invalid) + · ── ╰──── - × The keyword 'implements' is reserved - ╭─[language/future-reserved-words/implements-strict-escaped.js:24:5] - 23 │ - 24 │ var \u0069mplements = 123; - · ─────────────── + × Invalid Character ` + │ ` + ╭─[language/line-terminators/S7.3_A6_T1.js:17:10] + 16 │ + 17 │ var\u000Ax; + · ▲ ╰──── - × The keyword 'implements' is reserved - ╭─[language/future-reserved-words/implements-strict.js:23:5] - 22 │ - 23 │ var implements = 1; - · ────────── + × Invalid Character ` ` + ╭─[language/line-terminators/S7.3_A6_T2.js:17:10] + 16 │ + 17 │ var\u000Dx; + · ▲ ╰──── - × Unexpected token - ╭─[language/future-reserved-words/import.js:20:5] - 19 │ - 20 │ var import = 1; - · ────── + × Invalid Character `
` + ╭─[language/line-terminators/S7.3_A6_T3.js:17:10] + 16 │ + 17 │ var\u2028x; + · ▲ ╰──── - × The keyword 'interface' is reserved - ╭─[language/future-reserved-words/interface-strict-escaped.js:24:5] - 23 │ - 24 │ var inte\u0072face = 123; - · ────────────── + × Invalid Character `
` + ╭─[language/line-terminators/S7.3_A6_T4.js:17:10] + 16 │ + 17 │ var\u2029x; + · ▲ ╰──── - × The keyword 'interface' is reserved - ╭─[language/future-reserved-words/interface-strict.js:23:5] - 22 │ - 23 │ var interface = 1; - · ───────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/line-terminators/invalid-comment-single-cr.js:17:6] + 16 │ // this text is not included in the single-line comment that precedes it + · ▲ ╰──── + help: Try insert a semicolon here - × The keyword 'let' is reserved - ╭─[language/future-reserved-words/let-strict-escaped.js:24:5] - 23 │ - 24 │ var l\u0065t = 123; - · ──────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/line-terminators/invalid-comment-single-lf.js:17:5] + 16 │ //single + 17 │ line comment + · ▲ ╰──── + help: Try insert a semicolon here - × The keyword 'let' is reserved - ╭─[language/future-reserved-words/let-strict.js:23:5] - 22 │ - 23 │ var let = 1; - · ─── + × Unexpected token + ╭─[language/line-terminators/invalid-comment-single-ls.js:17:22] + 16 │ + 17 │ // single line LS>
??? (invalid) + · ── ╰──── - × The keyword 'package' is reserved - ╭─[language/future-reserved-words/package-strict-escaped.js:24:5] - 23 │ - 24 │ var packag\u0065 = 123; - · ──────────── + × Unexpected token + ╭─[language/line-terminators/invalid-comment-single-ps.js:15:22] + 14 │ + 15 │ // single line PS>
??? (invalid) + · ── ╰──── - × The keyword 'package' is reserved - ╭─[language/future-reserved-words/package-strict.js:23:5] - 22 │ - 23 │ var package = 1; - · ─────── + × Unterminated regular expression + ╭─[language/line-terminators/invalid-regexp-cr.js:17:1] + 16 │ + 17 │ / / + · ─ ╰──── - × The keyword 'private' is reserved - ╭─[language/future-reserved-words/private-strict-escaped.js:24:5] - 23 │ - 24 │ var privat\u0065 = 123; - · ──────────── + × Unexpected token + ╭─[language/line-terminators/invalid-regexp-cr.js:19:1] + 18 │ / ╰──── - × The keyword 'private' is reserved - ╭─[language/future-reserved-words/private-strict.js:23:5] - 22 │ - 23 │ var private = 1; - · ─────── + × Unterminated regular expression + ╭─[language/line-terminators/invalid-regexp-lf.js:17:1] + 16 │ + 17 │ / + · ── + 18 │ / ╰──── - × The keyword 'protected' is reserved - ╭─[language/future-reserved-words/protected-strict-escaped.js:25:5] - 24 │ - 25 │ var \u0070\u0072\u006f\u0074\u0065\u0063\u0074\u0065\u0064 = 123; - · ────────────────────────────────────────────────────── + × Unexpected token + ╭─[language/line-terminators/invalid-regexp-lf.js:19:1] + 18 │ / ╰──── - × The keyword 'protected' is reserved - ╭─[language/future-reserved-words/protected-strict.js:23:5] - 22 │ - 23 │ var protected = 1; - · ───────── + × Unterminated regular expression + ╭─[language/line-terminators/invalid-regexp-ls.js:17:1] + 16 │ + 17 │ /
/ + · ── ╰──── - × The keyword 'public' is reserved - ╭─[language/future-reserved-words/public-strict-escaped.js:24:5] - 23 │ - 24 │ var \u0070\u0075\u0062\u006c\u0069\u0063 = 123; - · ──────────────────────────────────── + × Unexpected token + ╭─[language/line-terminators/invalid-regexp-ls.js:18:1] + 17 │ /
/ ╰──── - × The keyword 'public' is reserved - ╭─[language/future-reserved-words/public-strict.js:23:5] - 22 │ - 23 │ var public = 1; - · ────── + × Unterminated regular expression + ╭─[language/line-terminators/invalid-regexp-ps.js:17:1] + 16 │ + 17 │ /
/ + · ── ╰──── - × The keyword 'static' is reserved - ╭─[language/future-reserved-words/static-strict-escaped.js:24:5] - 23 │ - 24 │ var \u0073\u0074\u0061\u0074\u0069\u0063 = 123; - · ──────────────────────────────────── + × Unexpected token + ╭─[language/line-terminators/invalid-regexp-ps.js:18:1] + 17 │ /
/ ╰──── - × The keyword 'static' is reserved - ╭─[language/future-reserved-words/static-strict.js:23:5] - 22 │ - 23 │ var static = 1; - · ────── + × Unterminated string + ╭─[language/line-terminators/invalid-string-cr.js:16:1] + 15 │ + 16 │ ' ' + · ─ ╰──── - × Unexpected token - ╭─[language/future-reserved-words/super.js:20:5] - 19 │ - 20 │ var super = 1; - · ───── + × Unterminated string + ╭─[language/line-terminators/invalid-string-lf.js:16:1] + 15 │ + 16 │ ' + · ── + 17 │ ' ╰──── - × The keyword 'yield' is reserved - ╭─[language/future-reserved-words/yield-strict-escaped.js:24:5] - 23 │ - 24 │ var \u0079ield = 123; - · ────────── + × Invalid Character `2` + ╭─[language/literals/bigint/binary-invalid-digit.js:26:3] + 25 │ + 26 │ 0b2n; + · ▲ ╰──── - × The keyword 'yield' is reserved - ╭─[language/future-reserved-words/yield-strict.js:22:5] - 21 │ - 22 │ var yield = 1; - · ───── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/literals/bigint/exponent-part.js:16:4] + 15 │ + 16 │ 0e0n; + · ▲ ╰──── + help: Try insert a semicolon here - × Cannot use export statement outside a module - ╭─[language/global-code/export.js:21:1] - 20 │ - 21 │ export default null; - · ────── + × Invalid Character `g` + ╭─[language/literals/bigint/hexadecimal-invalid-digit.js:26:3] + 25 │ + 26 │ 0xgn; + · ▲ ╰──── - × Cannot use import statement outside a module - ╭─[language/global-code/import.js:21:1] - 20 │ - 21 │ import v from './import.js'; - · ────── + × Invalid characters after number + ╭─[language/literals/bigint/legacy-octal-like-invalid-00n.js:28:3] + 27 │ + 28 │ 00n; + · ─ ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/global-code/invalid-private-names-call-expression-bad-reference.js:40:14] - 39 │ - 40 │ (() => {})().#x - · ── + × Invalid characters after number + ╭─[language/literals/bigint/legacy-octal-like-invalid-01n.js:28:3] + 27 │ + 28 │ 01n; + · ─ ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/global-code/invalid-private-names-call-expression-this.js:40:16] - 39 │ - 40 │ (() => this)().#x - · ── + × Invalid characters after number + ╭─[language/literals/bigint/legacy-octal-like-invalid-07n.js:28:3] + 27 │ + 28 │ 07n; + · ─ ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/global-code/invalid-private-names-member-expression-bad-reference.js:40:11] - 39 │ - 40 │ something.#x - · ── + × Invalid characters after number + ╭─[language/literals/bigint/mv-is-not-integer-dil-dot-dds.js:27:7] + 26 │ + 27 │ 2017.8n; + · ─ ╰──── - × Private identifier '#x' is not allowed outside class bodies - ╭─[language/global-code/invalid-private-names-member-expression-this.js:40:6] - 39 │ - 40 │ this.#x - · ── + × Invalid characters after number + ╭─[language/literals/bigint/mv-is-not-integer-dot-dds.js:27:12] + 26 │ + 27 │ .0000000001n; + · ─ ╰──── - × Unexpected new.target expression - ╭─[language/global-code/new.target-arrow.js:36:3] - 35 │ () => { - 36 │ new.target; - · ────────── - 37 │ }; + × Invalid characters after number + ╭─[language/literals/bigint/non-octal-like-invalid-0008n.js:28:5] + 27 │ + 28 │ 0008n; + · ─ ╰──── - help: new.target is only allowed in constructors and functions invoked using thew `new` operator - × Unexpected new.target expression - ╭─[language/global-code/new.target.js:20:1] - 19 │ - 20 │ new.target; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/non-octal-like-invalid-012348n.js:28:7] + 27 │ + 28 │ 012348n; + · ─ ╰──── - help: new.target is only allowed in constructors and functions invoked using thew `new` operator - × TS(1108): A 'return' statement can only be used within a function body. - ╭─[language/global-code/return.js:22:1] - 21 │ - 22 │ return; - · ────── + × Invalid characters after number + ╭─[language/literals/bigint/non-octal-like-invalid-08n.js:28:3] + 27 │ + 28 │ 08n; + · ─ ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/global-code/super-call-arrow.js:36:3] - 35 │ () => { - 36 │ super(); - · ─────── - 37 │ }; + × Invalid characters after number + ╭─[language/literals/bigint/non-octal-like-invalid-09n.js:28:3] + 27 │ + 28 │ 09n; + · ─ ╰──── - × Super calls are not permitted outside constructors or in nested functions inside constructors. - ╭─[language/global-code/super-call.js:20:1] - 19 │ - 20 │ super(); - · ─────── + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js:44:3] + 43 │ + 44 │ 0b_1n; + · ▲ ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/global-code/super-prop-arrow.js:36:3] - 35 │ () => { - 36 │ super.property; - · ───── - 37 │ }; + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js:44:5] + 43 │ + 44 │ 0b0__0n; + · ▲ ╰──── - × 'super' can only be referenced in members of derived classes or object literal expressions. - ╭─[language/global-code/super-prop.js:20:1] - 19 │ - 20 │ super.property; - · ───── + × Invalid Character `n` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js:43:5] + 42 │ + 43 │ 0b0_n; + · ▲ ╰──── - × The keyword 'yield' is reserved - ╭─[language/global-code/yield-strict.js:25:1] - 24 │ - 25 │ yield; - · ───── + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:36:3] + 35 │ + 36 │ 1__0123456789n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifier-resolution/static-init-invalid-await.js:23:10] - 22 │ static { - 23 │ await; - · ─ - 24 │ } + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:36:3] + 35 │ + 36 │ 1__0123456789n; + · ─ ╰──── - × Invalid Character `‍` - ╭─[language/identifiers/start-zwj-escaped.js:15:11] - 14 │ - 15 │ var \u200D; - · ▲ + × Invalid Character `n` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-err.js:38:3] + 37 │ + 38 │ 1_n; + · ▲ ╰──── - × Invalid Character `‌` - ╭─[language/identifiers/start-zwnj-escaped.js:15:11] - 14 │ - 15 │ var \u200C; - · ▲ + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:36:4] + 35 │ + 36 │ 10__0123456789n; + · ▲ ╰──── - × Invalid Unicode escape sequence - ╭─[language/identifiers/unicode-escape-nls-err.js:48:6] - 47 │ - 48 │ var \u{00_76} = 1; - · ──── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:36:4] + 35 │ + 36 │ 10__0123456789n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/unicode-escape-nls-err.js:48:13] - 47 │ - 48 │ var \u{00_76} = 1; - · ─ + × Invalid Character `n` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-err.js:39:4] + 38 │ + 39 │ 10_n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-break-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{62}\u{72}\u{65}\u{61}\u{6b} = 123;; - · ────────────────────────────── + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js:44:3] + 43 │ + 44 │ 0x_1n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-break-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0062\u0072\u0065\u0061\u006b = 123;; - · ────────────────────────────── + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js:44:5] + 43 │ + 44 │ 0x0__0n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-break.js:15:5] - 14 │ - 15 │ var break = 123;; - · ───── + × Invalid Character `n` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js:44:5] + 43 │ + 44 │ 0x0_n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-case-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{63}ase = 123; - · ───────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-00-err.js:52:3] + 51 │ + 52 │ 00_0n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-case-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0063ase = 123; - · ───────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-01-err.js:52:3] + 51 │ + 52 │ 01_0n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-case.js:15:5] - 14 │ - 15 │ var case = 123; - · ──── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-07-err.js:54:3] + 53 │ + 54 │ 07_0n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-catch-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{63}atch = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_0-err.js:52:2] + 51 │ + 52 │ 0_0n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-catch-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0063atch = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_1-err.js:52:2] + 51 │ + 52 │ 0_1n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-catch.js:15:5] - 14 │ - 15 │ var catch = 123; - · ───── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_7-err.js:53:2] + 52 │ + 53 │ 0_7n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-class-via-escape-hex.js:16:5] - 15 │ - 16 │ var cla\u{73}s = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-08-err.js:49:3] + 48 │ + 49 │ 08_0n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-class-via-escape-hex4.js:16:5] - 15 │ - 16 │ var cla\u0073s = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-09-err.js:49:3] + 48 │ + 49 │ 09_0n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-class.js:15:5] - 14 │ - 15 │ var class = 123; - · ───── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js:49:2] + 48 │ + 49 │ 0_8n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-const-via-escape-hex.js:16:5] - 15 │ - 16 │ var co\u{6e}st = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js:49:2] + 48 │ + 49 │ 0_9n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-const-via-escape-hex4.js:16:5] - 15 │ - 16 │ var co\u006est = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js:39:2] + 38 │ + 39 │ 0__0123456789n; + · ── ╰──── - × Unexpected token - ╭─[language/identifiers/val-const.js:15:5] - 14 │ - 15 │ var const = 123; - · ───── + × Invalid characters after number + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js:37:2] + 36 │ + 37 │ 0_0123456789n; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-continue-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{63}ontinue = 123; - · ───────────── + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js:44:5] + 43 │ + 44 │ 0o0__0n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-continue-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0063ontinue = 123; - · ───────────── + × Invalid Character `n` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js:44:5] + 43 │ + 44 │ 0o0_n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-continue.js:15:5] - 14 │ - 15 │ var continue = 123; - · ──────── + × Invalid Character `_` + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js:44:3] + 43 │ + 44 │ 0o_1n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-debugger-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{64}ebugger = 123; - · ───────────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-unicode-err.js:36:2] + 35 │ + 36 │ 1\u005F0123456789n; + · ▲ ╰──── + help: Try insert a semicolon here - × Unexpected token - ╭─[language/identifiers/val-debugger-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0064ebugger = 123; - · ───────────── + × Invalid Character `9` + ╭─[language/literals/bigint/octal-invalid-digit.js:26:3] + 25 │ + 26 │ 0o9n; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-debugger.js:15:5] - 14 │ - 15 │ var debugger = 123; - · ──────── + × Keywords cannot contain escape characters + ╭─[language/literals/boolean/false-with-unicode.js:20:1] + 19 │ + 20 │ f\u{61}lse; + · ────────── ╰──── - × Unexpected token - ╭─[language/identifiers/val-default-via-escape-hex.js:16:5] - 15 │ - 16 │ var def\u{61}ult = 123; - · ──────────── + × Keywords cannot contain escape characters + ╭─[language/literals/boolean/true-with-unicode.js:20:1] + 19 │ + 20 │ tru\u{65}; + · ───────── ╰──── - × Unexpected token - ╭─[language/identifiers/val-default-via-escape-hex4.js:16:5] - 15 │ - 16 │ var def\u0061ult = 123; - · ──────────── + × Keywords cannot contain escape characters + ╭─[language/literals/null/null-with-unicode.js:20:1] + 19 │ + 20 │ n\u{75}ll; + · ───────── ╰──── - × Unexpected token - ╭─[language/identifiers/val-default.js:15:5] + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/7.8.3-1gs.js:15:9] 14 │ - 15 │ var default = 123; - · ─────── + 15 │ var y = 010; + · ─── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-delete-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{64}elete = 123; - · ─────────── + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/7.8.3-2gs.js:19:5] + 18 │ a = 0x1; + 19 │ a = 01; + · ── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-delete-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0064elete = 123; - · ─────────── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/S7.8.3_A6.1_T1.js:16:3] + 15 │ //CHECK#1 + 16 │ 0x + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-delete.js:15:5] - 14 │ - 15 │ var delete = 123; - · ────── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/S7.8.3_A6.1_T2.js:16:3] + 15 │ //CHECK#1 + 16 │ 0X + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-do-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{64}\u{6f} = 123; - · ──────────── + × Invalid Character `G` + ╭─[language/literals/numeric/S7.8.3_A6.2_T1.js:16:3] + 15 │ //CHECK#1 + 16 │ 0xG + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-do-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0064\u006f = 123; - · ──────────── + × Invalid Character `g` + ╭─[language/literals/numeric/S7.8.3_A6.2_T2.js:16:3] + 15 │ //CHECK#1 + 16 │ 0xg + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-do.js:15:5] - 14 │ - 15 │ var do = 123; - · ── + × Invalid Character `2` + ╭─[language/literals/numeric/binary-invalid-digit.js:23:3] + 22 │ + 23 │ 0b2; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-else-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{65}lse = 123; - · ───────── + × Invalid characters after number + ╭─[language/literals/numeric/binary-invalid-leading.js:23:3] + 22 │ + 23 │ 00b0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-else-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0065lse = 123; - · ───────── + × Invalid Character `;` + ╭─[language/literals/numeric/binary-invalid-truncated.js:23:3] + 22 │ + 23 │ 0b; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-else.js:15:5] - 14 │ - 15 │ var else = 123; - · ──── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/literals/numeric/binary-invalid-unicode.js:23:2] + 22 │ + 23 │ 0\u00620; + · ▲ ╰──── + help: Try insert a semicolon here - × Unexpected token - ╭─[language/identifiers/val-enum-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{65}\u{6e}\u{75}\u{6d} = 123; - · ──────────────────────── + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integer-strict.js:33:1] + 32 │ + 33 │ 00; + · ── ╰──── - - × Unexpected token - ╭─[language/identifiers/val-enum-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0065\u006e\u0075\u006d = 123; - · ──────────────────────── + help: for octal literals use the '0o' prefix instead + + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integery-000-strict.js:15:1] + 14 │ + 15 │ 000; + · ─── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-enum.js:15:5] + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integery-005-strict.js:15:1] 14 │ - 15 │ var enum = 123; - · ──── + 15 │ 005; + · ─── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-export-via-escape-hex.js:16:5] - 15 │ - 16 │ var expor\u{74} = 123; - · ─────────── + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integery-01-strict.js:15:1] + 14 │ + 15 │ 01; + · ── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-export-via-escape-hex4.js:16:5] - 15 │ - 16 │ var expor\u0074 = 123; - · ─────────── + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integery-010-strict.js:15:1] + 14 │ + 15 │ 010; + · ─── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-export.js:15:5] + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integery-06-strict.js:15:1] 14 │ - 15 │ var export = 123; - · ────── + 15 │ 06; + · ── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-extends-via-escape-hex.js:16:5] - 15 │ - 16 │ var extend\u{73} = 123; - · ──────────── + × '0'-prefixed octal literals and octal escape sequences are deprecated + ╭─[language/literals/numeric/legacy-octal-integery-07-strict.js:15:1] + 14 │ + 15 │ 07; + · ── ╰──── + help: for octal literals use the '0o' prefix instead - × Unexpected token - ╭─[language/identifiers/val-extends-via-escape-hex4.js:16:5] - 15 │ - 16 │ var extend\u0073 = 123; - · ──────────── + × Decimals with leading zeros are not allowed in strict mode + ╭─[language/literals/numeric/non-octal-decimal-integer-strict.js:39:1] + 38 │ + 39 │ 08; + · ── ╰──── + help: remove the leading zero - × Unexpected token - ╭─[language/identifiers/val-extends.js:15:5] - 14 │ - 15 │ var extends = 123; - · ─────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-followed-by-ident.js:18:2] + 17 │ + 18 │ 3in [] + · ── ╰──── - × Unexpected token - ╭─[language/identifiers/val-false-via-escape-hex.js:16:5] - 15 │ - 16 │ var fals\u{65} = 123; - · ────────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js:34:3] + 33 │ + 34 │ 0b_1 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-false-via-escape-hex4.js:16:5] - 15 │ - 16 │ var fals\u0065 = 123; - · ────────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js:34:5] + 33 │ + 34 │ 0b0__0 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-false.js:15:5] - 14 │ - 15 │ var false = 123; - · ───── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js:34:5] + 33 │ + 34 │ 0b0_ + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-finally-via-escape-hex.js:16:5] - 15 │ - 16 │ var fina\u{6c}ly = 123; - · ──────────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:26:3] + 25 │ + 26 │ 1__0123456789 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-finally-via-escape-hex4.js:16:5] - 15 │ - 16 │ var fina\u006cly = 123; - · ──────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:26:3] + 25 │ + 26 │ 1__0123456789 + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-finally.js:15:5] - 14 │ - 15 │ var finally = 123; - · ─────── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-err.js:28:3] + 27 │ + 28 │ 1_ + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-for-via-escape-hex.js:16:5] - 15 │ - 16 │ var f\u{6f}r = 123; - · ──────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:26:4] + 25 │ + 26 │ 10__0123456789 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-for-via-escape-hex4.js:16:5] - 15 │ - 16 │ var f\u006fr = 123; - · ──────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:26:4] + 25 │ + 26 │ 10__0123456789 + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-for.js:15:5] - 14 │ - 15 │ var for = 123; - · ─── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-err.js:29:4] + 28 │ + 29 │ 10_ + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-function-via-escape-hex.js:16:5] - 15 │ - 16 │ var func\u{74}ion = 123; - · ───────────── + × Invalid Character `e` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-dds-nsl-ep-dd-err.js:28:6] + 27 │ + 28 │ 10.0_e1 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-function-via-escape-hex4.js:16:5] - 15 │ - 16 │ var func\u0074ion = 123; - · ───────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-dd-err.js:28:4] + 27 │ + 28 │ 10._1 + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-function.js:15:5] - 14 │ - 15 │ var function = 123; - · ──────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-ep-err.js:31:4] + 30 │ + 31 │ 10._e1 + · ── ╰──── - × Unexpected token - ╭─[language/identifiers/val-if-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{69}\u{66} = 123; - · ──────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-err.js:29:4] + 28 │ + 29 │ 10._ + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-if-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0069\u0066 = 123; - · ──────────── + × Invalid Character `e` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-ep-err.js:30:4] + 29 │ + 30 │ .0_e1 + · ▲ ╰──── × Unexpected token - ╭─[language/identifiers/val-if.js:15:5] - 14 │ - 15 │ var if = 123; - · ── + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-ep-err.js:31:1] + 30 │ + 31 │ ._e1 + · ─ ╰──── × Unexpected token - ╭─[language/identifiers/val-import-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{69}\u{6d}\u{70}\u{6f}\u{72}\u{74} = 123; - · ──────────────────────────────────── + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-err.js:29:1] + 28 │ + 29 │ ._ + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-import-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0069\u006d\u0070\u006f\u0072\u0074 = 123; - · ──────────────────────────────────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js:34:3] + 33 │ + 34 │ 0x_1 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-import.js:15:5] - 14 │ - 15 │ var import = 123; - · ────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js:34:5] + 33 │ + 34 │ 0x0__0 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-in-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{69}\u{6e} = 123; - · ──────────── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js:34:5] + 33 │ + 34 │ 0x0_ + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-in-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0069\u006e = 123; - · ──────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-lol-00-err.js:41:3] + 40 │ + 41 │ 00_0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-in.js:15:5] - 14 │ - 15 │ var in = 123; - · ── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-lol-01-err.js:41:3] + 40 │ + 41 │ 01_0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-instanceof-via-escape-hex.js:16:5] - 15 │ - 16 │ var insta\u{6e}ceof = 123; - · ─────────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-lol-07-err.js:43:3] + 42 │ + 43 │ 07_0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-instanceof-via-escape-hex4.js:16:5] - 15 │ - 16 │ var insta\u006eceof = 123; - · ─────────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_0-err.js:41:2] + 40 │ + 41 │ 0_0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-instanceof.js:15:5] - 14 │ - 15 │ var instanceof = 123; - · ────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_1-err.js:41:2] + 40 │ + 41 │ 0_1; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-new-via-escape-hex.js:16:5] - 15 │ - 16 │ var n\u{65}w = 123; - · ──────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_7-err.js:42:2] + 41 │ + 42 │ 0_7; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-new-via-escape-hex4.js:16:5] - 15 │ - 16 │ var n\u0065w = 123; - · ──────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-08-err.js:38:3] + 37 │ + 38 │ 08_0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-new.js:15:5] - 14 │ - 15 │ var new = 123; - · ─── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-09-err.js:38:3] + 37 │ + 38 │ 09_0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-null-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{6e}ull = 123; - · ───────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js:38:2] + 37 │ + 38 │ 0_8; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-null-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u006eull = 123; - · ───────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js:38:2] + 37 │ + 38 │ 0_9; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-null.js:15:5] - 14 │ - 15 │ var null = 123; - · ──── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js:29:2] + 28 │ + 29 │ 0__0123456789 + · ── ╰──── - × Unexpected token - ╭─[language/identifiers/val-return-via-escape-hex.js:16:5] - 15 │ - 16 │ var retur\u{6e} = 123; - · ─────────── + × Invalid characters after number + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js:27:2] + 26 │ + 27 │ 0_0123456789 + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-return-via-escape-hex4.js:16:5] - 15 │ - 16 │ var retur\u006e = 123; - · ─────────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js:34:5] + 33 │ + 34 │ 0o0__0 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-return.js:15:5] - 14 │ - 15 │ var return = 123; - · ────── + × Invalid Character ` + │ ` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js:34:5] + 33 │ + 34 │ 0o0_ + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-super-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{73}uper = 123; - · ────────── + × Invalid Character `_` + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js:34:3] + 33 │ + 34 │ 0o_1 + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-super-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0073uper = 123; - · ────────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-unicode-err.js:26:2] + 25 │ + 26 │ 1\u005F0123456789 + · ▲ ╰──── + help: Try insert a semicolon here - × Unexpected token - ╭─[language/identifiers/val-super.js:15:5] - 14 │ - 15 │ var super = 123; - · ───── + × Invalid Character `8` + ╭─[language/literals/numeric/octal-invalid-digit.js:23:3] + 22 │ + 23 │ 0o8; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-switch-via-escape-hex.js:16:5] - 15 │ - 16 │ var switc\u{68} = 123; - · ─────────── + × Invalid characters after number + ╭─[language/literals/numeric/octal-invalid-leading.js:23:3] + 22 │ + 23 │ 00o0; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-switch-via-escape-hex4.js:16:5] - 15 │ - 16 │ var switc\u0068 = 123; - · ─────────── + × Invalid Character `;` + ╭─[language/literals/numeric/octal-invalid-truncated.js:23:3] + 22 │ + 23 │ 0o; + · ▲ ╰──── - × Unexpected token - ╭─[language/identifiers/val-switch.js:15:5] - 14 │ - 15 │ var switch = 123; - · ────── + × Expected a semicolon or an implicit semicolon after a statement, but found none + ╭─[language/literals/numeric/octal-invalid-unicode.js:23:2] + 22 │ + 23 │ 0\u006f0; + · ▲ ╰──── + help: Try insert a semicolon here - × Unexpected token - ╭─[language/identifiers/val-this-via-escape-hex.js:16:5] - 15 │ - 16 │ var thi\u{73} = 123; - · ───────── + × Unterminated multiline comment + ╭─[language/literals/regexp/S7.8.5_A1.2_T1.js:23:1] + 22 │ + 23 │ /*/ + · ──── ╰──── - × Unexpected token - ╭─[language/identifiers/val-this-via-escape-hex4.js:16:5] - 15 │ - 16 │ var thi\u0073 = 123; - · ───────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A1.2_T2.js:26:1] + 25 │ + 26 │ /\/ + · ──── ╰──── × Unexpected token - ╭─[language/identifiers/val-this.js:15:5] - 14 │ - 15 │ var this = 123; - · ──── + ╭─[language/literals/regexp/S7.8.5_A1.2_T3.js:27:1] + 26 │ /// + 27 │ .source; + · ─ ╰──── × Unexpected token - ╭─[language/identifiers/val-throw-via-escape-hex.js:16:5] - 15 │ - 16 │ var thro\u{77} = 123; - · ────────── + ╭─[language/literals/regexp/S7.8.5_A1.2_T4.js:27:1] + 26 │ // + 27 │ .source; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-throw-via-escape-hex4.js:16:5] - 15 │ - 16 │ var thro\u0077 = 123; - · ────────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A1.3_T1.js:29:1] + 28 │ + 29 │ / + · ── + 30 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-throw.js:15:5] - 14 │ - 15 │ var throw = 123; - · ───── + ╭─[language/literals/regexp/S7.8.5_A1.3_T1.js:31:1] + 30 │ / + ╰──── + + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A1.3_T3.js:29:1] + 28 │ + 29 │ / + · ── + 30 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-true-via-escape-hex.js:16:5] - 15 │ - 16 │ var tr\u{75}e = 123; - · ───────── + ╭─[language/literals/regexp/S7.8.5_A1.3_T3.js:31:1] + 30 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-true-via-escape-hex4.js:16:5] - 15 │ - 16 │ var tr\u0075e = 123; - · ───────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A1.5_T1.js:23:1] + 22 │ + 23 │ /\ + · ─── + 24 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-true.js:15:5] - 14 │ - 15 │ var true = 123; - · ──── + × Invalid atom escape + ╭─[language/literals/regexp/S7.8.5_A1.5_T1.js:23:2] + 22 │ + 23 │ /\ + · ─ + 24 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-try-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{74}\u{72}\u{79} = 123; - · ────────────────── + ╭─[language/literals/regexp/S7.8.5_A1.5_T1.js:25:1] + 24 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-try-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0074\u0072\u0079 = 123; - · ────────────────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A1.5_T3.js:22:1] + 21 │ + 22 │ /\ + · ─── + 23 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-try.js:15:5] - 14 │ - 15 │ var try = 123; - · ─── + × Invalid atom escape + ╭─[language/literals/regexp/S7.8.5_A1.5_T3.js:22:2] + 21 │ + 22 │ /\ + · ─ + 23 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-typeof-via-escape-hex.js:16:5] - 15 │ - 16 │ var typeo\u{66} = 123; - · ─────────── + ╭─[language/literals/regexp/S7.8.5_A1.5_T3.js:24:1] + 23 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-typeof-via-escape-hex4.js:16:5] - 15 │ - 16 │ var typeo\u0066 = 123; - · ─────────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A2.2_T1.js:23:1] + 22 │ + 23 │ /a\/ + · ───── ╰──── × Unexpected token - ╭─[language/identifiers/val-typeof.js:15:5] - 14 │ - 15 │ var typeof = 123; - · ────── + ╭─[language/literals/regexp/S7.8.5_A2.2_T2.js:23:5] + 22 │ + 23 │ /a//.source; + · ─ ╰──── - × Unexpected token - ╭─[language/identifiers/val-var-via-escape-hex.js:16:5] - 15 │ - 16 │ var va\u{72} = 123; - · ──────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A2.3_T1.js:32:1] + 31 │ + 32 │ /a + · ─── + 33 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-var-via-escape-hex4.js:16:5] - 15 │ - 16 │ var va\u0072 = 123; - · ──────── + ╭─[language/literals/regexp/S7.8.5_A2.3_T1.js:34:1] + 33 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-var.js:15:5] - 14 │ - 15 │ var var = 123; - · ─── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A2.3_T3.js:33:1] + 32 │ + 33 │ /a + · ─── + 34 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-void-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{76}\u{6f}\u{69}\u{64} = 123; - · ──────────────────────── + ╭─[language/literals/regexp/S7.8.5_A2.3_T3.js:35:1] + 34 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-void-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0076\u006f\u0069\u0064 = 123; - · ──────────────────────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A2.5_T1.js:28:1] + 27 │ + 28 │ /a\ + · ──── + 29 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-void.js:15:5] - 14 │ - 15 │ var void = 123; - · ──── + × Invalid atom escape + ╭─[language/literals/regexp/S7.8.5_A2.5_T1.js:28:3] + 27 │ + 28 │ /a\ + · ─ + 29 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-while-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{77}\u{68}\u{69}\u{6c}\u{65} = 123; - · ────────────────────────────── + ╭─[language/literals/regexp/S7.8.5_A2.5_T1.js:30:1] + 29 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-while-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0077\u0068\u0069\u006c\u0065 = 123; - · ────────────────────────────── + × Unterminated regular expression + ╭─[language/literals/regexp/S7.8.5_A2.5_T3.js:28:1] + 27 │ + 28 │ /a\ + · ──── + 29 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-while.js:15:5] - 14 │ - 15 │ var while = 123; - · ───── + × Invalid atom escape + ╭─[language/literals/regexp/S7.8.5_A2.5_T3.js:28:3] + 27 │ + 28 │ /a\ + · ─ + 29 │ / ╰──── × Unexpected token - ╭─[language/identifiers/val-with-via-escape-hex.js:16:5] - 15 │ - 16 │ var \u{77}ith = 123; - · ───────── + ╭─[language/literals/regexp/S7.8.5_A2.5_T3.js:30:1] + 29 │ / ╰──── - × Unexpected token - ╭─[language/identifiers/val-with-via-escape-hex4.js:16:5] - 15 │ - 16 │ var \u0077ith = 123; - · ───────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-add-remove-i.js:19:2] + 18 │ + 19 │ /(?i-i:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/identifiers/val-with.js:15:5] - 14 │ - 15 │ var with = 123; - · ──── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-add-remove-m.js:19:2] + 18 │ + 19 │ /(?m-m:a)//*{ global-modifiers }*/; + · ── ╰──── - × The keyword 'yield' is reserved - ╭─[language/identifiers/val-yield-strict.js:17:5] - 16 │ - 17 │ var yield = 13; - · ───── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-add-remove-multi-duplicate.js:19:2] + 18 │ + 19 │ /(?ims-m:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `ⸯ` - ╭─[language/identifiers/vertical-tilde-continue-escaped.js:16:12] - 15 │ - 16 │ var a\u2E2F; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s-escape.js:19:2] + 18 │ + 19 │ /(?\u{0073}-s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `ⸯ` - ╭─[language/identifiers/vertical-tilde-continue.js:16:6] - 15 │ - 16 │ var aⸯ; // U+2E2F - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s.js:19:2] + 18 │ + 19 │ /(?s-s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/identifiers/vertical-tilde-continue.js:16:6] - 15 │ - 16 │ var aⸯ; // U+2E2F - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-both-empty.js:19:2] + 18 │ + 19 │ /(?-:a)//*{ global-modifiers }*/; + · ── ╰──── - help: Try insert a semicolon here - × Invalid Character `ⸯ` - ╭─[language/identifiers/vertical-tilde-start-escaped.js:16:11] - 15 │ - 16 │ var \u2E2F; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-1.js:19:2] + 18 │ + 19 │ /(?-ii:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `ⸯ` - ╭─[language/identifiers/vertical-tilde-start.js:16:5] - 15 │ - 16 │ var ⸯ; // U+2E2F - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-2.js:19:2] + 18 │ + 19 │ /(?-imsi:a)//*{ global-modifiers }*/; + · ── ╰──── - × Identifier `x` has already been declared - ╭─[language/import/dup-bound-names.js:16:10] - 15 │ - 16 │ import { x, y as x } from 'z'; - · ┬ ┬ - · │ ╰── It can not be redeclared here - · ╰── `x` has already been declared here + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-no-colon-1.js:18:2] + 17 │ + 18 │ /(?ms-i)/; + · ── ╰──── - × Keywords cannot contain escape characters - ╭─[language/import/escaped-as-import-specifier.js:26:11] - 25 │ - 26 │ import {a \u0061s b} from "./escaped-as-import-specifier.js"; - · ─────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-no-colon-2.js:18:2] + 17 │ + 18 │ /(?-s)/; + · ── ╰──── - × Keywords cannot contain escape characters - ╭─[language/import/escaped-as-namespace-import.js:24:9] - 23 │ - 24 │ import* \u0061s self from "./escaped-as-namespace-import.js"; - · ─────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-no-colon-3.js:18:2] + 17 │ + 18 │ /(?i-)/; + · ── ╰──── - × Keywords cannot contain escape characters - ╭─[language/import/escaped-from.js:24:11] - 23 │ - 24 │ import {} \u0066rom "./escaped-from.js"; - · ───────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-arbitrary.js:19:2] + 18 │ + 19 │ /(?-1:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-break.js:20:7] - 19 │ - 20 │ break = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-i.js:19:2] + 18 │ + 19 │ /(?-iͥ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-case.js:20:1] - 19 │ - 20 │ case = 1; - · ──── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-m.js:19:2] + 18 │ + 19 │ /(?-mͫ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-catch.js:20:1] - 19 │ - 20 │ catch = 1; - · ───── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-s.js:19:2] + 18 │ + 19 │ /(?-s̀:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-continue.js:20:10] - 19 │ - 20 │ continue = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-d.js:19:2] + 18 │ + 19 │ /(?-d:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-default.js:20:1] - 19 │ - 20 │ default = 1; - · ─────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-g.js:19:2] + 18 │ + 19 │ /(?-g:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-delete.js:20:8] - 19 │ - 20 │ delete = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-1.js:19:2] + 18 │ + 19 │ /(?-s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-do.js:20:4] - 19 │ - 20 │ do = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-2.js:19:2] + 18 │ + 19 │ /(?-s‎:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-else.js:20:1] - 19 │ - 20 │ else = 1; - · ──── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-flag.js:19:2] + 18 │ + 19 │ /(?-Q:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-finally.js:20:1] - 19 │ - 20 │ finally = 1; - · ─────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-u.js:19:2] + 18 │ + 19 │ /(?-u:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `(` but found `=` - ╭─[language/keywords/ident-ref-for.js:20:5] - 19 │ - 20 │ for = 1; - · ┬ - · ╰── `(` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-uppercase-I.js:19:2] + 18 │ + 19 │ /(?-I:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `(` but found `=` - ╭─[language/keywords/ident-ref-function.js:20:10] - 19 │ - 20 │ function = 1; - · ┬ - · ╰── `(` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-y.js:19:2] + 18 │ + 19 │ /(?-y:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `(` but found `=` - ╭─[language/keywords/ident-ref-if.js:20:4] - 19 │ - 20 │ if = 1; - · ┬ - · ╰── `(` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwj.js:19:2] + 18 │ + 19 │ /(?-s‍:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-in.js:20:1] - 19 │ - 20 │ in = 1; - · ── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnbsp.js:19:2] + 18 │ + 19 │ /(?-s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-instanceof.js:20:1] - 19 │ - 20 │ instanceof = 1; - · ────────── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnj.js:19:2] + 18 │ + 19 │ /(?-s‌:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-new.js:20:5] - 19 │ - 20 │ new = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-i.js:19:2] + 18 │ + 19 │ /(?i-i:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-return.js:20:8] - 19 │ - 20 │ return = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-m.js:19:2] + 18 │ + 19 │ /(?m-m:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `(` but found `=` - ╭─[language/keywords/ident-ref-switch.js:20:8] - 19 │ - 20 │ switch = 1; - · ┬ - · ╰── `(` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-multi-duplicate.js:19:2] + 18 │ + 19 │ /(?m-ims:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-this.js:23:7] - 22 │ // Also see: sec-semantics-static-semantics-isvalidsimpleassignmenttarget - 23 │ ({this}); - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s-escape.js:19:2] + 18 │ + 19 │ /(?s-\u{0073}:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-throw.js:20:7] - 19 │ - 20 │ throw = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s.js:19:2] + 18 │ + 19 │ /(?s-s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `{` but found `=` - ╭─[language/keywords/ident-ref-try.js:20:5] - 19 │ - 20 │ try = 1; - · ┬ - · ╰── `{` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-1.js:19:2] + 18 │ + 19 │ /(?ii-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-typeof.js:20:8] - 19 │ - 20 │ typeof = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-2.js:19:2] + 18 │ + 19 │ /(?imsi-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-var.js:20:5] - 19 │ - 20 │ var = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-arbitrary.js:19:2] + 18 │ + 19 │ /(?1-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/keywords/ident-ref-void.js:20:6] - 19 │ - 20 │ void = 1; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-i.js:19:2] + 18 │ + 19 │ /(?iͥ-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `(` but found `=` - ╭─[language/keywords/ident-ref-while.js:20:7] - 19 │ - 20 │ while = 1; - · ┬ - · ╰── `(` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-m.js:19:2] + 18 │ + 19 │ /(?mͫ-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected `(` but found `=` - ╭─[language/keywords/ident-ref-with.js:20:6] - 19 │ - 20 │ with = 1; - · ┬ - · ╰── `(` expected + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-s.js:19:2] + 18 │ + 19 │ /(?s̀-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated string - ╭─[language/line-terminators/S7.3_A2.1_T2.js:16:1] - 15 │ //CHECK#1 - 16 │ " - · ── - 17 │ str - 18 │ ing + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-d.js:19:2] + 18 │ + 19 │ /(?d-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated string - ╭─[language/line-terminators/S7.3_A2.2_T2.js:16:1] - 15 │ //CHECK#1 - 16 │ " - · ── - 17 │ str - 18 │ ing + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-g.js:19:2] + 18 │ + 19 │ /(?g-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/line-terminators/S7.3_A3.2_T1.js:16:2] - 15 │ // single line comment - 16 │ ??? (invalid) + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-1.js:19:2] + 18 │ + 19 │ /(?s-:a)//*{ global-modifiers }*/; · ── ╰──── - × Invalid Character ` - │ ` - ╭─[language/line-terminators/S7.3_A6_T1.js:17:10] - 16 │ - 17 │ var\u000Ax; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-2.js:19:2] + 18 │ + 19 │ /(?s‎-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character ` ` - ╭─[language/line-terminators/S7.3_A6_T2.js:17:10] - 16 │ - 17 │ var\u000Dx; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-flag.js:19:2] + 18 │ + 19 │ /(?Q-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `
` - ╭─[language/line-terminators/S7.3_A6_T3.js:17:10] - 16 │ - 17 │ var\u2028x; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-u.js:19:2] + 18 │ + 19 │ /(?u-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `
` - ╭─[language/line-terminators/S7.3_A6_T4.js:17:10] - 16 │ - 17 │ var\u2029x; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-uppercase-I.js:19:2] + 18 │ + 19 │ /(?I-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/line-terminators/invalid-comment-single-cr.js:17:6] - 16 │ // this text is not included in the single-line comment that precedes it - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-y.js:19:2] + 18 │ + 19 │ /(?y-:a)//*{ global-modifiers }*/; + · ── ╰──── - help: Try insert a semicolon here - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/line-terminators/invalid-comment-single-lf.js:17:5] - 16 │ //single - 17 │ line comment - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwj.js:19:2] + 18 │ + 19 │ /(?s‍-:a)//*{ global-modifiers }*/; + · ── ╰──── - help: Try insert a semicolon here - × Unexpected token - ╭─[language/line-terminators/invalid-comment-single-ls.js:17:22] - 16 │ - 17 │ // single line LS>
??? (invalid) - · ── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnbsp.js:19:2] + 18 │ + 19 │ /(?s-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/line-terminators/invalid-comment-single-ps.js:15:22] - 14 │ - 15 │ // single line PS>
??? (invalid) - · ── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnj.js:19:2] + 18 │ + 19 │ /(?s‌-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated regular expression - ╭─[language/line-terminators/invalid-regexp-cr.js:17:1] - 16 │ - 17 │ / / - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-i.js:19:2] + 18 │ + 19 │ /(?I-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/line-terminators/invalid-regexp-cr.js:19:1] - 18 │ / + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-m.js:19:2] + 18 │ + 19 │ /(?M-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated regular expression - ╭─[language/line-terminators/invalid-regexp-lf.js:17:1] - 16 │ - 17 │ / - · ── - 18 │ / + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-s.js:19:2] + 18 │ + 19 │ /(?S-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/line-terminators/invalid-regexp-lf.js:19:1] - 18 │ / + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-i.js:19:2] + 18 │ + 19 │ /(?İ-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated regular expression - ╭─[language/line-terminators/invalid-regexp-ls.js:17:1] - 16 │ - 17 │ /
/ - · ── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-s.js:19:2] + 18 │ + 19 │ /(?ſ-:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/line-terminators/invalid-regexp-ls.js:18:1] - 17 │ /
/ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-i.js:19:2] + 18 │ + 19 │ /(?-I:a)//*{ global-modifiers }*/; + · ── + ╰──── + + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-m.js:19:2] + 18 │ + 19 │ /(?-M:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated regular expression - ╭─[language/line-terminators/invalid-regexp-ps.js:17:1] - 16 │ - 17 │ /
/ - · ── + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-s.js:19:2] + 18 │ + 19 │ /(?-S:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unexpected token - ╭─[language/line-terminators/invalid-regexp-ps.js:18:1] - 17 │ /
/ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-i.js:19:2] + 18 │ + 19 │ /(?-İ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated string - ╭─[language/line-terminators/invalid-string-cr.js:16:1] - 15 │ - 16 │ ' ' - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-s.js:19:2] + 18 │ + 19 │ /(?-ſ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Unterminated string - ╭─[language/line-terminators/invalid-string-lf.js:16:1] - 15 │ - 16 │ ' - · ── - 17 │ ' + × Unexpected flag G in regular expression literal + ╭─[language/literals/regexp/early-err-bad-flag.js:18:5] + 17 │ + 18 │ /./G; + · ▲ ╰──── - × Invalid Character `2` - ╭─[language/literals/bigint/binary-invalid-digit.js:26:3] - 25 │ - 26 │ 0b2n; - · ▲ + × Flag g is mentioned twice in regular expression literal + ╭─[language/literals/regexp/early-err-dup-flag.js:18:7] + 17 │ + 18 │ /./gig; + · ▲ ╰──── × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/literals/bigint/exponent-part.js:16:4] - 15 │ - 16 │ 0e0n; + ╭─[language/literals/regexp/early-err-flags-unicode-escape.js:18:4] + 17 │ + 18 │ /./\u0067; · ▲ ╰──── help: Try insert a semicolon here - × Invalid Character `g` - ╭─[language/literals/bigint/hexadecimal-invalid-digit.js:26:3] - 25 │ - 26 │ 0xgn; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-code-point-repeat-i-1.js:19:2] + 18 │ + 19 │ /(?ii:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/legacy-octal-like-invalid-00n.js:28:3] - 27 │ - 28 │ 00n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-code-point-repeat-i-2.js:19:2] + 18 │ + 19 │ /(?imsi:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/legacy-octal-like-invalid-01n.js:28:3] - 27 │ - 28 │ 01n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-arbitrary.js:19:2] + 18 │ + 19 │ /(?1:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/legacy-octal-like-invalid-07n.js:28:3] - 27 │ - 28 │ 07n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-combining-i.js:19:2] + 18 │ + 19 │ /(?iͥ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/mv-is-not-integer-dil-dot-dds.js:27:7] - 26 │ - 27 │ 2017.8n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-combining-m.js:19:2] + 18 │ + 19 │ /(?mͫ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/mv-is-not-integer-dot-dds.js:27:12] - 26 │ - 27 │ .0000000001n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-combining-s.js:19:2] + 18 │ + 19 │ /(?s̀:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/non-octal-like-invalid-0008n.js:28:5] - 27 │ - 28 │ 0008n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-d.js:19:2] + 18 │ + 19 │ /(?d:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/non-octal-like-invalid-012348n.js:28:7] - 27 │ - 28 │ 012348n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-g.js:19:2] + 18 │ + 19 │ /(?g:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/non-octal-like-invalid-08n.js:28:3] - 27 │ - 28 │ 08n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-non-display-1.js:19:2] + 18 │ + 19 │ /(?s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/non-octal-like-invalid-09n.js:28:3] - 27 │ - 28 │ 09n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-non-display-2.js:19:2] + 18 │ + 19 │ /(?s‎:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js:44:3] - 43 │ - 44 │ 0b_1n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-non-flag.js:19:2] + 18 │ + 19 │ /(?Q:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js:44:5] - 43 │ - 44 │ 0b0__0n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-u.js:19:2] + 18 │ + 19 │ /(?u:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `n` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js:43:5] - 42 │ - 43 │ 0b0_n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-uppercase-I.js:19:2] + 18 │ + 19 │ /(?I:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:36:3] - 35 │ - 36 │ 1__0123456789n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-y.js:19:2] + 18 │ + 19 │ /(?y:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:36:3] - 35 │ - 36 │ 1__0123456789n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-zwj.js:19:2] + 18 │ + 19 │ /(?s‍:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `n` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-err.js:38:3] - 37 │ - 38 │ 1_n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-zwnbsp.js:19:2] + 18 │ + 19 │ /(?s:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:36:4] - 35 │ - 36 │ 10__0123456789n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-other-code-point-zwnj.js:19:2] + 18 │ + 19 │ /(?s‌:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:36:4] - 35 │ - 36 │ 10__0123456789n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-case-fold-i.js:19:2] + 18 │ + 19 │ /(?I:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `n` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-err.js:39:4] - 38 │ - 39 │ 10_n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-case-fold-m.js:19:2] + 18 │ + 19 │ /(?M:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js:44:3] - 43 │ - 44 │ 0x_1n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-case-fold-s.js:19:2] + 18 │ + 19 │ /(?S:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js:44:5] - 43 │ - 44 │ 0x0__0n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-i.js:19:2] + 18 │ + 19 │ /(?İ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid Character `n` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js:44:5] - 43 │ - 44 │ 0x0_n; - · ▲ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-s.js:19:2] + 18 │ + 19 │ /(?ſ:a)//*{ global-modifiers }*/; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-00-err.js:52:3] - 51 │ - 52 │ 00_0n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-unicode-escape-i.js:19:2] + 18 │ + 19 │ /(?\u0069:a)/u /* i */; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-01-err.js:52:3] - 51 │ - 52 │ 01_0n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-unicode-escape-m.js:19:2] + 18 │ + 19 │ /(?\u006D:a)/u /* m */; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-07-err.js:54:3] - 53 │ - 54 │ 07_0n; - · ─ + × Capturing group name is missing + ╭─[language/literals/regexp/early-err-modifiers-should-not-unicode-escape-s.js:19:2] + 18 │ + 19 │ /(?\u0073:a)/u /* s */; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_0-err.js:52:2] - 51 │ - 52 │ 0_0n; + × Invalid braced quantifier + ╭─[language/literals/regexp/early-err-pattern.js:17:2] + 16 │ + 17 │ /?/; · ─ ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_1-err.js:52:2] - 51 │ - 52 │ 0_1n; - · ─ + × Invalid braced quantifier + ╭─[language/literals/regexp/invalid-braced-quantifier-exact.js:25:2] + 24 │ + 25 │ /{2}/; + · ─── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_7-err.js:53:2] - 52 │ - 53 │ 0_7n; - · ─ + × Invalid braced quantifier + ╭─[language/literals/regexp/invalid-braced-quantifier-lower.js:25:2] + 24 │ + 25 │ /{2,}/; + · ──── + ╰──── + + × Invalid braced quantifier + ╭─[language/literals/regexp/invalid-braced-quantifier-range.js:25:2] + 24 │ + 25 │ /{2,3}/; + · ───── + ╰──── + + × Invalid braced quantifier + ╭─[language/literals/regexp/invalid-optional-lookbehind.js:20:9] + 19 │ + 20 │ /.(?<=.)?/; + · ─ + ╰──── + + × Invalid braced quantifier + ╭─[language/literals/regexp/invalid-optional-negative-lookbehind.js:20:9] + 19 │ + 20 │ /.(?a)\k/u; + · ────── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-08-err.js:49:3] - 48 │ - 49 │ 08_0n; - · ─ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-2.js:20:9] + 19 │ + 20 │ /(?a)\k/; + · ────── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-09-err.js:49:3] - 48 │ - 49 │ 09_0n; - · ─ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-3-u.js:20:10] + 19 │ + 20 │ /(?a)\k/u; + · ───── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js:49:2] - 48 │ - 49 │ 0_8n; - · ─ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-3.js:20:10] + 19 │ + 20 │ /(?a)\k/; + · ───── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js:49:2] - 48 │ - 49 │ 0_9n; - · ─ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-4-u.js:20:2] + 19 │ + 20 │ /\k(?a)/u; + · ───── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js:39:2] - 38 │ - 39 │ 0__0123456789n; - · ── + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-4.js:20:2] + 19 │ + 20 │ /\k(?a)/; + · ───── ╰──── - × Invalid characters after number - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js:37:2] - 36 │ - 37 │ 0_0123456789n; - · ─ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-5.js:20:2] + 19 │ + 20 │ /\k(?x)/; + · ───── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js:44:5] - 43 │ - 44 │ 0o0__0n; - · ▲ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-u.js:20:9] + 19 │ + 20 │ /(?.)\k/u; + · ───── ╰──── - × Invalid Character `n` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js:44:5] - 43 │ - 44 │ 0o0_n; - · ▲ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname-without-group-u.js:20:2] + 19 │ + 20 │ /\k/u; + · ───── ╰──── - × Invalid Character `_` - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js:44:3] - 43 │ - 44 │ 0o_1n; - · ▲ + × Group specifier is empty + ╭─[language/literals/regexp/named-groups/invalid-dangling-groupname.js:20:9] + 19 │ + 20 │ /(?.)\k/; + · ───── ╰──── - × Expected a semicolon or an implicit semicolon after a statement, but found none - ╭─[language/literals/bigint/numeric-separators/numeric-separator-literal-unicode-err.js:36:2] - 35 │ - 36 │ 1\u005F0123456789n; - · ▲ + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Duplicated group name + + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-empty-groupspecifier-u.js:15:4] + 14 │ + 15 │ /(?<>a)/u; + · ─ ╰──── - help: Try insert a semicolon here - × Invalid Character `9` - ╭─[language/literals/bigint/octal-invalid-digit.js:26:3] - 25 │ - 26 │ 0o9n; - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-empty-groupspecifier.js:15:4] + 14 │ + 15 │ /(?<>a)/; + · ─ ╰──── - × Keywords cannot contain escape characters - ╭─[language/literals/boolean/false-with-unicode.js:20:1] - 19 │ - 20 │ f\u{61}lse; - · ────────── + × Invalid atom escape + ╭─[language/literals/regexp/named-groups/invalid-identity-escape-in-capture-u.js:15:7] + 14 │ + 15 │ /(?\a)/u; + · ─ ╰──── - × Keywords cannot contain escape characters - ╭─[language/literals/boolean/true-with-unicode.js:20:1] - 19 │ - 20 │ tru\u{65}; - · ───────── + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-2-u.js:15:11] + 14 │ + 15 │ /(?.)\k.)\k.)\k<>/u; + · ─ ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/7.8.3-2gs.js:19:5] - 18 │ a = 0x1; - 19 │ a = 01; - · ── + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-3.js:15:11] + 14 │ + 15 │ /(?.)\k<>/; + · ─ ╰──── - help: for octal literals use the '0o' prefix instead - × Invalid Character ` - │ ` - ╭─[language/literals/numeric/S7.8.3_A6.1_T1.js:16:3] - 15 │ //CHECK#1 - 16 │ 0x - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-4.js:15:4] + 14 │ + 15 │ /\ka)/; + · ── ╰──── - × Invalid Character ` - │ ` - ╭─[language/literals/numeric/S7.8.3_A6.1_T2.js:16:3] - 15 │ //CHECK#1 - 16 │ 0X - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-5.js:15:4] + 14 │ + 15 │ /\k.)/; + · ── ╰──── - × Invalid Character `G` - ╭─[language/literals/numeric/S7.8.3_A6.2_T1.js:16:3] - 15 │ //CHECK#1 - 16 │ 0xG - · ▲ + × Invalid named reference + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-6.js:15:2] + 14 │ + 15 │ /\k(?.)/; + · ── ╰──── - × Invalid Character `g` - ╭─[language/literals/numeric/S7.8.3_A6.2_T2.js:16:3] - 15 │ //CHECK#1 - 16 │ 0xg - · ▲ + × Invalid named reference + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-u.js:15:9] + 14 │ + 15 │ /(?.)\k/u; + · ── ╰──── - × Invalid Character `2` - ╭─[language/literals/numeric/binary-invalid-digit.js:23:3] - 22 │ - 23 │ 0b2; - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-2-u.js:15:4] + 14 │ + 15 │ /\k<>/u; + · ─ ╰──── - × Invalid characters after number - ╭─[language/literals/numeric/binary-invalid-leading.js:23:3] - 22 │ - 23 │ 00b0; - · ─ + × Invalid named reference + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-3-u.js:15:2] + 14 │ + 15 │ /\k/u; + · ── ╰──── - × Invalid Character `;` - ╭─[language/literals/numeric/binary-invalid-truncated.js:23:3] - 22 │ - 23 │ 0b; - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-u.js:15:4] + 14 │ + 15 │ /\k.)\k/; + · ── ╰──── - help: Try insert a semicolon here - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integer-strict.js:33:1] - 32 │ - 33 │ 00; - · ── + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier.js:15:4] + 14 │ + 15 │ /(?<$❞>a)/; + · ── ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integery-000-strict.js:15:1] + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2-u.js:15:4] 14 │ - 15 │ 000; - · ─── + 15 │ /(?<𐒤>a)/u; + · ─ ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integery-005-strict.js:15:1] + × Invalid surrogate pair + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2.js:15:5] 14 │ - 15 │ 005; - · ─── + 15 │ /(?<𐒤>a)/; + · ─ ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integery-01-strict.js:15:1] + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-3.js:15:6] 14 │ - 15 │ 01; - · ── + 15 │ /(?.)/; + · ──────────── ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integery-010-strict.js:15:1] + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4-u.js:15:6] 14 │ - 15 │ 010; - · ─── + 15 │ /(?.)/u; + · ────── ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integery-06-strict.js:15:1] + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4.js:15:6] 14 │ - 15 │ 06; - · ── + 15 │ /(?.)/; + · ────── ╰──── - help: for octal literals use the '0o' prefix instead - × '0'-prefixed octal literals and octal escape sequences are deprecated - ╭─[language/literals/numeric/legacy-octal-integery-07-strict.js:15:1] + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5-u.js:15:6] 14 │ - 15 │ 07; - · ── + 15 │ /(?.)/u; + · ────── ╰──── - help: for octal literals use the '0o' prefix instead - × Decimals with leading zeros are not allowed in strict mode - ╭─[language/literals/numeric/non-octal-decimal-integer-strict.js:39:1] - 38 │ - 39 │ 08; - · ── + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5.js:15:6] + 14 │ + 15 │ /(?.)/; + · ────── ╰──── - help: remove the leading zero - × Invalid characters after number - ╭─[language/literals/numeric/numeric-followed-by-ident.js:18:2] - 17 │ - 18 │ 3in [] - · ── + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-6.js:15:6] + 14 │ + 15 │ /(?.)/; + · ───────── ╰──── - × Invalid Character `_` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js:34:3] - 33 │ - 34 │ 0b_1 - · ▲ + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-7.js:15:6] + 14 │ + 15 │ /(?.)/; + · ────────── ╰──── - × Invalid Character `_` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js:34:5] - 33 │ - 34 │ 0b0__0 - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8-u.js:15:4] + 14 │ + 15 │ /(?<\>.)/u; + · ── ╰──── - × Invalid Character ` - │ ` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js:34:5] - 33 │ - 34 │ 0b0_ - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8.js:15:4] + 14 │ + 15 │ /(?<\>.)/; + · ── ╰──── - × Invalid Character `_` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:26:3] - 25 │ - 26 │ 1__0123456789 - · ▲ + × Invalid unicode escape sequence + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-9-u.js:15:7] + 14 │ + 15 │ /(?.)/u; + · ─ ╰──── - × Invalid characters after number - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js:26:3] - 25 │ - 26 │ 1__0123456789 - · ─ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-u.js:15:4] + 14 │ + 15 │ /(?<❤>a)/u; + · ─ ╰──── - × Invalid Character ` - │ ` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-err.js:28:3] - 27 │ - 28 │ 1_ - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier.js:15:4] + 14 │ + 15 │ /(?<❤>a)/; + · ─ ╰──── - × Invalid Character `_` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:26:4] - 25 │ - 26 │ 10__0123456789 - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-numeric-groupspecifier-u.js:15:4] + 14 │ + 15 │ /(?<42a>a)/u; + · ─ ╰──── - × Invalid characters after number - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js:26:4] - 25 │ - 26 │ 10__0123456789 + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-numeric-groupspecifier.js:15:4] + 14 │ + 15 │ /(?<42a>a)/; · ─ ╰──── - × Invalid Character ` - │ ` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-err.js:29:4] - 28 │ - 29 │ 10_ - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier-u.js:15:4] + 14 │ + 15 │ /(?<:a>a)/u; + · ─ ╰──── - × Invalid Character `e` - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-dds-nsl-ep-dd-err.js:28:6] - 27 │ - 28 │ 10.0_e1 - · ▲ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier.js:15:4] + 14 │ + 15 │ /(?<:a>a)/; + · ─ ╰──── - × Invalid characters after number - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-dd-err.js:28:4] - 27 │ - 28 │ 10._1 - · ─ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier-u.js:15:4] + 14 │ + 15 │ /(?a)/u; + · ── ╰──── - × Invalid characters after number - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-ep-err.js:31:4] - 30 │ - 31 │ 10._e1 + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier.js:15:4] + 14 │ + 15 │ /(?a)/; · ── ╰──── - × Invalid characters after number - ╭─[language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-err.js:29:4] - 28 │ - 29 │ 10._ - · ─ + × Unterminated capturing group name + ╭─[language/literals/regexp/named-groups/invalid-unterminated-groupspecifier-u.js:15:4] + 14 │ + 15 │ /(?)\k/; + · ─────── + ╰──── + × Unexpected flag a in regular expression literal ╭─[compiler/regularExpressionScanning.ts:3:12] 2 │ // Flags @@ -10329,6 +10516,178 @@ Expect to Parse: "conformance/salsa/typeFromPropertyAssignmentWithExport.ts" 4 │ // Pattern modifiers ╰──── + × Capturing group name is missing + ╭─[compiler/regularExpressionScanning.ts:5:3] + 4 │ // Pattern modifiers + 5 │ /(?med-ium:bar)/, + · ── + 6 │ // Capturing groups + ╰──── + + × Invalid indexed reference + ╭─[compiler/regularExpressionScanning.ts:13:8] + 12 │ /\2()(\12)(foo)\1\0[\0\1\01\123\08\8](\3\03)\5\005\9\009/, + 13 │ /\2()(\12)(foo)\1\0[\0\1\01\123\08\8](\3\03)\5\005\9\009/u, + · ─── + 14 │ /(?)((?bar)bar)(?baz)|(foo(?foo))(?)/, + ╰──── + + × Duplicated group name + + × Duplicated group name + + × Numbers out of order in braced quantifier + ╭─[compiler/regularExpressionScanning.ts:17:31] + 16 │ // Quantifiers + 17 │ /{}{1,2}_{3}.{4,}?(foo){008}${32,16}\b{064,128}.+&*?\???\n{,256}{\\{,/, + · ─────── + 18 │ // Character classes + ╰──── + + × Character class range out of order + ╭─[compiler/regularExpressionScanning.ts:19:13] + 18 │ // Character classes + 19 │ /[-A-Za-z-z-aZ-A\d_-\d-.-.\r-\n\w-\W]/, + · ── + 20 │ /\p{L}\p{gc=L}\p{ASCII}\p{Invalid}[\p{L}\p{gc=L}\P{ASCII}\p{Invalid}]/, + ╰──── + + × Invalid unicode property name or value + ╭─[compiler/regularExpressionScanning.ts:21:28] + 20 │ /\p{L}\p{gc=L}\p{ASCII}\p{Invalid}[\p{L}\p{gc=L}\P{ASCII}\p{Invalid}]/, + 21 │ /\p{L}\p{gc=L}\p{ASCII}\p{Invalid}[\p{L}\p{gc=L}\P{ASCII}\p{Invalid}]/u, + · ─────── + 22 │ /\p{L}\p{gc=L}\p{ASCII}\p{Invalid}[\p{L}\p{gc=L}\P{ASCII}\p{Invalid}]/v, + ╰──── + + × Invalid unicode property name or value + ╭─[compiler/regularExpressionScanning.ts:22:28] + 21 │ /\p{L}\p{gc=L}\p{ASCII}\p{Invalid}[\p{L}\p{gc=L}\P{ASCII}\p{Invalid}]/u, + 22 │ /\p{L}\p{gc=L}\p{ASCII}\p{Invalid}[\p{L}\p{gc=L}\P{ASCII}\p{Invalid}]/v, + · ─────── + 23 │ /\p{InvalidProperty=Value}\p{=}\p{sc=}\P{=foo}[\p{}\p\\\P\P{]\p{/, + ╰──── + + × Invalid unicode property name + ╭─[compiler/regularExpressionScanning.ts:24:22] + 23 │ /\p{InvalidProperty=Value}\p{=}\p{sc=}\P{=foo}[\p{}\p\\\P\P{]\p{/, + 24 │ /\p{InvalidProperty=Value}\p{=}\p{sc=}\P{=foo}[\p{}\p\\\P\P{]\p{/u, + · ───── + 25 │ /\p{InvalidProperty=Value}\p{=}\p{sc=}\P{=foo}[\p{}\p\\\P\P{]\p{/v, + ╰──── + + × Invalid unicode property name + ╭─[compiler/regularExpressionScanning.ts:25:22] + 24 │ /\p{InvalidProperty=Value}\p{=}\p{sc=}\P{=foo}[\p{}\p\\\P\P{]\p{/u, + 25 │ /\p{InvalidProperty=Value}\p{=}\p{sc=}\P{=foo}[\p{}\p\\\P\P{]\p{/v, + · ───── + 26 │ /\p{RGI_Emoji}\P{RGI_Emoji}[^\p{RGI_Emoji}\P{RGI_Emoji}]/, + ╰──── + + × `UnicodeSetsMode` is required for binary property of strings + ╭─[compiler/regularExpressionScanning.ts:27:6] + 26 │ /\p{RGI_Emoji}\P{RGI_Emoji}[^\p{RGI_Emoji}\P{RGI_Emoji}]/, + 27 │ /\p{RGI_Emoji}\P{RGI_Emoji}[^\p{RGI_Emoji}\P{RGI_Emoji}]/u, + · ───────── + 28 │ /\p{RGI_Emoji}\P{RGI_Emoji}[^\p{RGI_Emoji}\P{RGI_Emoji}]/v, + ╰──── + + × Invalid property name(negative + property of strings) + ╭─[compiler/regularExpressionScanning.ts:28:16] + 27 │ /\p{RGI_Emoji}\P{RGI_Emoji}[^\p{RGI_Emoji}\P{RGI_Emoji}]/u, + 28 │ /\p{RGI_Emoji}\P{RGI_Emoji}[^\p{RGI_Emoji}\P{RGI_Emoji}]/v, + · ───────────── + 29 │ // Character escapes + ╰──── + + × Invalid atom escape + ╭─[compiler/regularExpressionScanning.ts:30:3] + 29 │ // Character escapes + 30 │ /\c[\c0\ca\cQ\c\C]\c1\C/, + · ─ + 31 │ /\c[\c0\ca\cQ\c\C]\c1\C/u, + ╰──── + + × Invalid atom escape + ╭─[compiler/regularExpressionScanning.ts:31:3] + 30 │ /\c[\c0\ca\cQ\c\C]\c1\C/, + 31 │ /\c[\c0\ca\cQ\c\C]\c1\C/u, + · ─ + 32 │ /\q\\\`[\q\\\`[\Q\\\Q{\q{foo|bar|baz]\q{]\q{/, + ╰──── + + × Invalid atom escape + ╭─[compiler/regularExpressionScanning.ts:33:3] + 32 │ /\q\\\`[\q\\\`[\Q\\\Q{\q{foo|bar|baz]\q{]\q{/, + 33 │ /\q\\\`[\q\\\`[\Q\\\Q{\q{foo|bar|baz]\q{]\q{/u, + · ─ + 34 │ /\q\\\`[\q\\\`[\Q\\\Q{\q{foo|bar|baz]\q{]\q{/v, + ╰──── + + × Invalid atom escape + ╭─[compiler/regularExpressionScanning.ts:34:3] + 33 │ /\q\\\`[\q\\\`[\Q\\\Q{\q{foo|bar|baz]\q{]\q{/u, + 34 │ /\q\\\`[\q\\\`[\Q\\\Q{\q{foo|bar|baz]\q{]\q{/v, + · ─ + 35 │ // Unicode sets notation + ╰──── + + × Character class range out of order + ╭─[compiler/regularExpressionScanning.ts:36:5] + 35 │ // Unicode sets notation + 36 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/, + · ── + 37 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/u, + ╰──── + + × Character class range out of order + ╭─[compiler/regularExpressionScanning.ts:37:5] + 36 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/, + 37 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/u, + · ── + 38 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/v, + ╰──── + + × Invalid character in character class set subtraction + ╭─[compiler/regularExpressionScanning.ts:38:8] + 37 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/u, + 38 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/v, + · ▲ + 39 │ /[[^\P{Decimal_Number}&&[0-9]]&&\p{L}&&\p{ID_Continue}--\p{ASCII}\p{CWCF}]/v, + ╰──── + + × Invalid character in character class set interseciton + ╭─[compiler/regularExpressionScanning.ts:39:56] + 38 │ /[a--b[--][\d++[]]&&[[&0-9--]&&[\p{L}]--\P{L}-_-]]&&&\q{foo}[0---9][&&q&&&\q{bar}&&]/v, + 39 │ /[[^\P{Decimal_Number}&&[0-9]]&&\p{L}&&\p{ID_Continue}--\p{ASCII}\p{CWCF}]/v, + · ▲ + 40 │ /[^\p{Emoji}\p{RGI_Emoji}][^\p{Emoji}--\p{RGI_Emoji}][^\p{Emoji}&&\p{RGI_Emoji}]/v, + ╰──── + + × Invalid character class + ╭─[compiler/regularExpressionScanning.ts:40:3] + 39 │ /[[^\P{Decimal_Number}&&[0-9]]&&\p{L}&&\p{ID_Continue}--\p{ASCII}\p{CWCF}]/v, + 40 │ /[^\p{Emoji}\p{RGI_Emoji}][^\p{Emoji}--\p{RGI_Emoji}][^\p{Emoji}&&\p{RGI_Emoji}]/v, + · ───────────────────────── + 41 │ /[^\p{RGI_Emoji}\p{Emoji}][^\p{RGI_Emoji}--\p{Emoji}][^\p{RGI_Emoji}&&\p{Emoji}]/v, + ╰──── + + × Invalid character class + ╭─[compiler/regularExpressionScanning.ts:41:3] + 40 │ /[^\p{Emoji}\p{RGI_Emoji}][^\p{Emoji}--\p{RGI_Emoji}][^\p{Emoji}&&\p{RGI_Emoji}]/v, + 41 │ /[^\p{RGI_Emoji}\p{Emoji}][^\p{RGI_Emoji}--\p{Emoji}][^\p{RGI_Emoji}&&\p{Emoji}]/v, + · ───────────────────────── + 42 │ /[^\p{RGI_Emoji}\q{foo}][^\p{RGI_Emoji}--\q{foo}][^\p{RGI_Emoji}&&\q{foo}]/v, + ╰──── + + × Invalid character class + ╭─[compiler/regularExpressionScanning.ts:42:3] + 41 │ /[^\p{RGI_Emoji}\p{Emoji}][^\p{RGI_Emoji}--\p{Emoji}][^\p{RGI_Emoji}&&\p{Emoji}]/v, + 42 │ /[^\p{RGI_Emoji}\q{foo}][^\p{RGI_Emoji}--\q{foo}][^\p{RGI_Emoji}&&\q{foo}]/v, + · ─────────────────────── + 43 │ /[^\p{Emoji}[[\p{RGI_Emoji}]]][^\p{Emoji}--[[\p{RGI_Emoji}]]][^\p{Emoji}&&[[\p{RGI_Emoji}]]]/v, + ╰──── + × The 'u' and 'v' regular expression flags cannot be enabled at the same time ╭─[compiler/regularExpressionScanning.ts:3:2] 2 │ // Flags @@ -10337,6 +10696,19 @@ Expect to Parse: "conformance/salsa/typeFromPropertyAssignmentWithExport.ts" 4 │ // Pattern modifiers ╰──── + × Invalid unicode property name or value + ╭─[compiler/regularExpressionUnicodePropertyValueExpressionSuggestions.ts:1:19] + 1 │ const regex = /\p{ascii}\p{Sc=Unknown}\p{sc=unknownX}\p{Script_Declensions=Inherited}\p{scx=inherit}/u; + · ───── + ╰──── + + × Capturing group name is missing + ╭─[compiler/regularExpressionWithNonBMPFlags.ts:7:31] + 6 │ // See https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols + 7 │ const 𝘳𝘦𝘨𝘦𝘹 = /(?𝘴𝘪-𝘮:^𝘧𝘰𝘰.)/𝘨𝘮𝘶; + · ── + ╰──── + × Expected a semicolon or an implicit semicolon after a statement, but found none ╭─[compiler/regularExpressionWithNonBMPFlags.ts:7:63] 6 │ // See https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols @@ -15412,6 +15784,38 @@ Expect to Parse: "conformance/salsa/typeFromPropertyAssignmentWithExport.ts" 2 │ // Once this is supported, yield *must* be parenthesized. ╰──── + × Invalid unicode escape sequence + ╭─[conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions07.ts:3:11] + 2 │ // 1. Assert: 0 ≤ cp ≤ 0x10FFFF. + 3 │ var x = /\u{110000}/gu; + · ─ + ╰──── + + × Invalid unicode escape sequence + ╭─[conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions12.ts:1:11] + 1 │ var x = /\u{FFFFFFFF}/gu; + · ─ + ╰──── + + × Invalid unicode escape sequence + ╭─[conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions14.ts:2:11] + 1 │ // Shouldn't work, negatives are not allowed. + 2 │ var x = /\u{-DDDD}/gu; + · ─ + ╰──── + + × Invalid unicode escape sequence + ╭─[conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions17.ts:1:11] + 1 │ var x = /\u{r}\u{n}\u{t}/gu; + · ─ + ╰──── + + × Invalid unicode escape sequence + ╭─[conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInRegularExpressions19.ts:1:11] + 1 │ var x = /\u{}/gu; + · ─ + ╰──── + × Invalid escape sequence ╭─[conformance/es6/unicodeExtendedEscapes/unicodeExtendedEscapesInStrings07.ts:3:10] 2 │ // 1. Assert: 0 ≤ cp ≤ 0x10FFFF. @@ -17859,6 +18263,8 @@ Expect to Parse: "conformance/salsa/typeFromPropertyAssignmentWithExport.ts" · ╰── `,` expected ╰──── + × Too many capturing groups + × A rest parameter must be last in a parameter list ╭─[conformance/functions/functionOverloadErrorsSyntax.ts:9:25] 8 │ //Function overload signature with rest param followed by non-optional parameter @@ -19900,6 +20306,12 @@ Expect to Parse: "conformance/salsa/typeFromPropertyAssignmentWithExport.ts" · ── ╰──── + × Unterminated capturing group + ╭─[conformance/parser/ecmascript5/RegressionTests/parser579071.ts:1:12] + 1 │ var x = /fo(o/; + · ── + ╰──── + × Expected a semicolon or an implicit semicolon after a statement, but found none ╭─[conformance/parser/ecmascript5/RegressionTests/parser585151.ts:2:6] 1 │ class Foo2 { @@ -19958,6 +20370,12 @@ Expect to Parse: "conformance/salsa/typeFromPropertyAssignmentWithExport.ts" · ──────────── ╰──── + × Could not parse the entire pattern + ╭─[conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity4.ts:1:15] + 1 │ foo(/notregexp); + · ▲ + ╰──── + × Expected `)` but found `EOF` ╭─[conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity4.ts:1:17] 1 │ foo(/notregexp); diff --git a/tasks/coverage/src/test262/mod.rs b/tasks/coverage/src/test262/mod.rs index b8ca968edfd56..302d3f346e2bb 100644 --- a/tasks/coverage/src/test262/mod.rs +++ b/tasks/coverage/src/test262/mod.rs @@ -33,9 +33,7 @@ impl Suite for Test262Suite { // ignore markdown files path.ends_with(".md") || // ignore fixtures - path.contains("_FIXTURE") || - // ignore regexp as we don't have a regexp parser for now - (path.contains("literals") && path.contains("regexp")) + path.contains("_FIXTURE") } fn save_test_cases(&mut self, cases: Vec) { @@ -104,13 +102,7 @@ impl Case for Test262Case { } fn skip_test_case(&self) -> bool { - [ - // Regex parser is required. See https://github.com/oxc-project/oxc/issues/385#issuecomment-1755566240 - "regexp-v-flag", - "regexp-unicode-property-escapes", - ] - .iter() - .any(|feature| self.meta.features.iter().any(|f| **f == **feature)) + false } // Unless configured otherwise (via the noStrict, onlyStrict, module, or raw flags), diff --git a/tasks/coverage/transformer_test262.snap b/tasks/coverage/transformer_test262.snap index b0ae557a16f05..fba59f84581f5 100644 --- a/tasks/coverage/transformer_test262.snap +++ b/tasks/coverage/transformer_test262.snap @@ -1,5 +1,5 @@ commit: a1587416 transformer_test262 Summary: -AST Parsed : 46406/46406 (100.00%) -Positive Passed: 46406/46406 (100.00%) +AST Parsed : 46466/46466 (100.00%) +Positive Passed: 46466/46466 (100.00%)