@flint.fyi/ts 0.14.2 → 0.14.4

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

package/src/rules/returnAssignments.test.ts

@@ -0,0 +1,186 @@
+import rule from "./returnAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+function getValue() {
+    let value;
+    return value = 1;
+}
+`,
+			snapshot: `
+function getValue() {
+    let value;
+    return value = 1;
+                 ~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function process() {
+    let result;
+    return result = calculate();
+}
+`,
+			snapshot: `
+function process() {
+    let result;
+    return result = calculate();
+                  ~
+                  Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function update() {
+    let status;
+    return (status = "updated");
+}
+`,
+			snapshot: `
+function update() {
+    let status;
+    return (status = "updated");
+                   ~
+                   Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+const arrow = () => {
+    let value;
+    return value = 42;
+};
+`,
+			snapshot: `
+const arrow = () => {
+    let value;
+    return value = 42;
+                 ~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+};
+`,
+		},
+		{
+			code: `
+const arrowImplicit = () => (value = 100);
+`,
+			snapshot: `
+const arrowImplicit = () => (value = 100);
+                                   ~
+                                   Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+`,
+		},
+		{
+			code: `
+function multiply(factor: number) {
+    let result;
+    return result = factor * 2;
+}
+`,
+			snapshot: `
+function multiply(factor: number) {
+    let result;
+    return result = factor * 2;
+                  ~
+                  Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function compound() {
+    let count;
+    return count += 5;
+}
+`,
+			snapshot: `
+function compound() {
+    let count;
+    return count += 5;
+                 ~~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function bitwise() {
+    let flags;
+    return flags |= 0x01;
+}
+`,
+			snapshot: `
+function bitwise() {
+    let flags;
+    return flags |= 0x01;
+                 ~~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+	],
+	valid: [
+		`function getValue() { return 1; }`,
+		`function getValue() { let value = 1; return value; }`,
+		`function process() { const result = calculate(); return result; }`,
+		`const arrow = () => { let value = 42; return value; };`,
+		`const arrowImplicit = () => getValue();`,
+		`
+function update() {
+    let status = "updated";
+    return status;
+}
+`,
+		`
+function multiply(factor: number) {
+    let result = factor * 2;
+    return result;
+}
+`,
+		`
+function compound() {
+    let count = 0;
+    count += 5;
+    return count;
+}
+`,
+		`
+function calculate() {
+    const value = 10;
+    return value;
+}
+`,
+		`
+const process = (input: number) => {
+    const result = input * 2;
+    return result;
+};
+`,
+		`
+class MyClass {
+    method() {
+        const value = 42;
+        return value;
+    }
+}
+`,
+		`
+function compare(a: number, b: number) {
+    return a === b;
+}
+`,
+		`
+function arrowReturn() {
+    const fn = () => 42;
+    return fn;
+}
+`,
+	],
+});

package/src/rules/returnAssignments.ts

@@ -0,0 +1,57 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using assignment expressions in return statements.",
+		id: "returnAssignments",
+		preset: "stylistic",
+	},
+	messages: {
+		noReturnAssign: {
+			primary:
+				"Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.",
+			secondary: [
+				"Using assignments in return statements can make code harder to read and can lead to confusion about whether the assignment or the returned value is the primary intent.",
+				"Assignment expressions return the assigned value, but mixing assignment with return makes the control flow less clear.",
+			],
+			suggestions: [
+				"Perform the assignment on a separate line before the return statement.",
+			],
+		},
+	},
+	setup(context) {
+		function checkForAssignment(node: ts.Expression): void {
+			const unwrapped = unwrapParenthesizedExpression(node);
+
+			if (
+				ts.isBinaryExpression(unwrapped) &&
+				tsutils.isAssignmentKind(unwrapped.operatorToken.kind)
+			) {
+				context.report({
+					message: "noReturnAssign",
+					range: getTSNodeRange(unwrapped.operatorToken, context.sourceFile),
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				ArrowFunction: (node) => {
+					if (!ts.isBlock(node.body)) {
+						checkForAssignment(node.body);
+					}
+				},
+				ReturnStatement: (node) => {
+					if (node.expression) {
+						checkForAssignment(node.expression);
+					}
+				},
+			},
+		};
+	},
+});

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),
+						});
+					}
+				},
+			},
+		};
+	},
+});