@effect/language-service 0.67.0 → 0.69.0

package/README.md

@@ -81,7 +81,9 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when using `Effect.fail` with the global `Error` type, recommending tagged errors
 - Warn when `Layer.mergeAll` contains layers with interdependencies (where one layer provides a service that another layer in the same call requires)
 - Suggest using `Effect.fn` for functions that return `Effect.gen` for better tracing and concise syntax
+- Warn when `Effect.fn` or `Effect.fnUntraced` is used as an IIFE (Immediately Invoked Function Expression), suggesting `Effect.gen` instead
 - Suggest removing redundant identifier argument when it equals the tag value in `Schema.TaggedClass`, `Schema.TaggedError`, or `Schema.TaggedRequest`
+- Suggest using `Schema.is` instead of `instanceof` for Effect Schema types
 
 ### Completions
 

package/cli.js

@@ -26161,6 +26161,7 @@ var text7 = (name) => makeSingle(name, empty2(), text6);
 var getHelp3 = (self) => getHelpInternal2(self);
 var getUsage = (self) => getUsageInternal(self);
 var map29 = /* @__PURE__ */ dual(2, (self, f) => makeMap(self, (a) => right2(f(a))));
+var mapEffect5 = /* @__PURE__ */ dual(2, (self, f) => makeMap(self, f));
 var optional3 = (self) => withDefault2(map29(self, some2), none2());
 var orElse14 = /* @__PURE__ */ dual(2, (self, that) => orElseEither4(self, that).pipe(map29(merge)));
 var orElseEither4 = /* @__PURE__ */ dual(2, (self, that) => makeOrElse(self, that));
@@ -27122,6 +27123,7 @@ var directory2 = directory;
 var file3 = file2;
 var integer5 = integer4;
 var text8 = text7;
+var mapEffect6 = mapEffect5;
 var optional4 = optional3;
 var repeated4 = repeated3;
 var withDefault3 = withDefault2;
@@ -27173,8 +27175,8 @@ var none11 = /* @__PURE__ */ (() => {
 })();
 var getHelp4 = (self) => getHelpInternal3(self);
 var getUsage2 = (self) => getUsageInternal2(self);
