@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/unsafeNegations.ts

@@ -1,59 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
-
-const operatorStrings = new Map([
-	[ts.SyntaxKind.InKeyword, "in"],
-	[ts.SyntaxKind.InstanceOfKeyword, "instanceof"],
-]);
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports negating the left operand of `in` or `instanceof` relations.",
-		id: "unsafeNegations",
-		preset: "untyped",
-	},
-	messages: {
-		preferNegatingRelation: {
-			primary: "This negation applies before the `{{ operator }}` operator.",
-			secondary: [
-				"The logical not operator (!) has higher precedence than `in` and `instanceof`.",
-				"Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended.",
-			],
-			suggestions: ["Wrap the relation in parentheses and negate it."],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					const operator = operatorStrings.get(node.operatorToken.kind);
-					if (!operator) {
-						return;
-					}
-
-					const left = unwrapParenthesizedExpression(node.left);
-					if (
-						!ts.isPrefixUnaryExpression(left) ||
-						left.operator !== ts.SyntaxKind.ExclamationToken
-					) {
-						return;
-					}
-
-					const begin = left.getStart(context.sourceFile);
-
-					context.report({
-						data: { operator },
-						message: "preferNegatingRelation",
-						range: {
-							begin,
-							end: begin + 1,
-						},
-					});
-				},
-			},
-		};
-	},
-});

package/src/rules/utils/discriminateAnyType.ts

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

@@ -1,9 +0,0 @@
-import * as ts from "typescript";
-
-export function getConstrainedTypeAtLocation(
-	node: ts.Node,
-	typeChecker: ts.TypeChecker,
-) {
-	const type = typeChecker.getTypeAtLocation(node);
-	return typeChecker.getBaseConstraintOfType(type) ?? type;
-}

package/src/rules/utils/getThisExpression.ts

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

package/src/rules/utils/isTypeRecursive.ts

@@ -1,10 +0,0 @@
-import * as ts from "typescript";
-
-export function isTypeRecursive(
-	type: ts.Type,
-	predicate: (t: ts.Type) => boolean,
-): boolean {
-	return type.isUnionOrIntersection()
-		? type.types.some((subType) => isTypeRecursive(subType, predicate))
-		: predicate(type);
-}

package/src/rules/utils/isUnsafeAssignment.ts

@@ -1,113 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-
-/**
- * Does a simple check to see if there is an any being assigned to a non-any type.
- *
- * This also checks generic positions to ensure there's no unsafe sub-assignments.
- * Note: in the case of generic positions, it makes the assumption that the two types are the same.
- * @example See tests for examples
- * @returns false if it's safe, or an object with the two types if it's unsafe
- */
-export function isUnsafeAssignment(
-	type: ts.Type,
-	receiver: ts.Type,
-	checker: ts.TypeChecker,
-	senderNode: null | ts.Node,
-): false | { receiver: ts.Type; sender: ts.Type } {
-	return isUnsafeAssignmentWorker(
-		type,
-		receiver,
-		checker,
-		senderNode,
-		new Map(),
-	);
-}
-
-function isUnsafeAssignmentWorker(
-	type: ts.Type,
-	receiver: ts.Type,
-	checker: ts.TypeChecker,
-	senderNode: null | ts.Node,
-	visited: Map<ts.Type, Set<ts.Type>>,
-): false | { receiver: ts.Type; sender: ts.Type } {
-	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
-		// Allow assignment of any ==> unknown.
-		if (tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Unknown)) {
-			return false;
-		}
-
-		if (!tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Any)) {
-			return { receiver, sender: type };
-		}
-	}
-
-	const typeAlreadyVisited = visited.get(type);
-
-	if (typeAlreadyVisited) {
-		if (typeAlreadyVisited.has(receiver)) {
-			return false;
-		}
-		typeAlreadyVisited.add(receiver);
-	} else {
-		visited.set(type, new Set([receiver]));
-	}
-
-	if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) {
-		// TODO - figure out how to handle cases like this,
-		// where the types are assignable, but not the same type
-		/*
-    function foo(): ReadonlySet<number> { return new Set<any>(); }
-
-    // and
-
-    type Test<T> = { prop: T }
-    type Test2 = { prop: string }
-    declare const a: Test<any>;
-    const b: Test2 = a;
-    */
-
-		if (type.target !== receiver.target) {
-			// if the type references are different, assume safe, as we won't know how to compare the two types
-			// the generic positions might not be equivalent for both types
-			return false;
-		}
-
-		if (
-			senderNode != null &&
-			ts.isNewExpression(senderNode) &&
-			ts.isIdentifier(senderNode.expression) &&
-			senderNode.expression.text === "Map" &&
-			(senderNode.arguments == null || senderNode.arguments.length === 0) &&
-			senderNode.typeArguments == null
-		) {
-			// special case to handle `new Map()`
-			// unfortunately Map's default empty constructor is typed to return `Map<any, any>` :(
-			// https://github.com/typescript-eslint/typescript-eslint/issues/2109#issuecomment-634144396
-			return false;
-		}
-
-		const typeArguments = type.typeArguments ?? [];
-		const receiverTypeArguments = receiver.typeArguments ?? [];
-
-		for (let i = 0; i < typeArguments.length; i += 1) {
-			const arg = typeArguments[i];
-			const receiverArg = receiverTypeArguments[i];
-
-			const unsafe = isUnsafeAssignmentWorker(
-				arg,
-				receiverArg,
-				checker,
-				senderNode,
-				visited,
-			);
-			if (unsafe) {
-				return { receiver, sender: type };
-			}
-		}
-
-		return false;
-	}
-
-	return false;
-}

