@flint.fyi/ts 0.14.3 → 0.14.4

package/src/rules/negativeZeroComparisons.ts

@@ -1,30 +1,11 @@
 import * as ts from "typescript";
 
 import { typescriptLanguage } from "../language.js";
-
-const comparisonOperators = new Set([
-	ts.SyntaxKind.EqualsEqualsEqualsToken,
-	ts.SyntaxKind.EqualsEqualsToken,
-	ts.SyntaxKind.ExclamationEqualsEqualsToken,
-	ts.SyntaxKind.ExclamationEqualsToken,
-	ts.SyntaxKind.GreaterThanEqualsToken,
-	ts.SyntaxKind.GreaterThanToken,
-	ts.SyntaxKind.LessThanEqualsToken,
-	ts.SyntaxKind.LessThanToken,
-]);
-
-function isEqualityOperator(operator: string) {
-	return (
-		operator === "===" ||
-		operator === "==" ||
-		operator === "!==" ||
-		operator === "!="
-	);
-}
-
-function isNegatedEqualityOperator(operator: string) {
-	return operator === "!==" || operator === "!=";
-}
+import {
+	isComparisonOperator,
+	isEqualityOperator,
+	isNegatedEqualityOperator,
+} from "./utils/operators.js";
 
 function isNegativeZero(node: ts.Node): boolean {
 	return (
@@ -68,7 +49,7 @@ export default typescriptLanguage.createRule({
 			visitors: {
 				BinaryExpression: (node) => {
 					if (
-						!comparisonOperators.has(node.operatorToken.kind) ||
+						!isComparisonOperator(node.operatorToken) ||
 						(!isNegativeZero(node.left) && !isNegativeZero(node.right))
 					) {
 						return;
@@ -86,14 +67,14 @@ export default typescriptLanguage.createRule({
 						},
 						message: "unexpectedNegativeZeroComparison",
 						range,
-						suggestions: isEqualityOperator(operator)
+						suggestions: isEqualityOperator(node.operatorToken)
 							? [
 									{
 										id: "useObjectIs",
 										range,
 										text: generateObjectIsText(
 											node,
-											isNegatedEqualityOperator(operator),
+											isNegatedEqualityOperator(node.operatorToken),
 										),
 									},
 								]

package/src/rules/nonOctalDecimalEscapes.test.ts

@@ -0,0 +1,70 @@
+import rule from "./nonOctalDecimalEscapes.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+"\\8"
+`,
+			snapshot: `
+"\\8"
+ ~~
+ Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+		},
+		{
+			code: `
+"\\9"
+`,
+			snapshot: `
+"\\9"
+ ~~
+ Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+		},
+		{
+			code: `
+"w\\8less"
+`,
+			snapshot: `
+"w\\8less"
+  ~~
+  Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+		},
+		{
+			code: `
+"December 1\\9"
+`,
+			snapshot: `
+"December 1\\9"
+           ~~
+           Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+		},
+		{
+			code: `
+"Don't use \\8 and \\9 escapes."
+`,
+			snapshot: `
+"Don't use \\8 and \\9 escapes."
+           ~~
+           Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+                  ~~
+                  Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+		},
+		{
+			code: `
+"\\0\\8"
+`,
+			snapshot: `
+"\\0\\8"
+   ~~
+   Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+		},
+	],
+	valid: ['"8"', '"9"', '"w8less"', '"December 19"', '"\\\\8"', '"\\0\\u0038"'],
+});

package/src/rules/nonOctalDecimalEscapes.ts

@@ -0,0 +1,70 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+const nonOctalDecimalEscapePattern = /\\[89]/g;
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
+		id: "nonOctalDecimalEscapes",
+		preset: "logical",
+	},
+	messages: {
+		unexpectedEscape: {
+			primary:
+				"Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.",
+			secondary: [
+				"Non-octal decimal escape sequences \\8 and \\9 are legacy features that are treated as identity escapes (the same as the literal digits).",
+				"They are optional in the ECMAScript specification and not supported in strict mode in all environments.",
+				"Use the literal digits directly instead.",
+			],
+			suggestions: [
+				"Remove the backslash to use the literal digit.",
+				"If an escape sequence is needed, use a Unicode escape like \\u0038 or \\u0039.",
+			],
+		},
+	},
+	setup(context) {
+		function checkNode(
+			node: ts.NoSubstitutionTemplateLiteral | ts.StringLiteral,
+		) {
+			const text = node.getText(context.sourceFile);
+			const matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
+
+			for (const match of matches) {
+				// Ignore escapes where the backslash itself is escaped (e.g. "\\\\8" -> literal "\\8").
+				// Count the number of consecutive backslashes immediately before the match.
+				const matchIndex = match.index;
+				let backslashesBefore = 0;
+				for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) {
+					backslashesBefore++;
+				}
+
+				// If there is an odd number of backslashes before this one, the backslash is escaped
+				// and should not be treated as an escape sequence.
+				if (backslashesBefore % 2 === 1) {
+					continue;
+				}
+
+				const start = node.getStart(context.sourceFile) + matchIndex;
+
+				context.report({
+					message: "unexpectedEscape",
+					range: {
+						begin: start,
+						end: start + match[0].length,
+					},
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				NoSubstitutionTemplateLiteral: checkNode,
+				StringLiteral: checkNode,
+			},
+		};
+	},
+});

package/src/rules/numericLiteralParsing.test.ts

@@ -0,0 +1,100 @@
+import rule from "./numericLiteralParsing.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const binary = parseInt("111110111", 2);
+`,
+			snapshot: `
+const binary = parseInt("111110111", 2);
+               ~~~~~~~~~~~~~~~~~~~~~~~~
+               Use 0b111110111 instead of parseInt with radix 2.
+`,
+		},
+		{
+			code: `
+const octal = parseInt("767", 8);
+`,
+			snapshot: `
+const octal = parseInt("767", 8);
+              ~~~~~~~~~~~~~~~~~~
+              Use 0o767 instead of parseInt with radix 8.
+`,
+		},
+		{
+			code: `
+const hex = parseInt("1F7", 16);
+`,
+			snapshot: `
+const hex = parseInt("1F7", 16);
+            ~~~~~~~~~~~~~~~~~~~
+            Use 0x1F7 instead of parseInt with radix 16.
+`,
+		},
+		{
+			code: `
+const value = Number.parseInt("111110111", 2);
+`,
+			snapshot: `
+const value = Number.parseInt("111110111", 2);
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+              Use 0b111110111 instead of parseInt with radix 2.
+`,
+		},
+		{
+			code: `
+const result = Number.parseInt("767", 8);
+`,
+			snapshot: `
+const result = Number.parseInt("767", 8);
+               ~~~~~~~~~~~~~~~~~~~~~~~~~
+               Use 0o767 instead of parseInt with radix 8.
+`,
+		},
+		{
+			code: `
+const num = Number.parseInt("1F7", 16);
+`,
+			snapshot: `
+const num = Number.parseInt("1F7", 16);
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~
+            Use 0x1F7 instead of parseInt with radix 16.
+`,
+		},
+		{
+			code: `
+const value = parseInt(\`111110111\`, 2);
+`,
+			snapshot: `
+const value = parseInt(\`111110111\`, 2);
+              ~~~~~~~~~~~~~~~~~~~~~~~~
+              Use 0b111110111 instead of parseInt with radix 2.
+`,
+		},
+	],
+	valid: [
+		`const decimal = parseInt("123");`,
+		`const value = parseInt("123", 10);`,
+		`const ternary = parseInt("102", 3);`,
+		`const binary = 0b111110111;`,
+		`const octal = 0o767;`,
+		`const hex = 0x1F7;`,
+		`const dynamic = parseInt(value, 2);`,
+		`const variable = parseInt("111", radix);`,
+		`const single = parseInt("111");`,
+		`Number.parseInt("123");`,
+		`Number.parseInt("123", 10);`,
+		`
+			function parseInt(...values: unknown[]) {}
+			parseInt("1", 2);
+			export {};
+		`,
+		`
+			const Number = { parseInt(...values: unknown[]) {} };
+			Number.parseInt("1", 2);
+			export {};
+		`,
+	],
+});

package/src/rules/numericLiteralParsing.ts

@@ -0,0 +1,116 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+
+function convertToLiteral(value: string, radix: number): string {
+	const parsed = Number.parseInt(value, radix);
+	if (Number.isNaN(parsed)) {
+		return value;
+	}
+
+	switch (radix) {
+		case 2:
+			return `0b${parsed.toString(2)}`;
+		case 8:
+			return `0o${parsed.toString(8)}`;
+		case 16:
+			return `0x${parsed.toString(16).toUpperCase()}`;
+		default:
+			return value;
+	}
+}
+
+function getRadixValue(node: ts.Expression): number | undefined {
+	if (!ts.isNumericLiteral(node)) {
+		return undefined;
+	}
+
+	const value = Number(node.text);
+	if (![2, 8, 16].includes(value)) {
+		return undefined;
+	}
+
+	return value;
+}
+
+// TODO: Use a util like getStaticValue
+function getStringValue(node: ts.Expression): string | undefined {
+	return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+		? node.text
+		: undefined;
+}
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
+		id: "numericLiteralParsing",
+		preset: "stylistic",
+	},
+	messages: {
+		preferLiteral: {
+			primary: "Use {{ literal }} instead of parseInt with radix {{ radix }}.",
+			secondary: [
+				"Binary, octal, and hexadecimal numeric literals are more readable and direct than using parseInt with a radix.",
+				"Numeric literals are supported natively and don't require function calls.",
+			],
+			suggestions: ["Replace the parseInt call with the numeric literal."],
+		},
+	},
+	setup(context) {
+		function checkParseIntCall(node: ts.CallExpression) {
+			if (node.arguments.length !== 2) {
+				return;
+			}
+
+			const stringValue = getStringValue(node.arguments[0]);
+			if (!stringValue) {
+				return;
+			}
+
+			const radixValue = getRadixValue(node.arguments[1]);
+			if (!radixValue) {
+				return;
+			}
+
+			context.report({
+				data: {
+					literal: convertToLiteral(stringValue, radixValue),
+					radix: String(radixValue),
+				},
+				message: "preferLiteral",
+				range: getTSNodeRange(node, context.sourceFile),
+			});
+		}
+
+		return {
+			visitors: {
+				CallExpression: (node) => {
+					if (ts.isIdentifier(node.expression)) {
+						if (
+							node.expression.text === "parseInt" &&
+							isGlobalDeclaration(node.expression, context.typeChecker)
+						) {
+							checkParseIntCall(node);
+						}
+					} else if (ts.isPropertyAccessExpression(node.expression)) {
+						if (
+							ts.isIdentifier(node.expression.expression) &&
+							node.expression.expression.text === "Number" &&
+							ts.isIdentifier(node.expression.name) &&
+							node.expression.name.text === "parseInt" &&
+							isGlobalDeclaration(
+								node.expression.expression,
+								context.typeChecker,
+							)
+						) {
+							checkParseIntCall(node);
+						}
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/selfAssignments.test.ts

@@ -0,0 +1,67 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./selfAssignments.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+value = value;
+`,
+			snapshot: `
+value = value;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+		},
+		{
+			code: `
+count &&= count;
+`,
+			snapshot: `
+count &&= count;
+~~~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+		},
+		{
+			code: `
+flag ||= flag;
+`,
+			snapshot: `
+flag ||= flag;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+		},
+		{
+			code: `
+data ??= data;
+`,
+			snapshot: `
+data ??= data;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+		},
+		{
+			code: `
+a.b ??= a.b;
+`,
+			snapshot: `
+a.b ??= a.b;
+~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+		},
+	],
+	valid: [
+		`value = other;`,
+		`first = second;`,
+		`let value = value;`,
+		`const data = data;`,
+		`value += value;`,
+		`count -= count;`,
+		`a ||= b;`,
+		`a.b ||= a.c;`,
+	],
+});

package/src/rules/selfAssignments.ts

@@ -0,0 +1,50 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports self-assignments which have no effect and are likely errors.",
+		id: "selfAssignments",
+		preset: "logical",
+	},
+	messages: {
+		selfAssignment: {
+			primary: "This value is being assigned to itself, which does nothing.",
+			secondary: [
+				"Self-assignments have no effect and typically indicate an incomplete refactoring or copy-paste error.",
+			],
+			suggestions: [
+				"Review the assignment and ensure you're assigning the correct value.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (
+						node.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
+						node.operatorToken.kind !==
+							ts.SyntaxKind.AmpersandAmpersandEqualsToken &&
+						node.operatorToken.kind !== ts.SyntaxKind.BarBarEqualsToken &&
+						node.operatorToken.kind !==
+							ts.SyntaxKind.QuestionQuestionEqualsToken
+					) {
+						return;
+					}
+
+					if (hasSameTokens(node.left, node.right, context.sourceFile)) {
+						context.report({
+							message: "selfAssignment",
+							range: getTSNodeRange(node, context.sourceFile),
+						});
+					}
+				},
+			},
+		};
+	},
+});