@effect/language-service 0.21.2 → 0.21.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.21.2",
+  "version": "0.21.4",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "repository": {

package/transform.js

@@ -1014,6 +1014,8 @@ function parsePackageContentNameAndVersionFromScope(v) {
   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;
   if (!isString(name)) return;
   if (!isString(version)) return;
@@ -1022,7 +1024,8 @@ function parsePackageContentNameAndVersionFromScope(v) {
     name: name.toLowerCase(),
     version: version.toLowerCase(),
     hasEffectInPeerDependencies,
-    contents: packageJsonContent
+    contents: packageJsonContent,
+    packageDirectory: packageJsonScope.packageDirectory
   };
 }
 
@@ -2369,7 +2372,7 @@ var duplicatePackage = createDiagnostic({
         if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
         if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
         resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
-        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.contents;
+        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
       });
       checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
       programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
@@ -2382,7 +2385,9 @@ var duplicatePackage = createDiagnostic({
           category: ts.DiagnosticCategory.Warning,
           messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
 Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
-If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.`,
+If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
+
+${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
           fixes: []
         });
       }
@@ -2439,6 +2444,54 @@ var floatingEffect = createDiagnostic({
   })
 });
 
+// src/diagnostics/genericEffectServices.ts
+var genericEffectServices = createDiagnostic({
+  name: "genericEffectServices",
+  code: 10,
+  apply: fn("genericEffectServices.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const effectDiagnostics = [];
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const typesToCheck = [];
+      if (ts.isClassDeclaration(node) && node.name && node.typeParameters && node.heritageClauses) {
+        const classSym = typeChecker.getSymbolAtLocation(node.name);
+        if (classSym) {
+          const type = typeChecker.getTypeOfSymbol(classSym);
+          typesToCheck.push([type, node.name]);
+        }
+      } else {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      for (const [type, reportAt] of typesToCheck) {
+        yield* pipe(
+          typeParser.contextTag(type, node),
+          map3(() => {
+            effectDiagnostics.push({
+              node: reportAt,
+              category: ts.DiagnosticCategory.Warning,
+              messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
+              fixes: []
+            });
+          }),
+          orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          ignore
+        );
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/leakingRequirements.ts
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
@@ -2517,7 +2570,7 @@ var leakingRequirements = createDiagnostic({
       const typesToCheck = [];
       if (ts.isCallExpression(node)) {
         typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
-      } else if (ts.isClassDeclaration(node) && node.name) {
+      } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
         if (classSym) {
           const type = typeChecker.getTypeOfSymbol(classSym);
@@ -2713,7 +2766,7 @@ var missingReturnYieldStar = createDiagnostic({
       effectDiagnostics.push({
         node,
         category: ts.DiagnosticCategory.Error,
-        messageText: `Yielded Effect never completes, so it is best to use a 'return yield*' instead.`,
+        messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
         fixes: fix
       });
     });
@@ -2797,6 +2850,78 @@ var missingStarInYieldEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/returnEffectInGen.ts
+var returnEffectInGen = createDiagnostic({
+  name: "returnEffectInGen",
+  code: 11,
+  apply: fn("returnEffectInGen.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const effectDiagnostics = [];
+    const brokenReturnStatements = /* @__PURE__ */ new Set();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isReturnStatement(node) && node.expression) {
+        if (ts.isYieldExpression(node.expression)) continue;
+        const generatorOrRegularFunction = ts.findAncestor(
+          node,
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_)
+        );
+        if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const maybeEffect = yield* option(typeParser.effectType(type, node.expression));
+        if (isSome2(maybeEffect)) {
+          const maybeEffectSubtype = yield* option(typeParser.effectSubtype(type, node.expression));
+          if (isNone2(maybeEffectSubtype)) {
+            if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
+              const effectGenNode = generatorOrRegularFunction.parent;
+              yield* pipe(
+                typeParser.effectGen(effectGenNode),
+                orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+                orElse2(() => typeParser.effectFnGen(effectGenNode)),
+                map3(() => brokenReturnStatements.add(node)),
+                ignore
+              );
+            }
+          }
+        }
+      }
+    }
+    brokenReturnStatements.forEach((node) => {
+      const fix = node.expression ? [{
+        fixName: "returnEffectInGen_fix",
+        description: "Add yield* statement",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node.expression,
+            ts.factory.createYieldExpression(
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              node.expression
+            )
+          );
+        })
+      }] : [];
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Suggestion,
+        messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>. Maybe you wanted to return yield* instead? Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect.`,
+        fixes: fix
+      });
+    });
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -2901,7 +3026,9 @@ var diagnostics = [
   unnecessaryEffectGen,
   missingReturnYieldStar,
   leakingRequirements,
-  unnecessaryPipe
+  unnecessaryPipe,
+  genericEffectServices,
+  returnEffectInGen
 ];
 
 // src/transform.ts