@effect/language-service 0.38.1 → 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;
 });
@@ -3226,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) {
@@ -3308,6 +3373,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     pipeCall,
     scopeType,
     promiseLike,
+    extendsEffectTag,
     extendsEffectService,
     extendsContextTag,
     extendsSchemaClass,
@@ -3520,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");
@@ -10821,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* () {
@@ -11678,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)),
@@ -11691,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, {
@@ -13061,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])
         ),