@effect/language-service 0.69.0 → 0.69.2

package/index.js

@@ -3479,6 +3479,7 @@ var defaults = {
   }],
   extendedKeyDetection: false,
   pipeableMinArgCount: 2,
+  effectFn: ["span"],
   layerGraphFollowDepth: 0,
   mermaidProvider: "mermaid.live"
 };
@@ -3518,6 +3519,7 @@ function parse(config) {
     keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns,
     extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection,
     pipeableMinArgCount: isObject(config) && hasProperty(config, "pipeableMinArgCount") && isNumber(config.pipeableMinArgCount) ? config.pipeableMinArgCount : defaults.pipeableMinArgCount,
+    effectFn: isObject(config) && hasProperty(config, "effectFn") && isArray(config.effectFn) && config.effectFn.every(isString) ? config.effectFn.map((_) => _.toLowerCase()) : defaults.effectFn,
     layerGraphFollowDepth: isObject(config) && hasProperty(config, "layerGraphFollowDepth") && isNumber(config.layerGraphFollowDepth) ? config.layerGraphFollowDepth : defaults.layerGraphFollowDepth,
     mermaidProvider: isObject(config) && hasProperty(config, "mermaidProvider") && isString(config.mermaidProvider) ? config.mermaidProvider : defaults.mermaidProvider
   };
@@ -5421,6 +5423,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           node
         );
       }
+      const traceExpression = ts.isCallExpression(node.expression) && node.expression.arguments.length > 0 ? node.expression.arguments[0] : void 0;
       const propertyAccess = expressionToTest;
       const pipeArguments2 = node.arguments.slice(1);
       return pipe(
@@ -5430,7 +5433,8 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           generatorFunction,
           effectModule: propertyAccess.expression,
           body: generatorFunction.body,
-          pipeArguments: pipeArguments2
+          pipeArguments: pipeArguments2,
+          traceExpression
         }))
       );
     },
@@ -5513,6 +5517,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       if (!ts.isPropertyAccessExpression(expressionToTest)) {
         return typeParserIssue("Node is not a property access expression", void 0, node);
       }
+      const traceExpression = ts.isCallExpression(node.expression) && node.expression.arguments.length > 0 ? node.expression.arguments[0] : void 0;
       const propertyAccess = expressionToTest;
       const pipeArguments2 = node.arguments.slice(1);
       return pipe(
@@ -5521,7 +5526,8 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           node,
           effectModule: propertyAccess.expression,
           regularFunction,
-          pipeArguments: pipeArguments2
+          pipeArguments: pipeArguments2,
+          traceExpression
         }))
       );
     },
@@ -8358,7 +8364,8 @@ var effectFnIife = createDiagnostic({
           kind: "fn",
           effectModule: result.effectModule,
           generatorFunction: result.generatorFunction,
-          pipeArguments: result.pipeArguments
+          pipeArguments: result.pipeArguments,
+          traceExpression: result.traceExpression
         })),
         orElse2(
           () => pipe(
@@ -8367,7 +8374,8 @@ var effectFnIife = createDiagnostic({
               kind: "fnUntraced",
               effectModule: result.effectModule,
               generatorFunction: result.generatorFunction,
-              pipeArguments: result.pipeArguments
+              pipeArguments: result.pipeArguments,
+              traceExpression: void 0
             }))
           )
         ),
@@ -8378,14 +8386,15 @@ var effectFnIife = createDiagnostic({
               kind: "fn",
               effectModule: result.effectModule,
               generatorFunction: void 0,
-              pipeArguments: result.pipeArguments
+              pipeArguments: result.pipeArguments,
+              traceExpression: result.traceExpression
             }))
           )
         ),
         option
       );
       if (isNone2(parsed)) continue;
-      const { effectModule, generatorFunction, kind, pipeArguments: pipeArguments2 } = parsed.value;
+      const { effectModule, generatorFunction, kind, pipeArguments: pipeArguments2, traceExpression } = parsed.value;
       const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
       const fixes = [];
       if (generatorFunction && generatorFunction.parameters.length === 0) {
@@ -8414,9 +8423,10 @@ var effectFnIife = createDiagnostic({
           })
         });
       }
+      const traceExpressionText = traceExpression ? sourceFile.text.slice(traceExpression.pos, traceExpression.end) : void 0;
       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).`,
+        messageText: `${effectModuleName}.${kind} returns a reusable function that can take arguments, but here it's called immediately. Use Effect.gen instead${traceExpressionText ? ` with Effect.withSpan(${traceExpressionText}) piped in the end to mantain tracing spans` : ``}.`,
         fixes
       });
     }
