@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/negativeZeroComparisons.test.ts

@@ -0,0 +1,210 @@
+import rule from "./negativeZeroComparisons.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+if (value === -0) {}
+`,
+			snapshot: `
+if (value === -0) {}
+    ~~~~~~~~~~~~
+    Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+if (Object.is(value, -0)) {}
+`,
+				},
+			],
+		},
+		{
+			code: `
+if (-0 === value) {}
+`,
+			snapshot: `
+if (-0 === value) {}
+    ~~~~~~~~~~~~
+    Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+if (Object.is(-0, value)) {}
+`,
+				},
+			],
+		},
+		{
+			code: `
+if (value == -0) {}
+`,
+			snapshot: `
+if (value == -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using == do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+if (Object.is(value, -0)) {}
+`,
+				},
+			],
+		},
+		{
+			code: `
+if (value !== -0) {}
+`,
+			snapshot: `
+if (value !== -0) {}
+    ~~~~~~~~~~~~
+    Comparisons with -0 using !== do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+if (!Object.is(value, -0)) {}
+`,
+				},
+			],
+		},
+		{
+			code: `
+if (value != -0) {}
+`,
+			snapshot: `
+if (value != -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using != do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+if (!Object.is(value, -0)) {}
+`,
+				},
+			],
+		},
+		{
+			code: `
+if (value < -0) {}
+`,
+			snapshot: `
+if (value < -0) {}
+    ~~~~~~~~~~
+    Comparisons with -0 using < do not distinguish between -0 and +0.
+`,
+		},
+		{
+			code: `
+if (value <= -0) {}
+`,
+			snapshot: `
+if (value <= -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using <= do not distinguish between -0 and +0.
+`,
+		},
+		{
+			code: `
+if (value > -0) {}
+`,
+			snapshot: `
+if (value > -0) {}
+    ~~~~~~~~~~
+    Comparisons with -0 using > do not distinguish between -0 and +0.
+`,
+		},
+		{
+			code: `
+if (value >= -0) {}
+`,
+			snapshot: `
+if (value >= -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using >= do not distinguish between -0 and +0.
+`,
+		},
+		{
+			code: `
+const result = value === -0 ? "negative zero" : "other";
+`,
+			snapshot: `
+const result = value === -0 ? "negative zero" : "other";
+               ~~~~~~~~~~~~
+               Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+const result = Object.is(value, -0) ? "negative zero" : "other";
+`,
+				},
+			],
+		},
+		{
+			code: `
+while (value !== -0) {
+	value++;
+}
+`,
+			snapshot: `
+while (value !== -0) {
+       ~~~~~~~~~~~~
+       Comparisons with -0 using !== do not distinguish between -0 and +0.
+	value++;
+}
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+while (!Object.is(value, -0)) {
+	value++;
+}
+`,
+				},
+			],
+		},
+		{
+			code: `
+const isNegativeZero = value === -0;
+`,
+			snapshot: `
+const isNegativeZero = value === -0;
+                       ~~~~~~~~~~~~
+                       Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+			suggestions: [
+				{
+					id: "useObjectIs",
+					updated: `
+const isNegativeZero = Object.is(value, -0);
+`,
+				},
+			],
+		},
+	],
+	valid: [
+		`if (value === 0) {}`,
+		`if (value === -1) {}`,
+		`if (value === 1) {}`,
+		`if (Object.is(value, -0)) {}`,
+		`if (Object.is(-0, value)) {}`,
+		`const result = -0;`,
+		`const value = -0 + 1;`,
+		`const value = -0 * 2;`,
+		`const value = Math.abs(-0);`,
+		`const value = [-0, 0, 1];`,
+		`function test() { return -0; }`,
+	],
+});

package/src/rules/negativeZeroComparisons.ts

