@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/constructorSupers.js

@@ -0,0 +1,77 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/constructorSupers.ts
+function classHasExtendsClause(node) {
+	return node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
+}
+function containsSuperCall(node) {
+	if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword) return true;
+	if (tsutils.isFunctionScopeBoundary(node)) return false;
+	return ts.forEachChild(node, containsSuperCall) ?? false;
+}
+var constructorSupers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.",
+		id: "constructorSupers",
+		presets: ["javascript"]
+	},
+	messages: {
+		missingSuperCall: {
+			primary: "Constructors of derived classes must call `super()` before using `this` or returning.",
+			secondary: ["The derived class constructor must initialize the parent class by calling `super()` before accessing `this`.", "Failing to call `super()` in a derived class constructor causes a runtime error."],
+			suggestions: ["Add a `super()` call at the beginning of the constructor.", "Pass required arguments to `super()` if the parent constructor expects them."]
+		},
+		unexpectedSuperCall: {
+			primary: "Constructors of non-derived classes must not call `super()`.",
+			secondary: ["This class does not extend another class, so there is no parent constructor to call.", "Calling `super()` in a non-derived class causes a syntax error."],
+			suggestions: ["Remove the `super()` call.", "If this class should inherit from another class, add an `extends` clause."]
+		}
+	},
+	setup(context) {
+		function checkConstructor(classNode, constructor, sourceFile) {
+			if (!constructor.body) return;
+			const isDerivedClass = classHasExtendsClause(classNode) ?? false;
+			const hasSuperCall = containsSuperCall(constructor.body);
+			if (isDerivedClass && !hasSuperCall) {
+				const constructorKeyword = constructor.getChildren(sourceFile).find((child) => child.kind === ts.SyntaxKind.Constructor);
+				context.report({
+					message: "missingSuperCall",
+					range: {
+						begin: constructorKeyword?.getStart(sourceFile) ?? constructor.getStart(sourceFile),
+						end: constructorKeyword?.getEnd() ?? constructor.getStart(sourceFile) + 11
+					}
+				});
+			}
+			if (!isDerivedClass && hasSuperCall) findAndReportSuperCalls(constructor.body, sourceFile);
+		}
+		function findAndReportSuperCalls(node, sourceFile) {
+			if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword) {
+				context.report({
+					message: "unexpectedSuperCall",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+				return;
+			}
+			if (tsutils.isFunctionScopeBoundary(node)) return;
+			ts.forEachChild(node, (child) => {
+				findAndReportSuperCalls(child, sourceFile);
+			});
+		}
+		function checkClass(node, { sourceFile }) {
+			for (const member of node.members) if (member.kind === ts.SyntaxKind.Constructor) checkConstructor(node, member, sourceFile);
+		}
+		return { visitors: {
+			ClassDeclaration: checkClass,
+			ClassExpression: checkClass
+		} };
+	}
+});
+//#endregion
+export { constructorSupers_default as default };
+
+//# sourceMappingURL=constructorSupers.js.map

package/lib/rules/dateConstructorClones.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.";
+    readonly id: "dateConstructorClones";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryGetTime", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=dateConstructorClones.d.ts.map

package/lib/rules/dateConstructorClones.js

