@effect/language-service 0.21.3 → 0.21.4

package/package.json

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

package/transform.js

@@ -2444,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",
@@ -2522,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);
@@ -2802,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",
@@ -2906,7 +3026,9 @@ var diagnostics = [
   unnecessaryEffectGen,
   missingReturnYieldStar,
   leakingRequirements,
-  unnecessaryPipe
+  unnecessaryPipe,
+  genericEffectServices,
+  returnEffectInGen
 ];
 
 // src/transform.ts