oxlint-plugin-effect 0.3.0 → 0.4.0

package/dist/rules/no-dynamic-imports.js

@@ -1,87 +1,116 @@
+import { importSource, narrow } from "../vendor/effect-oxlint/AST.js";
 import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-dynamic-imports.ts
-const allowPattern = /\beffect\/no-dynamic-imports:\s*allow\s+\S/;
-const isAstNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
-const getNodeField = (node, field) => {
-	const value = node[field];
-	return isAstNode(value) ? value : void 0;
+const identifierName = (node) => node?.type === "Identifier" ? node.name : void 0;
+const hasNamedBinding = (pattern) => {
+	if (pattern.type === "Identifier") return true;
+	if (pattern.type === "ObjectPattern") return pattern.properties.length > 0;
+	if (pattern.type === "ArrayPattern") return pattern.elements.some((element) => element !== null);
+	return false;
 };
-const getStringField = (node, field) => {
-	const value = node[field];
-	return typeof value === "string" ? value : void 0;
+const isNamedVariable = (node, value) => node.type === "VariableDeclarator" && node.init === value && hasNamedBinding(node.id);
+const transparentWrappers = new Set([
+	"AwaitExpression",
+	"ChainExpression",
+	"TSAsExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"YieldExpression"
+]);
+const climbTransparent = (start) => {
+	let current = start;
+	while (current.parent != null && transparentWrappers.has(current.parent.type)) current = current.parent;
+	return current;
 };
-const getLine = (node, edge) => {
-	const loc = node["loc"];
-	if (typeof loc !== "object" || loc === null) return void 0;
-	const point = loc[edge];
-	if (typeof point !== "object" || point === null) return void 0;
-	const line = point["line"];
-	return typeof line === "number" ? line : void 0;
+const isNamedDirectBinding = (node) => {
+	const value = climbTransparent(node);
+	return value.parent != null && isNamedVariable(value.parent, value);
 };
-const hasAllowComment = (node, comments) => {
-	const startLine = getLine(node, "start");
-	if (startLine === void 0) return false;
-	return comments.some((comment) => {
-		const endLine = getLine(comment, "end");
-		if (endLine === void 0) return false;
-		if (endLine !== startLine - 1 && endLine !== startLine) return false;
-		return allowPattern.test(comment.value);
-	});
+const isNamedFunctionBoundary = (node) => {
+	const parent = node.parent;
+	if (parent?.type === "ArrowFunctionExpression" && parent.body === node) return parent.parent != null && isNamedVariable(parent.parent, parent);
+	if (parent?.type !== "ReturnStatement" || parent.argument !== node) return false;
+	const block = parent.parent;
+	const fn = block?.parent;
+	return block?.type === "BlockStatement" && fn?.type === "FunctionDeclaration" && fn.id !== null;
 };
-const createRequireAliasName = (node) => {
-	if (node.type !== "VariableDeclarator") return void 0;
-	const id = getNodeField(node, "id");
-	const init = getNodeField(node, "init");
-	if (id?.type !== "Identifier" || init?.type !== "CallExpression") return void 0;
-	const callee = getNodeField(init, "callee");
-	if (callee?.type !== "Identifier" || getStringField(callee, "name") !== "createRequire") return void 0;
-	return getStringField(id, "name");
+const isEffectPromiseCall = (node) => {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee.type !== "MemberExpression" || callee.computed) return false;
+	return identifierName(callee.object) === "Effect" && ["promise", "tryPromise"].includes(identifierName(callee.property) ?? "");
 };
-const classifyDynamicLoadCall = (callee, createRequireAliases) => {
-	if (callee === void 0) return void 0;
-	if (callee.type === "Identifier") {
-		const name = getStringField(callee, "name");
-		if (name === "require") return "`require(...)` is forbidden. Use a top-level static import.";
-		if (name !== void 0 && createRequireAliases.has(name)) return "`createRequire(...)` aliases are forbidden. Use a top-level static import.";
-	}
-	if (callee.type === "MemberExpression") {
-		const object = getNodeField(callee, "object");
-		const property = getNodeField(callee, "property");
-		if (object?.type === "Identifier" && getStringField(object, "name") === "module" && property?.type === "Identifier" && getStringField(property, "name") === "require") return "`module.require(...)` is forbidden. Use a top-level static import.";
-	}
-	if (callee.type === "CallExpression") {
-		const inner = getNodeField(callee, "callee");
-		if (inner?.type === "Identifier" && getStringField(inner, "name") === "createRequire") return "`createRequire(...)(...)` is forbidden. Use a top-level static import.";
-	}
+const isEffectPromiseBoundary = (node) => {
+	const callback = node.parent;
+	if (callback?.type !== "ArrowFunctionExpression" || callback.body !== node) return false;
+	const call = callback.parent;
+	return call != null && isEffectPromiseCall(call);
+};
+const isNamedLazyBoundary = (node) => {
+	return isNamedDirectBinding(node) || isNamedFunctionBoundary(node) || isEffectPromiseBoundary(node);
+};
+const dynamicRequireMessage = (callee) => {
+	if (identifierName(callee) === "require") return "Avoid require(). Use a static import.";
+	if (callee?.type !== "MemberExpression") return void 0;
+	return identifierName(callee.object) === "module" && identifierName(callee.property) === "require" ? "Avoid module.require(). Use a static import." : void 0;
 };
 const noDynamicImports = define({
 	name: "no-dynamic-imports",
 	meta: meta({
 		type: "problem",
-		description: "Avoid dynamic import/require. Use top-level static imports."
+		description: "Keep dynamic imports behind named lazy-loading boundaries."
 	}),
 	create: function* () {
 		const ctx = yield* RuleContext;
-		const createRequireAliases = /* @__PURE__ */ new Set();
-		const reportUnlessAllowed = (node, message) => hasAllowComment(node, ctx.sourceCode.getAllComments()) ? Effect.void : ctx.report(make({
+		const createRequireNames = /* @__PURE__ */ new Set();
+		const requireAliases = /* @__PURE__ */ new Set();
+		const report = (node, message) => ctx.report(make({
 			node,
 			message
 		}));
 		return {
-			VariableDeclarator: (node) => {
-				const alias = createRequireAliasName(node);
-				if (alias === void 0) return Effect.void;
-				createRequireAliases.add(alias);
-				return reportUnlessAllowed(node, "`createRequire(...)` is forbidden. Use a top-level static import.");
-			},
-			ImportExpression: (node) => reportUnlessAllowed(node, "Dynamic `import(...)` is forbidden. Use a top-level static import."),
+			ImportDeclaration: (node) => Option.match(narrow(node, "ImportDeclaration"), {
+				onNone: () => Effect.void,
+				onSome: (declaration) => {
+					if (!["module", "node:module"].includes(importSource(declaration))) return Effect.void;
+					for (const specifier of declaration.specifiers) if (specifier.type === "ImportSpecifier" && identifierName(specifier.imported) === "createRequire") createRequireNames.add(specifier.local.name);
+					return Effect.void;
+				}
+			}),
+			VariableDeclarator: (node) => Option.match(narrow(node, "VariableDeclarator"), {
+				onNone: () => Effect.void,
+				onSome: (declaration) => {
+					if (declaration.id.type === "Identifier" && declaration.init?.type === "CallExpression" && declaration.init.callee.type === "Identifier" && createRequireNames.has(declaration.init.callee.name)) {
+						requireAliases.add(declaration.id.name);
+						return report(declaration, "Avoid createRequire(). Keep module loading static or use a named import() boundary.");
+					}
+					return Effect.void;
+				}
+			}),
+			ImportExpression: (node) => Option.match(narrow(node, "ImportExpression"), {
+				onNone: () => Effect.void,
+				onSome: (importExpression) => isNamedLazyBoundary(importExpression) ? Effect.void : ctx.report(make({
+					node,
+					message: "Avoid inline dynamic imports. Bind the imported module or a lazy loader to a descriptive name before using it."
+				}))
+			}),
 			CallExpression: (node) => {
-				const message = classifyDynamicLoadCall(getNodeField(node, "callee"), createRequireAliases);
-				return message === void 0 ? Effect.void : reportUnlessAllowed(node, message);
+				return Option.match(narrow(node, "CallExpression"), {
+					onNone: () => Effect.void,
+					onSome: (call) => {
+						const calleeName = identifierName(call.callee);
+						const message = calleeName !== void 0 && requireAliases.has(calleeName) ? "Avoid createRequire aliases. Keep module loading static." : dynamicRequireMessage(call.callee);
+						return message === void 0 ? Effect.void : ctx.report(make({
+							node: call,
+							message
+						}));
+					}
+				});
 			}
 		};
 	}

package/dist/rules/no-globals.js

@@ -1,163 +1,200 @@
-import { calleeName, matchMember, memberNames } from "../vendor/effect-oxlint/AST.js";
+import { calleeName, memberNames, narrow } from "../vendor/effect-oxlint/AST.js";
 import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
-import { merge } from "../vendor/effect-oxlint/Visitor.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
 import "../vendor/effect-oxlint/index.js";
-import { makeEffectContextTracker } from "./_effect-context.js";
 import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
-import * as Ref from "effect/Ref";
 //#region src/rules/no-globals.ts
 const memberBans = [
 	[
 		"console",
-		[
-			"log",
-			"warn",
+		new Set([
+			"debug",
 			"error",
 			"info",
-			"debug",
-			"trace"
-		],
-		"Avoid console.* inside Effect context. Use Effect.log / Effect.logWarning / Effect.logError."
+			"log",
+			"trace",
+			"warn"
+		]),
+		"Effect logging or Console"
 	],
 	[
 		"Date",
-		"now",
-		"Avoid Date.now() inside Effect context. Use Clock service from 'effect'."
+		new Set(["now"]),
+		"Clock or DateTime"
 	],
 	[
-		"JSON",
-		["parse", "stringify"],
-		"Avoid JSON.parse/stringify inside Effect context. Use Schema.fromJsonString."
+		"Math",
+		new Set(["random"]),
+		"Random"
 	],
 	[
-		"Math",
-		"random",
-		"Avoid Math.random() inside Effect context. Use Random service from 'effect'."
+		"performance",
+		new Set(["now"]),
+		"Clock.currentTimeNanos"
 	],
 	[
 		"crypto",
-		["randomUUID", "getRandomValues"],
-		"Avoid crypto.randomUUID() inside Effect context. Use Random service from 'effect'."
+		new Set(["getRandomValues", "randomUUID"]),
+		"Crypto"
+	],
+	[
+		"JSON",
+		new Set(["parse", "stringify"]),
+		"Schema JSON codecs"
+	],
+	[
+		"process",
+		new Set([
+			"argv",
+			"chdir",
+			"env",
+			"exit",
+			"hrtime",
+			"nextTick",
+			"stderr",
+			"stdin",
+			"stdout"
+		]),
+		"Config, Stdio, Clock, or Effect scheduling"
+	],
+	[
+		"Bun",
+		new Set([
+			"$",
+			"Glob",
+			"connect",
+			"env",
+			"file",
+			"listen",
+			"nanoseconds",
+			"randomUUIDv7",
+			"redis",
+			"serve",
+			"sleep",
+			"spawn",
+			"spawnSync",
+			"stderr",
+			"stdin",
+			"stdout",
+			"write"
+		]),
+		"the corresponding Effect platform service"
+	],
+	[
+		"Deno",
+		new Set([
+			"args",
+			"env",
+			"exit",
+			"mkdir",
+			"open",
+			"readDir",
+			"readFile",
+			"readTextFile",
+			"remove",
+			"serve",
+			"stat",
+			"stderr",
+			"stdin",
+			"stdout",
+			"writeFile",
+			"writeTextFile"
+		]),
+		"the corresponding Effect platform service"
+	],
+	[
+		"localStorage",
+		new Set([
+			"clear",
+			"getItem",
+			"key",
+			"removeItem",
+			"setItem"
+		]),
+		"KeyValueStore"
+	],
+	[
+		"sessionStorage",
+		new Set([
+			"clear",
+			"getItem",
+			"key",
+			"removeItem",
+			"setItem"
+		]),
+		"KeyValueStore"
 	]
 ];
-const platformObjects = new Set([
-	"Bun",
-	"process",
-	"Deno"
+const callBans = new Map([
+	["atob", "Encoding.decodeBase64"],
+	["btoa", "Encoding.encodeBase64"],
+	["fetch", "HttpClient"],
+	["queueMicrotask", "Effect scheduling"],
+	["setImmediate", "Effect scheduling"],
+	["setInterval", "Effect.sleep with Schedule"],
+	["setTimeout", "Effect.sleep or Schedule"]
 ]);
-const alternatives = {
-	Bun: {
-		file: "Use FileSystem from 'effect'",
-		write: "Use FileSystem from 'effect'",
-		read: "Use FileSystem from 'effect'",
-		serve: "Use HttpServer from 'effect/unstable/http'",
-		env: "Use Config from 'effect'",
-		spawn: "Use Command from 'effect'",
-		sleep: "Use Effect.sleep",
-		stdin: "Use Terminal from 'effect'",
-		stdout: "Use Terminal from 'effect'",
-		stderr: "Use Terminal from 'effect'",
-		cwd: "Use Path from 'effect'",
-		which: "Use Command from 'effect'",
-		resolveSync: "Use Path from 'effect'",
-		pathToFileURL: "Use Path from 'effect'",
-		randomUUID: "Use Random service from 'effect'",
-		randomUUIDv7: "Use Random service from 'effect'"
-	},
-	process: {
-		env: "Use Config from 'effect'",
-		exit: "Use Effect.fail or Effect.die",
-		cwd: "Use Path from 'effect'",
-		argv: "Use Args/Command from 'effect/unstable/cli'",
-		stdin: "Use Terminal from 'effect'",
-		stdout: "Use Terminal from 'effect'",
-		stderr: "Use Terminal from 'effect'",
-		chdir: "Use Path from 'effect'",
-		kill: "Use Command from 'effect'",
-		on: "Use Effect.async or Stream.async",
-		platform: "Use PlatformInfo from 'effect'",
-		arch: "Use PlatformInfo from 'effect'",
-		execPath: "Use Command from 'effect'",
-		execArgv: "Use Args/Command from 'effect/unstable/cli'"
-	},
-	Deno: {
-		readFile: "Use FileSystem from 'effect'",
-		writeFile: "Use FileSystem from 'effect'",
-		readTextFile: "Use FileSystem from 'effect'",
-		writeTextFile: "Use FileSystem from 'effect'",
-		open: "Use FileSystem from 'effect'",
-		remove: "Use FileSystem from 'effect'",
-		mkdir: "Use FileSystem from 'effect'",
-		readDir: "Use FileSystem from 'effect'",
-		stat: "Use FileSystem from 'effect'",
-		cwd: "Use Path from 'effect'",
-		env: "Use Config from 'effect'",
-		exit: "Use Effect.fail or Effect.die",
-		serve: "Use HttpServer from 'effect/unstable/http'",
-		run: "Use Command from 'effect'",
-		args: "Use Args/Command from 'effect/unstable/cli'"
-	}
-};
-function getHint(obj, prop) {
-	const hint = alternatives[obj]?.[prop];
-	if (hint) return `. ${hint}`;
-	return ". Wrap in a service for testability";
-}
-const callBans = {
-	fetch: "Avoid fetch() inside Effect context. Use HttpClient from 'effect/unstable/http'.",
-	setTimeout: "Avoid setTimeout inside Effect context. Use Effect.sleep or Schedule.",
-	setInterval: "Avoid setInterval inside Effect context. Use Effect.sleep or Schedule."
+const constructorBans = new Map([
+	["Date", "Clock or DateTime"],
+	["SharedWorker", "Effect Worker"],
+	["WebSocket", "Socket"],
+	["Worker", "Effect Worker"]
+]);
+const isUnshadowedGlobal = (ctx, node, name) => Option.match(findVariableUp(ctx.sourceCode.getScope(node), name), {
+	onNone: () => true,
+	onSome: (variable) => variable.defs.length === 0
+});
+const staticMember = (node) => Option.getOrUndefined(memberNames(node));
+const isCryptoDigest = (node) => {
+	if (node.computed || node.property.type !== "Identifier" || node.property.name !== "digest") return false;
+	const object = node.object;
+	if (object.type !== "MemberExpression" || object.computed) return false;
+	return object.object.type === "Identifier" && object.object.name === "crypto" && object.property.type === "Identifier" && object.property.name === "subtle";
 };
 const noGlobals = define({
 	name: "no-globals",
 	meta: meta({
-		type: "suggestion",
-		description: "Avoid global/platform APIs inside Effect.gen/fn. Use Effect platform services instead."
+		type: "problem",
+		description: "Avoid ambient runtime capabilities that Effect provides as services."
 	}),
 	create: function* () {
 		const ctx = yield* RuleContext;
-		const [depth, tracker] = yield* makeEffectContextTracker;
-		return merge(tracker, {
-			MemberExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
-				if (d <= 0) return Effect.void;
-				const memberNode = node;
-				for (const [obj, props, message] of memberBans) if (Option.isSome(matchMember(memberNode, obj, props))) return ctx.report(make({
-					node,
-					message
-				}));
-				const names = Option.getOrUndefined(memberNames(memberNode));
-				if (names !== void 0) {
-					const [obj, prop] = names;
-					if (platformObjects.has(obj)) return ctx.report(make({
-						node,
-						message: `Avoid ${obj}.${prop} inside Effect context${getHint(obj, prop)}.`
-					}));
-				}
-				return Effect.void;
-			}),
-			CallExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
-				if (d <= 0) return Effect.void;
-				const name = Option.getOrUndefined(calleeName(node));
-				const message = name !== void 0 ? callBans[name] : void 0;
-				if (message !== void 0) return ctx.report(make({
-					node,
-					message
-				}));
-				return Effect.void;
-			}),
-			NewExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
-				if (d <= 0) return Effect.void;
-				const callee = node["callee"];
-				if (callee.type === "Identifier" && "name" in callee && callee.name === "Date") return ctx.report(make({
-					node,
-					message: "Avoid new Date() inside Effect context. Use Clock service from 'effect'."
-				}));
+		const report = (node, used, alternative) => ctx.report(make({
+			node,
+			message: `Avoid ${used}. Use ${alternative}; platform adapters may disable this rule explicitly.`
+		}));
+		return {
+			MemberExpression: (node) => {
+				const memberExpression = Option.getOrUndefined(narrow(node, "MemberExpression"));
+				if (memberExpression === void 0) return Effect.void;
+				if (isCryptoDigest(memberExpression) && isUnshadowedGlobal(ctx, memberExpression, "crypto")) return report(memberExpression, "crypto.subtle.digest", "Crypto.digest");
+				const names = staticMember(memberExpression);
+				if (names === void 0) return Effect.void;
+				const [object, property] = names;
+				if (!isUnshadowedGlobal(ctx, memberExpression, object)) return Effect.void;
+				for (const [bannedObject, properties, alternative] of memberBans) if (object === bannedObject && properties.has(property)) return report(memberExpression, `${object}.${property}`, alternative);
 				return Effect.void;
-			})
-		});
+			},
+			CallExpression: (node) => {
+				const call = Option.getOrUndefined(narrow(node, "CallExpression"));
+				if (call === void 0) return Effect.void;
+				const name = Option.getOrUndefined(calleeName(call));
+				if (name === void 0 || !isUnshadowedGlobal(ctx, call, name)) return Effect.void;
+				const alternative = callBans.get(name);
+				return alternative === void 0 ? Effect.void : report(call, `${name}()`, alternative);
+			},
+			NewExpression: (node) => {
+				const expression = Option.getOrUndefined(narrow(node, "NewExpression"));
+				if (expression === void 0 || expression.callee.type !== "Identifier") return Effect.void;
+				const name = expression.callee.name;
+				if (!isUnshadowedGlobal(ctx, expression, name)) return Effect.void;
+				const alternative = constructorBans.get(name);
+				return alternative === void 0 ? Effect.void : report(expression, `new ${name}()`, alternative);
+			}
+		};
 	}
 });
 //#endregion

package/dist/rules/no-new-error.js

@@ -1,11 +1,10 @@
+import { narrow } from "../vendor/effect-oxlint/AST.js";
 import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
-import { merge } from "../vendor/effect-oxlint/Visitor.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
-import { makeEffectContextTracker } from "./_effect-context.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
-import * as Ref from "effect/Ref";
 //#region src/rules/no-new-error.ts
 const nativeErrors = new Set([
 	"Error",
@@ -16,23 +15,37 @@ const nativeErrors = new Set([
 	"URIError",
 	"EvalError"
 ]);
+const defectNamespaces = new Set([
+	"Effect",
+	"Cause",
+	"Exit"
+]);
+const isDirectDefectArgument = (node) => {
+	const parent = node.parent;
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return false;
+	const callee = parent.callee;
+	if (callee.type !== "MemberExpression" || callee.computed) return false;
+	if (callee.object.type !== "Identifier" || callee.property.type !== "Identifier") return false;
+	return defectNamespaces.has(callee.object.name) && callee.property.name === "die";
+};
 const noNewError = define({
 	name: "no-new-error",
 	meta: meta({
 		type: "suggestion",
-		description: "Avoid native Error constructors. Use Schema.TaggedErrorClass."
+		description: "Reserve native Error values for explicit Effect defects."
 	}),
 	create: function* () {
 		const ctx = yield* RuleContext;
-		const [depth, tracker] = yield* makeEffectContextTracker;
-		return merge(tracker, { NewExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
-			const callee = node["callee"];
-			if (callee.type === "Identifier" && "name" in callee && nativeErrors.has(callee.name)) return ctx.report(make({
-				node,
-				message: d > 0 ? "Avoid native Error inside Effect.gen/fn. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { ... }) {} — then yield* new MyError()." : "Avoid native Error constructors. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { message: Schema.String }) {}"
-			}));
-			return Effect.void;
-		}) });
+		return { NewExpression: (node) => Option.match(narrow(node, "NewExpression"), {
+			onNone: () => Effect.void,
+			onSome: (expression) => {
+				if (expression.callee.type !== "Identifier" || !nativeErrors.has(expression.callee.name) || isDirectDefectArgument(expression)) return Effect.void;
+				return ctx.report(make({
+					node: expression,
+					message: "Avoid native Error constructors for expected failures. Use a tagged error, or pass the Error directly to Effect.die, Cause.die, or Exit.die for an explicit defect."
+				}));
+			}
+		}) };
 	}
 });
 //#endregion

package/dist/rules/no-new-promise.js

@@ -1,37 +1,38 @@
+import { memberNames, narrow } from "../vendor/effect-oxlint/AST.js";
 import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
-import { merge } from "../vendor/effect-oxlint/Visitor.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
-import { makeEffectContextTracker } from "./_effect-context.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
-import * as Ref from "effect/Ref";
 //#region src/rules/no-new-promise.ts
-/**
-* Ban `new Promise()`. Context-aware messaging.
-*
-* Inside Effect.gen/fn: "Use Effect.tryPromise or Effect.async"
-* Outside: "Use Effect.tryPromise or wrap with Effect.fn"
-*
-* Source: language-service/newPromise
-*/
+const isPromiseIdentifier = (node) => node.type === "Identifier" && "name" in node && node.name === "Promise";
 const noNewPromise = define({
 	name: "no-new-promise",
 	meta: meta({
 		type: "suggestion",
-		description: "Avoid new Promise(). Use Effect.async or Effect.tryPromise."
+		description: "Avoid Promise APIs. Use Effect concurrency and promise boundaries."
 	}),
 	create: function* () {
 		const ctx = yield* RuleContext;
-		const [depth, tracker] = yield* makeEffectContextTracker;
-		return merge(tracker, { NewExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
-			const callee = node["callee"];
-			if (callee != null && typeof callee === "object" && "type" in callee && callee.type === "Identifier" && "name" in callee && callee.name === "Promise") return ctx.report(make({
-				node,
-				message: d > 0 ? "Avoid new Promise() inside Effect.gen/fn. Use Effect.async for callback APIs, Effect.tryPromise for existing promises, or Effect.promise for infallible promises." : "Avoid new Promise(). Use Effect.async for callback APIs, Effect.tryPromise for existing promises — wrap this function with Effect.fn."
-			}));
-			return Effect.void;
-		}) });
+		const report = (node) => ctx.report(make({
+			node,
+			message: "Avoid Promise APIs. Use Effect.async for callbacks and Effect.promise or Effect.tryPromise at promise boundaries."
+		}));
+		return {
+			NewExpression: (node) => Option.match(narrow(node, "NewExpression"), {
+				onNone: () => Effect.void,
+				onSome: (expression) => isPromiseIdentifier(expression.callee) ? report(expression) : Effect.void
+			}),
+			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
+				onNone: () => Effect.void,
+				onSome: (call) => {
+					if (isPromiseIdentifier(call.callee)) return report(call);
+					if (call.callee.type !== "MemberExpression") return Effect.void;
+					return Option.getOrUndefined(memberNames(call.callee))?.[0] === "Promise" ? report(call) : Effect.void;
+				}
+			})
+		};
 	}
 });
 //#endregion