@@ -0,0 +1,37 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/dateConstructorClones.ts
+function isDateType(node, typeChecker) {
+	return typeChecker.getTypeAtLocation(node).getSymbol()?.getName() === "Date";
+}
+var dateConstructorClones_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.",
+		id: "dateConstructorClones",
+		presets: ["logical"]
+	},
+	messages: { unnecessaryGetTime: {
+		primary: "Prefer passing the Date directly instead of calling getTime().",
+		secondary: ["The Date constructor can clone a Date object directly when passed as an argument.", "Calling getTime() first is unnecessary since ES2015."],
+		suggestions: ["Remove the `.getTime()` call and pass the Date directly."]
+	} },
+	setup(context) {
+		return { visitors: { NewExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "Date" || node.arguments?.length !== 1 || !isGlobalDeclarationOfName(node.expression, "Date", typeChecker)) return;
+			const argument = node.arguments[0];
+			if (argument.kind !== SyntaxKind.CallExpression || argument.expression.kind !== SyntaxKind.PropertyAccessExpression || argument.expression.name.kind !== SyntaxKind.Identifier || argument.expression.name.text !== "getTime" || !!argument.arguments.length || !isDateType(argument.expression.expression, typeChecker)) return;
+			context.report({
+				message: "unnecessaryGetTime",
+				range: {
+					begin: argument.expression.name.getStart(sourceFile),
+					end: argument.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { dateConstructorClones_default as default };
+
+//# sourceMappingURL=dateConstructorClones.js.map

package/lib/rules/dateNowTimestamps.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.";
+    readonly id: "dateNowTimestamps";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferDateNow", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=dateNowTimestamps.d.ts.map

package/lib/rules/dateNowTimestamps.js

@@ -0,0 +1,57 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/dateNowTimestamps.ts
+var dateNowTimestamps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.",
+		id: "dateNowTimestamps",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferDateNow: {
+		primary: "Prefer the shorter `Date.now()` to get the current timestamp.",
+		secondary: ["`Date.now()` is shorter and avoids unnecessary instantiation of `Date` objects.", "It's more efficient and clearer than alternatives like `new Date().getTime()`."],
+		suggestions: ["Replace with `Date.now()`."]
+	} },
+	setup(context) {
+		function isNewDateWithNoArguments(node, typeChecker) {
+			return node.expression.kind === SyntaxKind.Identifier && node.expression.text === "Date" && !node.arguments?.length && isGlobalDeclarationOfName(node.expression, "Date", typeChecker);
+		}
+		return { visitors: {
+			CallExpression: (node, { sourceFile, typeChecker }) => {
+				if (node.expression.kind !== SyntaxKind.PropertyAccessExpression || node.expression.name.kind !== SyntaxKind.Identifier || !!node.arguments.length) return;
+				const methodName = node.expression.name.text;
+				if (methodName !== "getTime" && methodName !== "valueOf") return;
+				if (node.expression.expression.kind !== SyntaxKind.NewExpression || !isNewDateWithNoArguments(node.expression.expression, typeChecker)) return;
+				context.report({
+					message: "preferDateNow",
+					range: {
+						begin: node.expression.expression.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+			},
+			NewExpression: (node, { sourceFile, typeChecker }) => {
+				if (!isNewDateWithNoArguments(node, typeChecker)) return;
+				switch (node.parent.kind) {
+					case SyntaxKind.CallExpression:
+						if (node.parent.expression.kind === SyntaxKind.Identifier && (node.parent.expression.text === "BigInt" || node.parent.expression.text === "Number") && node.parent.arguments.length === 1 && isGlobalDeclarationOfName(node.parent.expression, node.parent.expression.text, typeChecker)) context.report({
+							message: "preferDateNow",
+							range: getTSNodeRange(node.parent, sourceFile)
+						});
+						break;
+					case SyntaxKind.PrefixUnaryExpression:
+						if (node.parent.operator === SyntaxKind.MinusToken || node.parent.operator === SyntaxKind.PlusToken) context.report({
+							message: "preferDateNow",
+							range: getTSNodeRange(node, sourceFile)
+						});
+						break;
+				}
+			}
+		} };
+	}
+});
+//#endregion
+export { dateNowTimestamps_default as default };
+
+//# sourceMappingURL=dateNowTimestamps.js.map

package/lib/rules/debuggerStatements.d.ts

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

package/lib/rules/debuggerStatements.js

@@ -1,44 +1,33 @@
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using debugger statements.",
-        id: "debuggerStatements",
-        preset: "logical",
-    },
-    messages: {
-        noDebugger: {
-            primary: "Debugger statements should not be used in production code.",
-            secondary: [
-                "The `debugger` statement causes the JavaScript runtime to pause execution and start a debugger if one is available, such as when browser developer tools are open.",
-                "This can be useful during development, but should not be left in production code.",
-            ],
-            suggestions: [
-                "Remove the `debugger` statement before shipping this code to users.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                DebuggerStatement: (node) => {
-                    const range = {
-                        begin: node.getStart(),
-                        end: node.getEnd(),
-                    };
-                    context.report({
-                        message: "noDebugger",
-                        range,
-                        suggestions: [
-                            {
-                                id: "removeDebugger",
-                                range,
-                                text: "",
-                            },
-                        ],
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/debuggerStatements.ts
+var debuggerStatements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using debugger statements.",
+		id: "debuggerStatements",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noDebugger: {
+		primary: "Debugger statements should not be used in production code.",
+		secondary: ["The `debugger` statement causes the JavaScript runtime to pause execution and start a debugger if one is available, such as when browser developer tools are open.", "This can be useful during development, but should not be left in production code."],
+		suggestions: ["Remove the `debugger` statement before shipping this code to users."]
+	} },
+	setup(context) {
+		return { visitors: { DebuggerStatement: (node, { sourceFile }) => {
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				message: "noDebugger",
+				range,
+				suggestions: [{
+					id: "removeDebugger",
+					range,
+					text: ""
+				}]
+			});
+		} } };
+	}
 });
+//#endregion
+export { debuggerStatements_default as default };
+
 //# sourceMappingURL=debuggerStatements.js.map

package/lib/rules/defaultCaseLast.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports switch statements where the default clause is not last.";
     readonly id: "defaultCaseLast";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "defaultCaseShouldBeLast", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "defaultCaseShouldBeLast", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=defaultCaseLast.d.ts.map

package/lib/rules/defaultCaseLast.js

@@ -1,44 +1,36 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports switch statements where the default clause is not last.",
-        id: "defaultCaseLast",
-        preset: "logical",
-    },
-    messages: {
-        defaultCaseShouldBeLast: {
-            primary: "Default clauses in switch statements should be last.",
-            secondary: [
-                "Placing the default clause in a position other than last can lead to confusion and unexpected behavior.",
-                "While the default clause is executed when no case matches, having it in the middle of other cases makes the control flow harder to follow.",
-            ],
-            suggestions: [
-                "Move the default clause to the end of the switch statement to improve code clarity.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                SwitchStatement: (node, { sourceFile }) => {
-                    const clauses = node.caseBlock.clauses;
-                    const defaultClauseIndex = clauses.findIndex((clause) => clause.kind === ts.SyntaxKind.DefaultClause);
-                    if (defaultClauseIndex === -1 ||
-                        defaultClauseIndex === clauses.length - 1) {
-                        return;
-                    }
-                    const defaultClause = clauses[defaultClauseIndex];
-                    context.report({
-                        message: "defaultCaseShouldBeLast",
-                        range: {
-                            begin: defaultClause.getStart(sourceFile),
-                            end: defaultClause.getStart(sourceFile) + "default".length,
-                        },
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/defaultCaseLast.ts
+var defaultCaseLast_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports switch statements where the default clause is not last.",
+		id: "defaultCaseLast",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { defaultCaseShouldBeLast: {
+		primary: "Default clauses in switch statements should be last.",
+		secondary: ["Placing the default clause in a position other than last can lead to confusion and unexpected behavior.", "While the default clause is executed when no case matches, having it in the middle of other cases makes the control flow harder to follow."],
+		suggestions: ["Move the default clause to the end of the switch statement to improve code clarity."]
+	} },
+	setup(context) {
+		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
+			const clauses = node.caseBlock.clauses;
+			const defaultClauseIndex = clauses.findIndex((clause) => clause.kind === SyntaxKind.DefaultClause);
+			if (defaultClauseIndex === -1 || defaultClauseIndex === clauses.length - 1) return;
+			const defaultClause = nullThrows(clauses[defaultClauseIndex], "Default clause is expected to be present by prior length check");
+			context.report({
+				message: "defaultCaseShouldBeLast",
+				range: {
+					begin: defaultClause.getStart(sourceFile),
+					end: defaultClause.getStart(sourceFile) + 7
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { defaultCaseLast_default as default };
+
 //# sourceMappingURL=defaultCaseLast.js.map

package/lib/rules/defaultParameterLast.d.ts

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

package/lib/rules/defaultParameterLast.js

@@ -0,0 +1,42 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/defaultParameterLast.ts
+var defaultParameterLast_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforce default parameters to be last.",
+		id: "defaultParameterLast",
+		presets: ["javascript"]
+	},
+	messages: { defaultParameterLast: {
+		primary: "Default parameters should be last to allow omitting optional tail arguments.",
+		secondary: ["Putting default parameters last allows function calls to omit optional tail arguments.", "Non-default parameters after default ones must always be explicitly provided."],
+		suggestions: ["Move the default parameter to the end of the parameter list."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			let hasSeenDefaultParameter = false;
+			for (const parameter of node.parameters) {
+				if (parameter.dotDotDotToken) continue;
+				if (parameter.questionToken || parameter.initializer) {
+					hasSeenDefaultParameter = true;
+					continue;
+				}
+				if (hasSeenDefaultParameter) context.report({
+					message: "defaultParameterLast",
+					range: getTSNodeRange(parameter, sourceFile)
+				});
+			}
+		}
+		return { visitors: {
+			ArrowFunction: checkNode,
+			Constructor: checkNode,
+			FunctionDeclaration: checkNode,
+			FunctionExpression: checkNode,
+			MethodDeclaration: checkNode
+		} };
+	}
+});
+//#endregion
+export { defaultParameterLast_default as default };
+
+//# sourceMappingURL=defaultParameterLast.js.map

package/lib/rules/deprecated.d.ts

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