@effect/language-service 0.30.0 → 0.31.0

package/README.md

@@ -52,6 +52,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn on usage of try/catch inside `Effect.gen` and family
 - Detect unnecessary pipe chains like `X.pipe(Y).pipe(Z)`
 - Warn when using `Effect.Service` with `accessors: true` but methods have generics or multiple signatures
+- Warn on missing service dependencies in `Effect.Service` declarations
 
 ### Completions
 

package/cli.js

@@ -30562,6 +30562,7 @@ function make64(ts2, tsUtils, typeChecker) {
                   );
                   if (isSome2(parsedContextTag)) {
                     let accessors2 = void 0;
+                    let dependencies = void 0;
                     if (wholeCall.arguments.length >= 2) {
                       const args3 = wholeCall.arguments[1];
                       if (ts2.isObjectLiteralExpression(args3)) {
@@ -30569,6 +30570,9 @@ function make64(ts2, tsUtils, typeChecker) {
                           if (ts2.isPropertyAssignment(property) && property.name && ts2.isIdentifier(property.name) && property.name.text === "accessors" && property.initializer && property.initializer.kind === ts2.SyntaxKind.TrueKeyword) {
                             accessors2 = true;
                           }
+                          if (ts2.isPropertyAssignment(property) && property.name && ts2.isIdentifier(property.name) && property.name.text === "dependencies" && property.initializer && ts2.isArrayLiteralExpression(property.initializer)) {
+                            dependencies = property.initializer.elements;
+                          }
                         }
                       }
                     }
@@ -30577,7 +30581,8 @@ function make64(ts2, tsUtils, typeChecker) {
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
-                      accessors: accessors2
+                      accessors: accessors2,
+                      dependencies
                     };
                   }
                 }
@@ -31299,6 +31304,89 @@ var missingEffectError = createDiagnostic({
   })
 });
 
+// src/diagnostics/missingEffectServiceDependency.ts
+var missingEffectServiceDependency = createDiagnostic({
+  name: "missingEffectServiceDependency",
+  code: 21,
+  severity: "off",
+  apply: fn("missingEffectServiceDependency.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts2.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const serviceResult = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse14(() => void_8)
+        );
+        if (serviceResult) {
+          const { className, dependencies } = serviceResult;
+          const classSymbol = typeChecker.getSymbolAtLocation(className);
+          if (classSymbol) {
+            const classType = typeChecker.getTypeOfSymbol(classSymbol);
+            const defaultWithoutDepsProperty = typeChecker.getPropertyOfType(classType, "DefaultWithoutDependencies");
+            const defaultProperty = defaultWithoutDepsProperty || typeChecker.getPropertyOfType(classType, "Default");
+            if (defaultProperty) {
+              const defaultType = typeChecker.getTypeOfSymbolAtLocation(defaultProperty, node);
+              const layerResult = yield* pipe(
+                typeParser.layerType(defaultType, node),
+                orElse14(() => void_8)
+              );
+              if (layerResult) {
+                const servicesMemory = /* @__PURE__ */ new Map();
+                const excludeNever = (type2) => succeed17((type2.flags & ts2.TypeFlags.Never) !== 0);
+                const { allIndexes: requiredIndexes } = yield* appendToUniqueTypesMap(
+                  servicesMemory,
+                  layerResult.RIn,
+                  excludeNever
+                );
+                const providedIndexes = /* @__PURE__ */ new Set();
+                const dependenciesToProcess = dependencies || [];
+                for (const depExpression of dependenciesToProcess) {
+                  const depType = typeChecker.getTypeAtLocation(depExpression);
+                  const depLayerResult = yield* pipe(
+                    typeParser.layerType(depType, depExpression),
+                    orElse14(() => void_8)
+                  );
+                  if (depLayerResult) {
+                    const { allIndexes } = yield* appendToUniqueTypesMap(
+                      servicesMemory,
+                      depLayerResult.ROut,
+                      excludeNever
+                    );
+                    for (const index of allIndexes) {
+                      providedIndexes.add(index);
+                    }
+                  }
+                }
+                const missingIndexes = requiredIndexes.filter((index) => !providedIndexes.has(index));
+                if (missingIndexes.length > 0) {
+                  const missingTypes = missingIndexes.map((index) => servicesMemory.get(index));
+                  const missingTypeNames = missingTypes.map((t) => typeChecker.typeToString(t));
+                  const message = missingTypeNames.length === 1 ? `Service '${missingTypeNames[0]}' is required but not provided by dependencies` : `Services ${missingTypeNames.map((s) => `'${s}'`).join(", ")} are required but not provided by dependencies`;
+                  report({
+                    location: className,
+                    messageText: message,
+                    fixes: []
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      ts2.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/missingReturnYieldStar.ts
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
@@ -32355,6 +32443,7 @@ var diagnostics = [
   duplicatePackage,
   missingEffectContext,
   missingEffectError,
+  missingEffectServiceDependency,
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,