@effect/language-service 0.38.1 → 0.38.3

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);
@@ -1181,10 +1194,10 @@ function makeTypeScriptUtils(ts) {
     if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
     const packageJsonContent = packageJsonScope.contents.packageJsonContent;
     if (!hasProperty(packageJsonContent, "name")) return;
-    if (!hasProperty(packageJsonContent, "version")) return;
     if (!hasProperty(packageJsonScope, "packageDirectory")) return;
     if (!isString(packageJsonScope.packageDirectory)) return;
-    const { name, version } = packageJsonContent;
+    const { name } = packageJsonContent;
+    const version = hasProperty(packageJsonScope, "version") ? packageJsonScope.version : "";
     if (!isString(name)) return;
     if (!isString(version)) return;
     const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
@@ -1206,9 +1219,20 @@ function makeTypeScriptUtils(ts) {
       exportsKeys
     };
   }
-  function resolveModulePattern(sourceFile, pattern) {
+  function resolveModulePattern(program, sourceFile, pattern) {
     if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
-    const packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
+    let packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
+    if (!packageJsonScope && hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath) && hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction2(ts.getTemporaryModuleResolutionState) && hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath)) {
+      const temporaryModuleResolutionState = ts.getTemporaryModuleResolutionState(
+        void 0,
+        program,
+        program.getCompilerOptions()
+      );
+      packageJsonScope = parsePackageContentNameAndVersionFromScope({
+        ...sourceFile,
+        packageJsonScope: ts.getPackageScopeForPath(sourceFile.fileName, temporaryModuleResolutionState)
+      });
+    }
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
       if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -1746,18 +1770,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 +3253,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 +3384,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     pipeCall,
     scopeType,
     promiseLike,
+    extendsEffectTag,
     extendsEffectService,
     extendsContextTag,
     extendsSchemaClass,
@@ -3520,6 +3597,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");
@@ -3962,7 +4040,7 @@ var importFromBarrel = createDiagnostic({
     const program = yield* service(TypeScriptProgram);
     const packageNamesToCheck = flatten(
       languageServicePluginOptions.namespaceImportPackages.map(
-        (packageName) => tsUtils.resolveModulePattern(sourceFile, packageName)
+        (packageName) => tsUtils.resolveModulePattern(program, sourceFile, packageName)
       )
     );
     const isImportedFromBarrelExport = (element) => {
@@ -5700,7 +5778,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   const collectImportCache = fn("TypeScriptApi")(
     function* (packagePatterns, kind, topLevelNamedReexports) {
       for (const packagePattern of packagePatterns) {
-        const packageNames = tsUtils.resolveModulePattern(fromSourceFile, packagePattern);
+        const packageNames = tsUtils.resolveModulePattern(program, fromSourceFile, packagePattern);
         for (const packageName of packageNames) {
           const packageInfo = getPackageInfo(fromSourceFile.fileName, packageName);
           if (!packageInfo) continue;
@@ -10821,7 +10899,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 +11756,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 +11792,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 +13160,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])
         ),