@flint.fyi/ts 0.14.0 → 0.14.2

package/lib/rules/octalEscapes.test.js

@@ -0,0 +1,213 @@
+import rule from "./octalEscapes.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const a = "\\1";
+`,
+            snapshot: `
+const a = "\\1";
+           ~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\2";
+`,
+            snapshot: `
+const a = "\\2";
+           ~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\7";
+`,
+            snapshot: `
+const a = "\\7";
+           ~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\00";
+`,
+            snapshot: `
+const a = "\\00";
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\01";
+`,
+            snapshot: `
+const a = "\\01";
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\02";
+`,
+            snapshot: `
+const a = "\\02";
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\07";
+`,
+            snapshot: `
+const a = "\\07";
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\377";
+`,
+            snapshot: `
+const a = "\\377";
+           ~~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "\\12";
+`,
+            snapshot: `
+const a = "\\12";
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "before\\1after";
+`,
+            snapshot: `
+const a = "before\\1after";
+                 ~~
+                 Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = "before\\01after";
+`,
+            snapshot: `
+const a = "before\\01after";
+                 ~~~
+                 Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = '\\1';
+`,
+            snapshot: `
+const a = '\\1';
+           ~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = '\\01';
+`,
+            snapshot: `
+const a = '\\01';
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = \`\\1\`;
+`,
+            snapshot: `
+const a = \`\\1\`;
+           ~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = \`\\01\`;
+`,
+            snapshot: `
+const a = \`\\01\`;
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const a = \`before\\1after\`;
+`,
+            snapshot: `
+const a = \`before\\1after\`;
+                 ~~
+                 Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const x = 5;
+const a = \`value: \${x} \\1\`;
+`,
+            snapshot: `
+const x = 5;
+const a = \`value: \${x} \\1\`;
+                       ~~
+                       Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+        {
+            code: `
+const x = 5;
+const a = \`\\01 value: \${x}\`;
+`,
+            snapshot: `
+const x = 5;
+const a = \`\\01 value: \${x}\`;
+           ~~~
+           Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.
+`,
+        },
+    ],
+    valid: [
+        `const a = "\\0";`,
+        `const a = "\\8";`,
+        `const a = "\\9";`,
+        `const a = "\\x01";`,
+        `const a = "\\u0001";`,
+        `const a = "\\n";`,
+        `const a = "\\t";`,
+        `const a = "\\\\0";`,
+        `const a = "\\\\1";`,
+        `const a = "before\\0after";`,
+        `const a = "before\\8after";`,
+        `const a = "before\\9after";`,
+        `const a = '\\0';`,
+        `const a = '\\8';`,
+        `const a = '\\9';`,
+        `const a = \`\\0\`;`,
+        `const a = \`\\8\`;`,
+        `const a = \`\\9\`;`,
+        `const x = 5; const a = \`value: \${x} \\0\`;`,
+        `const x = 5; const a = \`\\0 value: \${x}\`;`,
+        `const x = 5; const a = \`\\8 \${x} \\9\`;`,
+    ],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/ts",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "repository": {
     "type": "git",

package/src/createTypeScriptFileFromProgram.ts

@@ -7,8 +7,11 @@ import * as ts from "typescript";
 
 import { collectReferencedFilePaths } from "./collectReferencedFilePaths.js";
 import { formatDiagnostic } from "./formatDiagnostic.js";
+import { getFirstEnumValues } from "./getFirstEnumValues.js";
 import { normalizeRange } from "./normalizeRange.js";
 
