@effect/language-service 0.28.0 → 0.28.1

package/README.md

@@ -65,6 +65,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Transform an async function definition, into an Effect by using Effect.gen.
 - Transform an async function definition, into an Effect by using Effect.gen, and generating a tagged error for each promise call.
 - Transform a function returning an Effect.gen into a Effect.fn
+- Implement Service accessors in an `Effect.Service` or `Context.Tag` declaration
 - Function calls to pipe: Transform a set of function calls to a pipe() call.
 - Pipe to datafirst: Transform a pipe() call into a series of datafirst function calls (where available).
 - Toggle return type signature: With a single refactor, adds or removes type annotations from the definition.

package/cli.js

@@ -31471,6 +31471,47 @@ function make62(ts2, typeChecker) {
     "TypeParser.scopeType",
     (type2) => type2
   );
+  const promiseLike = cachedBy(
+    function(type2, atLocation) {
+      const thenProperty = type2.getProperty("then");
+      if (!thenProperty) return typeParserIssue("not a promise - missing then property", type2, atLocation);
+      const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
+      if (!thenType) return typeParserIssue("not a promise - missing then property", type2, atLocation);
+      for (const callSignature of thenType.getCallSignatures()) {
+        const parameter = callSignature.parameters[0];
+        if (!parameter) continue;
+        const parameterType = callSignature.getTypeParameterAtPosition(0);
+        if (!parameterType) continue;
+        let callbackCallSignatures = [];
+        let toTest = [parameterType];
+        while (toTest.length > 0) {
+          const type3 = toTest.shift();
+          if (!type3) continue;
+          const callSignatures = type3.getCallSignatures();
+          callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
+          if (type3.isUnion()) {
+            toTest = toTest.concat(type3.types);
+          }
+        }
+        for (const callableType of callbackCallSignatures) {
+          const callbackParameter = callableType.parameters[0];
+          if (!callbackParameter) {
+            continue;
+          }
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed17({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type2, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type2) => type2
+  );
   return {
     effectType,
     strictEffectType,
@@ -31486,7 +31527,8 @@ function make62(ts2, typeChecker) {
     contextTag,
     pipeableType,
     pipeCall,
-    scopeType
+    scopeType,
+    promiseLike
   };
 }