feat: support TS syntax in no-unused-expressions (#19564)

Author: SwetaTanwar

docs/src/rules/no-unused-expressions.md

@@ -276,3 +276,64 @@ const myFragment = <></>;
 ```
 
 :::
+
+### TypeScript Support
+
+This rule supports TypeScript-specific expressions and follows these guidelines:
+
+1. Directives (like `'use strict'`) are allowed in module and namespace declarations
+2. Type-related expressions are treated as unused if their wrapped value expressions are unused:
+   * Type assertions (`x as number`, `<number>x`)
+   * Non-null assertions (`x!`)
+   * Type instantiations (`Set<number>`)
+
+**Note**: Although type expressions never have runtime side effects (e.g., `x!` is equivalent to `x` at runtime), they can be used to assert types for testing purposes.
+
+Examples of **correct** code for this rule when using TypeScript:
+
+::: correct
+
+```ts
+/* eslint no-unused-expressions: "error" */
+
+// Type expressions wrapping function calls are allowed
+function getSet() {
+    return Set;
+}
+getSet()<number>;
+getSet() as Set<unknown>;
+getSet()!;
+
+// Directives in modules and namespaces
+module Foo {
+    'use strict';
+    'hello world';
+}
+
+namespace Bar {
+    'use strict';
+    export class Baz {}
+}
+```
+
+:::
+
+Examples of **incorrect** code for this rule when using TypeScript:
+
+::: incorrect
+
+```ts
+/* eslint no-unused-expressions: "error" */
+
+// Standalone type expressions
+Set<number>;
+1 as number;
+window!;
+
+// Expressions inside namespaces
+namespace Bar {
+    123;
+}
+```
+
+:::

lib/rules/no-unused-expressions.js

@@ -83,61 +83,6 @@ 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.
@@ -190,13 +135,26 @@ module.exports = {
 			UnaryExpression(node) {
 				return node.operator !== "void" && node.operator !== "delete";
 			},
+			// TypeScript-specific node types
+			TSAsExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			TSTypeAssertion(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			TSNonNullExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
+			TSInstantiationExpression(node) {
+				return Checker.isDisallowed(node.expression);
+			},
 		});
 
 		return {
 			ExpressionStatement(node) {
 				if (
 					Checker.isDisallowed(node.expression) &&
-					!isDirective(node)
+					!astUtils.isDirective(node)
 				) {
 					context.report({ node, messageId: "unusedExpression" });
 				}