package/src/rules/utils/operators.ts

@@ -1,39 +0,0 @@
-import * as ts from "typescript";
-
-export function isComparisonOperator(token: ts.BinaryOperatorToken) {
-	switch (token.kind) {
-		case ts.SyntaxKind.EqualsEqualsEqualsToken:
-		case ts.SyntaxKind.EqualsEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsToken:
-		case ts.SyntaxKind.GreaterThanEqualsToken:
-		case ts.SyntaxKind.GreaterThanToken:
-		case ts.SyntaxKind.LessThanEqualsToken:
-		case ts.SyntaxKind.LessThanToken:
-			return true;
-		default:
-			return false;
-	}
-}
-
-export function isEqualityOperator(token: ts.BinaryOperatorToken) {
-	switch (token.kind) {
-		case ts.SyntaxKind.EqualsEqualsEqualsToken:
-		case ts.SyntaxKind.EqualsEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsToken:
-			return true;
-		default:
-			return false;
-	}
-}
-
-export function isNegatedEqualityOperator(token: ts.BinaryOperatorToken) {
-	switch (token.kind) {
-		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsToken:
-			return true;
-		default:
-			return false;
-	}
-}

package/src/rules/variableDeletions.test.ts

@@ -1,76 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./variableDeletions.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-delete value;
-`,
-			snapshot: `
-delete value;
-~~~~~~~~~~~~
-Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-`,
-		},
-		{
-			code: `
-let x = 5;
-delete x;
-`,
-			snapshot: `
-let x = 5;
-delete x;
-~~~~~~~~
-Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-`,
-		},
-		{
-			code: `
-const variable = 10;
-delete variable;
-`,
-			snapshot: `
-const variable = 10;
-delete variable;
-~~~~~~~~~~~~~~~
-Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-`,
-		},
-		{
-			code: `
-function test(parameter: number) {
-  delete parameter;
-}
-`,
-			snapshot: `
-function test(parameter: number) {
-  delete parameter;
-  ~~~~~~~~~~~~~~~~
-  Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-}
-`,
-		},
-		{
-			code: `
-for (let index = 0; index < 10; index++) {
-  delete index;
-}
-`,
-			snapshot: `
-for (let index = 0; index < 10; index++) {
-  delete index;
-  ~~~~~~~~~~~~
-  Deleting a variable with the delete operator outside of strict mode will silently fail and return false.
-}
-`,
-		},
-	],
-	valid: [
-		`const obj = { prop: 1 }; delete obj.prop;`,
-		`delete obj.property;`,
-		`delete obj["property"];`,
-		`const obj = { nested: { prop: 1 } }; delete obj.nested.prop;`,
-		`const array = [1, 2, 3]; delete array[0];`,
-	],
-});

package/src/rules/variableDeletions.ts

@@ -1,43 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports attempting to delete variables with the delete operator.",
-		id: "variableDeletions",
-		preset: "untyped",
-	},
-	messages: {
-		noDeleteVar: {
-			primary:
-				"Deleting a variable with the delete operator outside of strict mode will silently fail and return false.",
-			secondary: [
-				"The delete operator is only meant to remove properties from objects, not variables.",
-				"Attempting to delete a variable in strict mode will cause a syntax error.",
-				"In non-strict mode, it will silently fail and return false without actually deleting the variable.",
-			],
-			suggestions: [
-				"Remove the delete statement, or if you need to unset the value, assign undefined instead.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				DeleteExpression: (node) => {
-					if (node.expression.kind === ts.SyntaxKind.Identifier) {
-						context.report({
-							message: "noDeleteVar",
-							range: {
-								begin: node.getStart(context.sourceFile),
-								end: node.getEnd(),
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/voidOperator.test.ts

@@ -1,99 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./voidOperator.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-void 0;
-`,
-			snapshot: `
-void 0;
-~~~~~~
-Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-		{
-			code: `
-const value = void 0;
-`,
-			snapshot: `
-const value = void 0;
-              ~~~~~~
-              Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-		{
-			code: `
-void someFunction();
-`,
-			snapshot: `
-void someFunction();
-~~~~~~~~~~~~~~~~~~~
-Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-		{
-			code: `
-return void calculate();
-`,
-			snapshot: `
-return void calculate();
-       ~~~~~~~~~~~~~~~~
-       Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-		{
-			code: `
-const result = void (a + b);
-`,
-			snapshot: `
-const result = void (a + b);
-               ~~~~~~~~~~~~
-               Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-		{
-			code: `
-void expression, anotherExpression;
-`,
-			snapshot: `
-void expression, anotherExpression;
-~~~~~~~~~~~~~~~
-Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-		{
-			code: `
-function process() {
-	void doSomething();
-}
-`,
-			snapshot: `
-function process() {
-	void doSomething();
-	~~~~~~~~~~~~~~~~~~
-	Prefer an explicit value over using the void operator to produce undefined.
-}
-`,
-		},
-		{
-			code: `
-const callback = () => void action();
-`,
-			snapshot: `
-const callback = () => void action();
-                       ~~~~~~~~~~~~~
-                       Prefer an explicit value over using the void operator to produce undefined.
-`,
-		},
-	],
-	valid: [
-		`const value = undefined;`,
-		`return undefined;`,
-		`someFunction();`,
-		`const result = doSomething();`,
-		`if (value === undefined) {}`,
-		`function returns() { return; }`,
-	],
-});

