@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/undefinedVariables.js

@@ -1,77 +1,39 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using variables that are not defined.",
-        id: "undefinedVariables",
-        preset: "untyped",
-    },
-    messages: {
-        undefinedVariable: {
-            primary: "Variable '{{ name }}' is used but was never defined.",
-            secondary: [
-                "Variables must be declared before they can be used.",
-                "Using undefined variables will cause a ReferenceError at runtime.",
-            ],
-            suggestions: [
-                "Declare the variable before using it, or check if the variable name is spelled correctly.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                Identifier: (node, { sourceFile, typeChecker }) => {
-                    if (ts.isVariableDeclaration(node.parent) &&
-                        node.parent.name === node) {
-                        return;
-                    }
-                    if (ts.isParameter(node.parent) && node.parent.name === node) {
-                        return;
-                    }
-                    if ((ts.isFunctionDeclaration(node.parent) ||
-                        ts.isClassDeclaration(node.parent) ||
-                        ts.isInterfaceDeclaration(node.parent) ||
-                        ts.isTypeAliasDeclaration(node.parent) ||
-                        ts.isEnumDeclaration(node.parent) ||
-                        ts.isModuleDeclaration(node.parent)) &&
-                        node.parent.name === node) {
-                        return;
-                    }
-                    if (ts.isImportSpecifier(node.parent) ||
-                        ts.isImportClause(node.parent) ||
-                        ts.isNamespaceImport(node.parent)) {
-                        return;
-                    }
-                    if (ts.isPropertyAccessExpression(node.parent) &&
-                        node.parent.name === node) {
-                        return;
-                    }
-                    if (ts.isPropertyAssignment(node.parent) &&
-                        node.parent.name === node) {
-                        return;
-                    }
-                    if (ts.isTypeOfExpression(node.parent) &&
-                        node.parent.expression === node) {
-                        return;
-                    }
-                    // TODO: This rule is untyped, so it should use scope analysis
-                    // https://github.com/flint-fyi/flint/issues/400
-                    if (!typeChecker.getSymbolAtLocation(node)) {
-                        context.report({
-                            data: {
-                                name: node.text,
-                            },
-                            message: "undefinedVariable",
-                            range: {
-                                begin: node.getStart(sourceFile),
-                                end: node.getEnd(),
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/undefinedVariables.ts
+var undefinedVariables_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using variables that are not defined.",
+		id: "undefinedVariables",
+		presets: ["javascript"]
+	},
+	messages: { undefinedVariable: {
+		primary: "Variable '{{ name }}' is used but was never defined.",
+		secondary: ["Variables must be declared before they can be used.", "Using undefined variables will cause a ReferenceError at runtime."],
+		suggestions: ["Declare the variable before using it, or check if the variable name is spelled correctly."]
+	} },
+	setup(context) {
+		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
+			if (node.parent.kind === SyntaxKind.VariableDeclaration && node.parent.name === node) return;
+			if (node.parent.kind === SyntaxKind.Parameter && node.parent.name === node) return;
+			if ((node.parent.kind === SyntaxKind.FunctionDeclaration || node.parent.kind === SyntaxKind.ClassDeclaration || node.parent.kind === SyntaxKind.InterfaceDeclaration || node.parent.kind === SyntaxKind.TypeAliasDeclaration || node.parent.kind === SyntaxKind.EnumDeclaration || node.parent.kind === SyntaxKind.ModuleDeclaration) && node.parent.name === node) return;
+			if (node.parent.kind === SyntaxKind.ImportSpecifier || node.parent.kind === SyntaxKind.ImportClause || node.parent.kind === SyntaxKind.NamespaceImport) return;
+			if (node.parent.kind === SyntaxKind.PropertyAccessExpression && node.parent.name === node) return;
+			if (node.parent.kind === SyntaxKind.PropertyAssignment && node.parent.name === node) return;
+			if (node.parent.kind === SyntaxKind.TypeOfExpression && node.parent.expression === node) return;
+			if (!typeChecker.getSymbolAtLocation(node)) context.report({
+				data: { name: node.text },
+				message: "undefinedVariable",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { undefinedVariables_default as default };
+
 //# sourceMappingURL=undefinedVariables.js.map

package/lib/rules/unicodeBOMs.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
     readonly id: "unicodeBOMs";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noBOM", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noBOM", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=unicodeBOMs.d.ts.map

package/lib/rules/unicodeBOMs.js

@@ -1,48 +1,39 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports files with Unicode Byte Order Marks (BOMs).",
-        id: "unicodeBOMs",
-        preset: "stylistic",
-    },
-    messages: {
-        noBOM: {
-            primary: "This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.",
-            secondary: [
-                "The Unicode BOM is a special character (U+FEFF) that can appear at the start of a file to indicate its byte order and encoding.",
-                "While it can be useful in some contexts, it does not improve tooling portability and is not generally helpful for editors.",
-            ],
-            suggestions: ["Remove the BOM from the beginning of the file."],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                SourceFile: (node) => {
-                    const text = node.getFullText();
-                    if (text.charCodeAt(0) !== 0xfeff) {
-                        return {};
-                    }
-                    context.report({
-                        message: "noBOM",
-                        range: {
-                            begin: 0,
-                            end: 1,
-                        },
-                        suggestions: [
-                            {
-                                id: "removeBOM",
-                                range: {
-                                    begin: 0,
-                                    end: 1,
-                                },
-                                text: "",
-                            },
-                        ],
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/unicodeBOMs.ts
+var unicodeBOMs_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports files with Unicode Byte Order Marks (BOMs).",
+		id: "unicodeBOMs",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { noBOM: {
+		primary: "This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.",
+		secondary: ["The Unicode BOM is a special character (U+FEFF) that can appear at the start of a file to indicate its byte order and encoding.", "While it can be useful in some contexts, it does not improve tooling portability and is not generally helpful for editors."],
+		suggestions: ["Remove the BOM from the beginning of the file."]
+	} },
+	setup(context) {
+		return { visitors: { SourceFile: (node) => {
+			if (node.getFullText().charCodeAt(0) !== 65279) return {};
+			context.report({
+				message: "noBOM",
+				range: {
+					begin: 0,
+					end: 1
+				},
+				suggestions: [{
+					id: "removeBOM",
+					range: {
+						begin: 0,
+						end: 1
+					},
+					text: ""
+				}]
+			});
+		} } };
+	}
 });
+//#endregion
+export { unicodeBOMs_default as default };
+
 //# sourceMappingURL=unicodeBOMs.js.map

package/lib/rules/unnecessaryBinds.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary `.bind()` calls.";
+    readonly id: "unnecessaryBinds";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryBinds" | "arrowBind", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryBinds.d.ts.map

package/lib/rules/unnecessaryBinds.js

@@ -0,0 +1,78 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/unnecessaryBinds.ts
+function containsThis(node) {
+	if (node.kind === ts.SyntaxKind.ThisKeyword) return true;
+	if (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) return false;
+	let found = false;
+	node.forEachChild((child) => {
+		if (containsThis(child)) found = true;
+	});
+	return found;
+}
+function isStaticValue(node) {
+	if (ts.isParenthesizedExpression(node)) return isStaticValue(node.expression);
+	if (ts.isPrefixUnaryExpression(node)) return isStaticValue(node.operand);
+	if (ts.isIdentifier(node)) return true;
+	if (ts.isPropertyAccessExpression(node)) return isStaticValue(node.expression);
+	if (ts.isElementAccessExpression(node)) return isStaticValue(node.expression) && isStaticValue(node.argumentExpression);
+	return node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.SuperKeyword || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || ts.isBigIntLiteral(node) || ts.isNumericLiteral(node) || ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || node.kind === ts.SyntaxKind.RegularExpressionLiteral;
+}
+function unwrapParentheses(node) {
+	while (ts.isParenthesizedExpression(node)) node = node.expression;
+	return node;
+}
+var unnecessaryBinds_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary `.bind()` calls.",
+		id: "unnecessaryBinds",
+		presets: ["logical"]
+	},
+	messages: {
+		arrowBind: {
+			primary: "`.bind()` has no effect on arrow functions.",
+			secondary: ["Arrow functions have lexical 'this' binding.", "Calling .bind() on an arrow function has no effect."],
+			suggestions: ["Remove the `.bind()` call.", "Change the arrow function to a `function` that uses `this`"]
+		},
+		unnecessaryBinds: {
+			primary: "This `.bind()` call is unnecessary because the function does not use `this`.",
+			secondary: ["This function does not use `this`.", "`.bind()`'s purpose is to bind `this`, so using it on this function doesn't change anything."],
+			suggestions: ["Remove the `.bind()` call.", "Change the function to use `this` if that was intended."]
+		}
+	},
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile }) {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "bind" || node.arguments.length !== 1) return;
+			const boundArgument = node.arguments[0];
+			const boundFunction = unwrapParentheses(node.expression.expression);
+			const fix = isStaticValue(boundArgument) ? {
+				range: getTSNodeRange(node, sourceFile),
+				text: node.expression.expression.getText(sourceFile)
+			} : void 0;
+			if (ts.isArrowFunction(boundFunction)) {
+				context.report({
+					fix,
+					message: "arrowBind",
+					range: {
+						begin: node.expression.name.getStart(sourceFile),
+						end: node.end
+					}
+				});
+				return;
+			}
+			if (ts.isFunctionExpression(boundFunction) && !containsThis(boundFunction.body)) context.report({
+				fix,
+				message: "unnecessaryBinds",
+				range: {
+					begin: node.expression.name.getStart(sourceFile),
+					end: node.end
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { unnecessaryBinds_default as default };
+
+//# sourceMappingURL=unnecessaryBinds.js.map

package/lib/rules/unnecessaryBlocks.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports standalone block statements that don't create a meaningful scope.";
     readonly id: "unnecessaryBlocks";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unnecessaryBlock", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryBlock", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=unnecessaryBlocks.d.ts.map

package/lib/rules/unnecessaryBlocks.js

@@ -1,76 +1,60 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports standalone block statements that don't create a meaningful scope.",
-        id: "unnecessaryBlocks",
-        preset: "stylistic",
-    },
-    messages: {
-        unnecessaryBlock: {
-            primary: "This standalone block statement is unnecessary and doesn't change any variable scopes.",
-            secondary: [
-                "Standalone block statements that aren't part of control flow (if/else, loops, switch) or don't create a meaningful lexical scope can be confusing and should be avoided.",
-                "In modern JavaScript and TypeScript, blocks primarily serve to create lexical scope for `let` and `const` variables, but this is often better achieved through other means.",
-            ],
-            suggestions: [
-                "Remove the block statement and move its contents to the parent scope.",
-                "If you need lexical scoping, consider using an IIFE (Immediately Invoked Function Expression) or extracting to a separate function.",
-            ],
-        },
-    },
-    setup(context) {
-        function isValidBlock(node) {
-            const parent = node.parent;
-            // Valid blocks: function bodies, arrow functions, class/interface bodies, etc.
-            if (ts.isFunctionDeclaration(parent) ||
-                ts.isFunctionExpression(parent) ||
-                ts.isArrowFunction(parent) ||
-                ts.isMethodDeclaration(parent) ||
-                ts.isConstructorDeclaration(parent) ||
-                ts.isGetAccessorDeclaration(parent) ||
-                ts.isSetAccessorDeclaration(parent) ||
-                ts.isModuleBlock(parent)) {
-                return true;
-            }
-            // Valid blocks: control flow statements
-            if (ts.isIfStatement(parent) ||
-                ts.isForStatement(parent) ||
-                ts.isForInStatement(parent) ||
-                ts.isForOfStatement(parent) ||
-                ts.isWhileStatement(parent) ||
-                ts.isDoStatement(parent) ||
-                ts.isWithStatement(parent) ||
-                ts.isTryStatement(parent) ||
-                ts.isCatchClause(parent)) {
-                return true;
-            }
-            // Valid block: switch case/default clause with block
-            // In ES6+, blocks in switch cases create scope for let/const
-            if (ts.isCaseClause(parent) || ts.isDefaultClause(parent)) {
-                return true;
-            }
-            // Valid block: labeled statement
-            if (ts.isLabeledStatement(parent)) {
-                return true;
-            }
-            return false;
-        }
-        return {
-            visitors: {
-                Block: (node, { sourceFile }) => {
-                    if (!isValidBlock(node)) {
-                        context.report({
-                            message: "unnecessaryBlock",
-                            range: {
-                                begin: node.getStart(sourceFile),
-                                end: node.getStart(sourceFile) + 1,
-                            },
-                        });
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+import { isNodeFlagSet } from "ts-api-utils";
+//#region src/rules/unnecessaryBlocks.ts
+function isUsingVariableStatement(node) {
+	return node.kind === SyntaxKind.VariableStatement && isNodeFlagSet(node.declarationList, ts.NodeFlags.Using);
+}
+function isValidBlock(node) {
+	switch (node.parent.kind) {
+		case SyntaxKind.ArrowFunction:
+		case SyntaxKind.CaseClause:
+		case SyntaxKind.CatchClause:
+		case SyntaxKind.Constructor:
+		case SyntaxKind.DefaultClause:
+		case SyntaxKind.DoStatement:
+		case SyntaxKind.ForInStatement:
+		case SyntaxKind.ForOfStatement:
+		case SyntaxKind.ForStatement:
+		case SyntaxKind.FunctionDeclaration:
+		case SyntaxKind.FunctionExpression:
+		case SyntaxKind.GetAccessor:
+		case SyntaxKind.IfStatement:
+		case SyntaxKind.LabeledStatement:
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.ModuleBlock:
+		case SyntaxKind.SetAccessor:
+		case SyntaxKind.TryStatement:
+		case SyntaxKind.WhileStatement:
+		case SyntaxKind.WithStatement: return true;
+		default: return node.statements.some(isUsingVariableStatement);
+	}
+}
+var unnecessaryBlocks_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports standalone block statements that don't create a meaningful scope.",
+		id: "unnecessaryBlocks",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { unnecessaryBlock: {
+		primary: "This standalone block statement is unnecessary and doesn't change any variable scopes.",
+		secondary: ["Standalone block statements that aren't part of control flow (if/else, loops, switch) or don't create a meaningful lexical scope can be confusing and should be avoided.", "In modern JavaScript and TypeScript, blocks primarily serve to create lexical scope for `let` and `const` variables, but this is often better achieved through other means."],
+		suggestions: ["Remove the block statement and move its contents to the parent scope.", "If you need lexical scoping, consider using an IIFE (Immediately Invoked Function Expression) or extracting to a separate function."]
+	} },
+	setup(context) {
+		return { visitors: { Block: (node, { sourceFile }) => {
+			if (!isValidBlock(node)) context.report({
+				message: "unnecessaryBlock",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getStart(sourceFile) + 1
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { unnecessaryBlocks_default as default };
+
 //# sourceMappingURL=unnecessaryBlocks.js.map

package/lib/rules/unnecessaryBooleanCasts.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary boolean casts.";
+    readonly id: "unnecessaryBooleanCasts";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessary", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryBooleanCasts.d.ts.map

package/lib/rules/unnecessaryBooleanCasts.js

@@ -0,0 +1,58 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isInBooleanContext } from "./utils/isInBooleanContext.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/unnecessaryBooleanCasts.ts
+function getNodeText(node, sourceFile) {
+	return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
+}
+function isBooleanCall(node) {
+	return ts.isIdentifier(node.expression) && node.expression.text === "Boolean";
+}
+function isDoubleNegation(node) {
+	if (node.operator !== ts.SyntaxKind.ExclamationToken) return false;
+	const operand = node.operand;
+	if (ts.isPrefixUnaryExpression(operand) && operand.operator === ts.SyntaxKind.ExclamationToken) return true;
+	return false;
+}
+var unnecessaryBooleanCasts_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary boolean casts.",
+		id: "unnecessaryBooleanCasts",
+		presets: ["logical"]
+	},
+	messages: { unnecessary: {
+		primary: "Casting this value to a boolean is unnecessary in this context.",
+		secondary: ["The value is already in a boolean context.", "Using `{{ cast }}` to cast it does not change program behavior."],
+		suggestions: ["Remove the `{{ cast }}` call."]
+	} },
+	setup(context) {
+		function reportCast(cast, outer, inner, sourceFile) {
+			const range = getTSNodeRange(outer, sourceFile);
+			context.report({
+				data: { cast },
+				fix: {
+					range,
+					text: getNodeText(inner, sourceFile)
+				},
+				message: "unnecessary",
+				range
+			});
+		}
+		return { visitors: {
+			CallExpression(node, { sourceFile }) {
+				if (!isBooleanCall(node) || !isInBooleanContext(node)) return;
+				const argument = node.arguments[0];
+				reportCast("Boolean()", node, argument, sourceFile);
+			},
+			PrefixUnaryExpression(node, { sourceFile }) {
+				if (!isDoubleNegation(node) || !isInBooleanContext(node)) return;
+				reportCast("!!", node, node.operand.operand, sourceFile);
+			}
+		} };
+	}
+});
+//#endregion
+export { unnecessaryBooleanCasts_default as default };
+
+//# sourceMappingURL=unnecessaryBooleanCasts.js.map

package/lib/rules/unnecessaryCatches.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
     readonly id: "unnecessaryCatches";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unnecessaryCatch", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryCatch", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=unnecessaryCatches.d.ts.map