+const NodeSyntaxKinds = getFirstEnumValues(ts.SyntaxKind);
+
 export function createTypeScriptFileFromProgram(
 	program: ts.Program,
 	sourceFile: ts.SourceFile,
@@ -65,7 +68,7 @@ export function createTypeScriptFileFromProgram(
 
 			const { visitors } = runtime;
 			const visit = (node: ts.Node) => {
-				visitors[ts.SyntaxKind[node.kind]]?.(node);
+				visitors[NodeSyntaxKinds[node.kind]]?.(node);
 
 				node.forEachChild(visit);
 			};

package/src/getFirstEnumValues.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+
+import { getFirstEnumValues } from "./getFirstEnumValues.js";
+
+describe("getFirstEnumValues", () => {
+	it("returns an empty object when given an empty enum", () => {
+		enum Empty {}
+
+		const result = getFirstEnumValues(Empty);
+
+		expect(result).toEqual({});
+	});
+
+	it("returns all original pairs when when given a non-repeating enum", () => {
+		enum NonRepeating {
+			A = 1,
+			B = 2,
+			C = 3,
+		}
+
+		const result = getFirstEnumValues(NonRepeating);
+
+		expect(result).toEqual({
+			1: "A",
+			2: "B",
+			3: "C",
+			A: 1,
+			B: 2,
+			C: 3,
+		});
+	});
+
+	it("returns the first key when when given a repeating-value enum", () => {
+		enum Repeating {
+			A = 1,
+			B = 2,
+			// eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+			C = A,
+		}
+
+		const result = getFirstEnumValues(Repeating);
+
+		expect(result).toEqual({
+			1: "A",
+			2: "B",
+			A: 1,
+			B: 2,
+			C: 1,
+		});
+	});
+});

package/src/getFirstEnumValues.ts

@@ -0,0 +1,59 @@
+/**
+ * Removes TypeScript enum values that alias earlier values.
+ * @param original Any TypeScript enum with numeric values.
+ * @returns A version of the enum with only the first occurrence of each value.
+ * @example
+ * Given the following enum:
+ * ```ts
+ * enum Example {
+ *   A = 1,
+ *   B = 2,
+ *   C = A
+ * }
+ * ```
+ * Its original value looks like:
+ * ```ts
+ * {
+ *   1: 'C', // <-- Points to 'C', the alias of 'A'
+ *   2: 'B',
+ *   A: 1,
+ *   B: 2,
+ *   C: 1,
+ * }
+ * ```
+ * Calling `getFirstEnumValues(Example)` would return:
+ * ```ts
+ * {
+ *   1: 'A', // <-- Corrected to the original 'A'
+ *   2: 'B',
+ *   A: 1,
+ *   B: 2,
+ *   C: 1,
+ * }
+ * ```
+ */
+export function getFirstEnumValues<
+	Keys extends string,
+	Values extends number,
+	Original extends Record<Keys | Values, Keys | Values>,
+>(original: Original) {
+	const result = {} as Original;
+
+	for (const key in original) {
+		if (typeof original[key] !== "number") {
+			continue;
+		}
+
+		if (!(key in result)) {
+			result[key] = original[key];
+		}
+
+		if (!(original[key] in result)) {
+			// 🤷 enums are tricky to type.
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+			result[original[key]] = key as any;
+		}
+	}
+
+	return result;
+}

package/src/plugin.ts

@@ -1,13 +1,21 @@
 import { createPlugin } from "@flint.fyi/core";
 
 import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
+import debuggerStatements from "./rules/debuggerStatements.js";
 import forInArrays from "./rules/forInArrays.js";
 import namespaceDeclarations from "./rules/namespaceDeclarations.js";
+import octalEscapes from "./rules/octalEscapes.js";
 
 export const ts = createPlugin({
 	files: {
 		all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
 	},
 	name: "ts",
-	rules: [forInArrays, consecutiveNonNullAssertions, namespaceDeclarations],
+	rules: [
+		consecutiveNonNullAssertions,
+		debuggerStatements,
+		forInArrays,
+		namespaceDeclarations,
+		octalEscapes,
+	],
 });

package/src/rules/consecutiveNonNullAssertions.ts

@@ -4,6 +4,7 @@ import { typescriptLanguage } from "../language.js";
 
 export default typescriptLanguage.createRule({
 	about: {
+		description: "Reports unnecessary extra non-null assertions.",
 		id: "consecutiveNonNullAssertions",
 		preset: "logical",
 	},
@@ -26,8 +27,8 @@ export default typescriptLanguage.createRule({
 					}
 
 					const range = {
-						begin: node.end,
-						end: node.parent.end + 1,
+						begin: node.end - 1,
+						end: node.parent.end,
 					};
 
 					context.report({

package/src/rules/debuggerStatements.test.ts

@@ -0,0 +1,81 @@
+import rule from "./debuggerStatements.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+debugger;
+`,
+			snapshot: `
+debugger;
+~~~~~~~~~
+Debugger statements should not be used in production code.
+`,
+			suggestions: [
+				{
+					id: "removeDebugger",
+					updated: `
+
+`,
+				},
+			],
+		},
+		{
+			code: `
+function test() {
+	debugger;
+}
+`,
+			snapshot: `
+function test() {
+	debugger;
+ ~~~~~~~~~
+ Debugger statements should not be used in production code.
+}
+`,
+			suggestions: [
+				{
+					id: "removeDebugger",
+					updated: `
+function test() {
+	
+}
+`,
+				},
+			],
+		},
+		{
+			code: `
+if (condition) {
+	debugger;
+}
+`,
+			snapshot: `
+if (condition) {
+	debugger;
+ ~~~~~~~~~
+ Debugger statements should not be used in production code.
+}
+`,
+			suggestions: [
+				{
+					id: "removeDebugger",
+					updated: `
+if (condition) {
+	
+}
+`,
+				},
+			],
+		},
+	],
+	valid: [
+		`console.log("debugging");`,
+		`function test() { console.log("test"); }`,
+		`for (let i = 0; i < 10; i++) { break; }`,
+		`for (let i = 0; i < 10; i++) { continue; }`,
+		`function test() { return; }`,
+		`throw new Error("test");`,
+	],
+});

package/src/rules/debuggerStatements.ts

@@ -0,0 +1,45 @@
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using debugger statements.",
+		id: "debuggerStatements",
+		preset: "logical",
+	},
+	messages: {
+		noDebugger: {
+			primary: "Debugger statements should not be used in production code.",
+			secondary: [
+				"The `debugger` statement causes the JavaScript runtime to pause execution and start a debugger if one is available, such as when browser developer tools are open.",
+				"This can be useful during development, but should not be left in production code.",
+			],
+			suggestions: [
+				"Remove the `debugger` statement before shipping this code to users.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				DebuggerStatement: (node) => {
+					const range = {
+						begin: node.getStart(),
+						end: node.getEnd(),
+					};
+
+					context.report({
+						message: "noDebugger",
+						range,
+						suggestions: [
+							{
+								id: "removeDebugger",
+								range,
+								text: "",
+							},
+						],
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/forInArrays.ts

@@ -7,6 +7,7 @@ import { isTypeRecursive } from "./utils/isTypeRecursive.js";
 
 export default typescriptLanguage.createRule({
 	about: {
+		description: "Reports iterating over an array with a for-in loop.",
 		id: "forInArrays",
 		preset: "logical",
 	},

package/src/rules/namespaceDeclarations.ts

@@ -7,6 +7,7 @@ import { typescriptLanguage } from "../language.js";
 
 export default typescriptLanguage.createRule({
 	about: {
+		description: "Reports using legacy `namespace` declarations.",
 		id: "namespaceDeclarations",
 		preset: "logical",
 	},
@@ -23,8 +24,18 @@ export default typescriptLanguage.createRule({
 		},
 	},
 	options: {
-		allowDeclarations: z.boolean().default(false),
-		allowDefinitionFiles: z.boolean().default(false),
+		allowDeclarations: z
+			.boolean()
+			.default(false)
+			.describe(
+				"Whether to allow namespaces declared with the `declare` keyword.",
+			),
+		allowDefinitionFiles: z
+			.boolean()
+			.default(false)
+			.describe(
+				"Whether to allow namespaces in `.d.ts` and other definition files.",
+			),
 	},
 	setup(context, { allowDeclarations, allowDefinitionFiles }) {
 		if (allowDefinitionFiles && context.sourceFile.isDeclarationFile) {