test(linter/unicorn): regenerate tests

crates/oxc_linter/src/rules/unicorn/consistent_date_clone.rs

@@ -95,22 +95,22 @@ fn test() {
         "Date(date.getTime())",
         // TODO: We may support these cases in future
         "new Date(
-				date.getFullYear(),
-				date.getMonth(),
-				date.getDate(),
-				date.getHours(),
-				date.getMinutes(),
-				date.getSeconds(),
-				date.getMilliseconds(),
-			);",
+                date.getFullYear(),
+                date.getMonth(),
+                date.getDate(),
+                date.getHours(),
+                date.getMinutes(),
+                date.getSeconds(),
+                date.getMilliseconds(),
+            );",
         "new Date(
-				date.getFullYear(),
-				date.getMonth(),
-				date.getDate(),
-				date.getHours(),
-				date.getMinutes(),
-				date.getSeconds(),
-			);",
+                date.getFullYear(),
+                date.getMonth(),
+                date.getDate(),
+                date.getHours(),
+                date.getMinutes(),
+                date.getSeconds(),
+            );",
     ];
 
     let fail = vec![

crates/oxc_linter/src/rules/unicorn/error_message.rs

@@ -110,48 +110,112 @@ fn test() {
     use crate::tester::Tester;
 
     let pass = vec![
-        ("throw new Error('error')", None),
-        ("throw new TypeError('error')", None),
-        ("throw new MyCustomError('error')", None),
-        ("throw new MyCustomError()", None),
-        ("throw generateError()", None),
-        ("throw foo()", None),
-        ("throw err", None),
-        ("throw 1", None),
-        ("new Error(\"message\", 0, 0)", None),
-        ("new Error(foo)", None),
-        ("new Error(...foo)", None),
-        ("new AggregateError(errors, \"message\")", None),
-        ("new NotAggregateError(errors)", None),
-        ("new AggregateError(...foo)", None),
-        ("new AggregateError(...foo, \"\")", None),
-        ("new AggregateError(errors, ...foo)", None),
-        ("new AggregateError(errors, message, \"\")", None),
-        ("new AggregateError(\"\", message, \"\")", None),
+        "throw new Error('error')",
+        "throw new TypeError('error')",
+        "throw new MyCustomError('error')",
+        "throw new MyCustomError()",
+        "throw generateError()",
+        "throw foo()",
+        "throw err",
+        "throw 1",
+        "const err = TypeError('error');
+            throw err;",
+        r#"new Error("message", 0, 0)"#,
+        "new Error(foo)",
+        r"const errors = [];
+            if (condition) {
+                errors.push('hello');
+            }
+            if (errors.length) {
+                throw new Error(errors.join('\\\\n'));
+            }",
+        "new Error(...foo)",
+        "/* global x */
+            const a = x;
+            throw x;",
+        // TODO: Get this passing.
+        // "const Error = function () {};
+        //     const err = new Error({
+        //         name: 'Unauthorized',
+        //     });",
+        r#"new AggregateError(errors, "message")"#,
+        "new NotAggregateError(errors)",
+        "new AggregateError(...foo)",
+        r#"new AggregateError(...foo, "")"#,
+        "new AggregateError(errors, ...foo)",
+        r#"new AggregateError(errors, message, "")"#,
+        r#"new AggregateError("", message, "")"#,
+        r#"new SuppressedError(error, suppressed, "message")"#,
+        "new NotSuppressedError(error, suppressed)",
+        "new SuppressedError(...foo)",
+        r#"new SuppressedError(...foo, "")"#,
+        "new SuppressedError(error, suppressed, ...foo)",
+        r#"new SuppressedError(error, suppressed, message, "")"#,
+        r#"new SuppressedError("", "", message, "")"#,
     ];
 
     let fail = vec![
-        ("throw new Error()", None),
-        ("throw Error()", None),
-        ("throw new Error('')", None),
-        ("throw new Error(``)", None),
-        ("const foo = new TypeError()", None),
-        ("const foo = new SyntaxError()", None),
-        ("throw new Error([])", None),
-        ("throw new Error([foo])", None),
-        ("throw new Error({})", None),
-        ("throw new Error({foo})", None),
-        ("const error = new RangeError;", None),
-        ("new AggregateError(errors)", None),
-        ("AggregateError(errors)", None),
-        ("new AggregateError(errors, \"\")", None),
-        ("new AggregateError(errors, ``)", None),
-        ("new AggregateError(errors, \"\", extraArgument)", None),
-        ("new AggregateError(errors, [])", None),
-        ("new AggregateError(errors, [foo])", None),
-        ("new AggregateError(errors, {})", None),
-        ("new AggregateError(errors, {foo})", None),
-        ("const error = new AggregateError;", None),
+        "throw new Error()",
+        "throw Error()",
+        "throw new Error('')",
+        "throw new Error(``)",
+        "const err = new Error();
+            throw err;",
+        "let err = 1;
+            err = new Error();
+            throw err;",
+        "let err = new Error();
+            err = 1;
+            throw err;",
+        "const foo = new TypeError()",
+        "const foo = new SyntaxError()",
+        // TODO: Get all of the comments tests here passing.
+        // "const errorMessage = Object.freeze({errorMessage: 1}).errorMessage;
+        //     throw new Error(errorMessage)",
+        "throw new Error([])",
+        "throw new Error([foo])",
+        // "throw new Error([0][0])",
+        "throw new Error({})",
+        "throw new Error({foo})",
+        // "throw new Error({foo: 0}.foo)",
+        // "throw new Error(lineNumber=2)",
+        "const error = new RangeError;",
+        "throw Object.assign(new Error(), {foo})",
+        "new AggregateError(errors)",
+        "AggregateError(errors)",
+        r#"new AggregateError(errors, "")"#,
+        "new AggregateError(errors, ``)",
+        r#"new AggregateError(errors, "", extraArgument)"#,
+        // "const errorMessage = Object.freeze({errorMessage: 1}).errorMessage;
+        //     throw new AggregateError(errors, errorMessage)",
+        "new AggregateError(errors, [])",
+        "new AggregateError(errors, [foo])",
+        // "new AggregateError(errors, [0][0])",
+        "new AggregateError(errors, {})",
+        "new AggregateError(errors, {foo})",
+        // "new AggregateError(errors, {foo: 0}.foo)",
+        // "new AggregateError(errors, lineNumber=2)",
+        "const error = new AggregateError;",
+        // TODO: Update the rule to get these tests working.
+        // "new SuppressedError(error, suppressed,)",
+        // "new SuppressedError(error,)",
+        // "new SuppressedError()",
+        // "SuppressedError(error, suppressed,)",
+        // "SuppressedError(error,)",
+        // "SuppressedError()",
+        // r#"new SuppressedError(error, suppressed, "")"#,
+        // "new SuppressedError(error, suppressed, ``)",
+        // r#"new SuppressedError(error, suppressed, "", options)"#,
+        // "const errorMessage = Object.freeze({errorMessage: 1}).errorMessage;
+        //     throw new SuppressedError(error, suppressed, errorMessage)",
+        // "new SuppressedError(error, suppressed, [])",
+        // "new SuppressedError(error, suppressed, [foo])",
+        // "new SuppressedError(error, suppressed, [0][0])",
+        // "new SuppressedError(error, suppressed, {})",
+        // "new SuppressedError(error, suppressed, {foo})",
+        // "new SuppressedError(error, suppressed, {foo: 0}.foo)",
+        // "new SuppressedError(error, suppressed, lineNumber=2)",
+        // "const error = new SuppressedError;",
     ];
 
     Tester::new(ErrorMessage::NAME, ErrorMessage::PLUGIN, pass, fail).test_and_snapshot();

crates/oxc_linter/src/rules/unicorn/no_array_for_each.rs

@@ -114,28 +114,28 @@ fn test() {
     use crate::tester::Tester;
 
     let pass = vec![
-        r"new foo.forEach(element => bar())",
-        r"forEach(element => bar())",
-        r"foo.notForEach(element => bar())",
-        r"React.Children.forEach(children, (child) => {});",
-        r"Children.forEach(children, (child) => {});",
+        "new foo.forEach(element => bar())",
+        "forEach(element => bar())",
+        "foo.notForEach(element => bar())",
+        "React.Children.forEach(children, (child) => {});",
+        "Children.forEach(children, (child) => {});",
         r#"import { Effect } from "effect"; Effect.forEach([], () => {})"#,
         r#"import { Effect as E } from "effect"; E.forEach([], () => {})"#,
     ];
 
     let fail = vec![
-        r"foo.forEach?.(element => bar(element))",
-        r"1?.forEach((a, b) => call(a, b))",
-        r"array.forEach((arrayInArray) => arrayInArray.forEach(element => bar(element)));",
-        r"array.forEach((arrayInArray) => arrayInArray?.forEach(element => bar(element)));",
-        r"array.forEach((element, index = element) => {})",
-        r"array.forEach(({foo}, index = foo) => {})",
-        r"array.forEach((element, {bar = element}) => {})",
-        r"array.forEach(({foo}, {bar = foo}) => {})",
-        r"foo.forEach(function(element, element1) {})",
-        r"foo.forEach(function element(element, element1) {})",
-        r"this._listeners.forEach((listener: () => void) => listener());",
-        r"return foo.forEach(element => {bar(element)});",
+        "foo.forEach?.(element => bar(element))",
+        "1?.forEach((a, b) => call(a, b))",
+        "array.forEach((arrayInArray) => arrayInArray.forEach(element => bar(element)));",
+        "array.forEach((arrayInArray) => arrayInArray?.forEach(element => bar(element)));",
+        "array.forEach((element, index = element) => {})",
+        "array.forEach(({foo}, index = foo) => {})",
+        "array.forEach((element, {bar = element}) => {})",
+        "array.forEach(({foo}, {bar = foo}) => {})",
+        "foo.forEach(function(element, element1) {})",
+        "foo.forEach(function element(element, element1) {})",
+        "this._listeners.forEach((listener: () => void) => listener());",
+        "return foo.forEach(element => {bar(element)});",
     ];
 
     // TODO: Implement a fixer.

crates/oxc_linter/src/rules/unicorn/no_array_method_this_argument.rs

@@ -229,6 +229,7 @@ fn test() {
         "Array.fromAsync(iterableOrArrayLike, ...() => {}, thisArgument)",
         "Array.fromAsync(...iterableOrArrayLike, () => {}, thisArgument)",
         "Array.fromAsync(iterableOrArrayLike, () => {}, thisArgument, extraArgument)",
+        "Array?.fromAsync(iterableOrArrayLike, () => {}, thisArgument)",
         "lodash.every(array, () => {})",
         "lodash.find(array, () => {})",
         "jQuery.map(array, () => {})",

crates/oxc_linter/src/rules/unicorn/no_invalid_fetch_options.rs

@@ -257,24 +257,24 @@ fn test() {
     let pass = vec![
         r#"fetch(url, {method: "POST", body})"#,
         r#"new Request(url, {method: "POST", body})"#,
-        r"fetch(url, {})",
-        r"new Request(url, {})",
-        r"fetch(url)",
-        r"new Request(url)",
+        "fetch(url, {})",
+        "new Request(url, {})",
+        "fetch(url)",
+        "new Request(url)",
         r#"fetch(url, {method: "UNKNOWN", body})"#,
         r#"new Request(url, {method: "UNKNOWN", body})"#,
-        r"fetch(url, {body: undefined})",
-        r"new Request(url, {body: undefined})",
-        r"fetch(url, {body: null})",
-        r"new Request(url, {body: null})",
-        r"fetch(url, {...options, body})",
-        r"new Request(url, {...options, body})",
-        r"new fetch(url, {body})",
-        r"Request(url, {body})",
-        r"not_fetch(url, {body})",
-        r"new not_Request(url, {body})",
-        r"fetch({body}, url)",
-        r"new Request({body}, url)",
+        "fetch(url, {body: undefined})",
+        "new Request(url, {body: undefined})",
+        "fetch(url, {body: null})",
+        "new Request(url, {body: null})",
+        "fetch(url, {...options, body})",
+        "new Request(url, {...options, body})",
+        "new fetch(url, {body})",
+        "Request(url, {body})",
+        "not_fetch(url, {body})",
+        "new not_Request(url, {body})",
+        "fetch({body}, url)",
+        "new Request({body}, url)",
         r#"fetch(url, {[body]: "foo=bar"})"#,
         r#"new Request(url, {[body]: "foo=bar"})"#,
         r#"fetch(url, {body: "foo=bar", body: undefined});"#,
@@ -314,8 +314,8 @@ fn test() {
     ];
 
     let fail = vec![
-        r"fetch(url, {body})",
-        r"new Request(url, {body})",
+        "fetch(url, {body})",
+        "new Request(url, {body})",
         r#"fetch(url, {method: "GET", body})"#,
         r#"new Request(url, {method: "GET", body})"#,
         r#"fetch(url, {method: "HEAD", body})"#,
@@ -326,8 +326,8 @@ fn test() {
         r#"const method = "head"; new Request(url, {method, body: "foo=bar"})"#,
         r#"const method = "head"; fetch(url, {method, body: "foo=bar"})"#,
         r#"const method = `head`; fetch(url, {method, body: "foo=bar"})"#,
-        r"fetch(url, {body}, extraArgument)",
-        r"new Request(url, {body}, extraArgument)",
+        "fetch(url, {body}, extraArgument)",
+        "new Request(url, {body}, extraArgument)",
         r#"fetch(url, {body: undefined, body: "foo=bar"});"#,
         r#"new Request(url, {body: undefined, body: "foo=bar"});"#,
         r#"fetch(url, {method: "post", body: "foo=bar", method: "HEAD"});"#,

crates/oxc_linter/src/rules/unicorn/no_invalid_remove_event_listener.rs

@@ -137,16 +137,16 @@ fn test() {
         r#"el.notRemoveEventListener("click", () => {})"#,
         r#"el[removeEventListener]("click", () => {})"#,
         r#"el.removeEventListener("click")"#,
-        r"el.removeEventListener()",
-        r"el.removeEventListener(() => {})",
+        "el.removeEventListener()",
+        "el.removeEventListener(() => {})",
         r#"el.removeEventListener(...["click", () => {}], () => {})"#,
         r#"el.removeEventListener(() => {}, "click")"#,
         r#"window.removeEventListener("click", bind())"#,
         r#"window.removeEventListener("click", handler.notBind())"#,
         r#"window.removeEventListener("click", handler[bind]())"#,
         r#"window.removeEventListener("click", handler.bind?.())"#,
         r#"window.removeEventListener("click", handler?.bind())"#,
-        r"window.removeEventListener(handler)",
+        "window.removeEventListener(handler)",
         r#"this.removeEventListener("click", getListener())"#,
         r#"el.removeEventListener("scroll", handler)"#,
         r#"el.removeEventListener("keydown", obj.listener)"#,
@@ -168,7 +168,7 @@ fn test() {
         // r#"el?.removeEventListener("mouseout", function (e) {})"#,
         r#"el.removeEventListener("mouseout", function (e) {}, true)"#,
         r#"el.removeEventListener("click", function (e) {}, ...moreArguments)"#,
-        r"el.removeEventListener(() => {}, () => {}, () => {})",
+        "el.removeEventListener(() => {}, () => {}, () => {})",
         "document.removeEventListener('keydown', () => foo())",
         "document.removeEventListener('keydown', function () {})",
         // make sure that if the listener is a big one, we shorten the span.

crates/oxc_linter/src/rules/unicorn/no_negation_in_equality_check.rs

@@ -139,35 +139,23 @@ fn test() {
         "!foo !== bar",
         "!foo == bar",
         "!foo != bar",
-        "
-                        function x() {
-                            return!foo === bar;
-                        }
-                    ",
-        "
-                        function x() {
-                            return!
-                                foo === bar;
-                            throw!
-                                foo === bar;
-                        }
-                    ",
-        "
-                        foo
-                        !(a) === b
-                    ",
-        "
-                        foo
-                        ![a, b].join('') === c
-                    ",
-        "
-                        foo
-                        ! [a, b].join('') === c
-                    ",
-        "
-                        foo
-                        !/* comment */[a, b].join('') === c
-                    ",
+        "function x() {
+                return!foo === bar;
+            }",
+        "function x() {
+                return!
+                    foo === bar;
+                throw!
+                    foo === bar;
+            }",
+        "foo
+            !(a) === b",
+        "foo
+            ![a, b].join('') === c",
+        "foo
+            ! [a, b].join('') === c",
+        "foo
+            !/* comment */[a, b].join('') === c",
     ];
 
     let fix = vec![

crates/oxc_linter/src/rules/unicorn/no_nested_ternary.rs

@@ -132,6 +132,7 @@ fn test() {
         "const foo = i > 5 ? true : i < 100 ? true : false;",
         "foo ? bar : baz === qux ? quxx : foobar;",
         "foo ? baz === qux ? quxx : foobar : bar;",
+        "const foo = i > 5 ? i < 100 ? true : false : i < 100 ? true : false;",
         "const foo = i > 5 ? true : (i < 100 ? true : (i < 1000 ? true : false));",
         "const foo = a ?
                 b :