@flint.fyi/ts 0.14.3 → 0.14.4

package/src/rules/selfComparisons.test.ts

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

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

package/src/rules/sequences.test.ts

@@ -0,0 +1,49 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./sequences.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const a = (1, 2);
+`,
+			snapshot: `
+const a = (1, 2);
+            ~
+            The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
+`,
+		},
+		{
+			code: `
+function f() {
+    return (g(), h());
+}
+`,
+			snapshot: `
+function f() {
+    return (g(), h());
+               ~
+               The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
+}
+`,
+		},
+		{
+			code: `
+for ((a = 1, b = 2); ; ) {
+}
+`,
+			snapshot: `
+for ((a = 1, b = 2); ; ) {
+           ~
+           The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
+}
+`,
+		},
+	],
+	valid: [
+		`const a = [1, 2];`,
+		`const a = (1 + 2);`,
+		`function f() { g(); h(); }`,
+		`for (let i = 0; i < 10; i += 1) {}`,
+	],
+});

package/src/rules/sequences.ts

@@ -0,0 +1,37 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using the comma operator in expressions.",
+		id: "sequences",
+		preset: "untyped",
+	},
+	messages: {
+		noSequences: {
+			primary:
+				'The "sequence" (comma) operator is often confusing and a sign of mistaken logic.',
+			secondary: [
+				"The comma operator can make code harder to read and may hide side effects.",
+				"Prefer separate expressions instead of using a single sequence.",
+			],
+			suggestions: ["Split the expression into separate statements."],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (node.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+						context.report({
+							message: "noSequences",
+							range: getTSNodeRange(node.operatorToken, context.sourceFile),
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/typeofComparisons.test.ts

@@ -0,0 +1,86 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./typeofComparisons.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+if (typeof value === "") {
+    process();
+}
+`,
+			snapshot: `
+if (typeof value === "") {
+                     ~~
+                     This string literal is not one that the typeof operator will ever produce.
+    process();
+}
+`,
+		},
+		{
+			code: `
+if (typeof data != "invalid") {
+    reject();
+}
+`,
+			snapshot: `
+if (typeof data != "invalid") {
+                   ~~~~~~~~~
+                   This string literal is not one that the typeof operator will ever produce.
+    reject();
+}
+`,
+		},
+		{
+			code: `
+if ("invalid" === typeof flag) {
+    toggle();
+}
+`,
+			snapshot: `
+if ("invalid" === typeof flag) {
+    ~~~~~~~~~
+    This string literal is not one that the typeof operator will ever produce.
+    toggle();
+}
+`,
+		},
+		{
+			code: `
+if (typeof value === "String") {
+    process();
+}
+`,
+			snapshot: `
+if (typeof value === "String") {
+                     ~~~~~~~~
+                     This string literal is not one that the typeof operator will ever produce.
+    process();
+}
+`,
+		},
+		{
+			code: `
+const isValid = typeof input !== "array";
+`,
+			snapshot: `
+const isValid = typeof input !== "array";
+                                 ~~~~~~~
+                                 This string literal is not one that the typeof operator will ever produce.
+`,
+		},
+	],
+	valid: [
+		`if (typeof value === "string") { process(); }`,
+		`if (typeof variable == "undefined") { handle(); }`,
+		`if (typeof data != "number") { reject(); }`,
+		`if (typeof callback !== "function") { throw new Error("Invalid callback"); }`,
+		`if (typeof flag === "boolean") { toggle(); }`,
+		`if (typeof value === "object") { parse(); }`,
+		`if (typeof value === "symbol") { handle(); }`,
+		`if (typeof value === "bigint") { compute(); }`,
+		`if (typeof value === other) { process(); }`,
+		`if (typeof value === typeof other) { compare(); }`,
+		`const type = typeof value;`,
+	],
+});

package/src/rules/typeofComparisons.ts