@@ -0,0 +1,87 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import {
+	isComparisonOperator,
+	isEqualityOperator,
+	isNegatedEqualityOperator,
+} from "./utils/operators.js";
+
+function isNegativeZero(node: ts.Node): boolean {
+	return (
+		ts.isPrefixUnaryExpression(node) &&
+		node.operator === ts.SyntaxKind.MinusToken &&
+		ts.isNumericLiteral(node.operand) &&
+		node.operand.text === "0"
+	);
+}
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports comparisons with -0 that may not behave as expected.",
+		id: "negativeZeroComparisons",
+		preset: "logical",
+	},
+	messages: {
+		unexpectedNegativeZeroComparison: {
+			primary:
+				"Comparisons with -0 using {{ operator }} do not distinguish between -0 and +0.",
+			secondary: [
+				"In JavaScript, -0 and +0 are considered equal when using comparison operators like === or ==, even though they are distinct values.",
+				"To properly check for -0, use `Object.is(value, -0)` which correctly distinguishes between -0 and +0.",
+			],
+			suggestions: ["Use `Object.is()` to reliably check if a value is -0."],
+		},
+	},
+	setup(context) {
+		function generateObjectIsText(
+			node: ts.BinaryExpression,
+			isNegated: boolean,
+		) {
+			const leftText = node.left.getText(context.sourceFile);
+			const rightText = node.right.getText(context.sourceFile);
+			const objectIsCall = `Object.is(${leftText}, ${rightText})`;
+
+			return isNegated ? `!${objectIsCall}` : objectIsCall;
+		}
+
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (
+						!isComparisonOperator(node.operatorToken) ||
+						(!isNegativeZero(node.left) && !isNegativeZero(node.right))
+					) {
+						return;
+					}
+
+					const operator = node.operatorToken.getText(context.sourceFile);
+					const range = {
+						begin: node.getStart(context.sourceFile),
+						end: node.getEnd(),
+					};
+
+					context.report({
+						data: {
+							operator,
+						},
+						message: "unexpectedNegativeZeroComparison",
+						range,
+						suggestions: isEqualityOperator(node.operatorToken)
+							? [
+									{
+										id: "useObjectIs",
+										range,
+										text: generateObjectIsText(
+											node,
+											isNegatedEqualityOperator(node.operatorToken),
+										),
+									},
+								]
+							: undefined,
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/newExpressions.test.ts

@@ -0,0 +1,80 @@
+import rule from "./newExpressions.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+new MyClass();
+`,
+			snapshot: `
+new MyClass();
+~~~
+Constructors should only be called when their return value is used.
+`,
+		},
+		{
+			code: `
+function process() {
+    new EventEmitter();
+}
+`,
+			snapshot: `
+function process() {
+    new EventEmitter();
+    ~~~
+    Constructors should only be called when their return value is used.
+}
+`,
+		},
+		{
+			code: `
+if (condition) {
+    new Logger();
+}
+`,
+			snapshot: `
+if (condition) {
+    new Logger();
+    ~~~
+    Constructors should only be called when their return value is used.
+}
+`,
+		},
+		{
+			code: `
+new DatabaseConnection(), processData();
+`,
+			snapshot: `
+new DatabaseConnection(), processData();
+~~~
+Constructors should only be called when their return value is used.
+`,
+		},
+		{
+			code: `
+someFunction(), new Queue();
+`,
+			snapshot: `
+someFunction(), new Queue();
+                ~~~
+                Constructors should only be called when their return value is used.
+`,
+		},
+	],
+	valid: [
+		`const instance = new MyClass();`,
+		`let value = new MyClass();`,
+		`const result = condition ? new MyClass() : new OtherClass();`,
+		`return new MyClass();`,
+		`throw new Error("message");`,
+		`function create() { return new MyClass(); }`,
+		`const array = [new MyClass(), new OtherClass()];`,
+		`const object = { value: new MyClass() };`,
+		`myFunction(new MyClass());`,
+		`new MyClass().method();`,
+		`const value = new MyClass() || fallback;`,
+		`const value = new MyClass() && other;`,
+		`const value = new MyClass() ?? fallback;`,
+	],
+});

package/src/rules/newExpressions.ts

@@ -0,0 +1,67 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports standalone new expressions that don't use the constructed object.",
+		id: "newExpressions",
+		preset: "logical",
+	},
+	messages: {
+		noStandaloneNew: {
+			primary:
+				"Constructors should only be called when their return value is used.",
+			secondary: [
+				"Using `new` to construct an object but not storing or using the result is often a mistake or indicates unclear code intent.",
+				"If the constructor has side effects you want to trigger, it's better to make that explicit by calling a separate method rather than relying on constructor side effects.",
+			],
+			suggestions: [
+				"If you need to use the constructed object, assign it to a variable or return it.",
+				"If you only need the constructor's side effects, consider refactoring to a function that makes the side effects explicit.",
+			],
+		},
+	},
+	setup(context) {
+		function isStandaloneExpression(node: ts.Node): boolean {
+			const parent = node.parent;
+
+			// If parent is an ExpressionStatement, it's standalone
+			if (parent.kind === ts.SyntaxKind.ExpressionStatement) {
+				return true;
+			}
+
+			// If parent is a comma expression, check recursively
+			if (
+				ts.isBinaryExpression(parent) &&
+				parent.operatorToken.kind === ts.SyntaxKind.CommaToken
+			) {
+				// If this is the last expression in the comma sequence, check if the parent is standalone
+				if (parent.right === node) {
+					return isStandaloneExpression(parent);
+				}
+				return true;
+			}
+
+			return false;
+		}
+
+		return {
+			visitors: {
+				NewExpression: (node) => {
+					if (isStandaloneExpression(node)) {
+						context.report({
+							message: "noStandaloneNew",
+							range: getTSNodeRange(
+								node.getChildAt(0, context.sourceFile),
+								context.sourceFile,
+							),
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/newNativeNonConstructors.test.ts

@@ -0,0 +1,95 @@
+import rule from "./newNativeNonConstructors.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+new Symbol("description");
+`,
+			output: `
+Symbol("description");
+`,
+			snapshot: `
+new Symbol("description");
+~~~
+Symbol cannot be called with \`new\`.
+`,
+		},
+		{
+			code: `
+new BigInt(42);
+`,
+			output: `
+BigInt(42);
+`,
+			snapshot: `
+new BigInt(42);
+~~~
+BigInt cannot be called with \`new\`.
+`,
+		},
+		{
+			code: `
+const value = new Symbol();
+`,
+			output: `
+const value = Symbol();
+`,
+			snapshot: `
+const value = new Symbol();
+              ~~~
+              Symbol cannot be called with \`new\`.
+`,
+		},
+		{
+			code: `
+function create() {
+    return new BigInt(100);
+}
+`,
+			output: `
+function create() {
+    return BigInt(100);
+}
+`,
+			snapshot: `
+function create() {
+    return new BigInt(100);
+           ~~~
+           BigInt cannot be called with \`new\`.
+}
+`,
+		},
+	],
+	valid: [
+		`Symbol("description");`,
+		`BigInt(42);`,
+		`const value = Symbol();`,
+		`const number = BigInt(100);`,
+		`function create() { return Symbol("key"); }`,
+		`const array = [Symbol("a"), Symbol("b")];`,
+		`new String("text");`,
+		`new Number(42);`,
+		`new Boolean(true);`,
+		`new Object();`,
+		`new Array();`,
+		`new Date();`,
+		`new Error("message");`,
+		`new Map();`,
+		`new Set();`,
+		`new Promise((resolve) => resolve());`,
+		`new WeakMap();`,
+		`new WeakSet();`,
+		`
+			class BigInt {}
+			new BigInt();
+			export {}
+		`,
+		`
+			class Symbol {}
+			new Symbol();
+			export {}
+		`,
+	],
+});

package/src/rules/newNativeNonConstructors.ts

@@ -0,0 +1,59 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
+		id: "newNativeNonConstructors",
+		preset: "untyped",
+	},
+	messages: {
+		noNewNonConstructor: {
+			primary: "{{ name }} cannot be called with `new`.",
+			secondary: [
+				"`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.",
+				"These functions should be called directly without the `new` keyword to create their respective values.",
+			],
+			suggestions: ["Remove the `new` keyword and call the function directly."],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				NewExpression: (node) => {
+					if (!ts.isIdentifier(node.expression)) {
+						return;
+					}
+
+					const name = node.expression.text;
+					if (
+						!["BigInt", "Symbol"].includes(name) ||
+						!isGlobalDeclaration(node.expression, context.typeChecker)
+					) {
+						return;
+					}
+
+					context.report({
+						data: { name },
+						fix: {
+							range: {
+								begin: node.getStart(context.sourceFile),
+								end: node.expression.getStart(context.sourceFile),
+							},
+							text: "",
+						},
+						message: "noNewNonConstructor",
+						range: getTSNodeRange(
+							node.getChildAt(0, context.sourceFile),
+							context.sourceFile,
+						),
+					});
+				},
+			},
+		};
+	},
+});

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