@flint.fyi/ts 0.14.2 → 0.14.3

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/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,7 @@
+export function declarationsIncludeGlobal(declarations) {
+    return declarations.some((declaration) => {
+        const sourceFile = declaration.getSourceFile();
+        return (sourceFile.hasNoDefaultLib ||
+            /\/lib\.[^/]*\.d\.ts$/.test(sourceFile.fileName));
+    });
+}

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/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/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.3",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "repository": {
     "type": "git",

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/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;

package/src/plugin.ts

@@ -1,10 +1,40 @@
 import { createPlugin } from "@flint.fyi/core";
 
+import asyncPromiseExecutors from "./rules/asyncPromiseExecutors.js";
+import caseDeclarations from "./rules/caseDeclarations.js";
+import chainedAssignments from "./rules/chainedAssignments.js";
+import classAssignments from "./rules/classAssignments.js";
 import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
+import constantAssignments from "./rules/constantAssignments.js";
+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 emptyDestructures from "./rules/emptyDestructures.js";
+import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
+import exceptionAssignments from "./rules/exceptionAssignments.js";
 import forInArrays from "./rules/forInArrays.js";
+import functionAssignments from "./rules/functionAssignments.js";
+import generatorFunctionYields from "./rules/generatorFunctionYields.js";
+import globalAssignments from "./rules/globalAssignments.js";
+import globalObjectCalls from "./rules/globalObjectCalls.js";
 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 objectProto from "./rules/objectProto.js";
 import octalEscapes from "./rules/octalEscapes.js";
+import octalNumbers from "./rules/octalNumbers.js";
+import returnAssignments from "./rules/returnAssignments.js";
+import sparseArrays from "./rules/sparseArrays.js";
+import symbolDescriptions from "./rules/symbolDescriptions.js";
+import unassignedVariables from "./rules/unassignedVariables.js";
+import undefinedVariables from "./rules/undefinedVariables.js";
+import unicodeBOMs from "./rules/unicodeBOMs.js";
+import unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unsafeNegations from "./rules/unsafeNegations.js";
+import variableDeletions from "./rules/variableDeletions.js";
+import voidOperator from "./rules/voidOperator.js";
 
 export const ts = createPlugin({
 	files: {
@@ -12,10 +42,40 @@ export const ts = createPlugin({
 	},
 	name: "ts",
 	rules: [
+		asyncPromiseExecutors,
+		caseDeclarations,
+		chainedAssignments,
+		classAssignments,
 		consecutiveNonNullAssertions,
+		constantAssignments,
+		constructorReturns,
 		debuggerStatements,
+		defaultCaseLast,
+		duplicateArguments,
+		emptyDestructures,
+		emptyStaticBlocks,
+		exceptionAssignments,
 		forInArrays,
+		functionAssignments,
+		generatorFunctionYields,
+		globalAssignments,
+		globalObjectCalls,
 		namespaceDeclarations,
+		negativeZeroComparisons,
+		newExpressions,
+		newNativeNonConstructors,
+		objectProto,
 		octalEscapes,
+		octalNumbers,
+		returnAssignments,
+		sparseArrays,
+		symbolDescriptions,
+		unassignedVariables,
+		undefinedVariables,
+		unicodeBOMs,
+		unnecessaryCatches,
+		unsafeNegations,
+		variableDeletions,
+		voidOperator,
 	],
 });

package/src/rules/asyncPromiseExecutors.test.ts

@@ -0,0 +1,72 @@
+import rule from "./asyncPromiseExecutors.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+new Promise(async (resolve, reject) => {
+    resolve(42);
+});
+`,
+			snapshot: `
+new Promise(async (resolve, reject) => {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+		},
+		{
+			code: `
+new Promise(async function(resolve, reject) {
+    resolve(42);
+});
+`,
+			snapshot: `
+new Promise(async function(resolve, reject) {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+		},
+		{
+			code: `
+const p = new Promise(async (resolve) => {
+    resolve();
+});
+`,
+			snapshot: `
+const p = new Promise(async (resolve) => {
+                      ~~~~~
+                      Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve();
+});
+`,
+		},
+	],
+	valid: [
+		`
+new Promise((resolve, reject) => {
+    resolve(42);
+});
+`,
+		`
+new Promise(function(resolve, reject) {
+    resolve(42);
+});
+`,
+		`
+const p = new Promise((resolve) => {
+    doSomething().then(resolve);
+});
+`,
+		`
+// Not a Promise constructor
+new SomethingElse(async (resolve) => {
+    resolve();
+});
+`,
+	],
+});

package/src/rules/asyncPromiseExecutors.ts

@@ -0,0 +1,61 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using async functions as Promise executor functions.",
+		id: "asyncPromiseExecutors",
+		preset: "logical",
+	},
+	messages: {
+		asyncPromiseExecutor: {
+			primary:
+				"Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.",
+			secondary: [
+				"The Promise executor function is called synchronously by the Promise constructor.",
+				"If an async function is used as a Promise executor, thrown errors will not be caught by the Promise and will instead result in unhandled rejections.",
+				"Additionally, if a Promise executor function is using `await`, there's probably no need to use the `new Promise` constructor.",
+			],
+			suggestions: [
+				"Remove the `async` keyword from the executor function.",
+				"If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				NewExpression: (node) => {
+					if (
+						!isGlobalDeclaration(node.expression, context.typeChecker) ||
+						!node.arguments?.length
+					) {
+						return;
+					}
+
+					const executor = node.arguments[0];
+					if (!ts.isFunctionLike(executor)) {
+						return;
+					}
+
+					const asyncModifier = executor.modifiers?.find(
+						(mod) => mod.kind === ts.SyntaxKind.AsyncKeyword,
+					);
+					if (!asyncModifier) {
+						return;
+					}
+
+					context.report({
+						message: "asyncPromiseExecutor",
+						range: {
+							begin: asyncModifier.getStart(context.sourceFile),
+							end: asyncModifier.getEnd(),
+						},
+					});
+				},
+			},
+		};
+	},
+});