@@ -0,0 +1,88 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+const validTypeofValues = new Set([
+	"bigint",
+	"boolean",
+	"function",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined",
+]);
+
+// TODO: Reuse a shared getStaticValue-style utility?
+function getStringValue(node: ts.Expression) {
+	return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+		? node.text
+		: undefined;
+}
+
+function getTypeofOperand(node: ts.Expression) {
+	return ts.isTypeOfExpression(node) && node.expression;
+}
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports typeof expressions that compare impossible string literals.",
+		id: "typeofComparisons",
+		preset: "untyped",
+	},
+	messages: {
+		invalidValue: {
+			primary:
+				"This string literal is not one that the typeof operator will ever produce.",
+			secondary: [
+				"The typeof operator returns one of a specific set of string values.",
+				"Comparing typeof to an invalid string is usually a typo and will never match.",
+				'The only valid values are: "bigint", "boolean", "function", "number", "object", "string", "symbol", and "undefined".',
+			],
+			suggestions: [
+				"Check for typos and use one of the valid typeof return values.",
+			],
+		},
+	},
+	setup(context) {
+		function checkComparison(node: ts.BinaryExpression) {
+			const leftTypeofOperand = getTypeofOperand(node.left);
+			const rightTypeofOperand = getTypeofOperand(node.right);
+
+			let comparisonValue: ts.Expression | undefined;
+			if (leftTypeofOperand) {
+				comparisonValue = node.right;
+			} else if (rightTypeofOperand) {
+				comparisonValue = node.left;
+			} else {
+				return;
+			}
+
+			const stringValue = getStringValue(comparisonValue);
+			if (stringValue != null && !validTypeofValues.has(stringValue)) {
+				context.report({
+					message: "invalidValue",
+					range: getTSNodeRange(comparisonValue, context.sourceFile),
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (
+						node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
+						node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+						node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
+						node.operatorToken.kind ===
+							ts.SyntaxKind.ExclamationEqualsEqualsToken
+					) {
+						checkComparison(node);
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/utils/discriminateAnyType.ts

@@ -0,0 +1,66 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+export enum AnyType {
+	Any,
+	PromiseAny,
+	AnyArray,
+	Safe,
+}
+
+/**
+ * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise<any>`,
+ * otherwise it returns `AnyType.Safe`.
+ */
+export function discriminateAnyType(
+	type: ts.Type,
+	checker: ts.TypeChecker,
+	program: ts.Program,
+	tsNode: ts.Node,
+): AnyType {
+	return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set());
+}
+
+function discriminateAnyTypeWorker(
+	type: ts.Type,
+	checker: ts.TypeChecker,
+	program: ts.Program,
+	tsNode: ts.Node,
+	visited: Set<ts.Type>,
+) {
+	if (visited.has(type)) {
+		return AnyType.Safe;
+	}
+	visited.add(type);
+	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
+		return AnyType.Any;
+	}
+	if (
+		checker.isArrayType(type) &&
+		tsutils.isTypeFlagSet(
+			checker.getTypeArguments(type as ts.TypeReference)[0],
+			ts.TypeFlags.Any,
+		)
+	) {
+		return AnyType.AnyArray;
+	}
+	for (const part of tsutils.typeConstituents(type)) {
+		if (tsutils.isThenableType(checker, tsNode, part)) {
+			const awaitedType = checker.getAwaitedType(part);
+			if (awaitedType) {
+				const awaitedAnyType = discriminateAnyTypeWorker(
+					awaitedType,
+					checker,
+					program,
+					tsNode,
+					visited,
+				);
+				if (awaitedAnyType === AnyType.Any) {
+					return AnyType.PromiseAny;
+				}
+			}
+		}
+	}
+
+	return AnyType.Safe;
+}

package/src/rules/utils/getThisExpression.ts

@@ -0,0 +1,24 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+export function getThisExpression(node: ts.Node): null | ts.ThisExpression {
+	while (true) {
+		node = skipParentheses(node);
+		if (ts.isCallExpression(node) || tsutils.isAccessExpression(node)) {
+			node = node.expression;
+		} else if (tsutils.isThisExpression(node)) {
+			return node;
+		} else {
+			break;
+		}
+	}
+
+	return null;
+}
+
+function skipParentheses(node: ts.Node): ts.Node {
+	while (ts.isParenthesizedExpression(node)) {
+		node = node.expression;
+	}
+	return node;
+}