@effect/language-service 0.29.0 → 0.31.0

package/README.md

@@ -46,10 +46,13 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn on leaking requirements in Effect services
 - Warn on Scope as requirement of a Layer
 - Warn on subsequent `Effect.provide` anti-pattern
+- Detect wrong `Self` type parameter for APIs like `Effect.Service` or `Schema.TaggedError` and similar 
 - Unnecessary usages of `Effect.gen` or `pipe()`
 - Warn when importing from a barrel file instead of from the module directly
 - 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
 
@@ -106,30 +109,6 @@ Few options can be provided alongside the initialization of the Language Service
 ### DiagnosticSeverty properties list
 
 The full list can be found in the [diagnostics](https://github.com/Effect-TS/language-service/tree/main/src/diagnostics) folder.
-Here is the current list of diagnostics you can use to override severity:
-
-
-```bash
-duplicatePackage 
-effectInVoidSuccess
-floatingEffect
-genericEffectServices
-importFromBarrel
-leakingRequirements
-middlewareAutoImportQuickfixes
-missingEffectContext
-missingEffectError
-missingReturnYieldStar
-missingStarInYieldEffectGen
-multipleEffectProvide
-returnEffectInGen
-scopeInLayerEffect
-strictBooleanExpressions
-tryCatchInEffectGen
-unnecessaryEffectGen
-unnecessaryPipe
-unnecessaryPipeChain
-```
 
 ## Why do diagnostics not appear at compile time?
 

package/cli.js

@@ -29927,6 +29927,36 @@ function make64(ts2, tsUtils, typeChecker) {
     "TypeParser.effectSubtype",
     (type2) => type2
   );
+  const importedSchemaModule = cachedBy(
+    fn("TypeParser.importedSchemaModule")(function* (node) {
+      const type2 = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type2, "Class");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Class' property", type2, node);
+      }
+      if (!ts2.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type2, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedSchemaModule",
+    (node) => node
+  );
+  const importedContextModule = cachedBy(
+    fn("TypeParser.importedContextModule")(function* (node) {
+      const type2 = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type2, "Tag");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Tag' property", type2, node);
+      }
+      if (!ts2.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type2, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedContextModule",
+    (node) => node
+  );
   const importedEffectModule = cachedBy(
     fn("TypeParser.importedEffectModule")(function* (node) {
       const type2 = typeChecker.getTypeAtLocation(node);
@@ -30283,6 +30313,226 @@ function make64(ts2, tsUtils, typeChecker) {
     "TypeParser.promiseLike",
     (type2) => type2
   );
+  const extendsSchemaClass = cachedBy(
+    fn("TypeParser.extendsSchemaClass")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaCall.typeArguments[0];
+                const schemaIdentifier = schemaCall.expression;
+                if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "Class") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option4
+                  );
+                  if (isSome2(parsedSchemaModule)) {
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      Schema: parsedSchemaModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.Class", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaClass",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedClass = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedClass")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts2.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedClass") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option4
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedClass", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedClass",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedError = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedError")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts2.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedError") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option4
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedError", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedError",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedRequest = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts2.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedRequest") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option4
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedRequest", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedRequest",
+    (atLocation) => atLocation
+  );
+  const extendsContextTag = cachedBy(
+    fn("TypeParser.extendsContextTag")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+      const type2 = typeChecker.getTypeOfSymbol(classSym);
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts2.isCallExpression(wholeCall)) {
+              const contextTagCall = wholeCall.expression;
+              if (ts2.isCallExpression(contextTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const contextTagIdentifier = contextTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts2.isPropertyAccessExpression(contextTagIdentifier) && ts2.isIdentifier(contextTagIdentifier.name) && contextTagIdentifier.name.text === "Tag") {
+                  const parsedContextModule = yield* pipe(
+                    importedContextModule(contextTagIdentifier.expression),
+                    option4
+                  );
+                  if (isSome2(parsedContextModule)) {
+                    const tagType = yield* contextTag(type2, atLocation);
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      args: contextTagCall.arguments,
+                      Identifier: tagType.Identifier,
+                      Tag: parsedContextModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Context.Tag", void 0, atLocation);
+    }),
+    "TypeParser.extendsContextTag",
+    (atLocation) => atLocation
+  );
   const extendsEffectService = cachedBy(
     fn("TypeParser.extendsEffectService")(function* (atLocation) {
       if (!atLocation.name) {
@@ -30312,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)) {
@@ -30319,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;
+                          }
                         }
                       }
                     }
@@ -30327,7 +30581,8 @@ function make64(ts2, tsUtils, typeChecker) {
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
-                      accessors: accessors2
+                      accessors: accessors2,
+                      dependencies
                     };
                   }
                 }
@@ -30358,10 +30613,78 @@ function make64(ts2, tsUtils, typeChecker) {
     pipeCall,
     scopeType,
     promiseLike,
-    extendsEffectService
+    extendsEffectService,
+    extendsContextTag,
+    extendsSchemaClass,
+    extendsSchemaTaggedClass,
+    extendsSchemaTaggedError,
+    extendsSchemaTaggedRequest
   };
 }
 
