@effect/language-service 0.51.0 → 0.52.0

package/index.js

@@ -2657,9 +2657,10 @@ var nanoLayer3 = (fa) => gen(function* () {
   const tsUtils = yield* service(TypeScriptUtils);
   const typeChecker = yield* service(TypeCheckerApi);
   const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const program = yield* service(TypeScriptProgram);
   return yield* pipe(
     fa,
-    provideService(TypeParser, make3(ts, tsUtils, typeChecker, typeCheckerUtils))
+    provideService(TypeParser, make3(ts, tsUtils, typeChecker, typeCheckerUtils, program))
   );
 });
 var TypeParserIssue = class _TypeParserIssue {
@@ -2669,7 +2670,92 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
+function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
+  const getSourceFilePackageInfo = cachedBy(
+    fn("TypeParser.getSourceFilePackageInfo")(function* (sourceFile) {
+      return tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
+    }),
+    `TypeParser.getSourceFilePackageInfo`,
+    (sourceFile) => sourceFile
+  );
+  const getSourceFilesDeclaringSymbolModule = (packageName) => cachedBy(
+    fn("TypeParser.getSourceFilesDeclaringSymbolModule")(function* (symbol3) {
+      const result = [];
+      if (!symbol3.declarations) return yield* typeParserIssue("Symbol has no declarations", void 0, void 0);
+      for (const sourceFile of symbol3.declarations) {
+        if (!ts.isSourceFile(sourceFile)) continue;
+        const packageInfo = yield* getSourceFilePackageInfo(sourceFile);
+        if (!packageInfo || packageInfo.name.toLowerCase() !== packageName.toLowerCase()) continue;
+        result.push(sourceFile);
+      }
+      if (result.length > 0) {
+        return result;
+      }
+      return yield* typeParserIssue(`Symbol has no source file declarations`, void 0, void 0);
+    }),
+    `TypeParser.getSourceFilesDeclaringSymbolModule(${packageName})`,
+    (symbol3) => symbol3
+  );
+  const isSymbolReferenceToPackageModule = (givenSymbol, packageName, checkSourceFile) => {
+    let symbol3 = givenSymbol;
+    while (symbol3.flags & ts.SymbolFlags.Alias) {
+      symbol3 = typeChecker.getAliasedSymbol(symbol3);
+    }
+    return pipe(
+      getSourceFilesDeclaringSymbolModule(packageName)(symbol3),
+      flatMap2(
+        (sourceFiles) => firstSuccessOf(
+          sourceFiles.map((_) => checkSourceFile(_))
+        )
+      )
+    );
+  };
+  const isNodeReferenceToPackageModule = (givenNode, packageName, isCorrectSourceFile) => {
+    const symbol3 = typeChecker.getSymbolAtLocation(givenNode);
+    if (!symbol3) return typeParserIssue("Node has no symbol", void 0, givenNode);
+    return isSymbolReferenceToPackageModule(symbol3, packageName, isCorrectSourceFile);
+  };
+  const getSourceFilesDeclaringSymbolExportedUnderPackageModule = (packageName, memberName) => cachedBy(
+    fn("TypeParser.getSourceFilesDeclaringSymbolUnderPackageExportedMember")(function* (symbol3) {
+      const result = [];
+      if (!symbol3.declarations) return yield* typeParserIssue("Symbol has no declarations", void 0, void 0);
+      for (const declaration of symbol3.declarations) {
+        const sourceFile = tsUtils.getSourceFileOfNode(declaration);
+        if (!sourceFile) continue;
+        const packageInfo = yield* getSourceFilePackageInfo(sourceFile);
+        if (!packageInfo || packageInfo.name.toLowerCase() !== packageName.toLowerCase()) continue;
+        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) continue;
+        const memberSymbol = typeChecker.tryGetMemberInModuleExports(memberName, moduleSymbol);
+        if (memberSymbol && memberSymbol === symbol3) result.push({ memberSymbol, moduleSymbol, sourceFile });
+      }
+      if (result.length > 0) {
+        return result;
+      }
+      return yield* typeParserIssue(`Symbol has no declarations`, void 0, void 0);
+    }),
+    `TypeParser.getSourceFilesDeclaringSymbolUnderPackageExportedMember(${packageName}, ${memberName})`,
+    (sym) => sym
+  );
+  const isSymbolExportOfPackageModule = (givenSymbol, packageName, memberName, checkSourceFile) => {
+    let symbol3 = givenSymbol;
+    while (symbol3.flags & ts.SymbolFlags.Alias) {
+      symbol3 = typeChecker.getAliasedSymbol(symbol3);
+    }
+    return pipe(
+      getSourceFilesDeclaringSymbolExportedUnderPackageModule(packageName, memberName)(symbol3),
+      flatMap2(
+        (sourceFiles) => firstSuccessOf(
+          sourceFiles.map((_) => checkSourceFile(_.sourceFile, _.moduleSymbol, _.memberSymbol))
+        )
+      )
+    );
+  };
+  const isNodeReferenceToExportOfPackageModule = (givenNode, packageName, isCorrectSourceFile, memberName) => {
+    const symbol3 = typeChecker.getSymbolAtLocation(givenNode);
+    if (!symbol3) return typeParserIssue("Node has no symbol", void 0, givenNode);
+    return isSymbolExportOfPackageModule(symbol3, packageName, memberName, isCorrectSourceFile);
+  };
   function covariantTypeArgument(type) {
     const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
@@ -2775,6 +2861,26 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.strictEffectType",
     (type) => type
   );