-var map30 = /* @__PURE__ */ dual(2, (self, f) => mapEffect6(self, (a) => succeed7(f(a))));
-var mapEffect6 = /* @__PURE__ */ dual(2, (self, f) => makeMap2(self, f));
+var map30 = /* @__PURE__ */ dual(2, (self, f) => mapEffect7(self, (a) => succeed7(f(a))));
+var mapEffect7 = /* @__PURE__ */ dual(2, (self, f) => makeMap2(self, f));
 var validate5 = /* @__PURE__ */ dual(3, (self, args3, config2) => validateInternal2(self, args3, config2));
 var wizard3 = /* @__PURE__ */ dual(2, (self, config2) => wizardInternal3(self, config2));
 var allTupled2 = (arg) => {
@@ -27615,8 +27617,8 @@ var getFishCompletions4 = (self, executable) => getFishCompletionsInternal(self,
 var getZshCompletions4 = (self, executable) => getZshCompletionsInternal(self, executable);
 var getSubcommands = (self) => fromIterable6(getSubcommandsInternal(self));
 var getUsage3 = (self) => getUsageInternal3(self);
-var map32 = /* @__PURE__ */ dual(2, (self, f) => mapEffect7(self, (a) => right2(f(a))));
-var mapEffect7 = /* @__PURE__ */ dual(2, (self, f) => {
+var map32 = /* @__PURE__ */ dual(2, (self, f) => mapEffect8(self, (a) => right2(f(a))));
+var mapEffect8 = /* @__PURE__ */ dual(2, (self, f) => {
   const op = Object.create(proto23);
   op._tag = "Map";
   op.command = self;
@@ -27921,7 +27923,7 @@ var withDescriptionInternal = (self, description) => {
       return op;
     }
     case "Map": {
-      return mapEffect7(withDescriptionInternal(self.command, description), self.f);
+      return mapEffect8(withDescriptionInternal(self.command, description), self.f);
     }
     case "Subcommands": {
       const op = Object.create(proto23);
@@ -28147,6 +28149,7 @@ var helpRequestedError = (command) => {
 
 // node_modules/.pnpm/@effect+cli@0.73.0_@effect+platform@0.94.1_@effect+printer-ansi@0.47.0_@effect+printer@0.47.0_effect@3.19.14/node_modules/@effect/cli/dist/esm/ValidationError.js
 var helpRequested = helpRequestedError;
+var invalidValue2 = invalidValue;
 
 // node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Logger.js
 var withMinimumLogLevel2 = withMinimumLogLevel;
@@ -30211,7 +30214,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.67.0",
+  version: "0.69.0",
   packageManager: "pnpm@8.11.0",
   publishConfig: {
     access: "public",
@@ -36263,6 +36266,104 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectFnIife.ts
+var effectFnIife = createDiagnostic({
+  name: "effectFnIife",
+  code: 46,
+  description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
+  severity: "warning",
+  apply: fn2("effectFnIife.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const sourceEffectModuleName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isCallExpression(node)) continue;
+      const innerCall = node.expression;
+      if (!ts.isCallExpression(innerCall)) continue;
+      const parsed = yield* pipe(
+        typeParser.effectFnGen(innerCall),
+        map34((result) => ({
+          kind: "fn",
+          effectModule: result.effectModule,
+          generatorFunction: result.generatorFunction,
+          pipeArguments: result.pipeArguments
+        })),
+        orElse15(
+          () => pipe(
+            typeParser.effectFnUntracedGen(innerCall),
+            map34((result) => ({
+              kind: "fnUntraced",
+              effectModule: result.effectModule,
+              generatorFunction: result.generatorFunction,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        orElse15(
+          () => pipe(
+            typeParser.effectFn(innerCall),
+            map34((result) => ({
+              kind: "fn",
+              effectModule: result.effectModule,
+              generatorFunction: void 0,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        option5
+      );
+      if (isNone2(parsed)) continue;
+      const { effectModule, generatorFunction, kind, pipeArguments: pipeArguments2 } = parsed.value;
+      const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
+      const fixes = [];
+      if (generatorFunction && generatorFunction.parameters.length === 0) {
+        fixes.push({
+          fixName: "effectFnIife_toEffectGen",
+          description: "Convert to Effect.gen",
+          apply: gen3(function* () {
+            const changeTracker = yield* service2(ChangeTracker);
+            const effectGenCall = ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleName),
+                "gen"
+              ),
+              void 0,
+              [generatorFunction]
+            );
+            let replacementNode = effectGenCall;
+            if (pipeArguments2.length > 0) {
+              replacementNode = ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(effectGenCall, "pipe"),
+                void 0,
+                [...pipeArguments2]
+              );
+            }
+            changeTracker.replaceNode(sourceFile, node, replacementNode);
+          })
+        });
+      }
+      report({
+        location: node,
+        messageText: `${effectModuleName}.${kind} returns a reusable function that can take arguments, but here it's called immediately. Use Effect.gen instead (optionally with Effect.withSpan for tracing).`,
+        fixes
+      });
+    }
+  })
+});
+
 // src/diagnostics/effectFnOpportunity.ts
 var effectFnOpportunity = createDiagnostic({
   name: "effectFnOpportunity",
@@ -37030,6 +37131,69 @@ var importFromBarrel = createDiagnostic({
   })
 });
 
+// src/diagnostics/instanceOfSchema.ts
+var instanceOfSchema = createDiagnostic({
+  name: "instanceOfSchema",
+  code: 45,
+  description: "Suggests using Schema.is instead of instanceof for Effect Schema types",
+  severity: "off",
+  apply: fn2("instanceOfSchema.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+        const leftExpr = node.left;
+        const rightExpr = node.right;
+        const rightType = typeCheckerUtils.getTypeAtLocation(rightExpr);
+        if (!rightType) {
+          ts.forEachChild(node, appendNodeToVisit);
+          continue;
+        }
+        const isSchemaType = yield* pipe(
+          typeParser.effectSchemaType(rightType, rightExpr),
+          option5
+        );
+        if (isSchemaType._tag === "Some") {
+          report({
+            location: node,
+            messageText: "Consider using Schema.is instead of instanceof for Effect Schema types.",
+            fixes: [{
+              fixName: "instanceOfSchema_fix",
+              description: "Replace with Schema.is",
+              apply: gen3(function* () {
+                const changeTracker = yield* service2(ChangeTracker);
+                const schemaIsCall = ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier("Schema"),
+                    "is"
+                  ),
+                  void 0,
+                  [rightExpr]
+                );
+                const fullCall = ts.factory.createCallExpression(
+                  schemaIsCall,
+                  void 0,
+                  [leftExpr]
+                );
+                changeTracker.replaceNode(sourceFile, node, fullCall);
+              })
+            }]
+          });
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/layerMergeAllWithDependencies.ts
 var layerMergeAllWithDependencies = createDiagnostic({
   name: "layerMergeAllWithDependencies",
@@ -37237,12 +37401,18 @@ var leakingRequirements = createDiagnostic({
     );
     function reportLeakingRequirements(node, requirements) {
       if (requirements.length === 0) return;
+      const requirementsStr = requirements.map((_) => typeChecker.typeToString(_)).join(" | ");
       report({
         location: node,
-        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
-If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can either safely disable this diagnostic for this line through quickfixes or mark the service declaration with a JSDoc @effect-leakable-service.
-Services should usually be collected in the layer creation body, and then provided at each method that requires them.
-More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
+        messageText: `Methods of this Service require \`${requirementsStr}\` from every caller.
+
+This leaks implementation details into the service's public type \u2014 callers shouldn't need to know *how* the service works internally, only *what* it provides.
+
+Resolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.
+
+To suppress this diagnostic for specific dependency types that are intentionally passed through (e.g., HttpServerRequest), add \`@effect-leakable-service\` JSDoc to their interface declarations (e.g., the \`${typeChecker.typeToString(requirements[0])}\` interface), not to this service.
+
+More info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
         fixes: []
       });
     }
@@ -39420,6 +39590,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 // src/diagnostics.ts
 var diagnostics = [
   anyUnknownInErrorContext,
+  instanceOfSchema,
   catchAllToMapError,
   catchUnfailableEffect,
   classSelfMismatch,
@@ -39460,6 +39631,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,
@@ -41702,6 +41874,14 @@ var renderCodeActions = (result, assessmentState) => gen2(function* () {
 });
 
 // src/cli/quickfixes.ts
+var validDiagnosticNames = new Set(diagnostics.map((_) => _.name));
+var validDiagnosticCodes = new Set(diagnostics.map((_) => String(_.code)));
+var diagnosticCodeByName = new Map(diagnostics.map((_) => [_.name, _.code]));
+var ColumnRequiresLineError = class extends TaggedError("ColumnRequiresLineError") {
+  get message() {
+    return "The --column option requires --line to be specified.";
+  }
+};
 var isSkipFix = (fixName) => fixName.endsWith("_skipNextLine") || fixName.endsWith("_skipFile");
 var renderQuickFix = (sourceFile, fix) => {
   const lines3 = [];
@@ -41767,9 +41947,42 @@ var quickfixes = make58(
     project: file3("project").pipe(
       optional4,
       withDescription3("The full path of the project tsconfig.json file to check for quick fixes.")
+    ),
+    code: text8("code").pipe(
+      withDescription3("Filter by diagnostic name or code (e.g., 'floatingEffect' or '5')."),
+      mapEffect6((value5) => {
+        if (validDiagnosticNames.has(value5)) {
+          return succeed7(diagnosticCodeByName.get(value5));
+        }
+        if (validDiagnosticCodes.has(value5)) {
+          return succeed7(Number(value5));
+        }
+        const validValues = [...validDiagnosticNames].sort().join(", ");
+        return fail7(
+          invalidValue2(
+            p2(`Invalid diagnostic code '${value5}'. Valid values: ${validValues}`)
+          )
+        );
+      }),
+      optional4
+    ),
+    line: integer5("line").pipe(
+      withDescription3("Filter by line number (1-based)."),
+      optional4
+    ),
+    column: integer5("column").pipe(
+      withDescription3("Filter by column number (1-based). Requires --line to be specified."),
+      optional4
+    ),
+    fix: text8("fix").pipe(
+      withDescription3("Filter by fix name (e.g., 'floatingEffect_yieldStar')."),
+      optional4
     )
   },
-  fn("quickfixes")(function* ({ file: file5, project: project3 }) {
+  fn("quickfixes")(function* ({ code: code2, column: column3, file: file5, fix, line: line4, project: project3 }) {
+    if (isSome2(column3) && isNone2(line4)) {
+      return yield* new ColumnRequiresLineError();
+    }
     const path2 = yield* Path2;
     const tsInstance = yield* TypeScriptContext;
     const filesToCheck = isSome2(project3) ? yield* getFileNamesInTsConfig(project3.value) : /* @__PURE__ */ new Set();
@@ -41813,6 +42026,12 @@ var quickfixes = make58(
           const diagnosticMap = /* @__PURE__ */ new Map();
           for (const diagnostic of result.diagnostics) {
             if (diagnostic.start === void 0) continue;
+            if (isSome2(code2) && diagnostic.code !== code2.value) continue;
+            if (isSome2(line4)) {
+              const pos = tsInstance.getLineAndCharacterOfPosition(sourceFile, diagnostic.start);
+              if (pos.line !== line4.value - 1) continue;
+              if (isSome2(column3) && pos.character !== column3.value - 1) continue;
+            }
             const key = `${diagnostic.start}-${diagnostic.start + (diagnostic.length ?? 0)}-${diagnostic.code}`;
             const ruleName = Object.values(diagnostics).find((_) => _.code === diagnostic.code)?.name ?? `unknown(${diagnostic.code})`;
             if (!diagnosticMap.has(key)) {
@@ -41834,6 +42053,7 @@ var quickfixes = make58(
           );
           for (const codeFix of result.codeFixes) {
             if (isSkipFix(codeFix.fixName)) continue;
+            if (isSome2(fix) && codeFix.fixName !== fix.value) continue;
             const key = `${codeFix.start}-${codeFix.end}-${codeFix.code}`;
             const info2 = diagnosticMap.get(key);
             if (!info2) continue;