package js_parser

import (

"fmt"

"strings"

"testing"

"github.com/evanw/esbuild/internal/ast"

"github.com/evanw/esbuild/internal/compat"

"github.com/evanw/esbuild/internal/config"

"github.com/evanw/esbuild/internal/helpers"

"github.com/evanw/esbuild/internal/js_ast"

"github.com/evanw/esbuild/internal/js_printer"

"github.com/evanw/esbuild/internal/logger"

"github.com/evanw/esbuild/internal/renamer"

"github.com/evanw/esbuild/internal/test"

)

func expectParseErrorCommon(t *testing.T, contents string, expected string, options config.Options) {

t.Helper()

t.Run(contents, func(t *testing.T) {

t.Helper()

log := logger.NewDeferLog(logger.DeferLogNoVerboseOrDebug, nil)

Parse(log, test.SourceForTest(contents), OptionsFromConfig(&options))

msgs := log.Done()

var text strings.Builder

for _, msg := range msgs {

text.WriteString(msg.String(logger.OutputOptions{}, logger.TerminalInfo{}))

}

test.AssertEqualWithDiff(t, text.String(), expected)

})

}

func expectParseError(t *testing.T, contents string, expected string) {

t.Helper()

expectParseErrorCommon(t, contents, expected, config.Options{})

}

func expectParseErrorTarget(t *testing.T, esVersion int, contents string, expected string) {

t.Helper()

expectParseErrorCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: compat.UnsupportedJSFeatures(map[compat.Engine]compat.Semver{

compat.ES: {Parts: []int{esVersion}},

}),

})

}

func expectPrintedWithUnsupportedFeatures(t *testing.T, unsupportedJSFeatures compat.JSFeature, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: unsupportedJSFeatures,

})

}

func expectParseErrorWithUnsupportedFeatures(t *testing.T, unsupportedJSFeatures compat.JSFeature, contents string, expected string) {

t.Helper()

expectParseErrorCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: unsupportedJSFeatures,

})

}

func expectPrintedCommon(t *testing.T, contents string, expected string, options config.Options) {

t.Helper()

t.Run(contents, func(t *testing.T) {

t.Helper()

log := logger.NewDeferLog(logger.DeferLogNoVerboseOrDebug, nil)

options.OmitRuntimeForTests = true

tree, ok := Parse(log, test.SourceForTest(contents), OptionsFromConfig(&options))

msgs := log.Done()

var text strings.Builder

for _, msg := range msgs {

if msg.Kind != logger.Warning {

text.WriteString(msg.String(logger.OutputOptions{}, logger.TerminalInfo{}))

}

}

test.AssertEqualWithDiff(t, text.String(), "")

if !ok {

t.Fatal("Parse error")

}

symbols := ast.NewSymbolMap(1)

symbols.SymbolsForSource[0] = tree.Symbols

r := renamer.NewNoOpRenamer(symbols)

js := js_printer.Print(tree, symbols, r, js_printer.Options{

UnsupportedFeatures: options.UnsupportedJSFeatures,

ASCIIOnly: options.ASCIIOnly,

}).JS

test.AssertEqualWithDiff(t, string(js), expected)

})

}

func expectPrinted(t *testing.T, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{})

}

func expectPrintedMangle(t *testing.T, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

MinifySyntax: true,

})

}

func expectPrintedNormalAndMangle(t *testing.T, contents string, normal string, mangle string) {

expectPrinted(t, contents, normal)

expectPrintedMangle(t, contents, mangle)

}

func expectPrintedTarget(t *testing.T, esVersion int, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: compat.UnsupportedJSFeatures(map[compat.Engine]compat.Semver{

compat.ES: {Parts: []int{esVersion}},

}),

})

}

func expectPrintedMangleTarget(t *testing.T, esVersion int, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: compat.UnsupportedJSFeatures(map[compat.Engine]compat.Semver{

compat.ES: {Parts: []int{esVersion}},

}),

MinifySyntax: true,

})

}

func expectPrintedASCII(t *testing.T, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

ASCIIOnly: true,

})

}

func expectPrintedTargetASCII(t *testing.T, esVersion int, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: compat.UnsupportedJSFeatures(map[compat.Engine]compat.Semver{

compat.ES: {Parts: []int{esVersion}},

}),

ASCIIOnly: true,

})

}

func expectParseErrorTargetASCII(t *testing.T, esVersion int, contents string, expected string) {

t.Helper()

expectParseErrorCommon(t, contents, expected, config.Options{

UnsupportedJSFeatures: compat.UnsupportedJSFeatures(map[compat.Engine]compat.Semver{

compat.ES: {Parts: []int{esVersion}},

}),

ASCIIOnly: true,

})

}

func expectParseErrorJSX(t *testing.T, contents string, expected string) {

t.Helper()

expectParseErrorCommon(t, contents, expected, config.Options{

JSX: config.JSXOptions{

Parse: true,

},

})

}

func expectPrintedJSX(t *testing.T, contents string, expectedPreserve string, expectedTransform string) {

t.Helper()

expectPrintedCommon(t, contents, expectedPreserve, config.Options{

JSX: config.JSXOptions{

Parse: true,

Preserve: true,

},

})

expectPrintedCommon(t, contents, expectedTransform, config.Options{

JSX: config.JSXOptions{

Parse: true,

},

})

}

func expectPrintedJSXSideEffects(t *testing.T, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

JSX: config.JSXOptions{

Parse: true,

SideEffects: true,

},

})

}

func expectPrintedMangleJSX(t *testing.T, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

MinifySyntax: true,

JSX: config.JSXOptions{

Parse: true,

},

})

}

type JSXAutomaticTestOptions struct {

Development bool

ImportSource string

OmitJSXRuntimeForTests bool

SideEffects bool

}

func expectParseErrorJSXAutomatic(t *testing.T, options JSXAutomaticTestOptions, contents string, expected string) {

t.Helper()

expectParseErrorCommon(t, contents, expected, config.Options{

OmitJSXRuntimeForTests: options.OmitJSXRuntimeForTests,

JSX: config.JSXOptions{

AutomaticRuntime: true,

Parse: true,

Development: options.Development,

ImportSource: options.ImportSource,

SideEffects: options.SideEffects,

},

})

}

func expectPrintedJSXAutomatic(t *testing.T, options JSXAutomaticTestOptions, contents string, expected string) {

t.Helper()

expectPrintedCommon(t, contents, expected, config.Options{

OmitJSXRuntimeForTests: options.OmitJSXRuntimeForTests,

JSX: config.JSXOptions{

AutomaticRuntime: true,

Parse: true,

Development: options.Development,

ImportSource: options.ImportSource,

SideEffects: options.SideEffects,

},

})

}

func TestUnOp(t *testing.T) {

// This was important to someone for a very obscure reason. See

// https://github.com/evanw/esbuild/issues/4041 for more info.

expectPrinted(t, "let x; void 0; x", "let x;\nx;\n")

expectPrinted(t, "let x; void x; x", "let x;\nvoid x;\nx;\n")

}

