@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/variableDeletions.test.ts

@@ -0,0 +1,76 @@
+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/src/rules/variableDeletions.ts

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

@@ -0,0 +1,99 @@
+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/src/rules/voidOperator.ts

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

@@ -0,0 +1,7 @@
+import * as ts from "typescript";
+
+import { declarationIncludesGlobal } from "./declarationIncludesGlobal.js";
+
+export function declarationsIncludeGlobal(declarations: ts.Declaration[]) {
+	return declarations.some(declarationIncludesGlobal);
+}

package/src/utils/getModifyingReferences.ts

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

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

package/src/utils/isGlobalDeclarationOfName.ts

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

package/src/utils/isGlobalVariable.ts

@@ -0,0 +1,30 @@
+import * as ts from "typescript";
+
+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: ts.Expression,
+	typeChecker: ts.TypeChecker,
+): boolean {
+	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/src/utils/unwrapParentParenthesizedExpressions.ts

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

package/src/utils/unwrapParenthesizedExpression.ts

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