@effect/language-service 0.38.1 → 0.38.2

package/effect-lsp-patch-utils.js

@@ -1053,7 +1053,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]);
@@ -1724,18 +1724,21 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   const effectRefactors = [];
   for (const refactor of refactors) {
-    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),
+      map4(
+        (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;
 });
@@ -3140,6 +3143,55 @@ function make2(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) {
@@ -3222,6 +3274,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     pipeCall,
     scopeType,
     promiseLike,
+    extendsEffectTag,
     extendsEffectService,
     extendsContextTag,
     extendsSchemaClass,
@@ -4464,6 +4517,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(() => map4(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");