@flint.fyi/ts 0.14.3 → 0.14.4

package/lib/rules/typeofComparisons.test.js

@@ -0,0 +1,85 @@
+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/lib/rules/utils/discriminateAnyType.d.ts

@@ -0,0 +1,12 @@
+import * as ts from "typescript";
+export declare enum AnyType {
+    Any = 0,
+    PromiseAny = 1,
+    AnyArray = 2,
+    Safe = 3
+}
+/**
+ * @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 declare function discriminateAnyType(type: ts.Type, checker: ts.TypeChecker, program: ts.Program, tsNode: ts.Node): AnyType;

package/lib/rules/utils/discriminateAnyType.js

@@ -0,0 +1,41 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+export var AnyType;
+(function (AnyType) {
+    AnyType[AnyType["Any"] = 0] = "Any";
+    AnyType[AnyType["PromiseAny"] = 1] = "PromiseAny";
+    AnyType[AnyType["AnyArray"] = 2] = "AnyArray";
+    AnyType[AnyType["Safe"] = 3] = "Safe";
+})(AnyType || (AnyType = {}));
+/**
+ * @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, checker, program, tsNode) {
+    return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set());
+}
+function discriminateAnyTypeWorker(type, checker, program, tsNode, visited) {
+    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)[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/lib/rules/utils/getThisExpression.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function getThisExpression(node: ts.Node): null | ts.ThisExpression;

package/lib/rules/utils/getThisExpression.js

@@ -0,0 +1,23 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+export function getThisExpression(node) {
+    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) {
+    while (ts.isParenthesizedExpression(node)) {
+        node = node.expression;
+    }
+    return node;
+}

package/lib/rules/utils/isUnsafeAssignment.d.ts

@@ -0,0 +1,13 @@
+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 declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, checker: ts.TypeChecker, senderNode: null | ts.Node): false | {
+    receiver: ts.Type;
+    sender: ts.Type;
+};

package/lib/rules/utils/isUnsafeAssignment.js

@@ -0,0 +1,76 @@
+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, receiver, checker, senderNode) {
+    return isUnsafeAssignmentWorker(type, receiver, checker, senderNode, new Map());
+}
+function isUnsafeAssignmentWorker(type, receiver, checker, senderNode, visited) {
+    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/lib/rules/utils/operators.d.ts

@@ -0,0 +1,4 @@
+import * as ts from "typescript";
+export declare function isComparisonOperator(token: ts.BinaryOperatorToken): boolean;
+export declare function isEqualityOperator(token: ts.BinaryOperatorToken): boolean;
+export declare function isNegatedEqualityOperator(token: ts.BinaryOperatorToken): boolean;

package/lib/rules/utils/operators.js

@@ -0,0 +1,36 @@
+import * as ts from "typescript";
+export function isComparisonOperator(token) {
+    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) {
+    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) {
+    switch (token.kind) {
+        case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+        case ts.SyntaxKind.ExclamationEqualsToken:
+            return true;
+        default:
+            return false;
+    }
+}

package/lib/utils/declarationIncludesGlobal.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function declarationIncludesGlobal(declaration: ts.Declaration): boolean;

package/lib/utils/declarationIncludesGlobal.js

@@ -0,0 +1,5 @@
+export function declarationIncludesGlobal(declaration) {
+    const sourceFile = declaration.getSourceFile();
+    return (sourceFile.hasNoDefaultLib ||
+        /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName));
+}

package/lib/utils/declarationsIncludeGlobal.js

@@ -1,7 +1,4 @@
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
 export function declarationsIncludeGlobal(declarations) {
-    return declarations.some((declaration) => {
-        const sourceFile = declaration.getSourceFile();
-        return (sourceFile.hasNoDefaultLib ||
-            /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName));
-    });
+    return declarations.some(declarationIncludesGlobal);
 }

package/lib/utils/hasSameTokens.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function hasSameTokens(nodeA: ts.Node, nodeB: ts.Node, sourceFile: ts.SourceFile): boolean;

package/lib/utils/hasSameTokens.js

@@ -0,0 +1,30 @@
+import * as ts from "typescript";
+export function hasSameTokens(nodeA, nodeB, sourceFile) {
+    const queueA = [nodeA];
+    const queueB = [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/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+/**
+ * TODO: Use a scope analyzer (#400).
+ */
+export declare function isGlobalDeclarationOfName(node: ts.Expression, name: string, typeChecker: ts.TypeChecker): boolean;

package/lib/utils/isGlobalDeclarationOfName.js

