@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/namespaceDeclarations.ts

@@ -1,74 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { z } from "zod";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using legacy `namespace` declarations.",
-		id: "namespaceDeclarations",
-		preset: "logical",
-	},
-	messages: {
-		preferModules: {
-			primary:
-				"Prefer using ECMAScript modules over legacy TypeScript namespaces.",
-			secondary: [
-				"Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules.",
-			],
-			suggestions: [
-				"Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead.",
-			],
-		},
-	},
-	options: {
-		allowDeclarations: z
-			.boolean()
-			.default(false)
-			.describe(
-				"Whether to allow namespaces declared with the `declare` keyword.",
-			),
-		allowDefinitionFiles: z
-			.boolean()
-			.default(false)
-			.describe(
-				"Whether to allow namespaces in `.d.ts` and other definition files.",
-			),
-	},
-	setup(context, { allowDeclarations, allowDefinitionFiles }) {
-		if (allowDefinitionFiles && context.sourceFile.isDeclarationFile) {
-			return;
-		}
-
-		return {
-			visitors: {
-				ModuleDeclaration: (node) => {
-					if (
-						node.parent.kind !== ts.SyntaxKind.SourceFile ||
-						node.name.kind !== ts.SyntaxKind.Identifier ||
-						node.name.text === "global"
-					) {
-						return;
-					}
-
-					if (
-						allowDeclarations &&
-						tsutils.includesModifier(
-							node.modifiers,
-							ts.SyntaxKind.DeclareKeyword,
-						)
-					) {
-						return;
-					}
-
-					context.report({
-						message: "preferModules",
-						range: getTSNodeRange(node.getChildAt(0), context.sourceFile),
-					});
-				},
-			},
-		};
-	},
-});

package/src/rules/negativeZeroComparisons.test.ts

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

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

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

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

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

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