@flint.fyi/ts 0.14.1 → 0.14.3

package/src/rules/octalEscapes.test.ts

@@ -0,0 +1,214 @@
+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/src/rules/octalEscapes.ts

@@ -0,0 +1,85 @@
+import * as ts from "typescript";
+
+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: string,
+): undefined | { index: number; length: number } {
+	// 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: ts.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/src/rules/octalNumbers.test.ts

@@ -0,0 +1,246 @@
+import rule from "./octalNumbers.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const value = 07;
+`,
+			snapshot: `
+const value = 07;
+              ~~
+              This legacy octal numeric literal evaluates to 7. Did you mean that value, or to use a modern octal syntax such as 0o7?
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const value = 0o7;
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const value = 7;
+`,
+				},
+			],
+		},
+		{
+			code: `
+const value = 077;
+`,
+			snapshot: `
+const value = 077;
+              ~~~
+              This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const value = 0o77;
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const value = 77;
+`,
+				},
+			],
+		},
+		{
+			code: `
+const value = 0123;
+`,
+			snapshot: `
+const value = 0123;
+              ~~~~
+              This legacy octal numeric literal evaluates to 83. Did you mean that value, or to use a modern octal syntax such as 0o123?
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const value = 0o123;
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const value = 123;
+`,
+				},
+			],
+		},
+		{
+			code: `
+const value = 01234567;
+`,
+			snapshot: `
+const value = 01234567;
+              ~~~~~~~~
+              This legacy octal numeric literal evaluates to 342391. Did you mean that value, or to use a modern octal syntax such as 0o1234567?
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const value = 0o1234567;
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const value = 1234567;
+`,
+				},
+			],
+		},
+		{
+			code: `
+const values = [01, 02, 03];
+`,
+			snapshot: `
+const values = [01, 02, 03];
+                ~~
+                This legacy octal numeric literal evaluates to 1. Did you mean that value, or to use a modern octal syntax such as 0o1?
+                    ~~
+                    This legacy octal numeric literal evaluates to 2. Did you mean that value, or to use a modern octal syntax such as 0o2?
+                        ~~
+                        This legacy octal numeric literal evaluates to 3. Did you mean that value, or to use a modern octal syntax such as 0o3?
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const values = [0o1, 02, 03];
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const values = [1, 02, 03];
+`,
+				},
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const values = [01, 0o2, 03];
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const values = [01, 2, 03];
+`,
+				},
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const values = [01, 02, 0o3];
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const values = [01, 02, 3];
+`,
+				},
+			],
+		},
+		{
+			code: `
+function calculate() {
+	return 077;
+}
+`,
+			snapshot: `
+function calculate() {
+	return 077;
+        ~~~
+        This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
+}
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+function calculate() {
+	return 0o77;
+}
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+function calculate() {
+	return 77;
+}
+`,
+				},
+			],
+		},
+		{
+			code: `
+const result = 010 + 020;
+`,
+			snapshot: `
+const result = 010 + 020;
+               ~~~
+               This legacy octal numeric literal evaluates to 8. Did you mean that value, or to use a modern octal syntax such as 0o10?
+                     ~~~
+                     This legacy octal numeric literal evaluates to 16. Did you mean that value, or to use a modern octal syntax such as 0o20?
+`,
+			suggestions: [
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const result = 0o10 + 020;
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const result = 10 + 020;
+`,
+				},
+				{
+					id: "useModernOctalSyntax",
+					updated: `
+const result = 010 + 0o20;
+`,
+				},
+				{
+					id: "removeLeadingZero",
+					updated: `
+const result = 010 + 20;
+`,
+				},
+			],
+		},
+	],
+	valid: [
+		`const value = 0;`,
+		`const value = 1;`,
+		`const value = 10;`,
+		`const value = 100;`,
+		`const value = 0x7F;`,
+		`const value = 0o77;`,
+		`const value = 0O77;`,
+		`const value = 0b111;`,
+		`const value = 0B111;`,
+		`const value = 0.8;`,
+		`const value = 8;`,
+		`const value = 9;`,
+		`const value = 123;`,
+		`const values = [0, 1, 10, 100];`,
+		`const hex = 0xFF;`,
+		`const binary = 0b1010;`,
+		`const octal = 0o755;`,
+		`const notOctal = 08;`,
+		`const alsoNotOctal = 09;`,
+	],
+});

package/src/rules/octalNumbers.ts

@@ -0,0 +1,75 @@
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using legacy octal numeric literals.",
+		id: "octalNumbers",
+		preset: "untyped",
+	},
+	messages: {
+		noOctalNumber: {
+			primary:
+				"This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
+			secondary: [
+				"Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
+				"They are forbidden in strict mode and are less readable than their modern alternatives.",
+				"The digit `0` by itself is allowed as it represents zero, not an octal literal.",
+			],
+			suggestions: [
+				"Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.",
+				"Remove the leading `0` if you intended to use the decimal value.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				NumericLiteral: (node) => {
+					const text = node.getText(context.sourceFile);
+
+					// Check for legacy octal literal: starts with 0 followed by octal digits (0-7)
+					// But not just "0" alone, and not modern formats like 0x, 0o, 0b
+					// cspell:ignore xobi
+					if (
+						text.length > 1 &&
+						text.startsWith("0") &&
+						text[1] >= "0" &&
+						text[1] <= "7" &&
+						!/^0[xobi]/i.test(text)
+					) {
+						const range = {
+							begin: node.getStart(context.sourceFile),
+							end: node.getEnd(),
+						};
+
+						// Parse the octal value
+						const octalValue = parseInt(text, 8);
+						const modernOctalSyntax = `0o${text.slice(1)}`;
+						const decimalWithoutLeadingZero = text.slice(1);
+
+						context.report({
+							data: {
+								equivalent: modernOctalSyntax,
+								raw: octalValue.toString(),
+							},
+							message: "noOctalNumber",
+							range,
+							suggestions: [
+								{
+									id: "useModernOctalSyntax",
+									range,
+									text: modernOctalSyntax,
+								},
+								{
+									id: "removeLeadingZero",
+									range,
+									text: decimalWithoutLeadingZero,
+								},
+							],
+						});
+					}
+				},
+			},
+		};
+	},
+});