@flint.fyi/ts 0.14.3 → 0.14.5

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/rules/voidOperator.test.js

@@ -71,8 +71,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/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/getDeclarationsIfGlobal.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function getDeclarationsIfGlobal(node: ts.Expression, typeChecker: ts.TypeChecker): ts.Declaration[] | undefined;

package/lib/utils/getDeclarationsIfGlobal.js

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

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/isGlobalDeclaration.js

@@ -1,5 +1,4 @@
-import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
+import { getDeclarationsIfGlobal } from "./getDeclarationsIfGlobal.js";
 export function isGlobalDeclaration(node, typeChecker) {
-    const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
-    return !!declarations && declarationsIncludeGlobal(declarations);
+    return !!getDeclarationsIfGlobal(node, typeChecker);
 }

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.Node, name: string, typeChecker: ts.TypeChecker): boolean;

package/lib/utils/isGlobalDeclarationOfName.js

@@ -0,0 +1,35 @@
+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);
+        }
+        // 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, 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.5",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "repository": {
     "type": "git",
@@ -17,12 +17,12 @@
   "dependencies": {
     "@flint.fyi/core": "",
     "@flint.fyi/rule-tester": "",
-    "@typescript-eslint/project-service": "^8.35.0",
+    "@typescript-eslint/project-service": "^8.46.2",
     "@typescript/vfs": "^1.6.1",
     "cached-factory": "^0.1.0",
     "debug-for-file": "^0.2.0",
     "ts-api-utils": "^2.1.0",
-    "typescript": ">=5.8.0"
+    "typescript": ">=5.9.3"
   },
   "engines": {
     "node": ">=24.0.0"

package/src/createTypeScriptFileFromProgram.ts

@@ -49,9 +49,14 @@ export function createTypeScriptFileFromProgram(
 			const reports: NormalizedReport[] = [];
 
 			const context = {
+				program,
 				report: (report: RuleReport) => {
 					reports.push({
 						...report,
+						fix:
+							report.fix && !Array.isArray(report.fix)
+								? [report.fix]
+								: report.fix,
 						message: rule.messages[report.message],
 						range: normalizeRange(report.range, sourceFile),
 					});
@@ -73,7 +78,7 @@ export function createTypeScriptFileFromProgram(
 				node.forEachChild(visit);
 			};
 
-			sourceFile.forEachChild(visit);
+			visit(sourceFile);
 
 			return reports;
 		},

package/src/index.ts

@@ -1,4 +1,7 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
+export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
+export { isGlobalVariable } from "./utils/isGlobalVariable.js";

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,15 @@ 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 emptyBlocks from "./rules/emptyBlocks.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,16 +28,25 @@ 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 shadowedRestrictedNames from "./rules/shadowedRestrictedNames.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";
+import unnecessaryBlocks from "./rules/unnecessaryBlocks.js";
 import unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.js";
 import unsafeNegations from "./rules/unsafeNegations.js";
 import variableDeletions from "./rules/variableDeletions.js";
 import voidOperator from "./rules/voidOperator.js";
@@ -42,8 +57,10 @@ export const ts = createPlugin({
 	},
 	name: "ts",
 	rules: [
+		anyReturns,
 		asyncPromiseExecutors,
 		caseDeclarations,
+		caseDuplicates,
 		chainedAssignments,
 		classAssignments,
 		consecutiveNonNullAssertions,
@@ -52,11 +69,15 @@ export const ts = createPlugin({
 		debuggerStatements,
 		defaultCaseLast,
 		duplicateArguments,
+		elseIfDuplicates,
+		emptyBlocks,
 		emptyDestructures,
 		emptyStaticBlocks,
 		exceptionAssignments,
+		forDirections,
 		forInArrays,
 		functionAssignments,
+		functionNewCalls,
 		generatorFunctionYields,
 		globalAssignments,
 		globalObjectCalls,
@@ -64,16 +85,25 @@ export const ts = createPlugin({
 		negativeZeroComparisons,
 		newExpressions,
 		newNativeNonConstructors,
+		nonOctalDecimalEscapes,
+		numericLiteralParsing,
 		objectProto,
 		octalEscapes,
 		octalNumbers,
 		returnAssignments,
+		selfAssignments,
+		selfComparisons,
+		sequences,
+		shadowedRestrictedNames,
 		sparseArrays,
 		symbolDescriptions,
+		typeofComparisons,
 		unassignedVariables,
 		undefinedVariables,
 		unicodeBOMs,
+		unnecessaryBlocks,
 		unnecessaryCatches,
+		unnecessaryConcatenation,
 		unsafeNegations,
 		variableDeletions,
 		voidOperator,