@effect/language-service 0.84.0 → 0.84.1

package/README.md

@@ -81,7 +81,7 @@ Some diagnostics are off by default or have a default severity of suggestion, bu
     <tr><td><code>leakingRequirements</code></td><td>💡</td><td></td><td>Detects implementation services leaked in service methods</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>multipleEffectProvide</code></td><td>⚠️</td><td>🔧</td><td>Warns against chaining Effect.provide calls which can cause service lifecycle issues</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>returnEffectInGen</code></td><td>💡</td><td>🔧</td><td>Warns when returning an Effect in a generator causes nested Effect&lt;Effect&lt;...&gt;&gt;</td><td>✓</td><td>✓</td></tr>
-    <tr><td><code>runEffectInsideEffect</code></td><td>💡</td><td>🔧</td><td>Suggests using Runtime methods instead of Effect.run* inside Effect contexts</td><td>✓</td><td></td></tr>
+    <tr><td><code>runEffectInsideEffect</code></td><td>💡</td><td>🔧</td><td>Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>schemaSyncInEffect</code></td><td>💡</td><td></td><td>Suggests using Effect-based Schema methods instead of sync methods inside Effect generators</td><td>✓</td><td></td></tr>
     <tr><td><code>scopeInLayerEffect</code></td><td>⚠️</td><td>🔧</td><td>Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements</td><td>✓</td><td></td></tr>
     <tr><td><code>strictEffectProvide</code></td><td>➖</td><td></td><td>Warns when using Effect.provide with layers outside of application entry points</td><td>✓</td><td>✓</td></tr>

package/cli.js

@@ -25942,7 +25942,7 @@ var runWith2 = (command, config2) => {
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.84.0",
+  version: "0.84.1",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -33935,12 +33935,14 @@ var getParameterName = (typescript, name) => {
   }
   return "parameter";
 };