+// src/diagnostics/classSelfMismatch.ts
+var classSelfMismatch = createDiagnostic({
+  name: "classSelfMismatch",
+  code: 20,
+  severity: "error",
+  apply: fn("classSelfMismatch.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    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 result = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse14(() => typeParser.extendsContextTag(node)),
+          orElse14(() => typeParser.extendsSchemaClass(node)),
+          orElse14(() => typeParser.extendsSchemaTaggedClass(node)),
+          orElse14(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse14(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse14(() => void_8)
+        );
+        if (result) {
+          const { className, selfTypeNode } = result;
+          let actualName = "";
+          if (ts2.isTypeReferenceNode(selfTypeNode)) {
+            if (ts2.isIdentifier(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.text;
+            } else if (ts2.isQualifiedName(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.right.text;
+            }
+          }
+          const expectedName = className.text;
+          if (actualName !== expectedName) {
+            report({
+              location: selfTypeNode,
+              messageText: `Self type parameter should be '${expectedName}'`,
+              fixes: [{
+                fixName: "classSelfMismatch_fix",
+                description: `Replace '${actualName}' with '${expectedName}'`,
+                apply: gen3(function* () {
+                  const changeTracker = yield* service2(ChangeTracker);
+                  const typeArgs = ts2.isTypeReferenceNode(selfTypeNode) ? selfTypeNode.typeArguments : void 0;
+                  const newTypeReference = ts2.factory.createTypeReferenceNode(
+                    ts2.factory.createIdentifier(expectedName),
+                    typeArgs
+                  );
+                  changeTracker.replaceNode(sourceFile, selfTypeNode, newTypeReference);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts2.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -30981,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",
@@ -31976,11 +32382,68 @@ var unnecessaryPipeChain = createDiagnostic({
   })
 });
 
+// src/diagnostics/unsupportedServiceAccessors.ts
+var unsupportedServiceAccessors = createDiagnostic({
+  name: "unsupportedServiceAccessors",
+  code: 21,
+  severity: "warning",
+  apply: fn("unsupportedServiceAccessors.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts2.forEachChild(node, appendNodeToVisit);
+      if (ts2.isClassDeclaration(node)) {
+        const parseResult = yield* pipe(
+          parse5(node),
+          orElse14(() => succeed17(null))
+        );
+        if (parseResult && parseResult.involvedMembers.length > 0) {
+          const existingStaticMembers = /* @__PURE__ */ new Set();
+          node.members?.forEach((member) => {
+            if (ts2.isPropertyDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts2.SyntaxKind.StaticKeyword)) {
+              if (member.name && ts2.isIdentifier(member.name)) {
+                existingStaticMembers.add(member.name.text);
+              }
+            }
+          });
+          const missingMembers = parseResult.involvedMembers.filter(
+            ({ property }) => !existingStaticMembers.has(property.getName())
+          );
+          if (missingMembers.length > 0) {
+            const memberNames = missingMembers.map(({ property }) => `'${property.getName()}'`).join(", ");
+            report({
+              location: parseResult.className,
+              messageText: `Even if accessors are enabled, accessors for ${memberNames} won't be available because the signature have generic type parameters or multiple call signatures.`,
+              fixes: [{
+                fixName: "unsupportedServiceAccessors_enableCodegen",
+                description: "Enable accessors codegen",
+                apply: gen3(function* () {
+                  const changeTracker = yield* service2(ChangeTracker);
+                  const comment = "// @effect-codegens accessors\n";
+                  changeTracker.insertText(sourceFile, node.getStart(sourceFile), comment);
+                })
+              }]
+            });
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
+  classSelfMismatch,
   duplicatePackage,
   missingEffectContext,
   missingEffectError,
+  missingEffectServiceDependency,
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
@@ -31996,7 +32459,8 @@ var diagnostics = [
   unnecessaryPipeChain,
   strictBooleanExpressions,
   multipleEffectProvide,
-  outdatedEffectCodegen
+  outdatedEffectCodegen,
+  unsupportedServiceAccessors
 ];
 
 // src/cli.ts