@flint.fyi/ts 0.14.3 → 0.14.5

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;
+}

package/src/rules/utils/isUnsafeAssignment.ts

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

@@ -0,0 +1,39 @@
+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/voidOperator.test.ts

@@ -72,8 +72,8 @@ function process() {
 			snapshot: `
 function process() {
 	void doSomething();
- ~~~~~~~~~~~~~~~~~~
- Prefer an explicit value over using the void operator to produce undefined.
+	~~~~~~~~~~~~~~~~~~
+	Prefer an explicit value over using the void operator to produce undefined.
 }
 `,
 		},

package/src/utils/declarationIncludesGlobal.ts

@@ -0,0 +1,9 @@
+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,11 +1,7 @@
 import * as ts from "typescript";
 
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+
 export function declarationsIncludeGlobal(declarations: ts.Declaration[]) {
-	return declarations.some((declaration) => {
-		const sourceFile = declaration.getSourceFile();
-		return (
-			sourceFile.hasNoDefaultLib ||
-			/\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName)
-		);
-	});
+	return declarations.some(declarationIncludesGlobal);
 }

package/src/utils/getDeclarationsIfGlobal.ts

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

@@ -0,0 +1,45 @@
+import * as ts from "typescript";
+
+export function hasSameTokens(
+	nodeA: ts.Node,
+	nodeB: ts.Node,
+	sourceFile: ts.SourceFile,
+): boolean {
+	const queueA: ts.Node[] = [nodeA];
+	const queueB: ts.Node[] = [nodeB];
+
+	while (true) {
+		const currentA = queueA.shift();
+		const currentB = queueB.shift();
+
+		if (!currentA || !currentB) {
+			break;
+		}
+
+		if (currentA.kind !== currentB.kind) {
+			return false;
+		}
+
+		if (
+			currentA.kind >= ts.SyntaxKind.FirstToken &&
+			currentA.kind <= ts.SyntaxKind.LastToken
+		) {
+			if (currentA.getText(sourceFile) !== currentB.getText(sourceFile)) {
+				return false;
+			}
+			continue;
+		}
+
+		const childrenA = currentA.getChildren(sourceFile);
+		const childrenB = currentB.getChildren(sourceFile);
+
+		if (childrenA.length !== childrenB.length) {
+			return false;
+		}
+
+		queueA.push(...childrenA);
+		queueB.push(...childrenB);
+	}
+
+	return queueA.length === queueB.length;
+}

package/src/utils/isGlobalDeclaration.ts

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

package/src/utils/isGlobalDeclarationOfName.ts

@@ -0,0 +1,56 @@
+import * as ts from "typescript";
+
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+
+/**
+ * TODO: Use a scope analyzer (#400).
+ */
+export function isGlobalDeclarationOfName(
+	node: ts.Node,
+	name: string,
+	typeChecker: ts.TypeChecker,
+): boolean {
+	const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
+	if (!declarations) {
+		return false;
+	}
+
+	return declarations.every((declaration) => {
+		// Special case: a variable set to a known identifier. E.g.:
+		// const CustomFunction = Function;
+		if (
+			ts.isVariableDeclaration(declaration) &&
+			declaration.initializer &&
+			declaration.initializer.kind === ts.SyntaxKind.Identifier
+		) {
+			return isGlobalDeclarationOfName(
+				declaration.initializer,
+				name,
+				typeChecker,
+			);
+		}
+
+		// Special case: a property of an interface
+		if (ts.isPropertySignature(declaration)) {
+			return isGlobalDeclarationOfName(declaration.parent, name, typeChecker);
+		}
+
+		return (
+			isDeclarationOfName(declaration, name) &&
+			declarationIncludesGlobal(declaration)
+		);
+	});
+}
+
+function isDeclarationOfName(node: ts.Node, name: string) {
+	if (
+		ts.isClassDeclaration(node) ||
+		ts.isFunctionDeclaration(node) ||
+		ts.isInterfaceDeclaration(node) ||
+		ts.isVariableDeclaration(node)
+	) {
+		return node.name && ts.isIdentifier(node.name) && node.name.text === name;
+	}
+
+	return false;
+}