func TestBinOp(t *testing.T) {

for code, entry := range js_ast.OpTable {

opCode := js_ast.OpCode(code)

if opCode.IsLeftAssociative() {

op := entry.Text

expectPrinted(t, "a "+op+" b "+op+" c", "a "+op+" b "+op+" c;\n")

expectPrinted(t, "(a "+op+" b) "+op+" c", "a "+op+" b "+op+" c;\n")

expectPrinted(t, "a "+op+" (b "+op+" c)", "a "+op+" (b "+op+" c);\n")

}

if opCode.IsRightAssociative() {

op := entry.Text

expectPrinted(t, "a "+op+" b "+op+" c", "a "+op+" b "+op+" c;\n")

// Avoid errors about invalid assignment targets

if opCode.BinaryAssignTarget() == js_ast.AssignTargetNone {

expectPrinted(t, "(a "+op+" b) "+op+" c", "(a "+op+" b) "+op+" c;\n")

}

expectPrinted(t, "a "+op+" (b "+op+" c)", "a "+op+" b "+op+" c;\n")

}

}

}

func TestComments(t *testing.T) {

expectParseError(t, "throw //\n x", "<stdin>: ERROR: Unexpected newline after \"throw\"\n")

expectParseError(t, "throw /**/\n x", "<stdin>: ERROR: Unexpected newline after \"throw\"\n")

expectParseError(t, "throw <!--\n x",

`<stdin>: ERROR: Unexpected newline after "throw"

<stdin>: WARNING: Treating "<!--" as the start of a legacy HTML single-line comment

`)

expectParseError(t, "throw -->\n x", "<stdin>: ERROR: Unexpected \">\"\n")

expectParseError(t, "export {}\n<!--", `<stdin>: ERROR: Legacy HTML single-line comments are not allowed in ECMAScript modules

<stdin>: NOTE: This file is considered to be an ECMAScript module because of the "export" keyword here:

<stdin>: WARNING: Treating "<!--" as the start of a legacy HTML single-line comment

`)

expectParseError(t, "export {}\n-->", `<stdin>: ERROR: Legacy HTML single-line comments are not allowed in ECMAScript modules

<stdin>: NOTE: This file is considered to be an ECMAScript module because of the "export" keyword here:

<stdin>: WARNING: Treating "-->" as the start of a legacy HTML single-line comment

`)

expectPrinted(t, "return //\n x", "return;\nx;\n")

expectPrinted(t, "return /**/\n x", "return;\nx;\n")

expectPrinted(t, "return <!--\n x", "return;\nx;\n")

expectPrinted(t, "-->\nx", "x;\n")

expectPrinted(t, "x\n-->\ny", "x;\ny;\n")

expectPrinted(t, "x\n -->\ny", "x;\ny;\n")

expectPrinted(t, "x\n/**/-->\ny", "x;\ny;\n")

expectPrinted(t, "x/*\n*/-->\ny", "x;\ny;\n")

expectPrinted(t, "x\n/**/ /**/-->\ny", "x;\ny;\n")

expectPrinted(t, "if(x-->y)z", "if (x-- > y) z;\n")

}

