@flint.fyi/ts 0.14.2 → 0.14.4

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/rules/variableDeletions.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to delete variables with the delete operator.";
+    readonly id: "variableDeletions";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noDeleteVar", undefined>;
+export default _default;

package/lib/rules/variableDeletions.js

@@ -0,0 +1,39 @@
+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/lib/rules/variableDeletions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/variableDeletions.test.js

@@ -0,0 +1,75 @@
+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/lib/rules/voidOperator.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the void operator.";
+    readonly id: "voidOperator";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noVoid", undefined>;
+export default _default;

package/lib/rules/voidOperator.js

@@ -0,0 +1,36 @@
+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/lib/rules/voidOperator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/voidOperator.test.js

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

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

package/lib/utils/declarationsIncludeGlobal.js

@@ -0,0 +1,4 @@
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+export function declarationsIncludeGlobal(declarations) {
+    return declarations.some(declarationIncludesGlobal);
+}

package/lib/utils/getModifyingReferences.d.ts

@@ -0,0 +1,8 @@
+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 declare function getModifyingReferences(identifier: ts.Identifier, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): ts.Identifier[];

package/lib/utils/getModifyingReferences.js

@@ -0,0 +1,42 @@
+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, sourceFile, typeChecker) {
+    const symbol = typeChecker.getSymbolAtLocation(identifier);
+    if (!symbol?.valueDeclaration) {
+        return [];
+    }
+    const valueDeclaration = symbol.valueDeclaration;
+    const modifyingReferences = [];
+    function visit(node) {
+        // 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;
+}

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.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function isGlobalDeclaration(node: ts.Expression, typeChecker: ts.TypeChecker): boolean;

package/lib/utils/isGlobalDeclaration.js

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

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/lib/utils/isGlobalVariable.d.ts

@@ -0,0 +1,8 @@
+import * as ts from "typescript";
+/**
+ * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
+ * Global variables are those declared in TypeScript's lib files or are global identifiers
+ * like undefined which have symbols but no user-defined declarations.
+ * TODO: Use a scope manager (#400).
+ */
+export declare function isGlobalVariable(node: ts.Expression, typeChecker: ts.TypeChecker): boolean;

package/lib/utils/isGlobalVariable.js

@@ -0,0 +1,21 @@
+import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
+/**
+ * Checks if a node is a reference to a global variable (e.g., Object, undefined, NaN).
+ * Global variables are those declared in TypeScript's lib files or are global identifiers
+ * like undefined which have symbols but no user-defined declarations.
+ * TODO: Use a scope manager (#400).
+ */
+export function isGlobalVariable(node, typeChecker) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return false;
+    }
+    const declarations = symbol.getDeclarations();
+    // undefined, NaN, Infinity etc. may have no declarations in some contexts
+    // but are still global identifiers. Check if they're global scope symbols.
+    if (!declarations?.length) {
+        // If there are no declarations, it's likely a built-in global like undefined
+        return true;
+    }
+    return declarationsIncludeGlobal(declarations);
+}

package/lib/utils/unwrapParentParenthesizedExpressions.d.ts

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

package/lib/utils/unwrapParentParenthesizedExpressions.js

@@ -0,0 +1,6 @@
+import * as ts from "typescript";
+export function unwrapParenthesizedExpressionsParent(node) {
+    return ts.isParenthesizedExpression(node.parent)
+        ? unwrapParenthesizedExpressionsParent(node.parent)
+        : node.parent;
+}

package/lib/utils/unwrapParenthesizedExpression.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function unwrapParenthesizedExpression(expression: ts.Expression): ts.Expression;

package/lib/utils/unwrapParenthesizedExpression.js

@@ -0,0 +1,6 @@
+import * as ts from "typescript";
+export function unwrapParenthesizedExpression(expression) {
+    return ts.isParenthesizedExpression(expression)
+        ? unwrapParenthesizedExpression(expression.expression)
+        : expression;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/ts",
-  "version": "0.14.2",
+  "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/index.ts

@@ -1,3 +1,4 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.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/nodes.ts

@@ -26,6 +26,7 @@ export interface TSNodesByName {
 	ComputedPropertyName: ts.ComputedPropertyName;
 	ConditionalExpression: ts.ConditionalExpression;
 	ConditionalType: ts.ConditionalType;
+	Constructor: ts.ConstructorDeclaration;
 	ContinueStatement: ts.ContinueStatement;
 	DebuggerStatement: ts.DebuggerStatement;
 	Decorator: ts.Decorator;