feat(ts): implement unnecessaryUseStricts rule

cspell.json

@@ -83,13 +83,15 @@
 		"shiki",
 		"shikijs",
 		"spinbutton",
+		"Stricts",
 		"subtag",
 		"subtags",
 		"thenables",
 		"treegrid",
 		"tsgolint",
 		"twoslash",
 		"typelang",
+		"useStricts",
 		"Waiblinger",
 		"webauthn",
 		"WHATWG",

packages/comparisons/src/data.json

@@ -18350,7 +18350,8 @@
 		"flint": {
 			"name": "unnecessaryUseStricts",
 			"plugin": "ts",
-			"preset": "logical"
+			"preset": "logical",
+			"status": "implemented"
 		}
 	},
 	{

packages/site/src/content/docs/rules/ts/unnecessaryUseStricts.mdx

@@ -0,0 +1,70 @@
+---
+description: 'Reports unnecessary "use strict" directives in ES modules and classes.'
+title: "unnecessaryUseStricts"
+topic: "rules"
+---
+
+import { Tabs, TabItem } from "@astrojs/starlight/components";
+import { RuleEquivalents } from "~/components/RuleEquivalents";
+import RuleSummary from "~/components/RuleSummary.astro";
+
+<RuleSummary plugin="ts" rule="unnecessaryUseStricts" />
+
+ECMAScript modules and class bodies are automatically in strict mode.
+The `"use strict"` directive has no effect in these contexts and is redundant.
+
+This rule reports on `"use strict"` directives that can be safely removed.
+
+## Examples
+
+<Tabs>
+<TabItem label="❌ Incorrect">
+
+```ts
+"use strict";
+
+export function calculate(value: number) {
+	return value * 2;
+}
+
+export class Calculator {
+	add(a: number, b: number) {
+		return a + b;
+	}
+}
+```
+
+</TabItem>
+<TabItem label="✅ Correct">
+
+```ts
+export function calculate(value: number) {
+	return value * 2;
+}
+
+export class Calculator {
+	add(a: number, b: number) {
+		return a + b;
+	}
+}
+```
+
+</TabItem>
+</Tabs>
+
+## Options
+
+This rule is not configurable.
+
+## When Not To Use It
+
+If you are working in a JavaScript environment with non-standard semantics, or otherwise have tooling that requires you to use seemingly redundant `"use strict"` directives, this rule might not be for you.
+
+## Further Reading
+
+- [MDN: Strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode)
+- [MDN: JavaScript modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
+
+## Equivalents in Other Linters
+
+<RuleEquivalents pluginId="ts" ruleId="unnecessaryUseStricts" />

packages/ts/src/plugin.ts

@@ -282,6 +282,7 @@ import unnecessaryBooleanCasts from "./rules/unnecessaryBooleanCasts.ts";
 import unnecessaryCatches from "./rules/unnecessaryCatches.ts";
 import unnecessaryComparisons from "./rules/unnecessaryComparisons.ts";
 import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.ts";
+import unnecessaryUseStricts from "./rules/unnecessaryUseStricts.ts";
 import unsafeNegations from "./rules/unsafeNegations.ts";
 import variableDeletions from "./rules/variableDeletions.ts";
 import voidOperator from "./rules/voidOperator.ts";
@@ -576,6 +577,7 @@ export const ts = createPlugin({
 		unnecessaryCatches,
 		unnecessaryComparisons,
 		unnecessaryConcatenation,
+		unnecessaryUseStricts,
 		unsafeNegations,
 		variableDeletions,
 		voidOperator,

packages/ts/src/rules/unnecessaryUseStricts.test.ts

@@ -0,0 +1,136 @@
+import { ruleTester } from "./ruleTester.ts";
+import rule from "./unnecessaryUseStricts.ts";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+"use strict";
+
+export function foo() {
+    return 42;
+}
+`,
+			output: `
+export function foo() {
+    return 42;
+}
+`,
+			snapshot: `
+"use strict";
+~~~~~~~~~~~~~
+This \`"use strict"\` directive is redundant and can be safely removed.
+
+export function foo() {
+    return 42;
+}
+`,
+		},
+		{
+			code: `
+'use strict';
+
+export const value = 10;
+`,
+			output: `
+export const value = 10;
+`,
+			snapshot: `
+'use strict';
+~~~~~~~~~~~~~
+This \`"use strict"\` directive is redundant and can be safely removed.
+
+export const value = 10;
+`,
+		},
+		{
+			code: `
+"use strict";
+
+import { something } from "./module";
+`,
+			output: `
+import { something } from "./module";
+`,
+			snapshot: `
+"use strict";
+~~~~~~~~~~~~~
+This \`"use strict"\` directive is redundant and can be safely removed.
+
+import { something } from "./module";
+`,
+		},
+		{
+			code: `
+"use strict";
+
+export default class MyClass {}
+`,
+			output: `
+export default class MyClass {}
+`,
+			snapshot: `
+"use strict";
+~~~~~~~~~~~~~
+This \`"use strict"\` directive is redundant and can be safely removed.
+
+export default class MyClass {}
+`,
+		},
+		{
+			code: `
+"use strict";
+export {};
+`,
+			output: `
+export {};
+`,
+			snapshot: `
+"use strict";
+~~~~~~~~~~~~~
+This \`"use strict"\` directive is redundant and can be safely removed.
+export {};
+`,
+		},
+		{
+			code: `
+"use strict";
+export const value = 42;
+`,
+			output: `
+export const value = 42;
+`,
+			snapshot: `
+"use strict";
+~~~~~~~~~~~~~
+This \`"use strict"\` directive is redundant and can be safely removed.
+export const value = 42;
+`,
+		},
+	],
+	valid: [
+		`
+function foo() {
+    return 42;
+}
+`,
+		`
+const value = 10;
+`,
+		`
+// No imports or exports means not a module
+"use strict";
+
+function foo() {
+    return 42;
+}
+`,
+		`
+// Comments don't make it a module
+"use strict";
+
+// Some comment
+console.log("hello");
+`,
+	],
+});