@@ -8435,6 +8445,7 @@ var effectFnOpportunity = createDiagnostic({
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
+    const pluginOptions = yield* service(LanguageServicePluginOptions);
     const sourceEffectModuleName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
       "effect",
@@ -8511,6 +8522,18 @@ var effectFnOpportunity = createDiagnostic({
       }
       return false;
     };
+    const tryExtractWithSpanExpression = (expr) => gen(function* () {
+      if (!ts.isCallExpression(expr)) return void 0;
+      const callee = expr.expression;
+      const isWithSpan = yield* pipe(
+        typeParser.isNodeReferenceToEffectModuleApi("withSpan")(callee),
+        map8(() => true),
+        orElse2(() => succeed(false))
+      );
+      if (!isWithSpan) return void 0;
+      if (expr.arguments.length === 0) return void 0;
+      return expr.arguments[0];
+    });
     const tryParseGenOpportunity = (fnNode) => gen(function* () {
       const bodyExpression = getBodyExpression(fnNode);
       if (!bodyExpression) return yield* TypeParserIssue.issue;
@@ -8521,7 +8544,15 @@ var effectFnOpportunity = createDiagnostic({
       );
       const { effectModule, generatorFunction } = yield* typeParser.effectGen(subject);
       const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
-      return { effectModuleName, generatorFunction, pipeArguments: pipeArguments2 };
+      let explicitTraceExpression;
+      if (pipeArguments2.length > 0) {
+        const lastArg = pipeArguments2[pipeArguments2.length - 1];
+        const withSpanExpr = yield* tryExtractWithSpanExpression(lastArg);
+        if (withSpanExpr) {
+          explicitTraceExpression = withSpanExpr;
+        }
+      }
+      return { effectModuleName, generatorFunction, pipeArguments: pipeArguments2, explicitTraceExpression };
     });
     const isInsideEffectFn = (fnNode) => {
       const parent = fnNode.parent;
@@ -8549,6 +8580,9 @@ var effectFnOpportunity = createDiagnostic({
       if (ts.isFunctionExpression(node) && node.name) {
         return yield* TypeParserIssue.issue;
       }
+      if (node.type) {
+        return yield* TypeParserIssue.issue;
+      }
       if (yield* isInsideEffectFn(node)) {
         return yield* TypeParserIssue.issue;
       }
@@ -8576,7 +8610,8 @@ var effectFnOpportunity = createDiagnostic({
           return succeed({
             effectModuleName: sourceEffectModuleName,
             pipeArguments: [],
-            generatorFunction: void 0
+            generatorFunction: void 0,
+            explicitTraceExpression: void 0
           });
         })
       );
@@ -8584,7 +8619,8 @@ var effectFnOpportunity = createDiagnostic({
         node,
         nameIdentifier,
         effectModuleName: opportunity.effectModuleName,
-        traceName,
+        inferredTraceName: traceName,
+        explicitTraceExpression: opportunity.explicitTraceExpression,
         pipeArguments: opportunity.pipeArguments,
         generatorFunction: opportunity.generatorFunction,
         hasParamsInPipeArgs: areParametersReferencedIn(node, opportunity.pipeArguments)
@@ -8603,7 +8639,7 @@ var effectFnOpportunity = createDiagnostic({
       if (ts.isArrowFunction(node)) return false;
       return node.asteriskToken !== void 0;
     };
-    const createEffectFnNode = (originalNode, innerFunction, effectModuleName, traceName, pipeArguments2) => {
+    const createEffectFnNode = (originalNode, innerFunction, effectModuleName, traceNameOrExpression, pipeArguments2) => {
       const isGenerator = isGeneratorFunction(innerFunction);
       const newFunction = ts.factory.createFunctionExpression(
         void 0,
@@ -8618,11 +8654,12 @@ var effectFnOpportunity = createDiagnostic({
         ts.factory.createIdentifier(effectModuleName),
         "fn"
       );
-      if (traceName) {
+      if (traceNameOrExpression) {
+        const traceArg = typeof traceNameOrExpression === "string" ? ts.factory.createStringLiteral(traceNameOrExpression) : traceNameOrExpression;
         fnExpression = ts.factory.createCallExpression(
           fnExpression,
           void 0,
-          [ts.factory.createStringLiteral(traceName)]
+          [traceArg]
         );
       }
       const effectFnCall = ts.factory.createCallExpression(fnExpression, void 0, [newFunction, ...pipeArguments2]);
@@ -8664,19 +8701,35 @@ var effectFnOpportunity = createDiagnostic({
       const target = yield* pipe(parseEffectFnOpportunityTarget(node), option);
       if (isNone2(target)) continue;
       if (target.value.hasParamsInPipeArgs) continue;
-      const { effectModuleName, nameIdentifier, node: targetNode, pipeArguments: pipeArguments2, traceName } = target.value;
+      const {
+        effectModuleName,
+        explicitTraceExpression,
+        inferredTraceName,
+        nameIdentifier,
+        node: targetNode,
+        pipeArguments: pipeArguments2
+      } = target.value;
       const innerFunction = target.value.generatorFunction ?? targetNode;
       const fixes = [];
-      fixes.push({
-        fixName: "effectFnOpportunity_toEffectFn",
-        description: traceName ? `Convert to Effect.fn("${traceName}")` : "Convert to Effect.fn",
-        apply: gen(function* () {
-          const changeTracker = yield* service(ChangeTracker);
-          const newNode = createEffectFnNode(targetNode, innerFunction, effectModuleName, traceName, pipeArguments2);
-          changeTracker.replaceNode(sourceFile, targetNode, newNode);
-        })
-      });
-      if (target.value.generatorFunction) {
+      if (pluginOptions.effectFn.includes("span") && explicitTraceExpression) {
+        fixes.push({
+          fixName: "effectFnOpportunity_toEffectFnWithSpan",
+          description: "Convert to Effect.fn (with span from withSpan)",
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const finalPipeArguments = pipeArguments2.slice(0, -1);
+            const newNode = createEffectFnNode(
+              targetNode,
+              innerFunction,
+              effectModuleName,
+              explicitTraceExpression,
+              finalPipeArguments
+            );
+            changeTracker.replaceNode(sourceFile, targetNode, newNode);
+          })
+        });
+      }
+      if (pluginOptions.effectFn.includes("untraced") && target.value.generatorFunction) {
         fixes.push({
           fixName: "effectFnOpportunity_toEffectFnUntraced",
           description: "Convert to Effect.fnUntraced",
@@ -8687,10 +8740,67 @@ var effectFnOpportunity = createDiagnostic({
           })
         });
       }
-      const pipeArgsSuffix = pipeArguments2.length > 0 ? ` Effect.fn also accepts the piped transformations as additional arguments.` : ``;
+      if (pluginOptions.effectFn.includes("no-span")) {
+        fixes.push({
+          fixName: "effectFnOpportunity_toEffectFnNoSpan",
+          description: "Convert to Effect.fn (no span)",
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const newNode = createEffectFnNode(targetNode, innerFunction, effectModuleName, void 0, pipeArguments2);
+            changeTracker.replaceNode(sourceFile, targetNode, newNode);
+          })
+        });
+      }
+      if (pluginOptions.effectFn.includes("inferred-span") && inferredTraceName && !explicitTraceExpression) {
+        fixes.push({
+          fixName: "effectFnOpportunity_toEffectFnSpanInferred",
+          description: `Convert to Effect.fn("${inferredTraceName}")`,
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const newNode = createEffectFnNode(
+              targetNode,
+              innerFunction,
+              effectModuleName,
+              inferredTraceName,
+              pipeArguments2
+            );
+            changeTracker.replaceNode(sourceFile, targetNode, newNode);
+          })
+        });
+      }
+      if (fixes.length === 0) continue;
+      const generateExpectedSignature = () => {
+        const firstFix = fixes[0];
+        if (!firstFix) return "Effect.fn(function*() { ... })";
+        const typeParamNames = targetNode.typeParameters ? `<${targetNode.typeParameters.map((tp) => ts.idText(tp.name)).join(", ")}>` : "";
+        const paramNames = targetNode.parameters.map((param) => {
+          if (ts.isIdentifier(param.name)) {
+            return ts.idText(param.name);
+          }
+          return "_";
+        }).join(", ");
+        const fnSignature = `function*${typeParamNames}(${paramNames}) { ... }`;
+        const pipeArgsForWithSpan = pipeArguments2.slice(0, -1);
+        const pipeArgsSuffix = (args2) => args2.length > 0 ? ", ...pipeTransformations" : "";
+        switch (firstFix.fixName) {
+          case "effectFnOpportunity_toEffectFnWithSpan": {
+            const traceName = explicitTraceExpression ? sourceFile.text.slice(explicitTraceExpression.pos, explicitTraceExpression.end).trim() : void 0;
+            return `${effectModuleName}.fn(${traceName})(${fnSignature}${pipeArgsSuffix(pipeArgsForWithSpan)})`;
+          }
+          case "effectFnOpportunity_toEffectFnUntraced":
+            return `${effectModuleName}.fnUntraced(${fnSignature}${pipeArgsSuffix(pipeArguments2)})`;
+          case "effectFnOpportunity_toEffectFnNoSpan":
+            return `${effectModuleName}.fn(${fnSignature}${pipeArgsSuffix(pipeArguments2)})`;
+          case "effectFnOpportunity_toEffectFnSpanInferred":
+            return `${effectModuleName}.fn("${inferredTraceName}")(${fnSignature}${pipeArgsSuffix(pipeArguments2)})`;
+          default:
+            return `${effectModuleName}.fn(${fnSignature})`;
+        }
+      };
+      const expectedSignature = generateExpectedSignature();
       report({
         location: nameIdentifier ?? targetNode,
-        messageText: target.value.generatorFunction ? `This function could benefit from Effect.fn's automatic tracing and concise syntax, or Effect.fnUntraced to get just a more concise syntax.${pipeArgsSuffix}` : `This function could benefit from Effect.fn's automatic tracing and concise syntax.${pipeArgsSuffix}`,
+        messageText: `Can be rewritten as a reusable function: ${expectedSignature}`,
         fixes
       });
     }