@effect/language-service 0.84.0 → 0.84.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.84.0",
+  "version": "0.84.2",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/schema.json

@@ -2757,7 +2757,7 @@
             "suggestion"
           ],
           "default": "suggestion",
-          "description": "Suggests using Runtime methods instead of Effect.run* inside Effect contexts Default severity: suggestion."
+          "description": "Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts Default severity: suggestion."
         },
         "schemaStructWithTag": {
           "type": "string",

package/transform.js

@@ -3118,10 +3118,42 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     if (node.parent && ts.isJsxOpeningElement(node.parent) && node.parent.tagName === node) return;
     if (node.parent && ts.isJsxClosingElement(node.parent) && node.parent.tagName === node) return;
     if (node.parent && ts.isJsxAttribute(node.parent) && node.parent.name === node) return;
+    if (isInsideTypeOnlyHeritageExpression(node)) return;
     if (ts.isExpression(node) || ts.isTypeNode(node)) {
       return typeChecker.getTypeAtLocation(node);
     }
   }
+  function isInsideTypeOnlyHeritageExpression(node) {
+    if (ts.isExpressionWithTypeArguments(node)) {
+      return isTypeOnlyHeritageClause(node.parent);
+    }
+    if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node)) {
+      return false;
+    }
+    for (let current = node.parent; current; current = current.parent) {
+      if (ts.isPropertyAccessExpression(current)) {
+        continue;
+      }
+      if (ts.isExpressionWithTypeArguments(current)) {
+        return isTypeOnlyHeritageClause(current.parent);
+      }
+      return false;
+    }
+    return false;
+  }
+  function isTypeOnlyHeritageClause(node) {
+    if (!node || !ts.isHeritageClause(node)) {
+      return false;
+    }
+    const container = node.parent;
+    if (!container) {
+      return false;
+    }
+    if (ts.isInterfaceDeclaration(container)) {
+      return true;
+    }
+    return ts.isClassLike(container) && node.token === ts.SyntaxKind.ImplementsKeyword;
+  }
   function resolveToGlobalSymbol(symbol3) {
     if (symbol3.flags & ts.SymbolFlags.Alias) {
       symbol3 = typeChecker.getAliasedSymbol(symbol3);
@@ -5933,12 +5965,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",
@@ -5952,6 +5986,7 @@ var effectFnImplicitAny = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const noImplicitAny = program.getCompilerOptions().noImplicitAny ?? program.getCompilerOptions().strict ?? false;
     if (!noImplicitAny) {
@@ -5991,7 +6026,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) {
@@ -11155,16 +11190,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: fn("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
-    if (typeParser.supportedEffect() === "v4") return;
+    const supportedEffect = typeParser.supportedEffect();
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map4(() => ({ node, methodName }))
@@ -11197,9 +11232,10 @@ var runEffectInsideEffect = createDiagnostic({
         if (scopeNode && scopeNode !== effectGen.generatorFunction) {
           const fixAddRuntime = gen(function* () {
             const changeTracker = yield* service(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];
@@ -11213,11 +11249,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),
+                      option
+                    );
+                    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,
@@ -11253,16 +11324,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
             }]
           });