@effect/language-service 0.38.0 → 0.38.2

package/index.js

@@ -960,7 +960,7 @@ var match = (fa, opts) => {
 var orElse2 = (f) => (fa) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
-  nano[contE] = f;
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : f(_);
   return nano;
 };
 var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse2(() => fa)(arr2), arr[0]);
@@ -1148,6 +1148,19 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
+var partition = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const left3 = [];
+  const right3 = [];
+  const as = fromIterable(self);
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      right3.push(as[i]);
+    } else {
+      left3.push(as[i]);
+    }
+  }
+  return [left3, right3];
+});
 var every = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
@@ -1746,18 +1759,21 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   const effectRefactors = [];
   for (const refactor of refactors2) {
-    const result = yield* option(refactor.apply(sourceFile, textRange));
-    if (isSome2(result)) {
-      effectRefactors.push({
-        name: refactorNameToFullyQualifiedName(refactor.name),
-        description: refactor.description,
-        actions: [{
+    yield* pipe(
+      refactor.apply(sourceFile, textRange),
+      map3(
+        (result) => effectRefactors.push({
           name: refactorNameToFullyQualifiedName(refactor.name),
-          description: result.value.description,
-          kind: result.value.kind
-        }]
-      });
-    }
+          description: refactor.description,
+          actions: [{
+            name: refactorNameToFullyQualifiedName(refactor.name),
+            description: result.description,
+            kind: result.kind
+          }]
+        })
+      ),
+      ignore
+    );
   }
   return effectRefactors;
 });
@@ -2622,8 +2638,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           node,
           effectModule,
           generatorFunction,
-          body: generatorFunction.body,
-          functionStar: generatorFunction.getFirstToken()
+          body: generatorFunction.body
         }))
       );
     },
@@ -2670,8 +2685,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           node,
           effectModule,
           generatorFunction,
-          body: generatorFunction.body,
-          functionStar: generatorFunction.getFirstToken()
+          body: generatorFunction.body
         }))
       );
     },
@@ -2723,8 +2737,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           node,
           generatorFunction,
           effectModule,
-          body: generatorFunction.body,
-          functionStar: generatorFunction.getFirstToken()
+          body: generatorFunction.body
         }))
       );
     },
@@ -3229,6 +3242,55 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsContextTag",
     (atLocation) => atLocation
   );
