feat: add ruleCreationMethods rule

.changeset/crisp-foxes-join.md

@@ -0,0 +1,5 @@
+---
+"@flint.fyi/plugin-flint": minor
+---
+
+Add `ruleCreationMethods` rule

packages/comparisons/src/data.json

@@ -798,6 +798,14 @@
 			"status": "skipped"
 		}
 	},
+	{
+		"flint": {
+			"name": "ruleCreationMethods",
+			"plugin": "flint",
+			"preset": "logical",
+			"status": "implemented"
+		}
+	},
 	{
 		"eslint": [
 			{

packages/core/src/plugins/createPlugin.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 import z from "zod/v4";
 
 import { createLanguage } from "../languages/createLanguage.ts";
+import { RuleCreator } from "../rules/RuleCreator.ts";
 import { createPlugin } from "./createPlugin.ts";
 
 const stubLanguage = createLanguage({
@@ -12,7 +13,13 @@ const stubLanguage = createLanguage({
 
 const stubMessages = { "": { primary: "", secondary: [], suggestions: [] } };
 
-const ruleStandalone = stubLanguage.createRule({
+const ruleCreator = new RuleCreator({
+	docs: (ruleId) => `https://flint.fyi/rules/stub/${ruleId.toLowerCase()}`,
+	pluginId: "stub",
+	presets: ["first", "second"],
+});
+
+const ruleStandalone = ruleCreator.createRule(stubLanguage, {
 	about: {
 		description: "",
 		id: "standalone",
@@ -22,7 +29,7 @@ const ruleStandalone = stubLanguage.createRule({
 	setup: vi.fn(),
 });
 
-const ruleWithOptionalOption = stubLanguage.createRule({
+const ruleWithOptionalOption = ruleCreator.createRule(stubLanguage, {
 	about: {
 		description: "",
 		id: "withOptionalOption",

packages/core/src/rules/RuleCreator.ts

@@ -46,6 +46,9 @@ export class RuleCreator<Presets extends string> {
 		MessageId,
 		OptionsSchema
 	> {
+		// Use RuleCreator.createRule instead of Language.createRule
+		// But this is the original implementation
+		// flint-disable-next-line flint/ruleCreationMethods
 		return language.createRule({
 			...rule,
 			about: {

packages/plugin-flint/src/plugin.ts

@@ -5,6 +5,7 @@ import invalidCodeLines from "./rules/invalidCodeLines.ts";
 import missingPlaceholders from "./rules/missingPlaceholders.ts";
 import nodePropertyInChecks from "./rules/nodePropertyInChecks.ts";
 import placeholderFormats from "./rules/placeholderFormats.ts";
+import ruleCreationMethods from "./rules/ruleCreationMethods.ts";
 import testCaseDuplicates from "./rules/testCaseDuplicates.ts";
 import testCaseNameDuplicates from "./rules/testCaseNameDuplicates.ts";
 import testShorthands from "./rules/testShorthands.ts";
@@ -17,6 +18,7 @@ export const flint = createPlugin({
 		testCaseDuplicates,
 		testCaseNameDuplicates,
 		missingPlaceholders,
+		ruleCreationMethods,
 		placeholderFormats,
 		testShorthands,
 		nodePropertyInChecks,

packages/plugin-flint/src/rules/getStartSourceFile.ts

@@ -5,8 +5,9 @@ import {
 import { SyntaxKind } from "typescript";
 
 import { isTSNode } from "../utils/isTSNode.ts";
+import { ruleCreator } from "./ruleCreator.ts";
 
-export default typescriptLanguage.createRule({
+export default ruleCreator.createRule(typescriptLanguage, {
 	about: {
 		description:
 			"Requires passing `sourceFile` to `getStart()` for better performance.",

packages/plugin-flint/src/rules/ruleCreationMethods.test.ts

@@ -0,0 +1,50 @@
+import rule from "./ruleCreationMethods.ts";
+import { ruleTester } from "./ruleTester.ts";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Test rule",
+		id: "testRule",
+		presets: ["logical"],
+	},
+	messages: {},
+	setup(context) {
+		return { visitors: {} };
+	},
+});
+`,
+			snapshot: `
+export default typescriptLanguage.createRule({
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+               Plugin rules should be created through RuleCreator instead of calling language.createRule() directly.
+	about: {
+		description: "Test rule",
+		id: "testRule",
+		presets: ["logical"],
+	},
+	messages: {},
+	setup(context) {
+		return { visitors: {} };
+	},
+});
+`,
+		},
+	],
+	valid: [
+		`
+interface RuleCreator { createRule<T>(language: any, ruleConfig: { messages: Record<string, string> }): T; }
+declare const ruleCreator: RuleCreator;
+
+export default ruleCreator.createRule(_, {
+	messages: {},
+	setup(context) {
+		return { visitors: {} };
+	}
+});
+`,
+	],
+});

packages/plugin-flint/src/rules/ruleCreationMethods.ts

@@ -0,0 +1,45 @@
+import {
+	getTSNodeRange,
+	typescriptLanguage,
+} from "@flint.fyi/typescript-language";
+
+import { isLanguageCreateRule } from "../utils/ruleCreatorHelpers.ts";
+import { ruleCreator } from "./ruleCreator.ts";
+
+export default ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description:
+			"Reports plugin rules created directly with language instead of through RuleCreator.",
+		id: "ruleCreationMethods",
+		presets: ["logical"],
+	},
+	messages: {
+		ruleCreationMethods: {
+			primary:
+				"Plugin rules should be created through RuleCreator instead of calling language.createRule() directly.",
+			secondary: [
+				"Direct language creation bypasses the standardized rule metadata and documentation provided by RuleCreator.",
+				"RuleCreator adds the `docs` property and ensures consistent rule structure across plugins.",
+			],
+			suggestions: [
+				"Create an instance of RuleCreator from `@flint.fyi/core` (e.g. `const ruleCreator = new RuleCreator({ presets: [...] })`), then use `ruleCreator.createRule(language, { ... })` instead of `language.createRule({ ... })`.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				CallExpression(node, { sourceFile, typeChecker }) {
+					if (!isLanguageCreateRule(node, typeChecker)) {
+						return;
+					}
+
+					context.report({
+						message: "ruleCreationMethods",
+						range: getTSNodeRange(node.expression, sourceFile),
+					});
+				},
+			},
+		};
+	},
+});

packages/plugin-flint/src/utils/ruleCreatorHelpers.ts

@@ -94,23 +94,33 @@ export function getStringOriginalQuote(
 	return text[0] ?? '"';
 }
 
+export function isLanguageCreateRule(
+	node: AST.CallExpression,
+	typeChecker: ts.TypeChecker,
+): boolean {
+	return (
+		node.expression.kind === SyntaxKind.PropertyAccessExpression &&
+		node.expression.name.text === "createRule" &&
+		!isRuleCreatorCreateRule(node, typeChecker)
+	);
+}
+
 // TODO: Maybe need to check it more strictly
 // https://github.com/flint-fyi/flint/issues/152
 export function isRuleCreatorCreateRule(
 	node: AST.CallExpression,
 	typeChecker: ts.TypeChecker,
 ): boolean {
-	if (node.expression.kind !== SyntaxKind.PropertyAccessExpression) {
-		return false;
-	}
-
-	const propertyAccess = node.expression;
-	const type = typeChecker.getTypeAtLocation(propertyAccess.expression);
-	const typeName = type.getSymbol()?.getName();
+	if (
+		node.expression.kind === SyntaxKind.PropertyAccessExpression &&
+		node.expression.name.text === "createRule"
+	) {
+		const propertyAccess = node.expression;
+		const type = typeChecker.getTypeAtLocation(propertyAccess.expression);
 
-	return (
-		typeName === "RuleCreator" && propertyAccess.name.text === "createRule"
-	);
+		return type.getSymbol()?.getName() === "RuleCreator";
+	}
+	return false;
 }
 
 // TODO: Maybe need to check it more strictly

packages/site/src/content/docs/rules/flint/ruleCreationMethods.mdx

@@ -0,0 +1,67 @@
+---
+description: "Reports plugin rules created directly with language instead of through RuleCreator."
+title: "ruleCreationMethods"
+topic: "rules"
+---
+
+import { Tabs, TabItem } from "@astrojs/starlight/components";
+import { RuleEquivalents } from "~/components/RuleEquivalents";
+import RuleSummary from "~/components/RuleSummary.astro";
+
+<RuleSummary plugin="flint" rule="ruleCreationMethods" />
+
+Plugin rules should be created through `RuleCreator` instead of calling `language.createRule()` directly.
+Direct language creation bypasses the standardized rule metadata and documentation provided by `RuleCreator`, which adds the `docs` property and ensures consistent rule structure across plugins.
+
+## Examples
+
+<Tabs>
+<TabItem label="❌ Incorrect">
+
+```ts
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "My rule",
+		id: "myRule",
+		presets: ["logical"],
+	},
+	setup(context) {
+		return { visitors: {} };
+	},
+});
+```
+
+</TabItem>
+<TabItem label="✅ Correct">
+
+```ts
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { RuleCreator } from "@flint.fyi/core";
+
+const ruleCreator = new RuleCreator({ presets: ["logical"] });
+
+export default ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "My rule",
+		id: "myRule",
+		presets: ["logical"],
+	},
+	setup(context) {
+		return { visitors: {} };
+	},
+});
+```
+
+</TabItem>
+</Tabs>
+
+## Options
+
+This rule is not configurable.
+
+## When Not To Use It
+
+If you are developing plugins that are only intended for internal use or tooling that
+will need to call `language.createRule()` directly, you can safely disable this rule.