package/src/rules/voidOperator.ts

@@ -1,38 +0,0 @@
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using the void operator.",
-		id: "voidOperator",
-		preset: "stylistic",
-	},
-	messages: {
-		noVoid: {
-			primary:
-				"Prefer an explicit value over using the void operator to produce undefined.",
-			secondary: [
-				"The void operator evaluates an expression and returns undefined, regardless of the expression's value.",
-				"This is often confusing and can be replaced with more explicit code.",
-				"Instead of using void, return or assign undefined directly.",
-			],
-			suggestions: [
-				"Replace void expressions with undefined or restructure the code to be more explicit.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				VoidExpression: (node) => {
-					context.report({
-						message: "noVoid",
-						range: {
-							begin: node.getStart(context.sourceFile),
-							end: node.getEnd(),
-						},
-					});
-				},
-			},
-		};
-	},
-});

package/src/utils/declarationIncludesGlobal.ts

@@ -1,9 +0,0 @@
-import * as ts from "typescript";
-
-export function declarationIncludesGlobal(declaration: ts.Declaration) {
-	const sourceFile = declaration.getSourceFile();
-	return (
-		sourceFile.hasNoDefaultLib ||
-		/\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName)
-	);
-}

package/src/utils/declarationsIncludeGlobal.ts

@@ -1,7 +0,0 @@
-import * as ts from "typescript";
-
-import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
-
-export function declarationsIncludeGlobal(declarations: ts.Declaration[]) {
-	return declarations.some(declarationIncludesGlobal);
-}

package/src/utils/getDeclarationsIfGlobal.ts

@@ -1,14 +0,0 @@
-import * as ts from "typescript";
-
-import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
-
-export function getDeclarationsIfGlobal(
-	node: ts.Expression,
-	typeChecker: ts.TypeChecker,
-) {
-	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
-
-	return !!declarations && declarationsIncludeGlobal(declarations)
-		? declarations
-		: undefined;
-}

package/src/utils/getModifyingReferences.ts

@@ -1,58 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-
-/**
- * Gets all references to a variable that modify it (assignments, increments, decrements).
- *
- * TODO: Replace with a proper scope manager when available (see #400).
- * @returns An array of identifier nodes that modify the variable.
- */
-export function getModifyingReferences(
-	identifier: ts.Identifier,
-	sourceFile: ts.SourceFile,
-	typeChecker: ts.TypeChecker,
-): ts.Identifier[] {
-	const symbol = typeChecker.getSymbolAtLocation(identifier);
-	if (!symbol?.valueDeclaration) {
-		return [];
-	}
-
-	const valueDeclaration = symbol.valueDeclaration;
-	const modifyingReferences: ts.Identifier[] = [];
-
-	function visit(node: ts.Node): void {
-		// Check if this is an identifier that refers to the same symbol
-		if (ts.isIdentifier(node)) {
-			const nodeSymbol = typeChecker.getSymbolAtLocation(node);
-			if (
-				nodeSymbol?.valueDeclaration &&
-				nodeSymbol.valueDeclaration === valueDeclaration
-			) {
-				// Check if this identifier is being modified
-				const parent = node.parent;
-
-				// Assignment expressions (=, +=, -=, etc.)
-				if (
-					ts.isBinaryExpression(parent) &&
-					tsutils.isAssignmentKind(parent.operatorToken.kind) &&
-					parent.left === node
-				) {
-					modifyingReferences.push(node);
-				}
-				// Unary expressions (++, --)
-				else if (
-					(ts.isPostfixUnaryExpression(parent) ||
-						ts.isPrefixUnaryExpression(parent)) &&
-					parent.operand === node
-				) {
-					modifyingReferences.push(node);
-				}
-			}
-		}
-
-		ts.forEachChild(node, visit);
-	}
-
-	visit(sourceFile);
-	return modifyingReferences;
-}