+  const isEffectTypeSourceFile = cachedBy(
+    fn("TypeParser.isEffectTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const effectTypeSymbol = typeChecker.tryGetMemberInModuleExports("Effect", moduleSymbol);
+      if (!effectTypeSymbol) return yield* typeParserIssue("Effect type not found", void 0, sourceFile);
+      const type = typeChecker.getDeclaredTypeOfSymbol(effectTypeSymbol);
+      yield* effectType(type, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectModuleApi(${memberName})`,
+    (node) => node
+  );
   const layerType = cachedBy(
     fn("TypeParser.layerType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
@@ -2831,36 +2937,6 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSubtype",
     (type) => type
   );
-  const importedSchemaModule = cachedBy(
-    fn("TypeParser.importedSchemaModule")(function* (node) {
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an expression", void 0, node);
-      }
-      const type = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type, "Class");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'Class' property", type, node);
-      }
-      const sourceFile = tsUtils.getSourceFileOfNode(node);
-      if (!sourceFile) {
-        return yield* typeParserIssue("Node is not in a source file", void 0, node);
-      }
-      const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Schema"
-      );
-      if (!schemaIdentifier) {
-        return yield* typeParserIssue("Schema module not found", void 0, node);
-      }
-      if (ts.idText(node) !== schemaIdentifier) {
-        return yield* typeParserIssue("Node is not a schema module reference", void 0, node);
-      }
-      return node;
-    }),
-    "TypeParser.importedSchemaModule",
-    (node) => node
-  );
   const importedContextModule = cachedBy(
     fn("TypeParser.importedContextModule")(function* (node) {
       const type = typeChecker.getTypeAtLocation(node);
@@ -2891,22 +2967,9 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.importedContextModule",
     (node) => node
   );
-  const importedEffectModule = cachedBy(
-    fn("TypeParser.importedEffectModule")(function* (node) {
-      const type = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type, "never");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'never' property", type, node);
-      }
-      if (!ts.isExpression(node)) {
-        return yield* typeParserIssue("Node is not an expression", type, node);
-      }
-      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-      yield* effectType(propertyType, node);
-      return node;
-    }),
-    "TypeParser.importedEffectModule",
-    (node) => node
+  const importedEffectModule = (node) => pipe(
+    isNodeReferenceToPackageModule(node, "effect", isEffectTypeSourceFile),
+    map5(() => node)
   );
   const importedDataModule = cachedBy(
     fn("TypeParser.importedDataModule")(function* (node) {
@@ -2957,14 +3020,11 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         return typeParserIssue("Node is not a property access expression", void 0, node);
       }
       const propertyAccess = node.expression;
-      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "gen")) {
-        return typeParserIssue("Call expression name is not 'gen'", void 0, node);
-      }
       return pipe(
-        importedEffectModule(propertyAccess.expression),
-        map5((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("gen")(propertyAccess),
+        map5(() => ({
           node,
-          effectModule,
+          effectModule: propertyAccess.expression,
           generatorFunction,
           body: generatorFunction.body
         }))
@@ -3000,18 +3060,11 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = node.expression;
-      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fnUntraced")) {
-        return typeParserIssue(
-          "Call expression name is not 'fnUntraced'",
-          void 0,
-          node
-        );
-      }
       return pipe(
-        importedEffectModule(propertyAccess.expression),
-        map5((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("fnUntraced")(propertyAccess),
+        map5(() => ({
           node,
-          effectModule,
+          effectModule: propertyAccess.expression,
           generatorFunction,
           body: generatorFunction.body
         }))
@@ -3052,19 +3105,12 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = expressionToTest;
-      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fn")) {
-        return typeParserIssue(
-          "Call expression name is not 'fn'",
-          void 0,
-          node
-        );
-      }
       return pipe(
-        importedEffectModule(propertyAccess.expression),
-        map5((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("fn")(propertyAccess),
+        map5(() => ({
           node,
           generatorFunction,
-          effectModule,
+          effectModule: propertyAccess.expression,
           body: generatorFunction.body
         }))
       );
@@ -3166,6 +3212,26 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSchemaType",
     (type) => type
   );
+  const isEffectSchemaTypeSourceFile = cachedBy(
+    fn("TypeParser.isEffectSchemaTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const typeSymbol = typeChecker.tryGetMemberInModuleExports("Schema", moduleSymbol);
+      if (!typeSymbol) return yield* typeParserIssue("Schema type not found", void 0, sourceFile);
+      const type = typeChecker.getDeclaredTypeOfSymbol(typeSymbol);
+      yield* effectSchemaType(type, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectSchemaModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectSchemaTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type, atLocation) => map5(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
@@ -3292,22 +3358,15 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
             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) && ts.idText(schemaIdentifier.name) === "Class") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      Schema: parsedSchemaModule.value
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("Class")(schemaCall.expression),
+                  option
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]
+                  };
                 }
               }
             }
@@ -3336,23 +3395,17 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
               const schemaTaggedClassTCall = expression.expression;
               if (ts.isCallExpression(schemaTaggedClassTCall) && schemaTaggedClassTCall.typeArguments && schemaTaggedClassTCall.typeArguments.length > 0) {
                 const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
-                const schemaIdentifier = schemaTaggedClassTCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedClass") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      keyStringLiteral: schemaTaggedClassTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedClassTCall.arguments[0]) ? schemaTaggedClassTCall.arguments[0] : void 0,
-                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
-                      Schema: parsedSchemaModule.value
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("TaggedClass")(schemaTaggedClassTCall.expression),
+                  option
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode,
+                    keyStringLiteral: schemaTaggedClassTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedClassTCall.arguments[0]) ? schemaTaggedClassTCall.arguments[0] : void 0,
+                    tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0
+                  };
                 }
               }
             }
@@ -3381,23 +3434,17 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
               const schemaTaggedErrorTCall = expression.expression;
               if (ts.isCallExpression(schemaTaggedErrorTCall) && schemaTaggedErrorTCall.typeArguments && schemaTaggedErrorTCall.typeArguments.length > 0) {
                 const selfTypeNode = schemaTaggedErrorTCall.typeArguments[0];
-                const schemaIdentifier = schemaTaggedErrorTCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedError") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      keyStringLiteral: schemaTaggedErrorTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedErrorTCall.arguments[0]) ? schemaTaggedErrorTCall.arguments[0] : void 0,
-                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
-                      Schema: parsedSchemaModule.value
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("TaggedError")(schemaTaggedErrorTCall.expression),
+                  option
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode,
+                    keyStringLiteral: schemaTaggedErrorTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedErrorTCall.arguments[0]) ? schemaTaggedErrorTCall.arguments[0] : void 0,
+                    tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0
+                  };
                 }
               }
             }
@@ -3409,8 +3456,8 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsSchemaTaggedError",
     (atLocation) => atLocation
   );
-  const extendsDataTaggedError = cachedBy(
-    fn("TypeParser.extendsDataTaggedError")(function* (atLocation) {
+  const extendsSchemaTaggedRequest = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -3423,18 +3470,19 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
             const expression = typeX.expression;
             if (ts.isCallExpression(expression)) {
-              const dataTaggedErrorCall = expression;
-              const dataIdentifier = dataTaggedErrorCall.expression;
-              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedError") {
-                const parsedDataModule = yield* pipe(
-                  importedDataModule(dataIdentifier.expression),
+              const schemaTaggedRequestTCall = expression.expression;
+              if (ts.isCallExpression(schemaTaggedRequestTCall) && schemaTaggedRequestTCall.typeArguments && schemaTaggedRequestTCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("TaggedRequest")(schemaTaggedRequestTCall.expression),
                   option
                 );
-                if (isSome2(parsedDataModule)) {
+                if (isSome2(isEffectSchemaModuleApi)) {
                   return {
                     className: atLocation.name,
-                    keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
-                    Data: parsedDataModule.value
+                    selfTypeNode,
+                    tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
+                    keyStringLiteral: schemaTaggedRequestTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedRequestTCall.arguments[0]) ? schemaTaggedRequestTCall.arguments[0] : void 0
                   };
                 }
               }
@@ -3442,13 +3490,13 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           }
         }
       }
-      return yield* typeParserIssue("Class does not extend Data.TaggedError", void 0, atLocation);
+      return yield* typeParserIssue("Class does not extend Schema.TaggedRequest", void 0, atLocation);
     }),
-    "TypeParser.extendsDataTaggedError",
+    "TypeParser.extendsSchemaTaggedRequest",
     (atLocation) => atLocation
   );
-  const extendsDataTaggedClass = cachedBy(
-    fn("TypeParser.extendsDataTaggedClass")(function* (atLocation) {
+  const extendsDataTaggedError = cachedBy(
+    fn("TypeParser.extendsDataTaggedError")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -3461,9 +3509,9 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
             const expression = typeX.expression;
             if (ts.isCallExpression(expression)) {
-              const dataTaggedClassCall = expression;
-              const dataIdentifier = dataTaggedClassCall.expression;
-              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedClass") {
+              const dataTaggedErrorCall = expression;
+              const dataIdentifier = dataTaggedErrorCall.expression;
+              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedError") {
                 const parsedDataModule = yield* pipe(
                   importedDataModule(dataIdentifier.expression),
                   option
@@ -3471,7 +3519,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 if (isSome2(parsedDataModule)) {
                   return {
                     className: atLocation.name,
-                    keyStringLiteral: dataTaggedClassCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedClassCall.arguments[0]) ? dataTaggedClassCall.arguments[0] : void 0,
+                    keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
                     Data: parsedDataModule.value
                   };
                 }
@@ -3480,13 +3528,13 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           }
         }
       }
-      return yield* typeParserIssue("Class does not extend Data.TaggedClass", void 0, atLocation);
+      return yield* typeParserIssue("Class does not extend Data.TaggedError", void 0, atLocation);
     }),
-    "TypeParser.extendsDataTaggedClass",
+    "TypeParser.extendsDataTaggedError",
     (atLocation) => atLocation
   );
-  const extendsSchemaTaggedRequest = cachedBy(
-    fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
+  const extendsDataTaggedClass = cachedBy(
+    fn("TypeParser.extendsDataTaggedClass")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -3499,35 +3547,28 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
             const expression = typeX.expression;
             if (ts.isCallExpression(expression)) {
-              const schemaTaggedRequestTCall = expression.expression;
-              if (ts.isCallExpression(schemaTaggedRequestTCall) && schemaTaggedRequestTCall.typeArguments && schemaTaggedRequestTCall.typeArguments.length > 0) {
-                const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
-                const schemaIdentifier = schemaTaggedRequestTCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedRequest") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
-                      keyStringLiteral: schemaTaggedRequestTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedRequestTCall.arguments[0]) ? schemaTaggedRequestTCall.arguments[0] : void 0,
-                      Schema: parsedSchemaModule.value
-                    };
-                  }
+              const dataTaggedClassCall = expression;
+              const dataIdentifier = dataTaggedClassCall.expression;
+              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedClass") {
+                const parsedDataModule = yield* pipe(
+                  importedDataModule(dataIdentifier.expression),
+                  option
+                );
+                if (isSome2(parsedDataModule)) {
+                  return {
+                    className: atLocation.name,
+                    keyStringLiteral: dataTaggedClassCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedClassCall.arguments[0]) ? dataTaggedClassCall.arguments[0] : void 0,
+                    Data: parsedDataModule.value
+                  };
                 }
               }
             }
           }
         }
       }
-      return yield* typeParserIssue("Class does not extend Schema.TaggedRequest", void 0, atLocation);
+      return yield* typeParserIssue("Class does not extend Data.TaggedClass", void 0, atLocation);
     }),
-    "TypeParser.extendsSchemaTaggedRequest",
+    "TypeParser.extendsDataTaggedClass",
     (atLocation) => atLocation
   );
   const extendsContextTag = cachedBy(
@@ -3587,6 +3628,10 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       if (!heritageClauses) {
         return yield* typeParserIssue("Class has no heritage clauses", 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 tagType = yield* contextTag(type, atLocation);
       for (const heritageClause of heritageClauses) {
         for (const typeX of heritageClause.types) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
@@ -3596,26 +3641,19 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
               if (ts.isCallExpression(effectTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
                 const effectTagIdentifier = effectTagCall.expression;
                 const selfTypeNode = wholeCall.typeArguments[0];
-                if (ts.isPropertyAccessExpression(effectTagIdentifier) && ts.isIdentifier(effectTagIdentifier.name) && ts.idText(effectTagIdentifier.name) === "Tag") {
-                  const parsedEffectModule = yield* pipe(
-                    importedEffectModule(effectTagIdentifier.expression),
-                    option
-                  );
-                  if (isSome2(parsedEffectModule)) {
-                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
-                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
-                    const type = typeChecker.getTypeOfSymbol(classSym);
-                    const tagType = yield* contextTag(type, atLocation);
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      keyStringLiteral: ts.isStringLiteral(effectTagCall.arguments[0]) ? effectTagCall.arguments[0] : void 0,
-                      args: effectTagCall.arguments,
-                      Identifier: tagType.Identifier,
-                      Service: tagType.Service,
-                      Tag: parsedEffectModule.value
-                    };
-                  }
+                const isEffectTag = yield* pipe(
+                  isNodeReferenceToEffectModuleApi("Tag")(effectTagIdentifier),
+                  option
+                );
+                if (isSome2(isEffectTag)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode,
+                    keyStringLiteral: ts.isStringLiteral(effectTagCall.arguments[0]) ? effectTagCall.arguments[0] : void 0,
+                    args: effectTagCall.arguments,
+                    Identifier: tagType.Identifier,
+                    Service: tagType.Service
+                  };
                 }
               }
             }
@@ -3645,13 +3683,16 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
               if (ts.isCallExpression(effectServiceCall) && effectServiceCall.typeArguments && effectServiceCall.typeArguments.length > 0) {
                 const effectServiceIdentifier = effectServiceCall.expression;
                 const selfTypeNode = effectServiceCall.typeArguments[0];
-                if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && ts.idText(effectServiceIdentifier.name) === "Service") {
+                const isEffectService = yield* pipe(
+                  isNodeReferenceToEffectModuleApi("Service")(effectServiceIdentifier),
+                  option
+                );
+                if (isSome2(isEffectService)) {
                   const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                   if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                   const type = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
-                    importedEffectModule(effectServiceIdentifier.expression),
-                    flatMap2(() => contextTag(type, atLocation)),
+                    contextTag(type, atLocation),
                     option
                   );
                   if (isSome2(parsedContextTag)) {
@@ -3693,6 +3734,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     (atLocation) => atLocation
   );
   return {
+    isNodeReferenceToEffectModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -4075,6 +4117,80 @@ var effectDataClasses = createCompletion({
   })
 });
 
+// src/diagnostics/catchUnfailableEffect.ts
+var catchUnfailableEffect = createDiagnostic({
+  name: "catchUnfailableEffect",
+  code: 2,
+  severity: "suggestion",
+  apply: fn("catchUnfailableEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    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.isCallExpression(node)) {
+        const catchFunctions = ["catchAll", "catch", "catchIf", "catchSome", "catchTag", "catchTags"];
+        const isCatchCall = yield* pipe(
+          firstSuccessOf(
+            catchFunctions.map((catchFn) => typeParser.isNodeReferenceToEffectModuleApi(catchFn)(node.expression))
+          ),
+          option
+        );
+        if (isSome2(isCatchCall)) {
+          const parent = node.parent;
+          if (parent && ts.isCallExpression(parent)) {
+            const pipeCallResult = yield* pipe(
+              typeParser.pipeCall(parent),
+              option
+            );
+            if (isSome2(pipeCallResult)) {
+              const { args: args2, node: pipeCallNode, subject } = pipeCallResult.value;
+              const argIndex = args2.findIndex((arg) => arg === node);
+              if (argIndex !== -1) {
+                let effectTypeToCheck;
+                if (argIndex === 0) {
+                  effectTypeToCheck = typeChecker.getTypeAtLocation(subject);
+                } else {
+                  const signature = typeChecker.getResolvedSignature(pipeCallNode);
+                  if (signature) {
+                    const typeArguments = typeChecker.getTypeArgumentsForResolvedSignature(signature);
+                    if (typeArguments && typeArguments.length > argIndex) {
+                      effectTypeToCheck = typeArguments[argIndex];
+                    }
+                  }
+                }
+                if (effectTypeToCheck) {
+                  const effectType = yield* pipe(
+                    typeParser.effectType(effectTypeToCheck, node),
+                    option
+                  );
+                  if (isSome2(effectType)) {
+                    const { E } = effectType.value;
+                    if (E.flags & ts.TypeFlags.Never) {
+                      report({
+                        location: node.expression,
+                        messageText: `Looks like the previous effect never fails, so probably this error handling will never be triggered.`,
+                        fixes: []
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Chunk.js
 var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Chunk");
 function copy(src, srcPos, dest, destPos, len) {
@@ -7533,11 +7649,11 @@ var multipleEffectProvide = createDiagnostic({
       "Layer"
     ) || "Layer";
     const parseEffectProvideLayer = (node) => {
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "provide" && node.arguments.length > 0) {
+      if (ts.isCallExpression(node) && node.arguments.length > 0) {
         const layer = node.arguments[0];
         const type = typeChecker.getTypeAtLocation(layer);
         return pipe(
-          typeParser.importedEffectModule(node.expression.expression),
+          typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression),
           flatMap2(() => typeParser.layerType(type, layer)),
           map5(() => ({ layer, node })),
           orElse2(() => void_)
@@ -8092,10 +8208,10 @@ var strictEffectProvide = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const parseEffectProvideWithLayer = (node) => gen(function* () {
-      if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.name) || ts.idText(node.expression.name) !== "provide" || node.arguments.length === 0) {
+      if (!ts.isCallExpression(node) || node.arguments.length === 0) {
         return yield* typeParserIssue("Not an Effect.provide call");
       }
-      yield* typeParser.importedEffectModule(node.expression.expression);
+      yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
       return yield* firstSuccessOf(
         node.arguments.map((arg) => {
           const argType = typeChecker.getTypeAtLocation(arg);
@@ -8390,6 +8506,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
   effectGenUsesAdapter,
@@ -13935,11 +14052,20 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
 });
 var formatLayerGraph = fn("formatLayerGraph")(function* (layerGraph) {
   const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
   return toMermaid(layerGraph, {
     edgeLabel: (edge) => JSON.stringify(edge),
     nodeLabel: (graphNode) => {
       const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
-      return sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+      let text = sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+      text += "\nprovides: " + graphNode.provides.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
+        ", "
+      );
+      text += "\nrequires: " + graphNode.requires.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
+        ", "
+      );
+      return text;
     }
   });
 });
@@ -14020,7 +14146,7 @@ var formatNestedLayerGraph = fn("formatNestedLayerGraph")(function* (layerGraph)
 var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   const typeChecker = yield* service(TypeCheckerApi);
   const mutableGraph = beginMutation3(directed());
-  const providers = /* @__PURE__ */ new WeakMap();
+  const providers = /* @__PURE__ */ new Map();
   const knownSymbols = /* @__PURE__ */ new WeakSet();
   const leafNodes = values2(externals(layerGraph, { direction: "outgoing" }));
   const dedupedLeafNodes = [];
@@ -14047,8 +14173,12 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   }
   for (const [nodeIndex, nodeInfo] of entries(nodes(mutableGraph))) {
     for (const requiredType of nodeInfo.requires) {
-      for (const providerNodeIndex of providers.get(requiredType) || []) {
-        addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+      for (const [providedType, providerNodeIndexes] of providers.entries()) {
+        if (requiredType === providedType || typeChecker.isTypeAssignableTo(requiredType, providedType)) {
+          for (const providerNodeIndex of providerNodeIndexes) {
+            addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+          }
+        }
       }
     }
   }
@@ -14135,7 +14265,8 @@ var walkLeavesMatching = (graph, predicate, config = {}) => {
 var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
   function* (layerGraph) {
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const rootWalker = externals(layerGraph, { direction: "outgoing" });
+    const typeChecker = yield* service(TypeCheckerApi);
+    const rootWalker = externals(layerGraph, { direction: "incoming" });
     const rootNodes = fromIterable(values2(rootWalker));
     const rootNodeIndexes = fromIterable(indices(rootWalker));
     const result = [];
@@ -14146,7 +14277,9 @@ var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
         for (const layerNode of values2(
           walkLeavesMatching(
             layerGraph,
-            (_) => (kind === "provided" ? _.provides : _.requires).indexOf(layerType) > -1,
+            (_) => (kind === "provided" ? _.provides : _.requires).some(
+              (_2) => _2 === layerType || typeChecker.isTypeAssignableTo(_2, layerType)
+            ),
             { start: rootNodeIndexes }
           )
         )) {