-var hasOuterContextualFunctionType = (typescript, typeChecker, node) => {
+var hasOuterContextualFunctionType = (typescript, typeChecker, typeCheckerUtils, node) => {
   const contextualType = typeChecker.getContextualType(node);
   if (!contextualType) {
     return false;
   }
-  return typeChecker.getSignaturesOfType(contextualType, typescript.SignatureKind.Call).length > 0;
+  return typeCheckerUtils.unrollUnionMembers(contextualType).some(
+    (type) => typeChecker.getSignaturesOfType(type, typescript.SignatureKind.Call).length > 0
+  );
 };
 var effectFnImplicitAny = createDiagnostic({
   name: "effectFnImplicitAny",
@@ -33954,6 +33956,7 @@ var effectFnImplicitAny = createDiagnostic({
     const ts = yield* service2(TypeScriptApi);
     const program = yield* service2(TypeScriptProgram);
     const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const typeParser = yield* service2(TypeParser);
     const noImplicitAny = program.getCompilerOptions().noImplicitAny ?? program.getCompilerOptions().strict ?? false;
     if (!noImplicitAny) {
@@ -33993,7 +33996,7 @@ var effectFnImplicitAny = createDiagnostic({
         ),
         orUndefined
       );
-      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, parsed.call)) {
+      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, typeCheckerUtils, parsed.call)) {
         continue;
       }
       for (const parameter of parsed.fn.parameters) {
@@ -38088,16 +38091,16 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
 var runEffectInsideEffect = createDiagnostic({
   name: "runEffectInsideEffect",
   code: 32,
-  description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+  description: "Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts",
   group: "antipattern",
   severity: "suggestion",
   fixable: true,
-  supportedEffect: ["v3"],
+  supportedEffect: ["v3", "v4"],
   apply: fn3("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
     const tsUtils = yield* service2(TypeScriptUtils);
-    if (typeParser.supportedEffect() === "v4") return;
+    const supportedEffect = typeParser.supportedEffect();
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map12(() => ({ node, methodName }))
@@ -38130,9 +38133,10 @@ var runEffectInsideEffect = createDiagnostic({
         if (scopeNode && scopeNode !== effectGen.generatorFunction) {
           const fixAddRuntime = gen3(function* () {
             const changeTracker = yield* service2(ChangeTracker);
-            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
             const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
             let runtimeIdentifier = void 0;
+            let servicesIdentifier = void 0;
             for (const statement of effectGen.generatorFunction.body.statements) {
               if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
                 const declaration = statement.declarationList.declarations[0];
@@ -38146,11 +38150,46 @@ var runEffectInsideEffect = createDiagnostic({
                     if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
                       runtimeIdentifier = ts.idText(declaration.name);
                     }
+                    const maybeEffectServices = yield* pipe(
+                      typeParser.isNodeReferenceToEffectModuleApi("services")(yieldedExpression.expression),
+                      option4
+                    );
+                    if (isSome2(maybeEffectServices) && ts.isIdentifier(declaration.name)) {
+                      servicesIdentifier = ts.idText(declaration.name);
+                    }
                   }
                 }
               }
             }
-            if (!runtimeIdentifier) {
+            if (supportedEffect === "v4" && !servicesIdentifier) {
+              changeTracker.insertNodeAt(
+                sourceFile,
+                effectGen.body.statements[0].pos,
+                ts.factory.createVariableStatement(
+                  void 0,
+                  ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                    "effectServices",
+                    void 0,
+                    void 0,
+                    ts.factory.createYieldExpression(
+                      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                      ts.factory.createCallExpression(
+                        ts.factory.createPropertyAccessExpression(
+                          ts.factory.createIdentifier(effectModuleIdentifier),
+                          "services"
+                        ),
+                        [ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)],
+                        []
+                      )
+                    )
+                  )], ts.NodeFlags.Const)
+                ),
+                {
+                  prefix: "\n",
+                  suffix: "\n"
+                }
+              );
+            } else if (supportedEffect === "v3" && !runtimeIdentifier) {
               changeTracker.insertNodeAt(
                 sourceFile,
                 effectGen.body.statements[0].pos,
@@ -38186,16 +38225,19 @@ var runEffectInsideEffect = createDiagnostic({
             changeTracker.insertText(
               sourceFile,
               node.arguments[0].pos,
-              `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+              supportedEffect === "v4" ? `${effectModuleIdentifier}.${isEffectRunCall.value.methodName}With(${servicesIdentifier || "effectServices"})(` : `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
             );
           });
+          const v4MethodName = `${isEffectRunCall.value.methodName}With`;
+          const messageText = supportedEffect === "v4" ? `Using ${nodeText} inside an Effect is not recommended. The same services should generally be used instead to run child effects.
+Consider extracting the current services by using for example Effect.services and then use Effect.${v4MethodName} with the extracted services instead.` : `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
+Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`;
           report({
             location: node.expression,
-            messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
-Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`,
+            messageText,
             fixes: [{
               fixName: "runEffectInsideEffect_fix",
-              description: "Use a runtime to run the Effect",
+              description: supportedEffect === "v4" ? "Use the current services to run the Effect" : "Use a runtime to run the Effect",
               apply: fixAddRuntime
             }]
           });
@@ -39861,11 +39903,12 @@ var metadata_default = {
     {
       name: "runEffectInsideEffect",
       group: "antipattern",
-      description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+      description: "Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts",
       defaultSeverity: "suggestion",
       fixable: true,
       supportedEffect: [
-        "v3"
+        "v3",
+        "v4"
       ],
       preview: {
         sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  const run = () => Effect.runSync(Effect.succeed(1))\n  return run()\n})\n',
@@ -39873,7 +39916,7 @@ var metadata_default = {
           {
             start: 101,
             end: 115,
-            text: "Using Effect.runSync inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.\nConsider extracting the Runtime by using for example Effect.runtime and then use Runtime.runSync with the extracted runtime instead.    effect(runEffectInsideEffect)"
+            text: "Using Effect.runSync inside an Effect is not recommended. The same services should generally be used instead to run child effects.\nConsider extracting the current services by using for example Effect.services and then use Effect.runSyncWith with the extracted services instead.    effect(runEffectInsideEffect)"
           }
         ]
       }