fix: revert directive detection in no-unused-expressions (#19639)

sethamus · web-flow · commit cdc8e8c950dd · 2025-04-21T21:40:51.000+05:30
* revert: use node.directive for directive check

* format

* add test

* review
diff --git a/lib/rules/no-unused-expressions.js b/lib/rules/no-unused-expressions.js
@@ -29,6 +29,8 @@ function alwaysFalse() {
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		docs: {
@@ -83,6 +85,61 @@ module.exports = {
 			},
 		] = context.options;
 
+		/**
+		 * Has AST suggesting a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node structurally represents a directive
+		 */
+		function looksLikeDirective(node) {
+			return (
+				node.type === "ExpressionStatement" &&
+				node.expression.type === "Literal" &&
+				typeof node.expression.value === "string"
+			);
+		}
+
+		/**
+		 * Gets the leading sequence of members in a list that pass the predicate.
+		 * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
+		 * @param {a[]} list the input list
+		 * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
+		 */
+		function takeWhile(predicate, list) {
+			for (let i = 0; i < list.length; ++i) {
+				if (!predicate(list[i])) {
+					return list.slice(0, i);
+				}
+			}
+			return list.slice();
+		}
+
+		/**
+		 * Gets leading directives nodes in a Node body.
+		 * @param {ASTNode} node a Program or BlockStatement node
+		 * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
+		 */
+		function directives(node) {
+			return takeWhile(looksLikeDirective, node.body);
+		}
+
+		/**
+		 * Detect if a Node is a directive.
+		 * @param {ASTNode} node any node
+		 * @returns {boolean} whether the given node is considered a directive in its current position
+		 */
+		function isDirective(node) {
+			/**
+			 * https://tc39.es/ecma262/#directive-prologue
+			 *
+			 * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
+			 * Class static blocks do not have directive prologue.
+			 */
+			return (
+				astUtils.isTopLevelExpressionStatement(node) &&
+				directives(node.parent).includes(node)
+			);
+		}
+
 		/**
 		 * The member functions return `true` if the type has no side-effects.
 		 * Unknown nodes are handled as `false`, then this rule ignores those.
@@ -154,7 +211,7 @@ module.exports = {
 			ExpressionStatement(node) {
 				if (
 					Checker.isDisallowed(node.expression) &&
-					!astUtils.isDirective(node)
+					!isDirective(node)
 				) {
 					context.report({ node, messageId: "unusedExpression" });
 				}
diff --git a/lib/rules/utils/ast-utils.js b/lib/rules/utils/ast-utils.js
@@ -1088,13 +1088,13 @@ function isConstant(scope, node, inBooleanPosition) {
 }
 
 /**
- * Checks whether a node is an ExpressionStatement at the top level of a file or function body.
+ * Checks whether a node is an ExpressionStatement at the top level of a file, function body, or TypeScript module block.
  * A top-level ExpressionStatement node is a directive if it contains a single unparenthesized
  * string literal and if it occurs either as the first sibling or immediately after another
  * directive.
  * @param {ASTNode} node The node to check.
  * @returns {boolean} Whether or not the node is an ExpressionStatement at the top level of a
- * file or function body.
+ * file, function body, or TypeScript module block.
  */
 function isTopLevelExpressionStatement(node) {
 	if (node.type !== "ExpressionStatement") {
@@ -1104,6 +1104,7 @@ function isTopLevelExpressionStatement(node) {
 
 	return (
 		parent.type === "Program" ||
+		parent.type === "TSModuleBlock" ||
 		(parent.type === "BlockStatement" && isFunction(parent.parent))
 	);
 }
diff --git a/tests/lib/rules/no-unused-expressions.js b/tests/lib/rules/no-unused-expressions.js
@@ -37,6 +37,10 @@ ruleTester.run("no-unused-expressions", rule, {
 		"delete foo.bar",
 		"void new C",
 		'"use strict";',
+		{
+			code: '"use strict";',
+			languageOptions: { ecmaVersion: 3, sourceType: "script" },
+		},
 		'"directive one"; "directive two"; f();',
 		'function foo() {"use strict"; return true; }',
 		{
