@effect/language-service 0.29.0 → 0.31.0

package/package.json

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

package/transform.js

@@ -2266,6 +2266,36 @@ function make2(ts, tsUtils, typeChecker) {
     "TypeParser.effectSubtype",
     (type) => type
   );
+  const importedSchemaModule = cachedBy(
+    fn("TypeParser.importedSchemaModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "Class");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Class' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedSchemaModule",
+    (node) => node
+  );
+  const importedContextModule = cachedBy(
+    fn("TypeParser.importedContextModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "Tag");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Tag' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedContextModule",
+    (node) => node
+  );
   const importedEffectModule = cachedBy(
     fn("TypeParser.importedEffectModule")(function* (node) {
       const type = typeChecker.getTypeAtLocation(node);
@@ -2622,6 +2652,226 @@ function make2(ts, tsUtils, typeChecker) {
     "TypeParser.promiseLike",
     (type) => type
   );
+  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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaCall.typeArguments[0];
+                const schemaIdentifier = schemaCall.expression;
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "Class") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option
+                  );
+                  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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedClass") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedError") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedRequest") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    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 type = 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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const contextTagCall = wholeCall.expression;
+              if (ts.isCallExpression(contextTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const contextTagIdentifier = contextTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(contextTagIdentifier) && ts.isIdentifier(contextTagIdentifier.name) && contextTagIdentifier.name.text === "Tag") {
+                  const parsedContextModule = yield* pipe(
+                    importedContextModule(contextTagIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedContextModule)) {
+                    const tagType = yield* contextTag(type, 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) {
@@ -2651,6 +2901,7 @@ function make2(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)) {
@@ -2658,6 +2909,9 @@ function make2(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;
+                          }
                         }
                       }
                     }
@@ -2666,7 +2920,8 @@ function make2(ts, tsUtils, typeChecker) {
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
-                      accessors: accessors2
+                      accessors: accessors2,
+                      dependencies
                     };
                   }
                 }
@@ -2697,10 +2952,78 @@ function make2(ts, 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 ts = yield* service(TypeScriptApi);
+    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 result = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse2(() => typeParser.extendsContextTag(node)),
+          orElse2(() => typeParser.extendsSchemaClass(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => void_)
+        );
+        if (result) {
+          const { className, selfTypeNode } = result;
+          let actualName = "";
+          if (ts.isTypeReferenceNode(selfTypeNode)) {
+            if (ts.isIdentifier(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.text;
+            } else if (ts.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: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const typeArgs = ts.isTypeReferenceNode(selfTypeNode) ? selfTypeNode.typeArguments : void 0;
+                  const newTypeReference = ts.factory.createTypeReferenceNode(
+                    ts.factory.createIdentifier(expectedName),
+                    typeArgs
+                  );
+                  changeTracker.replaceNode(sourceFile, selfTypeNode, newTypeReference);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -3320,6 +3643,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",
@@ -4315,11 +4721,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 ts = yield* service(TypeScriptApi);
+    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.isClassDeclaration(node)) {
+        const parseResult = yield* pipe(
+          parse2(node),
+          orElse2(() => succeed(null))
+        );
+        if (parseResult && parseResult.involvedMembers.length > 0) {
+          const existingStaticMembers = /* @__PURE__ */ new Set();
+          node.members?.forEach((member) => {
+            if (ts.isPropertyDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) {
+              if (member.name && ts.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: gen(function* () {
+                  const changeTracker = yield* service(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,
@@ -4335,7 +4798,8 @@ var diagnostics = [
   unnecessaryPipeChain,
   strictBooleanExpressions,
   multipleEffectProvide,
-  outdatedEffectCodegen
+  outdatedEffectCodegen,
+  unsupportedServiceAccessors
 ];
 
 // src/transform.ts