@effect/language-service 0.30.0 → 0.31.0

package/index.js

@@ -2974,6 +2974,7 @@ function make3(ts, tsUtils, typeChecker) {
                   );
                   if (isSome2(parsedContextTag)) {
                     let accessors2 = void 0;
+                    let dependencies = void 0;
                     if (wholeCall.arguments.length >= 2) {
                       const args2 = wholeCall.arguments[1];
                       if (ts.isObjectLiteralExpression(args2)) {
@@ -2981,6 +2982,9 @@ function make3(ts, tsUtils, typeChecker) {
                           if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && property.name.text === "accessors" && property.initializer && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
                             accessors2 = true;
                           }
+                          if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && property.name.text === "dependencies" && property.initializer && ts.isArrayLiteralExpression(property.initializer)) {
+                            dependencies = property.initializer.elements;
+                          }
                         }
                       }
                     }
@@ -2989,7 +2993,8 @@ function make3(ts, tsUtils, typeChecker) {
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
-                      accessors: accessors2
+                      accessors: accessors2,
+                      dependencies
                     };
                   }
                 }
@@ -4081,6 +4086,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 ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const serviceResult = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse2(() => void_)
+        );
+        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),
+                orElse2(() => void_)
+              );
+              if (layerResult) {
+                const servicesMemory = /* @__PURE__ */ new Map();
+                const excludeNever = (type) => succeed((type.flags & ts.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),
+                    orElse2(() => void_)
+                  );
+                  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: []
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/missingReturnYieldStar.ts
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
@@ -4861,6 +4949,7 @@ var diagnostics = [
   duplicatePackage,
   missingEffectContext,
   missingEffectError,
+  missingEffectServiceDependency,
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,