+  const extendsEffectTag = cachedBy(
+    fn("TypeParser.extendsEffectTag")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const effectTagCall = wholeCall.expression;
+              if (ts.isCallExpression(effectTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const effectTagIdentifier = effectTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(effectTagIdentifier) && ts.isIdentifier(effectTagIdentifier.name) && ts.idText(effectTagIdentifier.name) === "Tag") {
+                  const parsedEffectModule = yield* pipe(
+                    importedEffectModule(effectTagIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedEffectModule)) {
+                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                    const type = typeChecker.getTypeOfSymbol(classSym);
+                    const tagType = yield* contextTag(type, atLocation);
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      keyStringLiteral: ts.isStringLiteral(effectTagCall.arguments[0]) ? effectTagCall.arguments[0] : void 0,
+                      args: effectTagCall.arguments,
+                      Identifier: tagType.Identifier,
+                      Service: tagType.Service,
+                      Tag: parsedEffectModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Effect.Tag", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectTag",
+    (atLocation) => atLocation
+  );
   const extendsEffectService = cachedBy(
     fn("TypeParser.extendsEffectService")(function* (atLocation) {
       if (!atLocation.name) {
@@ -3311,6 +3373,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     pipeCall,
     scopeType,
     promiseLike,
+    extendsEffectTag,
     extendsEffectService,
     extendsContextTag,
     extendsSchemaClass,
@@ -3523,6 +3586,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
   const { Service, accessors: accessors2, className } = yield* pipe(
     typeParser.extendsEffectService(node),
+    orElse2(() => map3(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
     orElse2(() => fail("not a class extending Effect.Service call"))
   );
   if (accessors2 !== true) return yield* fail("accessors are not enabled in the Effect.Service call");
@@ -4564,6 +4628,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
     const brokenGenerators = /* @__PURE__ */ new Set();
     const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
@@ -4586,9 +4651,9 @@ var missingStarInYieldEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map3(({ functionStar }) => {
-              if (functionStar) {
-                brokenGenerators.add(functionStar);
+            map3(({ generatorFunction }) => {
+              if (generatorFunction) {
+                brokenGenerators.add(ts.getTokenPosOfNode(generatorFunction, tsUtils.getSourceFileOfNode(node)));
               }
               brokenYields.add(node);
             }),
@@ -4598,8 +4663,8 @@ var missingStarInYieldEffectGen = createDiagnostic({
       }
     }
     brokenGenerators.forEach(
-      (node) => report({
-        location: node,
+      (pos) => report({
+        location: { pos, end: pos + "function".length },
         messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
         fixes: []
       })
@@ -10823,7 +10888,7 @@ function findInnermostGraphEdge(graph, kind, key) {
   }
 }
 function escapeMermaid(text) {
-  return text.replace(/"/mg, "#quot;").replace(/\n/mg, " ");
+  return text.replace(/"/mg, "#quot;").replace(/\n/mg, " ").replace(/</mg, "#lt;").replace(/>/mg, "#gt;");
 }
 function processNodeMermaid(graph, ctx, ctxL) {
   return gen(function* () {
@@ -11680,12 +11745,35 @@ var layerMagic = createRefactor({
                   (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
                 );
               }
-              const typeReferences = pipe(
+              const previouslyProvided = yield* pipe(
+                typeParser.layerType(typeChecker.getTypeAtLocation(atLocation), atLocation),
+                map3((_) => _.ROut),
+                option
+              );
+              const [existingBefore, newlyIntroduced] = pipe(
                 fromIterable(memory.values()),
                 sort(typeCheckerUtils.deterministicTypeOrder),
+                partition(
+                  (_) => isNone2(previouslyProvided) || typeChecker.isTypeAssignableTo(_, previouslyProvided.value)
+                )
+              );
+              const typeReferences = pipe(
+                newlyIntroduced,
                 map5((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
                 filter((_) => !!_)
               );
+              const providesUnion = typeReferences.length === 0 ? ts.factory.createTypeReferenceNode("never") : ts.factory.createUnionTypeNode(typeReferences);
+              const typeStrings = pipe(
+                existingBefore,
+                map5((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)),
+                filter((_) => !!_)
+              );
+              const unionWithComment = typeStrings.length === 0 ? providesUnion : ts.addSyntheticTrailingComment(
+                providesUnion,
+                ts.SyntaxKind.MultiLineCommentTrivia,
+                " " + typeStrings.join(" | ") + " ",
+                false
+              );
               const newDeclaration = ts.factory.createAsExpression(
                 ts.factory.createAsExpression(
                   ts.factory.createArrayLiteralExpression(extractedLayers.map((_) => _.node)),
@@ -11693,9 +11781,7 @@ var layerMagic = createRefactor({
                 ),
                 ts.factory.createTypeReferenceNode(
                   ts.factory.createQualifiedName(ts.factory.createIdentifier(layerIdentifier), "Layer"),
-                  typeReferences.length === 0 ? [
-                    ts.factory.createTypeReferenceNode("never")
-                  ] : [ts.factory.createUnionTypeNode(typeReferences)]
+                  [unionWithComment]
                 )
               );
               changeTracker.replaceNode(sourceFile, atLocation, newDeclaration, {
@@ -13063,6 +13149,7 @@ var renameKeyStrings = (sourceFile, position, _findInStrings, _findInComments, _
       const baseIdentifier = yield* pipe(
         map3(typeParser.extendsContextTag(parentClass), (_) => [_.keyStringLiteral]),
         orElse2(() => map3(typeParser.extendsEffectService(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(() => map3(typeParser.extendsEffectTag(parentClass), (_) => [_.keyStringLiteral])),
         orElse2(
           () => map3(typeParser.extendsSchemaTaggedClass(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
         ),