@effect/language-service 0.21.2 → 0.21.4

package/README.md

@@ -6,11 +6,11 @@ This package implements a TypeScript language service plugin that allows additio
 
 1. `npm install @effect/language-service --save-dev` in your project
 2. inside your tsconfig.json, you should add the plugin configuration as follows:
-
 ```json
 {
   "compilerOptions": {
     "plugins": [
+      // ... other LSPs (if any) and as last
       {
         "name": "@effect/language-service"
       }
@@ -133,3 +133,42 @@ Effect.succeed(1); // This will not be reported as a floating effect
 // @effect-diagnostics effect/floatingEffect:error
 Effect.succeed(1); // This will be reported as a floating effect
 ```
+
+or you can set the severity for the entire project in the global plugin configuration
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        // ...
+        "diagnosticSeverity": { // allows to change per-rule default severity of the diagnostic in the whole project
+          "floatingEffect": "warning" // example for a rule, allowed values are off,error,warning,message,suggestion
+        },
+        // ...
+      }
+    ]
+  }
+}
+```
+
+## Known gotchas
+
+### Svelte VSCode extension and SvelteKit
+
+The Svelte LSP does not properly compose with other LSPs when using SvelteKit. So the Effect LSP should be loaded as last entry to ensure proper composition.
+
+If you did not installed the Svelte LSP into your local project but instead through the Svelte VSCode extension, we recommend instead to install locally and add it as first entry. That way it won't be applied by the VSCode extension.
+
+Your tsconfig should look like this:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      { "name": "typescript-svelte-plugin" },
+      { "name": "@effect/language-service" }
+    ]
+  }
+}
+```

package/index.js

@@ -1191,6 +1191,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;
@@ -1199,7 +1201,8 @@ function parsePackageContentNameAndVersionFromScope(v) {
     name: name.toLowerCase(),
     version: version.toLowerCase(),
     hasEffectInPeerDependencies,
-    contents: packageJsonContent
+    contents: packageJsonContent,
+    packageDirectory: packageJsonScope.packageDirectory
   };
 }
 
@@ -2864,7 +2867,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);
@@ -2877,7 +2880,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: []
         });
       }
@@ -2934,6 +2939,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),
+          map4(() => {
+            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: []
+            });
+          }),
+          orElse3(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          ignore
+        );
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/leakingRequirements.ts
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
@@ -3012,7 +3065,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);
@@ -3208,7 +3261,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
       });
     });
@@ -3292,6 +3345,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),
+                orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
+                orElse3(() => typeParser.effectFnGen(effectGenNode)),
+                map4(() => brokenReturnStatements.add(node)),
+                ignore
+              );
+            }
+          }
+        }
+      }
+    }
+    brokenReturnStatements.forEach((node) => {
+      const fix = node.expression ? [{
+        fixName: "returnEffectInGen_fix",
+        description: "Add yield* statement",
+        apply: gen2(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",
@@ -3396,7 +3521,9 @@ var diagnostics = [
   unnecessaryEffectGen,
   missingReturnYieldStar,
   leakingRequirements,
-  unnecessaryPipe
+  unnecessaryPipe,
+  genericEffectServices,
+  returnEffectInGen
 ];
 
 // src/goto/effectRpcDefinition.ts