func TestStrictMode(t *testing.T) {

useStrict := "<stdin>: NOTE: Strict mode is triggered by the \"use strict\" directive here:\n"

expectPrinted(t, "'use strict'", "\"use strict\";\n")

expectPrinted(t, "`use strict`", "`use strict`;\n")

expectPrinted(t, "//! @legal comment\n 'use strict'", "\"use strict\";\n//! @legal comment\n")

expectPrinted(t, "/*! @legal comment */ 'use strict'", "\"use strict\";\n/*! @legal comment */\n")

expectPrinted(t, "function f() { //! @legal comment\n 'use strict' }", "function f() {\n //! @legal comment\n \"use strict\";\n}\n")

expectPrinted(t, "function f() { /*! @legal comment */ 'use strict' }", "function f() {\n /*! @legal comment */\n \"use strict\";\n}\n")

expectParseError(t, "//! @legal comment\n 'use strict'", "")

expectParseError(t, "/*! @legal comment */ 'use strict'", "")

expectParseError(t, "function f() { //! @legal comment\n 'use strict' }", "")

expectParseError(t, "function f() { /*! @legal comment */ 'use strict' }", "")

nonSimple := "<stdin>: ERROR: Cannot use a \"use strict\" directive in a function with a non-simple parameter list\n"

expectParseError(t, "function f() { 'use strict' }", "")

expectParseError(t, "function f(x) { 'use strict' }", "")

expectParseError(t, "function f([x]) { 'use strict' }", nonSimple)

expectParseError(t, "function f({x}) { 'use strict' }", nonSimple)

expectParseError(t, "function f(x = 1) { 'use strict' }", nonSimple)

expectParseError(t, "function f(x, ...y) { 'use strict' }", nonSimple)

expectParseError(t, "(function() { 'use strict' })", "")

expectParseError(t, "(function(x) { 'use strict' })", "")

expectParseError(t, "(function([x]) { 'use strict' })", nonSimple)

expectParseError(t, "(function({x}) { 'use strict' })", nonSimple)

expectParseError(t, "(function(x = 1) { 'use strict' })", nonSimple)

expectParseError(t, "(function(x, ...y) { 'use strict' })", nonSimple)

expectParseError(t, "() => { 'use strict' }", "")

expectParseError(t, "(x) => { 'use strict' }", "")

expectParseError(t, "([x]) => { 'use strict' }", nonSimple)

expectParseError(t, "({x}) => { 'use strict' }", nonSimple)

expectParseError(t, "(x = 1) => { 'use strict' }", nonSimple)

expectParseError(t, "(x, ...y) => { 'use strict' }", nonSimple)

expectParseError(t, "(x, ...y) => { //! @license comment\n 'use strict' }", nonSimple)

why := "<stdin>: NOTE: This file is considered to be an ECMAScript module because of the \"export\" keyword here:\n"

expectPrinted(t, "let x = '\\0'", "let x = \"\\0\";\n")

expectPrinted(t, "let x = '\\00'", "let x = \"\\0\";\n")

expectPrinted(t, "'use strict'; let x = '\\0'", "\"use strict\";\nlet x = \"\\0\";\n")

expectPrinted(t, "let x = '\\0'; export {}", "let x = \"\\0\";\nexport {};\n")

expectParseError(t, "'use strict'; let x = '\\00'", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let x = '\\08'", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let x = '\\008'", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "let x = '\\00'; export {}", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in an ECMAScript module\n"+why)

expectParseError(t, "let x = '\\09'; export {}", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in an ECMAScript module\n"+why)

expectParseError(t, "let x = '\\009'; export {}", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in an ECMAScript module\n"+why)

expectPrinted(t, "'\\0'", "\"\\0\";\n")

expectPrinted(t, "'\\00'", "\"\\0\";\n")

expectPrinted(t, "'use strict'; '\\0'", "\"use strict\";\n\"\\0\";\n")

expectParseError(t, "'use strict'; '\\00'", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; '\\08'", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; '\\008'", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'\\00'; 'use strict';", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'\\08'; 'use strict';", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'\\008'; 'use strict';", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'\\00'; export {}", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in an ECMAScript module\n"+why)

expectParseError(t, "'\\09'; export {}", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in an ECMAScript module\n"+why)

expectParseError(t, "'\\009'; export {}", "<stdin>: ERROR: Legacy octal escape sequences cannot be used in an ECMAScript module\n"+why)

expectPrinted(t, "with (x) y", "with (x) y;\n")

expectParseError(t, "'use strict'; with (x) y", "<stdin>: ERROR: With statements cannot be used in strict mode\n"+useStrict)

expectParseError(t, "with (x) y; export {}", "<stdin>: ERROR: With statements cannot be used in an ECMAScript module\n"+why)

expectPrinted(t, "delete x", "delete x;\n")

expectParseError(t, "'use strict'; delete x", "<stdin>: ERROR: Delete of a bare identifier cannot be used in strict mode\n"+useStrict)

expectParseError(t, "delete x; export {}", "<stdin>: ERROR: Delete of a bare identifier cannot be used in an ECMAScript module\n"+why)

expectPrinted(t, "for (var x = y in z) ;", "x = y;\nfor (var x in z) ;\n")

expectParseError(t, "'use strict'; for (var x = y in z) ;",

"<stdin>: ERROR: Variable initializers inside for-in loops cannot be used in strict mode\n"+useStrict)

expectParseError(t, "for (var x = y in z) ; export {}",

"<stdin>: ERROR: Variable initializers inside for-in loops cannot be used in an ECMAScript module\n"+why)

expectPrinted(t, "function f(a, a) {}", "function f(a, a) {\n}\n")

expectPrinted(t, "(function(a, a) {})", "(function(a, a) {\n});\n")

expectPrinted(t, "({ f: function(a, a) {} })", "({ f: function(a, a) {\n} });\n")

expectPrinted(t, "({ f: function*(a, a) {} })", "({ f: function* (a, a) {\n} });\n")

expectPrinted(t, "({ f: async function(a, a) {} })", "({ f: async function(a, a) {\n} });\n")

bindingError := "<stdin>: ERROR: \"a\" cannot be bound multiple times in the same parameter list\n" +

"<stdin>: NOTE: The name \"a\" was originally bound here:\n"

expectParseError(t, "function f(a, a) { 'use strict' }", bindingError)

expectParseError(t, "function *f(a, a) { 'use strict' }", bindingError)

expectParseError(t, "async function f(a, a) { 'use strict' }", bindingError)

expectParseError(t, "(function(a, a) { 'use strict' })", bindingError)

expectParseError(t, "(function*(a, a) { 'use strict' })", bindingError)

expectParseError(t, "(async function(a, a) { 'use strict' })", bindingError)

expectParseError(t, "function f(a, [a]) {}", bindingError)

expectParseError(t, "function f([a], a) {}", bindingError)

expectParseError(t, "'use strict'; function f(a, a) {}", bindingError)

expectParseError(t, "'use strict'; (function(a, a) {})", bindingError)

expectParseError(t, "'use strict'; ((a, a) => {})", bindingError)

expectParseError(t, "function f(a, a) {}; export {}", bindingError)

expectParseError(t, "(function(a, a) {}); export {}", bindingError)

expectParseError(t, "(function(a, [a]) {})", bindingError)

expectParseError(t, "({ f(a, a) {} })", bindingError)

expectParseError(t, "({ *f(a, a) {} })", bindingError)

expectParseError(t, "({ async f(a, a) {} })", bindingError)

expectParseError(t, "(a, a) => {}", bindingError)

expectParseError(t, "'use strict'; if (0) function f() {}",

"<stdin>: ERROR: Function declarations inside if statements cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; if (0) ; else function f() {}",

"<stdin>: ERROR: Function declarations inside if statements cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; x: function f() {}",

"<stdin>: ERROR: Function declarations inside labels cannot be used in strict mode\n"+useStrict)

expectParseError(t, "if (0) function f() {} export {}",

"<stdin>: ERROR: Function declarations inside if statements cannot be used in an ECMAScript module\n"+why)

expectParseError(t, "if (0) ; else function f() {} export {}",

"<stdin>: ERROR: Function declarations inside if statements cannot be used in an ECMAScript module\n"+why)

expectParseError(t, "x: function f() {} export {}",

"<stdin>: ERROR: Function declarations inside labels cannot be used in an ECMAScript module\n"+why)

expectPrinted(t, "eval++", "eval++;\n")

expectPrinted(t, "eval = 0", "eval = 0;\n")

expectPrinted(t, "eval += 0", "eval += 0;\n")

expectPrinted(t, "[eval] = 0", "[eval] = 0;\n")

expectPrinted(t, "arguments++", "arguments++;\n")

expectPrinted(t, "arguments = 0", "arguments = 0;\n")

expectPrinted(t, "arguments += 0", "arguments += 0;\n")

expectPrinted(t, "[arguments] = 0", "[arguments] = 0;\n")

expectParseError(t, "'use strict'; eval++", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; eval = 0", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; eval += 0", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; [eval] = 0", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; arguments++", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; arguments = 0", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; arguments += 0", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "'use strict'; [arguments] = 0", "<stdin>: ERROR: Invalid assignment target\n")

evalDecl := "<stdin>: ERROR: Declarations with the name \"eval\" cannot be used in strict mode\n" + useStrict

argsDecl := "<stdin>: ERROR: Declarations with the name \"arguments\" cannot be used in strict mode\n" + useStrict

expectPrinted(t, "function eval() {}", "function eval() {\n}\n")

expectPrinted(t, "function arguments() {}", "function arguments() {\n}\n")

expectPrinted(t, "function f(eval) {}", "function f(eval) {\n}\n")

expectPrinted(t, "function f(arguments) {}", "function f(arguments) {\n}\n")

expectPrinted(t, "({ f(eval) {} })", "({ f(eval) {\n} });\n")

expectPrinted(t, "({ f(arguments) {} })", "({ f(arguments) {\n} });\n")

expectParseError(t, "'use strict'; function eval() {}", evalDecl)

expectParseError(t, "'use strict'; function arguments() {}", argsDecl)

expectParseError(t, "'use strict'; function f(eval) {}", evalDecl)

expectParseError(t, "'use strict'; function f(arguments) {}", argsDecl)

expectParseError(t, "function eval() { 'use strict' }", evalDecl)

expectParseError(t, "function arguments() { 'use strict' }", argsDecl)

expectParseError(t, "function f(eval) { 'use strict' }", evalDecl)

expectParseError(t, "function f(arguments) { 'use strict' }", argsDecl)

expectParseError(t, "({ f(eval) { 'use strict' } })", evalDecl)

expectParseError(t, "({ f(arguments) { 'use strict' } })", argsDecl)

expectParseError(t, "'use strict'; class eval {}", evalDecl)

expectParseError(t, "'use strict'; class arguments {}", argsDecl)

expectPrinted(t, "let protected", "let protected;\n")

expectPrinted(t, "let protecte\\u0064", "let protected;\n")

expectPrinted(t, "let x = protected", "let x = protected;\n")

expectPrinted(t, "let x = protecte\\u0064", "let x = protected;\n")

expectParseError(t, "'use strict'; let protected",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let protecte\\u0064",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let x = protected",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let x = protecte\\u0064",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; protected: 0",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; protecte\\u0064: 0",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; function protected() {}",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; function protecte\\u0064() {}",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; (function protected() {})",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; (function protecte\\u0064() {})",

"<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+useStrict)

expectPrinted(t, "0123", "83;\n")

expectPrinted(t, "({0123: 4})", "({ 83: 4 });\n")

expectPrinted(t, "let {0123: x} = y", "let { 83: x } = y;\n")

expectParseError(t, "'use strict'; 0123",

"<stdin>: ERROR: Legacy octal literals cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; ({0123: 4})",

"<stdin>: ERROR: Legacy octal literals cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let {0123: x} = y",

"<stdin>: ERROR: Legacy octal literals cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; 08",

"<stdin>: ERROR: Legacy octal literals cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; ({08: 4})",

"<stdin>: ERROR: Legacy octal literals cannot be used in strict mode\n"+useStrict)

expectParseError(t, "'use strict'; let {08: x} = y",

"<stdin>: ERROR: Legacy octal literals cannot be used in strict mode\n"+useStrict)

classNote := "<stdin>: NOTE: All code inside a class is implicitly in strict mode\n"

expectPrinted(t, "function f() { 'use strict' } with (x) y", "function f() {\n \"use strict\";\n}\nwith (x) y;\n")

expectPrinted(t, "with (x) y; function f() { 'use strict' }", "with (x) y;\nfunction f() {\n \"use strict\";\n}\n")

expectPrinted(t, "class f {} with (x) y", "class f {\n}\nwith (x) y;\n")

expectPrinted(t, "with (x) y; class f {}", "with (x) y;\nclass f {\n}\n")

expectPrinted(t, "`use strict`; with (x) y", "`use strict`;\nwith (x) y;\n")

expectPrinted(t, "{ 'use strict'; with (x) y }", "{\n \"use strict\";\n with (x) y;\n}\n")

expectPrinted(t, "if (0) { 'use strict'; with (x) y }", "if (0) {\n \"use strict\";\n with (x) y;\n}\n")

expectPrinted(t, "while (0) { 'use strict'; with (x) y }", "while (0) {\n \"use strict\";\n with (x) y;\n}\n")

expectPrinted(t, "try { 'use strict'; with (x) y } catch {}", "try {\n \"use strict\";\n with (x) y;\n} catch {\n}\n")

expectPrinted(t, "try {} catch { 'use strict'; with (x) y }", "try {\n} catch {\n \"use strict\";\n with (x) y;\n}\n")

expectPrinted(t, "try {} finally { 'use strict'; with (x) y }", "try {\n} finally {\n \"use strict\";\n with (x) y;\n}\n")

expectParseError(t, "\"use strict\"; with (x) y", "<stdin>: ERROR: With statements cannot be used in strict mode\n"+useStrict)

expectParseError(t, "function f() { 'use strict'; with (x) y }", "<stdin>: ERROR: With statements cannot be used in strict mode\n"+useStrict)

expectParseError(t, "function f() { 'use strict'; function y() { with (x) y } }", "<stdin>: ERROR: With statements cannot be used in strict mode\n"+useStrict)

expectParseError(t, "class f { x() { with (x) y } }", "<stdin>: ERROR: With statements cannot be used in strict mode\n"+classNote)

expectParseError(t, "class f { x() { function y() { with (x) y } } }", "<stdin>: ERROR: With statements cannot be used in strict mode\n"+classNote)

expectParseError(t, "class f { x() { function protected() {} } }", "<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in strict mode\n"+classNote)

reservedWordExport := "<stdin>: ERROR: \"protected\" is a reserved word and cannot be used in an ECMAScript module\n" +

why

expectParseError(t, "var protected; export {}", reservedWordExport)

expectParseError(t, "class protected {} export {}", reservedWordExport)

expectParseError(t, "(class protected {}); export {}", reservedWordExport)

expectParseError(t, "function protected() {} export {}", reservedWordExport)

expectParseError(t, "(function protected() {}); export {}", reservedWordExport)

importMeta := "<stdin>: ERROR: With statements cannot be used in an ECMAScript module\n" +

"<stdin>: NOTE: This file is considered to be an ECMAScript module because of the use of \"import.meta\" here:\n"

importStatement := "<stdin>: ERROR: With statements cannot be used in an ECMAScript module\n" +

"<stdin>: NOTE: This file is considered to be an ECMAScript module because of the \"import\" keyword here:\n"

exportKeyword := "<stdin>: ERROR: With statements cannot be used in an ECMAScript module\n" +

"<stdin>: NOTE: This file is considered to be an ECMAScript module because of the \"export\" keyword here:\n"

tlaKeyword := "<stdin>: ERROR: With statements cannot be used in an ECMAScript module\n" +

"<stdin>: NOTE: This file is considered to be an ECMAScript module because of the top-level \"await\" keyword here:\n"

expectPrinted(t, "import(x); with (y) z", "import(x);\nwith (y) z;\n")

expectPrinted(t, "import('x'); with (y) z", "import(\"x\");\nwith (y) z;\n")

expectPrinted(t, "with (y) z; import(x)", "with (y) z;\nimport(x);\n")

expectPrinted(t, "with (y) z; import('x')", "with (y) z;\nimport(\"x\");\n")

expectPrinted(t, "(import(x)); with (y) z", "import(x);\nwith (y) z;\n")

expectPrinted(t, "(import('x')); with (y) z", "import(\"x\");\nwith (y) z;\n")

expectPrinted(t, "with (y) z; (import(x))", "with (y) z;\nimport(x);\n")

expectPrinted(t, "with (y) z; (import('x'))", "with (y) z;\nimport(\"x\");\n")

expectParseError(t, "import.meta; with (y) z", importMeta)

expectParseError(t, "with (y) z; import.meta", importMeta)

expectParseError(t, "(import.meta); with (y) z", importMeta)

expectParseError(t, "with (y) z; (import.meta)", importMeta)

expectParseError(t, "import 'x'; with (y) z", importStatement)

expectParseError(t, "import * as x from 'x'; with (y) z", importStatement)

expectParseError(t, "import x from 'x'; with (y) z", importStatement)

expectParseError(t, "import {x} from 'x'; with (y) z", importStatement)

expectParseError(t, "export {}; with (y) z", exportKeyword)

expectParseError(t, "export let x; with (y) z", exportKeyword)

expectParseError(t, "export function x() {} with (y) z", exportKeyword)

expectParseError(t, "export class x {} with (y) z", exportKeyword)

expectParseError(t, "await 0; with (y) z", tlaKeyword)

expectParseError(t, "with (y) z; await 0", tlaKeyword)

expectParseError(t, "for await (x of y); with (y) z", tlaKeyword)

expectParseError(t, "with (y) z; for await (x of y);", tlaKeyword)

expectParseError(t, "await using x = _; with (y) z", tlaKeyword)

expectParseError(t, "with (y) z; await using x = _", tlaKeyword)

expectParseError(t, "for (await using x of _) ; with (y) z", tlaKeyword)

expectParseError(t, "with (y) z; for (await using x of _) ;", tlaKeyword)

fAlreadyDeclaredError := "<stdin>: ERROR: The symbol \"f\" has already been declared\n" +

"<stdin>: NOTE: The symbol \"f\" was originally declared here:\n"

nestedNote := "<stdin>: NOTE: Duplicate function declarations are not allowed in nested blocks"

moduleNote := "<stdin>: NOTE: Duplicate top-level function declarations are not allowed in an ECMAScript module. " +

"This file is considered to be an ECMAScript module because of the \"export\" keyword here:\n"

cases := []string{

"function f() {} function f() {}",

"function f() {} function *f() {}",

"function *f() {} function f() {}",

"function f() {} async function f() {}",

"async function f() {} function f() {}",

"function f() {} async function *f() {}",

"async function *f() {} function f() {}",

}

for _, c := range cases {

expectParseError(t, c, "")

expectParseError(t, "'use strict'; "+c, "")

expectParseError(t, "function foo() { 'use strict'; "+c+" }", "")

}

expectParseError(t, "function f() {} function f() {} export {}", fAlreadyDeclaredError+moduleNote)

expectParseError(t, "function f() {} function *f() {} export {}", fAlreadyDeclaredError+moduleNote)

expectParseError(t, "function f() {} async function f() {} export {}", fAlreadyDeclaredError+moduleNote)

expectParseError(t, "function *f() {} function f() {} export {}", fAlreadyDeclaredError+moduleNote)

expectParseError(t, "async function f() {} function f() {} export {}", fAlreadyDeclaredError+moduleNote)

expectParseError(t, "'use strict'; { function f() {} function f() {} }",

fAlreadyDeclaredError+nestedNote+" in strict mode. Strict mode is triggered by the \"use strict\" directive here:\n")

expectParseError(t, "'use strict'; switch (0) { case 1: function f() {} default: function f() {} }",

fAlreadyDeclaredError+nestedNote+" in strict mode. Strict mode is triggered by the \"use strict\" directive here:\n")

expectParseError(t, "function foo() { 'use strict'; { function f() {} function f() {} } }",

fAlreadyDeclaredError+nestedNote+" in strict mode. Strict mode is triggered by the \"use strict\" directive here:\n")

expectParseError(t, "function foo() { 'use strict'; switch (0) { case 1: function f() {} default: function f() {} } }",

fAlreadyDeclaredError+nestedNote+" in strict mode. Strict mode is triggered by the \"use strict\" directive here:\n")

expectParseError(t, "{ function f() {} function f() {} } export {}",

fAlreadyDeclaredError+nestedNote+" in an ECMAScript module. This file is considered to be an ECMAScript module because of the \"export\" keyword here:\n")

expectParseError(t, "switch (0) { case 1: function f() {} default: function f() {} } export {}",

fAlreadyDeclaredError+nestedNote+" in an ECMAScript module. This file is considered to be an ECMAScript module because of the \"export\" keyword here:\n")

expectParseError(t, "var x; var x", "")

expectParseError(t, "'use strict'; var x; var x", "")

expectParseError(t, "var x; var x; export {}", "")

}

func TestExponentiation(t *testing.T) {

expectPrinted(t, "--x ** 2", "--x ** 2;\n")

expectPrinted(t, "++x ** 2", "++x ** 2;\n")

expectPrinted(t, "x-- ** 2", "x-- ** 2;\n")

expectPrinted(t, "x++ ** 2", "x++ ** 2;\n")

expectPrinted(t, "(-x) ** 2", "(-x) ** 2;\n")

expectPrinted(t, "(+x) ** 2", "(+x) ** 2;\n")

expectPrinted(t, "(~x) ** 2", "(~x) ** 2;\n")

expectPrinted(t, "(!x) ** 2", "(!x) ** 2;\n")

expectPrinted(t, "(-1) ** 2", "(-1) ** 2;\n")

expectPrinted(t, "(+1) ** 2", "1 ** 2;\n")

expectPrinted(t, "(~1) ** 2", "(~1) ** 2;\n")

expectPrinted(t, "(!1) ** 2", "false ** 2;\n")

expectPrinted(t, "(void x) ** 2", "(void x) ** 2;\n")

expectPrinted(t, "(delete x) ** 2", "(delete x) ** 2;\n")

expectPrinted(t, "(typeof x) ** 2", "(typeof x) ** 2;\n")

expectPrinted(t, "undefined ** 2", "(void 0) ** 2;\n")

expectParseError(t, "-x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "+x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "~x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "!x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "void x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "delete x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "typeof x ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "-x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "+x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "~x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "!x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "void x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "delete x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "typeof x.y() ** 2", "<stdin>: ERROR: Unexpected \"**\"\n")

// https://github.com/tc39/ecma262/issues/2197

expectParseError(t, "delete x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "delete x.prop ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "delete x[0] ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "delete x?.prop ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "void x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "typeof x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "+x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "-x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "~x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "!x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "await x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectParseError(t, "await -x ** 0", "<stdin>: ERROR: Unexpected \"**\"\n")

expectPrinted(t, "(delete x) ** 0", "(delete x) ** 0;\n")

expectPrinted(t, "(delete x.prop) ** 0", "(delete x.prop) ** 0;\n")

expectPrinted(t, "(delete x[0]) ** 0", "(delete x[0]) ** 0;\n")

expectPrinted(t, "(delete x?.prop) ** 0", "(delete x?.prop) ** 0;\n")

expectPrinted(t, "(void x) ** 0", "(void x) ** 0;\n")

expectPrinted(t, "(typeof x) ** 0", "(typeof x) ** 0;\n")

expectPrinted(t, "(+x) ** 0", "(+x) ** 0;\n")

expectPrinted(t, "(-x) ** 0", "(-x) ** 0;\n")

expectPrinted(t, "(~x) ** 0", "(~x) ** 0;\n")

expectPrinted(t, "(!x) ** 0", "(!x) ** 0;\n")

expectPrinted(t, "(await x) ** 0", "(await x) ** 0;\n")

expectPrinted(t, "(await -x) ** 0", "(await -x) ** 0;\n")

}

func TestAwait(t *testing.T) {

expectPrinted(t, "await x", "await x;\n")

expectPrinted(t, "await +x", "await +x;\n")

expectPrinted(t, "await -x", "await -x;\n")

expectPrinted(t, "await ~x", "await ~x;\n")

expectPrinted(t, "await !x", "await !x;\n")

expectPrinted(t, "await --x", "await --x;\n")

expectPrinted(t, "await ++x", "await ++x;\n")

expectPrinted(t, "await x--", "await x--;\n")

expectPrinted(t, "await x++", "await x++;\n")

expectPrinted(t, "await void x", "await void x;\n")

expectPrinted(t, "await typeof x", "await typeof x;\n")

expectPrinted(t, "await (x * y)", "await (x * y);\n")

expectPrinted(t, "await (x ** y)", "await (x ** y);\n")

expectParseError(t, "var { await } = {}", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "async function f() { var { await } = {} }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "async function* f() { var { await } = {} }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "class C { async f() { var { await } = {} } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "class C { async* f() { var { await } = {} } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "class C { static { var { await } = {} } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "var {} = { await }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "async function f() { var {} = { await } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "async function* f() { var {} = { await } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "class C { async f() { var {} = { await } } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "class C { async* f() { var {} = { await } } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "class C { static { var {} = { await } } }", "<stdin>: ERROR: Cannot use \"await\" as an identifier here:\n")

expectParseError(t, "await delete x",

`<stdin>: ERROR: Delete of a bare identifier cannot be used in an ECMAScript module

<stdin>: NOTE: This file is considered to be an ECMAScript module because of the top-level "await" keyword here:

`)

expectPrinted(t, "async function f() { await delete x }", "async function f() {\n await delete x;\n}\n")

// Can't use await at the top-level without top-level await

err := "<stdin>: ERROR: Top-level await is not available in the configured target environment\n"

expectParseErrorWithUnsupportedFeatures(t, compat.TopLevelAwait, "await x;", err)

expectParseErrorWithUnsupportedFeatures(t, compat.TopLevelAwait, "if (true) await x;", err)

expectPrintedWithUnsupportedFeatures(t, compat.TopLevelAwait, "if (false) await x;", "if (false) x;\n")

expectParseErrorWithUnsupportedFeatures(t, compat.TopLevelAwait, "with (x) y; if (false) await x;",

"<stdin>: ERROR: With statements cannot be used in an ECMAScript module\n"+

"<stdin>: NOTE: This file is considered to be an ECMAScript module because of the top-level \"await\" keyword here:\n")

}

func TestRegExp(t *testing.T) {

expectPrinted(t, "/x/d", "/x/d;\n")

expectPrinted(t, "/x/g", "/x/g;\n")

expectPrinted(t, "/x/i", "/x/i;\n")

expectPrinted(t, "/x/m", "/x/m;\n")

expectPrinted(t, "/x/s", "/x/s;\n")

expectPrinted(t, "/x/u", "/x/u;\n")

expectPrinted(t, "/x/y", "/x/y;\n")

expectParseError(t, "/)/", "<stdin>: ERROR: Unexpected \")\" in regular expression\n")

expectPrinted(t, "/[\\])]/", "/[\\])]/;\n")

expectParseError(t, "/x/msuygig",

`<stdin>: ERROR: Duplicate flag "g" in regular expression

<stdin>: NOTE: The first "g" was here:

`)

}

func TestUnicodeIdentifierNames(t *testing.T) {

// There are two code points that are valid in identifiers in ES5 but not in ES6+:

//

// U+30FB KATAKANA MIDDLE DOT

// U+FF65 HALFWIDTH KATAKANA MIDDLE DOT

//

expectPrinted(t, "x = {x・: 0}", "x = { \"x・\": 0 };\n")

expectPrinted(t, "x = {x･: 0}", "x = { \"x･\": 0 };\n")

expectPrinted(t, "x = {xπ: 0}", "x = { xπ: 0 };\n")

expectPrinted(t, "x = y.x・", "x = y[\"x・\"];\n")

expectPrinted(t, "x = y.x･", "x = y[\"x･\"];\n")

expectPrinted(t, "x = y.xπ", "x = y.xπ;\n")

}

func TestIdentifierEscapes(t *testing.T) {

expectPrinted(t, "var _\\u0076\\u0061\\u0072", "var _var;\n")

expectParseError(t, "var \\u0076\\u0061\\u0072", "<stdin>: ERROR: Expected identifier but found \"\\\\u0076\\\\u0061\\\\u0072\"\n")

expectParseError(t, "\\u0076\\u0061\\u0072 foo", "<stdin>: ERROR: Unexpected \"\\\\u0076\\\\u0061\\\\u0072\"\n")

expectPrinted(t, "foo._\\u0076\\u0061\\u0072", "foo._var;\n")

expectPrinted(t, "foo.\\u0076\\u0061\\u0072", "foo.var;\n")

expectParseError(t, "\u200Ca", "<stdin>: ERROR: Unexpected \"\\u200c\"\n")

expectParseError(t, "\u200Da", "<stdin>: ERROR: Unexpected \"\\u200d\"\n")

}

func TestSpecialIdentifiers(t *testing.T) {

expectPrinted(t, "exports", "exports;\n")

expectPrinted(t, "require", "require;\n")

expectPrinted(t, "module", "module;\n")

}

func TestDecls(t *testing.T) {

expectParseError(t, "var x = 0", "")

expectParseError(t, "let x = 0", "")

expectParseError(t, "const x = 0", "")

expectParseError(t, "for (var x = 0;;) ;", "")

expectParseError(t, "for (let x = 0;;) ;", "")

expectParseError(t, "for (const x = 0;;) ;", "")

expectParseError(t, "for (var x in y) ;", "")

expectParseError(t, "for (let x in y) ;", "")

expectParseError(t, "for (const x in y) ;", "")

expectParseError(t, "for (var x of y) ;", "")

expectParseError(t, "for (let x of y) ;", "")

expectParseError(t, "for (const x of y) ;", "")

expectParseError(t, "var x", "")

expectParseError(t, "let x", "")

expectParseError(t, "const x", "<stdin>: ERROR: The constant \"x\" must be initialized\n")

expectParseError(t, "const {}", "<stdin>: ERROR: This constant must be initialized\n")

expectParseError(t, "const []", "<stdin>: ERROR: This constant must be initialized\n")

expectParseError(t, "for (var x;;) ;", "")

expectParseError(t, "for (let x;;) ;", "")

expectParseError(t, "for (const x;;) ;", "<stdin>: ERROR: The constant \"x\" must be initialized\n")

expectParseError(t, "for (const {};;) ;", "<stdin>: ERROR: This constant must be initialized\n")

expectParseError(t, "for (const [];;) ;", "<stdin>: ERROR: This constant must be initialized\n")

// Make sure bindings are visited during parsing

expectPrinted(t, "var {[x]: y} = {}", "var { [x]: y } = {};\n")

expectPrinted(t, "var {...x} = {}", "var { ...x } = {};\n")

// Test destructuring patterns

expectPrinted(t, "var [...x] = []", "var [...x] = [];\n")

expectPrinted(t, "var {...x} = {}", "var { ...x } = {};\n")

expectPrinted(t, "([...x] = []) => {}", "([...x] = []) => {\n};\n")

expectPrinted(t, "({...x} = {}) => {}", "({ ...x } = {}) => {\n};\n")

expectParseError(t, "var [...x,] = []", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "var {...x,} = {}", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "([...x,] = []) => {}", "<stdin>: ERROR: Invalid binding pattern\n")

expectParseError(t, "({...x,} = {}) => {}", "<stdin>: ERROR: Invalid binding pattern\n")

expectPrinted(t, "[b, ...c] = d", "[b, ...c] = d;\n")

expectPrinted(t, "([b, ...c] = d)", "[b, ...c] = d;\n")

expectPrinted(t, "({b, ...c} = d)", "({ b, ...c } = d);\n")

expectPrinted(t, "({a = b} = c)", "({ a = b } = c);\n")

expectPrinted(t, "({a: b = c} = d)", "({ a: b = c } = d);\n")

expectPrinted(t, "({a: b.c} = d)", "({ a: b.c } = d);\n")

expectPrinted(t, "[a = {}] = b", "[a = {}] = b;\n")

expectPrinted(t, "[[...a, b].x] = c", "[[...a, b].x] = c;\n")

expectPrinted(t, "[{...a, b}.x] = c", "[{ ...a, b }.x] = c;\n")

expectPrinted(t, "({x: [...a, b].x} = c)", "({ x: [...a, b].x } = c);\n")

expectPrinted(t, "({x: {...a, b}.x} = c)", "({ x: { ...a, b }.x } = c);\n")

expectPrinted(t, "[x = [...a, b]] = c", "[x = [...a, b]] = c;\n")

expectPrinted(t, "[x = {...a, b}] = c", "[x = { ...a, b }] = c;\n")

expectPrinted(t, "({x = [...a, b]} = c)", "({ x = [...a, b] } = c);\n")

expectPrinted(t, "({x = {...a, b}} = c)", "({ x = { ...a, b } } = c);\n")

expectPrinted(t, "(x = y)", "x = y;\n")

expectPrinted(t, "([] = [])", "[] = [];\n")

expectPrinted(t, "({} = {})", "({} = {});\n")

expectPrinted(t, "([[]] = [[]])", "[[]] = [[]];\n")

expectPrinted(t, "({x: {}} = {x: {}})", "({ x: {} } = { x: {} });\n")

expectPrinted(t, "(x) = y", "x = y;\n")

expectParseError(t, "([]) = []", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "({}) = {}", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "[([])] = [[]]", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "({x: ({})} = {x: {}})", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "(([]) = []) => {}", "<stdin>: ERROR: Invalid binding pattern\n")

expectParseError(t, "(({}) = {}) => {}", "<stdin>: ERROR: Invalid binding pattern\n")

expectParseError(t, "function f(([]) = []) {}", "<stdin>: ERROR: Expected identifier but found \"(\"\n")

expectParseError(t, "function f(({}) = {}) {}", "<stdin>: ERROR: Expected identifier but found \"(\"\n")

expectPrinted(t, "for (x in y) ;", "for (x in y) ;\n")

expectPrinted(t, "for ([] in y) ;", "for ([] in y) ;\n")

expectPrinted(t, "for ({} in y) ;", "for ({} in y) ;\n")

expectPrinted(t, "for ((x) in y) ;", "for (x in y) ;\n")

expectParseError(t, "for (([]) in y) ;", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "for (({}) in y) ;", "<stdin>: ERROR: Invalid assignment target\n")

expectPrinted(t, "for (x of y) ;", "for (x of y) ;\n")

expectPrinted(t, "for ([] of y) ;", "for ([] of y) ;\n")

expectPrinted(t, "for ({} of y) ;", "for ({} of y) ;\n")

expectPrinted(t, "for ((x) of y) ;", "for (x of y) ;\n")

expectParseError(t, "for (([]) of y) ;", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "for (({}) of y) ;", "<stdin>: ERROR: Invalid assignment target\n")

expectParseError(t, "[[...a, b]] = c", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "[{...a, b}] = c", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "({x: [...a, b]} = c)", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "({x: {...a, b}} = c)", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "[b, ...c,] = d", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "([b, ...c,] = d)", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "({b, ...c,} = d)", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "({a = b})", "<stdin>: ERROR: Unexpected \"=\"\n")

expectParseError(t, "({x = {a = b}} = c)", "<stdin>: ERROR: Unexpected \"=\"\n")

expectParseError(t, "[a = {b = c}] = d", "<stdin>: ERROR: Unexpected \"=\"\n")

expectPrinted(t, "for ([{a = {}}] in b) {}", "for ([{ a = {} }] in b) {\n}\n")

expectPrinted(t, "for ([{a = {}}] of b) {}", "for ([{ a = {} }] of b) {\n}\n")

expectPrinted(t, "for ({a = {}} in b) {}", "for ({ a = {} } in b) {\n}\n")

expectPrinted(t, "for ({a = {}} of b) {}", "for ({ a = {} } of b) {\n}\n")

expectParseError(t, "({a = {}} in b)", "<stdin>: ERROR: Unexpected \"=\"\n")

expectParseError(t, "[{a = {}}]\nof()", "<stdin>: ERROR: Unexpected \"=\"\n")

expectParseError(t, "for ([...a, b] in c) {}", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

expectParseError(t, "for ([...a, b] of c) {}", "<stdin>: ERROR: Unexpected \",\" after rest pattern\n")

}

func TestBreakAndContinue(t *testing.T) {

expectParseError(t, "break", "<stdin>: ERROR: Cannot use \"break\" here:\n")

expectParseError(t, "continue", "<stdin>: ERROR: Cannot use \"continue\" here:\n")

expectParseError(t, "x: { break }", "<stdin>: ERROR: Cannot use \"break\" here:\n")

expectParseError(t, "x: { break x }", "")

expectParseError(t, "x: { continue }", "<stdin>: ERROR: Cannot use \"continue\" here:\n")

expectParseError(t, "x: { continue x }", "<stdin>: ERROR: Cannot continue to label \"x\"\n")

expectParseError(t, "while (1) break", "")

expectParseError(t, "while (1) continue", "")

expectParseError(t, "while (1) { function foo() { break } }", "<stdin>: ERROR: Cannot use \"break\" here:\n")

expectParseError(t, "while (1) { function foo() { continue } }", "<stdin>: ERROR: Cannot use \"continue\" here:\n")

expectParseError(t, "x: while (1) break x", "")

expectParseError(t, "x: while (1) continue x", "")

expectParseError(t, "x: while (1) y: { break x }", "")

expectParseError(t, "x: while (1) y: { continue x }", "")

expectParseError(t, "x: while (1) y: { break y }", "")

expectParseError(t, "x: while (1) y: { continue y }", "<stdin>: ERROR: Cannot continue to label \"y\"\n")

expectParseError(t, "x: while (1) { function foo() { break x } }", "<stdin>: ERROR: There is no containing label named \"x\"\n")

expectParseError(t, "x: while (1) { function foo() { continue x } }", "<stdin>: ERROR: There is no containing label named \"x\"\n")

expectParseError(t, "switch (1) { case 1: break }", "")

expectParseError(t, "switch (1) { case 1: continue }", "<stdin>: ERROR: Cannot use \"continue\" here:\n")

expectParseError(t, "x: switch (1) { case 1: break x }", "")

expectParseError(t, "x: switch (1) { case 1: continue x }", "<stdin>: ERROR: Cannot continue to label \"x\"\n")

}

func TestFor(t *testing.T) {

expectParseError(t, "for (; in x) ;", "<stdin>: ERROR: Unexpected \"in\"\n")

expectParseError(t, "for (; of x) ;", "<stdin>: ERROR: Expected \";\" but found \"x\"\n")

expectParseError(t, "for (; in; ) ;", "<stdin>: ERROR: Unexpected \"in\"\n")

expectPrinted(t, "for (; of; ) ;", "for (; of; ) ;\n")

expectPrinted(t, "for (a in b) ;", "for (a in b) ;\n")

expectPrinted(t, "for (var a in b) ;", "for (var a in b) ;\n")

expectPrinted(t, "for (let a in b) ;", "for (let a in b) ;\n")

expectPrinted(t, "for (const a in b) ;", "for (const a in b) ;\n")

expectPrinted(t, "for (a in b, c) ;", "for (a in b, c) ;\n")

expectPrinted(t, "for (a in b = c) ;", "for (a in b = c) ;\n")

expectPrinted(t, "for (var a in b, c) ;", "for (var a in b, c) ;\n")

expectPrinted(t, "for (var a in b = c) ;", "for (var a in b = c) ;\n")

expectParseError(t, "for (var a, b in b) ;", "<stdin>: ERROR: for-in loops must have a single declaration\n")

expectParseError(t, "for (let a, b in b) ;", "<stdin>: ERROR: for-in loops must have a single declaration\n")

expectParseError(t, "for (const a, b in b) ;", "<stdin>: ERROR: for-in loops must have a single declaration\n")

expectPrinted(t, "for (a of b) ;", "for (a of b) ;\n")

expectPrinted(t, "for (var a of b) ;", "for (var a of b) ;\n")

expectPrinted(t, "for (let a of b) ;", "for (let a of b) ;\n")

expectPrinted(t, "for (const a of b) ;", "for (const a of b) ;\n")

expectPrinted(t, "for (a of b = c) ;", "for (a of b = c) ;\n")

expectPrinted(t, "for (var a of b = c) ;", "for (var a of b = c) ;\n")

expectParseError(t, "for (a of b, c) ;", "<stdin>: ERROR: Expected \")\" but found \",\"\n")

expectParseError(t, "for (var a of b, c) ;", "<stdin>: ERROR: Expected \")\" but found \",\"\n")

expectParseError(t, "for (var a, b of b) ;", "<stdin>: ERROR: for-of loops must have a single declaration\n")

expectParseError(t, "for (let a, b of b) ;", "<stdin>: ERROR: for-of loops must have a single declaration\n")

expectParseError(t, "for (const a, b of b) ;", "<stdin>: ERROR: for-of loops must have a single declaration\n")

// Avoid the initializer starting with "let" token

expectPrinted(t, "for ((let) of bar);", "for ((let) of bar) ;\n")

expectPrinted(t, "for ((let).foo of bar);", "for ((let).foo of bar) ;\n")

expectPrinted(t, "for ((let.foo) of bar);", "for ((let).foo of bar) ;\n")

expectPrinted(t, "for ((let``.foo) of bar);", "for ((let)``.foo of bar) ;\n")

expectParseError(t, "for (let.foo of bar);", "<stdin>: ERROR: \"let\" must be wrapped in parentheses to be used as an expression here:\n")

expectParseError(t, "for (let().foo of bar);", "<stdin>: ERROR: \"let\" must be wrapped in parentheses to be used as an expression here:\n")

expectParseError(t, "for (let``.foo of bar);", "<stdin>: ERROR: \"let\" must be wrapped in parentheses to be used as an expression here:\n")

expectPrinted(t, "for (var x = 0 in y) ;", "x = 0;\nfor (var x in y) ;\n") // This is a weird special-case

expectParseError(t, "for (let x = 0 in y) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (const x = 0 in y) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (var x = 0 of y) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (let x = 0 of y) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (const x = 0 of y) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (var [x] = y in z) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (let [x] = y in z) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (const [x] = y in z) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (var [x] = y of z) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (let [x] = y of z) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (const [x] = y of z) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (var {x} = y in z) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (let {x} = y in z) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (const {x} = y in z) ;", "<stdin>: ERROR: for-in loop variables cannot have an initializer\n")

expectParseError(t, "for (var {x} = y of z) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (let {x} = y of z) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

expectParseError(t, "for (const {x} = y of z) ;", "<stdin>: ERROR: for-of loop variables cannot have an initializer\n")

// Make sure "in" rules are enabled

expectPrinted(t, "for (var x = () => a in b);", "x = () => a;\nfor (var x in b) ;\n")

expectPrinted(t, "for (var x = a + b in c);", "x = a + b;\nfor (var x in c) ;\n")

// Make sure "in" rules are disabled

expectPrinted(t, "for (var x = `${y in z}`;;);", "for (var x = `${y in z}`; ; ) ;\n")

expectPrinted(t, "for (var {[x in y]: z} = {};;);", "for (var { [x in y]: z } = {}; ; ) ;\n")

expectPrinted(t, "for (var {x = y in z} = {};;);", "for (var { x = y in z } = {}; ; ) ;\n")

expectPrinted(t, "for (var [x = y in z] = {};;);", "for (var [x = y in z] = {}; ; ) ;\n")

expectPrinted(t, "for (var {x: y = z in w} = {};;);", "for (var { x: y = z in w } = {}; ; ) ;\n")

expectPrinted(t, "for (var x = (a in b);;);", "for (var x = (a in b); ; ) ;\n")

expectPrinted(t, "for (var x = [a in b];;);", "for (var x = [a in b]; ; ) ;\n")

expectPrinted(t, "for (var x = y(a in b);;);", "for (var x = y(a in b); ; ) ;\n")

expectPrinted(t, "for (var x = {y: a in b};;);", "for (var x = { y: a in b }; ; ) ;\n")

expectPrinted(t, "for (a ? b in c : d;;);", "for (a ? b in c : d; ; ) ;\n")

expectPrinted(t, "for (var x = () => { a in b };;);", "for (var x = () => {\n a in b;\n}; ; ) ;\n")

expectPrinted(t, "for (var x = async () => { a in b };;);", "for (var x = async () => {\n a in b;\n}; ; ) ;\n")

expectPrinted(t, "for (var x = function() { a in b };;);", "for (var x = function() {\n a in b;\n}; ; ) ;\n")

expectPrinted(t, "for (var x = async function() { a in b };;);", "for (var x = async function() {\n a in b;\n}; ; ) ;\n")

expectPrinted(t, "for (var x = class { [a in b]() {} };;);", "for (var x = class {\n [a in b]() {\n }\n}; ; ) ;\n")

expectParseError(t, "for (var x = class extends a in b {};;);", "<stdin>: ERROR: Expected \"{\" but found \"in\"\n")

errorText := `<stdin>: WARNING: This assignment will throw because "x" is a constant

<stdin>: NOTE: The symbol "x" was declared a constant here:

`

expectParseError(t, "for (var x = 0; ; x = 1) ;", "")

expectParseError(t, "for (let x = 0; ; x = 1) ;", "")

expectParseError(t, "for (const x = 0; ; x = 1) ;", errorText)

expectParseError(t, "for (var x = 0; ; x++) ;", "")

expectParseError(t, "for (let x = 0; ; x++) ;", "")

expectParseError(t, "for (const x = 0; ; x++) ;", errorText)

expectParseError(t, "for (var x in y) x = 1", "")

expectParseError(t, "for (let x in y) x = 1", "")

expectParseError(t, "for (const x in y) x = 1", errorText)

expectParseError(t, "for (var x in y) x++", "")

expectParseError(t, "for (let x in y) x++", "")

expectParseError(t, "for (const x in y) x++", errorText)