@effect/language-service 0.51.0 → 0.52.0

package/cli.js

@@ -31907,9 +31907,10 @@ var nanoLayer3 = (fa) => gen3(function* () {
   const tsUtils = yield* service2(TypeScriptUtils);
   const typeChecker = yield* service2(TypeCheckerApi);
   const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const program = yield* service2(TypeScriptProgram);
   return yield* pipe(
     fa,
-    provideService7(TypeParser, make64(ts, tsUtils, typeChecker, typeCheckerUtils))
+    provideService7(TypeParser, make64(ts, tsUtils, typeChecker, typeCheckerUtils, program))
   );
 });
 var TypeParserIssue = class _TypeParserIssue {
@@ -31919,7 +31920,92 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
+function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
+  const getSourceFilePackageInfo = cachedBy(
+    fn2("TypeParser.getSourceFilePackageInfo")(function* (sourceFile) {
+      return tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
+    }),
+    `TypeParser.getSourceFilePackageInfo`,
+    (sourceFile) => sourceFile
+  );
+  const getSourceFilesDeclaringSymbolModule = (packageName) => cachedBy(
+    fn2("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),
+      flatMap18(
+        (sourceFiles) => firstSuccessOf2(
+          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(
+    fn2("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),
+      flatMap18(
+        (sourceFiles) => firstSuccessOf2(
+          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(type2) {
     const signatures = typeChecker.getSignaturesOfType(type2, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
@@ -32025,6 +32111,26 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.strictEffectType",
     (type2) => type2
   );
+  const isEffectTypeSourceFile = cachedBy(
+    fn2("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 type2 = typeChecker.getDeclaredTypeOfSymbol(effectTypeSymbol);
+      yield* effectType(type2, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectModuleApi = (memberName) => cachedBy(
+    fn2("TypeParser.isNodeReferenceToEffectModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectModuleApi(${memberName})`,
+    (node) => node
+  );
   const layerType = cachedBy(
     fn2("TypeParser.layerType")(function* (type2, atLocation) {
       yield* pipeableType(type2, atLocation);
@@ -32081,36 +32187,6 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSubtype",
     (type2) => type2
   );
-  const importedSchemaModule = cachedBy(
-    fn2("TypeParser.importedSchemaModule")(function* (node) {
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an expression", void 0, node);
-      }
-      const type2 = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type2, "Class");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'Class' property", type2, 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(
     fn2("TypeParser.importedContextModule")(function* (node) {
       const type2 = typeChecker.getTypeAtLocation(node);
@@ -32141,22 +32217,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.importedContextModule",
     (node) => node
   );
-  const importedEffectModule = cachedBy(
-    fn2("TypeParser.importedEffectModule")(function* (node) {
-      const type2 = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type2, "never");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'never' property", type2, node);
-      }
-      if (!ts.isExpression(node)) {
-        return yield* typeParserIssue("Node is not an expression", type2, 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),
+    map34(() => node)
   );
   const importedDataModule = cachedBy(
     fn2("TypeParser.importedDataModule")(function* (node) {
@@ -32207,14 +32270,11 @@ function make64(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),
-        map34((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("gen")(propertyAccess),
+        map34(() => ({
           node,
-          effectModule,
+          effectModule: propertyAccess.expression,
           generatorFunction,
           body: generatorFunction.body
         }))
@@ -32250,18 +32310,11 @@ function make64(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),
-        map34((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("fnUntraced")(propertyAccess),
+        map34(() => ({
           node,
-          effectModule,
+          effectModule: propertyAccess.expression,
           generatorFunction,
           body: generatorFunction.body
         }))
@@ -32302,19 +32355,12 @@ function make64(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),
-        map34((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("fn")(propertyAccess),
+        map34(() => ({
           node,
           generatorFunction,
-          effectModule,
+          effectModule: propertyAccess.expression,
           body: generatorFunction.body
         }))
       );
@@ -32416,6 +32462,26 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSchemaType",
     (type2) => type2
   );
+  const isEffectSchemaTypeSourceFile = cachedBy(
+    fn2("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 type2 = typeChecker.getDeclaredTypeOfSymbol(typeSymbol);
+      yield* effectSchemaType(type2, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaModuleApi = (memberName) => cachedBy(
+    fn2("TypeParser.isNodeReferenceToEffectSchemaModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectSchemaTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type2, atLocation) => map34(
     all9(
       varianceStructInvariantType(type2, atLocation, "_Identifier"),
@@ -32542,22 +32608,15 @@ function make64(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),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      Schema: parsedSchemaModule.value
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("Class")(schemaCall.expression),
+                  option4
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]
+                  };
                 }
               }
             }
@@ -32586,23 +32645,17 @@ function make64(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),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  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),
+                  option4
+                );
+                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
+                  };
                 }
               }
             }
@@ -32631,23 +32684,17 @@ function make64(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),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  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),
+                  option4
+                );
+                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
+                  };
                 }
               }
             }
@@ -32659,8 +32706,8 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsSchemaTaggedError",
     (atLocation) => atLocation
   );
-  const extendsDataTaggedError = cachedBy(
-    fn2("TypeParser.extendsDataTaggedError")(function* (atLocation) {
+  const extendsSchemaTaggedRequest = cachedBy(
+    fn2("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -32673,18 +32720,19 @@ function make64(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),
                   option4
                 );
-                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
                   };
                 }
               }
@@ -32692,13 +32740,13 @@ function make64(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(
-    fn2("TypeParser.extendsDataTaggedClass")(function* (atLocation) {
+  const extendsDataTaggedError = cachedBy(
+    fn2("TypeParser.extendsDataTaggedError")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -32711,9 +32759,9 @@ function make64(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),
                   option4
@@ -32721,7 +32769,7 @@ function make64(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
                   };
                 }
@@ -32730,13 +32778,13 @@ function make64(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(
-    fn2("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
+  const extendsDataTaggedClass = cachedBy(
+    fn2("TypeParser.extendsDataTaggedClass")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -32749,35 +32797,28 @@ function make64(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),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  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),
+                  option4
+                );
+                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(
@@ -32837,6 +32878,10 @@ function make64(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 type2 = typeChecker.getTypeOfSymbol(classSym);
+      const tagType = yield* contextTag(type2, atLocation);
       for (const heritageClause of heritageClauses) {
         for (const typeX of heritageClause.types) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
@@ -32846,26 +32891,19 @@ function make64(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),
-                    option4
-                  );
-                  if (isSome2(parsedEffectModule)) {
-                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
-                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
-                    const type2 = typeChecker.getTypeOfSymbol(classSym);
-                    const tagType = yield* contextTag(type2, 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),
+                  option4
+                );
+                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
+                  };
                 }
               }
             }
@@ -32895,13 +32933,16 @@ function make64(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),
+                  option4
+                );
+                if (isSome2(isEffectService)) {
                   const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                   if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                   const type2 = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
-                    importedEffectModule(effectServiceIdentifier.expression),
-                    flatMap18(() => contextTag(type2, atLocation)),
+                    contextTag(type2, atLocation),
                     option4
                   );
                   if (isSome2(parsedContextTag)) {
@@ -32943,6 +32984,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     (atLocation) => atLocation
   );
   return {
+    isNodeReferenceToEffectModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -32971,6 +33013,80 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
   };
 }
 
+// src/diagnostics/catchUnfailableEffect.ts
+var catchUnfailableEffect = createDiagnostic({
+  name: "catchUnfailableEffect",
+  code: 2,
+  severity: "suggestion",
+  apply: fn2("catchUnfailableEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeChecker = yield* service2(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(
+          firstSuccessOf2(
+            catchFunctions.map((catchFn) => typeParser.isNodeReferenceToEffectModuleApi(catchFn)(node.expression))
+          ),
+          option4
+        );
+        if (isSome2(isCatchCall)) {
+          const parent = node.parent;
+          if (parent && ts.isCallExpression(parent)) {
+            const pipeCallResult = yield* pipe(
+              typeParser.pipeCall(parent),
+              option4
+            );
+            if (isSome2(pipeCallResult)) {
+              const { args: args3, node: pipeCallNode, subject } = pipeCallResult.value;
+              const argIndex = args3.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),
+                    option4
+                  );
+                  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: []
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/classSelfMismatch.ts
 var classSelfMismatch = createDiagnostic({
   name: "classSelfMismatch",
@@ -34230,11 +34346,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 layer12 = node.arguments[0];
         const type2 = typeChecker.getTypeAtLocation(layer12);
         return pipe(
-          typeParser.importedEffectModule(node.expression.expression),
+          typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression),
           flatMap18(() => typeParser.layerType(type2, layer12)),
           map34(() => ({ layer: layer12, node })),
           orElse14(() => void_8)
@@ -35083,10 +35199,10 @@ var strictEffectProvide = createDiagnostic({
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
     const parseEffectProvideWithLayer = (node) => gen3(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* firstSuccessOf2(
         node.arguments.map((arg) => {
           const argType = typeChecker.getTypeAtLocation(arg);
@@ -35381,6 +35497,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
   effectGenUsesAdapter,