fix: remove unnecessary semicolon from fixes (#19857)

fasttime · web-flow · commit 7ef4cf76610d · 2025-06-17T21:58:33.000+02:00
diff --git a/lib/rules/utils/ast-utils.js b/lib/rules/utils/ast-utils.js
@@ -1193,6 +1193,35 @@ let needsPrecedingSemicolon;
 		"WithStatement",
 	]);
 
+	const TS_TYPE_NODE_TYPES = new Set([
+		"TSAsExpression",
+		"TSSatisfiesExpression",
+		"TSTypeAliasDeclaration",
+		"TSTypeAnnotation",
+	]);
+
+	/**
+	 * Determines whether a specified node is inside a TypeScript type context.
+	 * @param {ASTNode} node The node to check.
+	 * @returns {boolean} Whether the node is inside a TypeScript type context.
+	 */
+	function isInType(node) {
+		for (let currNode = node; ; ) {
+			const { parent } = currNode;
+			if (!parent) {
+				break;
+			}
+			if (
+				TS_TYPE_NODE_TYPES.has(parent.type) &&
+				currNode === parent.typeAnnotation
+			) {
+				return true;
+			}
+			currNode = parent;
+		}
+		return false;
+	}
+
 	needsPrecedingSemicolon = function (sourceCode, node) {
 		const prevToken = sourceCode.getTokenBefore(node);
 
@@ -1206,6 +1235,16 @@ let needsPrecedingSemicolon;
 
 		const prevNode = sourceCode.getNodeByRangeIndex(prevToken.range[0]);
 
+		if (
+			prevNode.type === "TSDeclareFunction" ||
+			prevNode.parent.type === "TSImportEqualsDeclaration" ||
+			prevNode.parent.parent?.type === "TSImportEqualsDeclaration" ||
+			TS_TYPE_NODE_TYPES.has(prevNode.type) ||
+			isInType(prevNode)
+		) {
+			return false;
+		}
+
 		if (isClosingParenToken(prevToken)) {
 			return !STATEMENTS.has(prevNode.type);
 		}
@@ -1222,6 +1261,12 @@ let needsPrecedingSemicolon;
 		}
 
 		if (IDENTIFIER_OR_KEYWORD.has(prevToken.type)) {
+			if (
+				prevNode.parent.type === "VariableDeclarator" &&
+				!prevNode.parent.init
+			) {
+				return false;
+			}
 			if (BREAK_OR_CONTINUE.has(prevNode.parent.type)) {
 				return false;
 			}
diff --git a/tests/lib/rules/no-array-constructor.js b/tests/lib/rules/no-array-constructor.js
@@ -491,6 +491,18 @@ ruleTester.run("no-array-constructor", rule, {
                         break yield
                     new Array();
                 }
+                `,
+			},
+			{
+				code: `
+                var foo
+                Array()
+                `,
+			},
+			{
+				code: `
+                let bar
+                Array()
                 `,
 			},
 		].map(props => ({
@@ -972,5 +984,74 @@ ruleTesterTypeScript.run("no-array-constructor", rule, {
 				},
 			],
 		},
+
+		// No semicolon required after TypeScript syntax
+		...[
+			"type T = Foo",
+			"type T = Foo<Bar>",
+			"type T = (A | B)",
+			"type T = -1",
+			"type T = 'foo'",
+			"const foo",
+			"declare const foo",
+			"function foo()",
+			"declare function foo()",
+			"function foo(): []",
+			"declare function foo(): []",
+			"function foo(): (Foo)",
+			"declare function foo(): (Foo)",
+			"let foo: bar",
+			"import Foo = require('foo')",
+			"import Foo = Bar",
+			"import Foo = Bar.Baz.Qux",
+		].map(code => ({
+			code: `${code}\nArray(0, 1)`,
+			output: `${code}\n[0, 1]`,
+			errors: [{ messageId: "preferLiteral" }],
+		})),
+		{
+			code: `
+			(function () {
+				Fn
+				Array() // ";" required
+			}) as Fn
+			Array() // ";" not required
+			`,
+			output: `
+			(function () {
+				Fn
+				;[] // ";" required
+			}) as Fn
+			[] // ";" not required
+			`,
+			errors: [
+				{ messageId: "preferLiteral" },
+				{ messageId: "preferLiteral" },
+			],
+		},
+		{
+			code: `
+			({
+				foo() {
+					Object
+					Array() // ";" required
+				}
+			}) as Object
+			Array() // ";" not required
+			`,
+			output: `
+			({
+				foo() {
+					Object
+					;[] // ";" required
+				}
+			}) as Object
+			[] // ";" not required
+			`,
+			errors: [
+				{ messageId: "preferLiteral" },
+				{ messageId: "preferLiteral" },
+			],
+		},
 	],
 });
diff --git a/tests/lib/rules/no-object-constructor.js b/tests/lib/rules/no-object-constructor.js
@@ -377,6 +377,18 @@ ruleTester.run("no-object-constructor", rule, {
                         break yield
                     new Object();
                 }
+                `,
+			},
+			{
+				code: `
+                var foo
+                Object()
+                `,
+			},
+			{
+				code: `
+                let bar
+                Object()
                 `,
 			},
 		].map(props => ({