@@ -0,0 +1,31 @@
+import * as ts from "typescript";
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+/**
+ * TODO: Use a scope analyzer (#400).
+ */
+export function isGlobalDeclarationOfName(node, name, typeChecker) {
+    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);
+        }
+        return (isDeclarationOfName(declaration, name) &&
+            declarationIncludesGlobal(declaration));
+    });
+}
+function isDeclarationOfName(node, name) {
+    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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/ts",
-  "version": "0.14.3",
+  "version": "0.14.4",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "repository": {
     "type": "git",

package/src/createTypeScriptFileFromProgram.ts

@@ -49,6 +49,7 @@ export function createTypeScriptFileFromProgram(
 			const reports: NormalizedReport[] = [];
 
 			const context = {
+				program,
 				report: (report: RuleReport) => {
 					reports.push({
 						...report,

package/src/language.ts

@@ -19,6 +19,7 @@ const log = debugForFile(import.meta.filename);
 const projectRoot = path.join(import.meta.dirname, "../..");
 
 export interface TypeScriptServices {
+	program: ts.Program;
 	sourceFile: ts.SourceFile;
 	typeChecker: ts.TypeChecker;
 }

package/src/plugin.ts

@@ -1,7 +1,9 @@
 import { createPlugin } from "@flint.fyi/core";
 
+import anyReturns from "./rules/anyReturns.js";
 import asyncPromiseExecutors from "./rules/asyncPromiseExecutors.js";
 import caseDeclarations from "./rules/caseDeclarations.js";
+import caseDuplicates from "./rules/caseDuplicates.js";
 import chainedAssignments from "./rules/chainedAssignments.js";
 import classAssignments from "./rules/classAssignments.js";
 import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
@@ -10,11 +12,14 @@ import constructorReturns from "./rules/constructorReturns.js";
 import debuggerStatements from "./rules/debuggerStatements.js";
 import defaultCaseLast from "./rules/defaultCaseLast.js";
 import duplicateArguments from "./rules/duplicateArguments.js";
+import elseIfDuplicates from "./rules/elseIfDuplicates.js";
 import emptyDestructures from "./rules/emptyDestructures.js";
 import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
 import exceptionAssignments from "./rules/exceptionAssignments.js";
+import forDirections from "./rules/forDirections.js";
 import forInArrays from "./rules/forInArrays.js";
 import functionAssignments from "./rules/functionAssignments.js";
+import functionNewCalls from "./rules/functionNewCalls.js";
 import generatorFunctionYields from "./rules/generatorFunctionYields.js";
 import globalAssignments from "./rules/globalAssignments.js";
 import globalObjectCalls from "./rules/globalObjectCalls.js";
@@ -22,12 +27,18 @@ import namespaceDeclarations from "./rules/namespaceDeclarations.js";
 import negativeZeroComparisons from "./rules/negativeZeroComparisons.js";
 import newExpressions from "./rules/newExpressions.js";
 import newNativeNonConstructors from "./rules/newNativeNonConstructors.js";
+import nonOctalDecimalEscapes from "./rules/nonOctalDecimalEscapes.js";
+import numericLiteralParsing from "./rules/numericLiteralParsing.js";
 import objectProto from "./rules/objectProto.js";
 import octalEscapes from "./rules/octalEscapes.js";
 import octalNumbers from "./rules/octalNumbers.js";
 import returnAssignments from "./rules/returnAssignments.js";
+import selfAssignments from "./rules/selfAssignments.js";
+import selfComparisons from "./rules/selfComparisons.js";
+import sequences from "./rules/sequences.js";
 import sparseArrays from "./rules/sparseArrays.js";
 import symbolDescriptions from "./rules/symbolDescriptions.js";
+import typeofComparisons from "./rules/typeofComparisons.js";
 import unassignedVariables from "./rules/unassignedVariables.js";
 import undefinedVariables from "./rules/undefinedVariables.js";
 import unicodeBOMs from "./rules/unicodeBOMs.js";
@@ -42,8 +53,10 @@ export const ts = createPlugin({
 	},
 	name: "ts",
 	rules: [
+		anyReturns,
 		asyncPromiseExecutors,
 		caseDeclarations,
+		caseDuplicates,
 		chainedAssignments,
 		classAssignments,
 		consecutiveNonNullAssertions,
@@ -52,11 +65,14 @@ export const ts = createPlugin({
 		debuggerStatements,
 		defaultCaseLast,
 		duplicateArguments,
+		elseIfDuplicates,
 		emptyDestructures,
 		emptyStaticBlocks,
 		exceptionAssignments,
+		forDirections,
 		forInArrays,
 		functionAssignments,
+		functionNewCalls,
 		generatorFunctionYields,
 		globalAssignments,
 		globalObjectCalls,
@@ -64,12 +80,18 @@ export const ts = createPlugin({
 		negativeZeroComparisons,
 		newExpressions,
 		newNativeNonConstructors,
+		nonOctalDecimalEscapes,
+		numericLiteralParsing,
 		objectProto,
 		octalEscapes,
 		octalNumbers,
 		returnAssignments,
+		selfAssignments,
+		selfComparisons,
+		sequences,
 		sparseArrays,
 		symbolDescriptions,
+		typeofComparisons,
 		unassignedVariables,
 		undefinedVariables,
 		unicodeBOMs,