packages/ts/src/rules/unnecessaryUseStricts.ts

@@ -0,0 +1,66 @@
+import {
+	getTSNodeRange,
+	typescriptLanguage,
+} from "@flint.fyi/typescript-language";
+import ts from "typescript";
+
+import { ruleCreator } from "./ruleCreator.ts";
+
+export default ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description:
+			'Reports unnecessary "use strict" directives in ES modules and classes.',
+		id: "unnecessaryUseStricts",
+		presets: ["logical"],
+	},
+	messages: {
+		unnecessaryUseStrict: {
+			primary:
+				'This `"use strict"` directive is redundant and can be safely removed.',
+			secondary: [
+				"ECMAScript modules and class bodies are automatically in strict mode.",
+				'The `"use strict"` directive has no effect and is redundant.',
+			],
+			suggestions: ['Remove the `"use strict"` directive.'],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				SourceFile(node, { sourceFile }) {
+					if (!ts.isExternalModule(sourceFile)) {
+						return;
+					}
+
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					const firstStatement = node.statements[0]!;
+
+					if (
+						!ts.isExpressionStatement(firstStatement) ||
+						!ts.isStringLiteral(firstStatement.expression) ||
+						firstStatement.expression.text !== "use strict"
+					) {
+						return;
+					}
+
+					const secondStatement = node.statements[1];
+					const fixEnd = secondStatement
+						? secondStatement.getStart(sourceFile)
+						: firstStatement.getEnd();
+
+					context.report({
+						fix: {
+							range: {
+								begin: firstStatement.getStart(sourceFile),
+								end: fixEnd,
+							},
+							text: "",
+						},
+						message: "unnecessaryUseStrict",
+						range: getTSNodeRange(firstStatement, sourceFile),
+					});
+				},
+			},
+		};
+	},
+});