@flint.fyi/ts 0.14.1 → 0.14.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @flint/ts
 
+## 0.14.2
+
+### Patch Changes
+
+- 6415134: feat: implement debuggerStatements rule for TypeScript plugin
+- Updated dependencies [b58d145]
+  - @flint.fyi/rule-tester@0.14.1
+
 ## 0.14.1
 
 ### Patch Changes

package/lib/plugin.d.ts

@@ -1,16 +1,24 @@
 export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
-    readonly description: "Reports iterating over an array with a for-in loop.";
-    readonly id: "forInArrays";
-    readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary extra non-null assertions.";
     readonly id: "consecutiveNonNullAssertions";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using debugger statements.";
+    readonly id: "debuggerStatements";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noDebugger", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports iterating over an array with a for-in loop.";
+    readonly id: "forInArrays";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferModules", {
     readonly allowDeclarations: import("zod").ZodDefault<import("zod").ZodBoolean>;
     readonly allowDefinitionFiles: import("zod").ZodDefault<import("zod").ZodBoolean>;
-}>]>;
+}>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using octal escape sequences in string literals.";
+    readonly id: "octalEscapes";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalEscape", undefined>]>;

package/lib/plugin.js

@@ -1,11 +1,19 @@
 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/lib/rules/debuggerStatements.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using debugger statements.";
+    readonly id: "debuggerStatements";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noDebugger", undefined>;
+export default _default;

package/lib/rules/debuggerStatements.js

@@ -0,0 +1,43 @@
+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/lib/rules/debuggerStatements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/debuggerStatements.test.js

@@ -0,0 +1,80 @@
+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/lib/rules/octalEscapes.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using octal escape sequences in string literals.";
+    readonly id: "octalEscapes";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noOctalEscape", undefined>;
+export default _default;

package/lib/rules/octalEscapes.js

@@ -0,0 +1,71 @@
+import { typescriptLanguage } from "../language.js";
+/**
+ * Finds the position and length of an octal escape sequence in a string.
+ * Returns undefined if no octal escape is found.
+ */
+function findOctalEscape(text) {
+    // Remove quotes from the string literal
+    const content = text.slice(1, -1);
+    // Match octal escapes: \0 followed by [0-7], or \1-7 optionally followed by [0-7]
+    // But exclude escaped backslashes (\\)
+    const octalEscapePattern = /(?<!\\)\\0[0-7]|(?<!\\)\\[1-7][0-7]*/;
+    const match = octalEscapePattern.exec(content);
+    if (!match) {
+        return undefined;
+    }
+    // Add 1 to account for the opening quote
+    return {
+        index: match.index + 1,
+        length: match[0].length,
+    };
+}
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using octal escape sequences in string literals.",
+        id: "octalEscapes",
+        preset: "logical",
+    },
+    messages: {
+        noOctalEscape: {
+            primary: "Prefer hexadecimal or Unicode escape sequences over legacy octal escape sequences.",
+            secondary: [
+                "Octal escape sequences (e.g., `\\01`, `\\02`, `\\377`) are a deprecated feature in JavaScript that can lead to confusion and are forbidden in strict mode and template literals.",
+                "They are less readable than their modern alternatives and can cause portability issues.",
+            ],
+            suggestions: [
+                "Use hexadecimal escape sequences (e.g., `\\x01`) or Unicode escape sequences (e.g., `\\u0001`) instead.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkNode(node) {
+            const text = node.getText(context.sourceFile);
+            const octalEscape = findOctalEscape(text);
+            if (!octalEscape) {
+                return;
+            }
+            const nodeStart = node.getStart(context.sourceFile);
+            context.report({
+                message: "noOctalEscape",
+                range: {
+                    begin: nodeStart + octalEscape.index,
+                    end: nodeStart + octalEscape.index + octalEscape.length,
+                },
+            });
+        }
+        return {
+            visitors: {
+                NoSubstitutionTemplateLiteral: checkNode,
+                StringLiteral: checkNode,
+                TemplateExpression: (node) => {
+                    // Check the head of the template
+                    checkNode(node.head);
+                    // Check each template span
+                    for (const span of node.templateSpans) {
+                        checkNode(span.literal);
+                    }
+                },
+            },
+        };
+    },
+});

package/lib/rules/octalEscapes.test.d.ts

@@ -0,0 +1 @@
+export {};

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.1",
+  "version": "0.14.2",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "repository": {
     "type": "git",

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/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: "",
+							},
+						],
+					});
+				},
+			},
+		};
+	},
+});