@flint.fyi/ts 0.14.6 → 0.18.0

package/src/rules/returnAssignments.test.ts

@@ -1,186 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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/ruleTester.ts

@@ -1,4 +0,0 @@
-import { RuleTester } from "@flint.fyi/rule-tester";
-import { describe, it } from "vitest";
-
-export const ruleTester = new RuleTester({ describe, it });

package/src/rules/selfAssignments.test.ts

@@ -1,67 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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),
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/selfComparisons.test.ts

@@ -1,298 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./selfComparisons.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-if (value === value) {
-	console.log("always true");
-}
-`,
-			snapshot: `
-if (value === value) {
-    ~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-		},
-		{
-			code: `
-if (value == value) {
-	console.log("always true");
-}
-`,
-			snapshot: `
-if (value == value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-		},
-		{
-			code: `
-if (value !== value) {
-	console.log("always false");
-}
-`,
-			snapshot: `
-if (value !== value) {
-    ~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-		},
-		{
-			code: `
-if (value != value) {
-	console.log("always false");
-}
-`,
-			snapshot: `
-if (value != value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-		},
-		{
-			code: `
-if (value < value) {
-	console.log("always false");
-}
-`,
-			snapshot: `
-if (value < value) {
-    ~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-		},
-		{
-			code: `
-if (value <= value) {
-	console.log("always true");
-}
-`,
-			snapshot: `
-if (value <= value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-		},
-		{
-			code: `
-if (value > value) {
-	console.log("always false");
-}
-`,
-			snapshot: `
-if (value > value) {
-    ~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always false");
-}
-`,
-		},
-		{
-			code: `
-if (value >= value) {
-	console.log("always true");
-}
-`,
-			snapshot: `
-if (value >= value) {
-    ~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("always true");
-}
-`,
-		},
-		{
-			code: `
-const result = object.property === object.property;
-`,
-			snapshot: `
-const result = object.property === object.property;
-               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-               Comparing a value to itself is unnecessary and likely indicates a logic error.
-`,
-		},
-		{
-			code: `
-const result = array[0] === array[0];
-`,
-			snapshot: `
-const result = array[0] === array[0];
-               ~~~~~~~~~~~~~~~~~~~~~
-               Comparing a value to itself is unnecessary and likely indicates a logic error.
-`,
-		},
-		{
-			code: `
-if (calculate() === calculate()) {
-	console.log("functions");
-}
-`,
-			snapshot: `
-if (calculate() === calculate()) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("functions");
-}
-`,
-		},
-		{
-			code: `
-if (value /* comment */ === value) {
-	console.log("with comment");
-}
-`,
-			snapshot: `
-if (value /* comment */ === value) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("with comment");
-}
-`,
-		},
-		{
-			code: `
-if (object.property /* comment */ === object.property) {
-	console.log("with comment in property access");
-}
-`,
-			snapshot: `
-if (object.property /* comment */ === object.property) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("with comment in property access");
-}
-`,
-		},
-		{
-			code: `
-if (array /* comment */ [0] === array[0]) {
-	console.log("with comment in array access");
-}
-`,
-			snapshot: `
-if (array /* comment */ [0] === array[0]) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("with comment in array access");
-}
-`,
-		},
-		{
-			code: `
-if (value === value /* comment */) {
-	console.log("comment on right side");
-}
-`,
-			snapshot: `
-if (value === value /* comment */) {
-    ~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comment on right side");
-}
-`,
-		},
-		{
-			code: `
-if (value /* left */ === value /* right */) {
-	console.log("comments on both sides");
-}
-`,
-			snapshot: `
-if (value /* left */ === value /* right */) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comments on both sides");
-}
-`,
-		},
-		{
-			code: `
-if (object.property === object /* comment */ .property) {
-	console.log("comment on right property access");
-}
-`,
-			snapshot: `
-if (object.property === object /* comment */ .property) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comment on right property access");
-}
-`,
-		},
-		{
-			code: `
-if (array[0] === array /* comment */ [0]) {
-	console.log("comment on right array access");
-}
-`,
-			snapshot: `
-if (array[0] === array /* comment */ [0]) {
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comment on right array access");
-}
-`,
-		},
-		{
-			code: `
-if (/* before */ value === value /* after */) {
-	console.log("comments before and after");
-}
-`,
-			snapshot: `
-if (/* before */ value === value /* after */) {
-                 ~~~~~~~~~~~~~~~
-                 Comparing a value to itself is unnecessary and likely indicates a logic error.
-	console.log("comments before and after");
-}
-`,
-		},
-		{
-			code: `
-const result = value /* a */ /* b */ === value /* c */ /* d */;
-`,
-			snapshot: `
-const result = value /* a */ /* b */ === value /* c */ /* d */;
-               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-               Comparing a value to itself is unnecessary and likely indicates a logic error.
-`,
-		},
-	],
-	valid: [
-		`if (value1 === value2) { console.log("different values"); }`,
-		`if (value === other) { console.log("different values"); }`,
-		`if (object.property === object.otherProperty) { console.log("different properties"); }`,
-		`if (array[0] === array[1]) { console.log("different elements"); }`,
-		`const result = value1 == value2;`,
-		`const result = value1 != value2;`,
-		`const result = value1 !== value2;`,
-		`const result = value1 < value2;`,
-		`const result = value1 <= value2;`,
-		`const result = value1 > value2;`,
-		`const result = value1 >= value2;`,
-		`if (Number.isNaN(value)) { console.log("checking for NaN correctly"); }`,
-		`if (value1 /* comment */ === value2) { console.log("different with comment on left"); }`,
-		`if (value1 === value2 /* comment */) { console.log("different with comment on right"); }`,
-		`if (value1 /* left */ === value2 /* right */) { console.log("different with comments on both"); }`,
-		`if (object /* comment */ .property === object.otherProperty) { console.log("different properties with comment"); }`,
-		`if (object.property === object /* comment */ .otherProperty) { console.log("different properties with comment on right"); }`,
-		`if (array /* comment */ [0] === array[1]) { console.log("different elements with comment on left"); }`,
-		`if (array[0] === array /* comment */ [1]) { console.log("different elements with comment on right"); }`,
-		`if (/* before */ value1 === value2 /* after */) { console.log("different with surrounding comments"); }`,
-		`const result = value1 /* a */ /* b */ === value2 /* c */ /* d */;`,
-	],
-});

package/src/rules/selfComparisons.ts

@@ -1,45 +0,0 @@
-import { typescriptLanguage } from "../language.js";
-import { hasSameTokens } from "../utils/hasSameTokens.js";
-import { isComparisonOperator } from "./utils/operators.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports comparing a value to itself.",
-		id: "selfComparisons",
-		preset: "logical",
-	},
-	messages: {
-		noSelfComparison: {
-			primary:
-				"Comparing a value to itself is unnecessary and likely indicates a logic error.",
-			secondary: [
-				"Self-comparisons always evaluate to the same result for a given operator.",
-				"This pattern often indicates a copy-paste error or typo where different variables were intended.",
-			],
-			suggestions: [
-				"Verify that you intended to compare two different values.",
-				"If checking for NaN, use `Number.isNaN()` or `isNaN()` instead.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					if (
-						isComparisonOperator(node.operatorToken) &&
-						hasSameTokens(node.left, node.right, context.sourceFile)
-					) {
-						context.report({
-							message: "noSelfComparison",
-							range: {
-								begin: node.getStart(context.sourceFile),
-								end: node.getEnd(),
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});