@effect/language-service 0.39.0 → 0.40.1

package/index.js

@@ -1701,7 +1701,8 @@ var defaults = {
   topLevelNamedReexports: "ignore",
   barrelImportPackages: [],
   importAliases: {},
-  renames: true
+  renames: true,
+  noExternal: false
 };
 function parse(config) {
   return {
@@ -1718,7 +1719,8 @@ function parse(config) {
     barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : defaults.barrelImportPackages,
     importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map4(config.importAliases, (value) => String(value)) : defaults.importAliases,
     topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
-    renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames
+    renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
+    noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal
   };
 }
 
@@ -2561,13 +2563,28 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
   );
   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);
       }
-      if (!ts.isExpression(node)) {
-        return yield* typeParserIssue("Node is not an expression", 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;
     }),
@@ -2581,8 +2598,23 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       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);
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an identifier", type, node);
+      }
+      const sourceFile = tsUtils.getSourceFileOfNode(node);
+      if (!sourceFile) {
+        return yield* typeParserIssue("Node is not in a source file", void 0, node);
+      }
+      const contextIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Context"
+      );
+      if (!contextIdentifier) {
+        return yield* typeParserIssue("Context module not found", void 0, node);
+      }
+      if (ts.idText(node) !== contextIdentifier) {
+        return yield* typeParserIssue("Node is not a context module reference", void 0, node);
       }
       return node;
     }),
@@ -2613,9 +2645,24 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       if (!propertySymbol) {
         return yield* typeParserIssue("Type has no 'TaggedError' property", type, node);
       }
-      if (!ts.isExpression(node)) {
+      if (!ts.isIdentifier(node)) {
         return yield* typeParserIssue("Node is not an expression", type, node);
       }
+      const sourceFile = tsUtils.getSourceFileOfNode(node);
+      if (!sourceFile) {
+        return yield* typeParserIssue("Node is not in a source file", void 0, node);
+      }
+      const dataIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Data"
+      );
+      if (!dataIdentifier) {
+        return yield* typeParserIssue("Data module not found", void 0, node);
+      }
+      if (ts.idText(node) !== dataIdentifier) {
+        return yield* typeParserIssue("Node is not a data module reference", void 0, node);
+      }
       return node;
     }),
     "TypeParser.importedDataModule",
@@ -2978,8 +3025,10 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 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(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3019,8 +3068,10 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 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(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3062,8 +3113,10 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 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(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3181,8 +3234,10 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 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(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3444,7 +3499,10 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
       ]
     );
     return ts.factory.createPropertyDeclaration(
-      [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
+      [
+        ts.factory.createModifier(ts.SyntaxKind.StaticKeyword),
+        ts.factory.createModifier(ts.SyntaxKind.OverrideKeyword)
+      ],
       propertyName,
       void 0,
       type,
@@ -3801,6 +3859,7 @@ var classSelfMismatch = createDiagnostic({
         const result = yield* pipe(
           typeParser.extendsEffectService(node),
           orElse2(() => typeParser.extendsContextTag(node)),
+          orElse2(() => typeParser.extendsEffectTag(node)),
           orElse2(() => typeParser.extendsSchemaClass(node)),
           orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
           orElse2(() => typeParser.extendsSchemaTaggedError(node)),
@@ -3809,7 +3868,7 @@ var classSelfMismatch = createDiagnostic({
         );
         if (result) {
           const { className, selfTypeNode } = result;
-          let actualName = "";
+          let actualName = sourceFile.text.substring(selfTypeNode.pos, selfTypeNode.end);
           if (ts.isTypeReferenceNode(selfTypeNode)) {
             if (ts.isIdentifier(selfTypeNode.typeName)) {
               actualName = ts.idText(selfTypeNode.typeName);
@@ -3893,6 +3952,43 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectGenUsesAdapter.ts
+var effectGenUsesAdapter = createDiagnostic({
+  name: "effectGenUsesAdapter",
+  code: 23,
+  severity: "warning",
+  apply: fn("effectGenUsesAdapter.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();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        yield* pipe(
+          typeParser.effectGen(node),
+          map3(({ generatorFunction }) => {
+            if (generatorFunction.parameters.length > 0) {
+              const adapter = generatorFunction.parameters[0];
+              report({
+                location: adapter,
+                messageText: `The adapter of Effect.gen is not required anymore, it is now just an alias of pipe.`,
+                fixes: []
+              });
+            }
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/effectInVoidSuccess.ts
 var effectInVoidSuccess = createDiagnostic({
   name: "effectInVoidSuccess",
@@ -5410,6 +5506,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 var diagnostics = [
   classSelfMismatch,
   duplicatePackage,
+  effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
   missingEffectServiceDependency,
@@ -10996,13 +11093,8 @@ function processNodeMermaid(graph, ctx, ctxL) {
     }
   });
 }
-function generateMarmaidUri(graph, ctxL) {
+function generateMarmaidUri(code) {
   return gen(function* () {
-    const ctx = {
-      seenIds: /* @__PURE__ */ new Set()
-    };
-    const lines = yield* processNodeMermaid(graph, ctx, ctxL);
-    const code = "flowchart TB\n" + lines.join("\n");
     const state = JSON.stringify({ code });
     const data = new TextEncoder().encode(state);
     const compressed = deflate_1(data, { level: 9 });
@@ -11010,75 +11102,110 @@ function generateMarmaidUri(graph, ctxL) {
     return "https://www.mermaidchart.com/play#" + pakoString;
   });
 }
+function getAdjustedNode(sourceFile, position) {
+  return gen(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const range = tsUtils.toTextRange(position);
+    const maybeNode = pipe(
+      tsUtils.getAncestorNodesInRange(sourceFile, range),
+      filter((_) => ts.isVariableDeclaration(_) || ts.isPropertyDeclaration(_)),
+      filter((_) => tsUtils.isNodeInRange(range)(_.name)),
+      head
+    );
+    if (isNone2(maybeNode)) return void 0;
+    const node = maybeNode.value;
+    const layerNode = node.initializer ? node.initializer : node;
+    const layerType = typeChecker.getTypeAtLocation(layerNode);
+    const maybeLayer = yield* option(typeParser.layerType(layerType, layerNode));
+    if (isNone2(maybeLayer)) return void 0;
+    return { node, layerNode };
+  });
+}
+function parseLayerGraph(sourceFile, layerNode) {
+  return gen(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    let lastId = 0;
+    const graphCtx = {
+      services: /* @__PURE__ */ new Map(),
+      serviceTypeToString: /* @__PURE__ */ new Map(),
+      nextId: () => "id" + lastId++
+    };
+    const rootNode = yield* processLayerGraphNode(graphCtx, layerNode, void 0);
+    const ctx = {
+      seenIds: /* @__PURE__ */ new Set()
+    };
+    const mermaidLines = yield* processNodeMermaid(rootNode, ctx, graphCtx);
+    const mermaidCode = "flowchart TB\n" + mermaidLines.join("\n");
+    const textualExplanation = [];
+    const appendInfo = (providesNode, type, kindText) => {
+      const typeString = typeChecker.typeToString(
+        type,
+        void 0,
+        ts.TypeFormatFlags.NoTruncation
+      );
+      const positions = providesNode.map((_) => {
+        const nodePosition = _.node.getStart(sourceFile, false);
+        const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
+        const nodeText = _.node.getText().trim().replace(/\n/g, " ").substr(0, 50);
+        return "ln " + (line + 1) + " col " + character + " by `" + nodeText + "`";
+      });
+      textualExplanation.push("- " + typeString + " " + kindText + " at " + positions.join(", "));
+    };
+    for (const providesKey of rootNode.rout) {
+      const providesNode = findInnermostGraphEdge(rootNode, "rout", providesKey);
+      appendInfo(providesNode, graphCtx.services.get(providesKey), "provided");
+    }
+    if (textualExplanation.length > 0) textualExplanation.push("");
+    for (const requiresKey of rootNode.rin) {
+      const requiresNode = findInnermostGraphEdge(rootNode, "rin", requiresKey);
+      appendInfo(requiresNode, graphCtx.services.get(requiresKey), "required");
+    }
+    return { mermaidCode, textualExplanation };
+  });
+}
+function effectApiGetLayerGraph(sourceFile, line, character) {
+  return pipe(
+    gen(function* () {
+      const ts = yield* service(TypeScriptApi);
+      const position = ts.getPositionOfLineAndCharacter(sourceFile, line, character);
+      const maybeNodes = yield* getAdjustedNode(sourceFile, position);
+      if (!maybeNodes) return yield* fail(new UnableToProduceLayerGraphError("No node found"));
+      const { layerNode, node } = maybeNodes;
+      const { mermaidCode } = yield* parseLayerGraph(sourceFile, layerNode);
+      return { start: node.pos, end: node.end, mermaidCode };
+    })
+  );
+}
 function layerInfo(sourceFile, position, quickInfo2) {
   return pipe(
     gen(function* () {
       const ts = yield* service(TypeScriptApi);
-      const tsUtils = yield* service(TypeScriptUtils);
-      const typeChecker = yield* service(TypeCheckerApi);
-      const typeParser = yield* service(TypeParser);
-      const range = tsUtils.toTextRange(position);
-      const maybeNode = pipe(
-        tsUtils.getAncestorNodesInRange(sourceFile, range),
-        filter((_) => ts.isVariableDeclaration(_) || ts.isPropertyDeclaration(_)),
-        filter((_) => tsUtils.isNodeInRange(range)(_.name)),
-        head
-      );
-      if (isNone2(maybeNode)) return quickInfo2;
-      const node = maybeNode.value;
-      const layerNode = node.initializer ? node.initializer : node;
-      const layerType = typeChecker.getTypeAtLocation(layerNode);
-      const maybeLayer = yield* option(typeParser.layerType(layerType, layerNode));
-      if (isNone2(maybeLayer)) return quickInfo2;
-      let lastId = 0;
-      const graphCtx = {
-        services: /* @__PURE__ */ new Map(),
-        serviceTypeToString: /* @__PURE__ */ new Map(),
-        nextId: () => "id" + lastId++
-      };
+      const options = yield* service(LanguageServicePluginOptions);
+      const maybeNodes = yield* getAdjustedNode(sourceFile, position);
+      if (!maybeNodes) return quickInfo2;
+      const { layerNode, node } = maybeNodes;
       const layerInfoDisplayParts = yield* pipe(
-        processLayerGraphNode(graphCtx, layerNode, void 0),
+        parseLayerGraph(sourceFile, layerNode),
         flatMap(
-          (rootNode) => gen(function* () {
-            yield* succeed(void 0);
-            const lines = [];
-            const appendInfo = (providesNode, type, kindText) => {
-              const typeString = typeChecker.typeToString(
-                type,
-                void 0,
-                ts.TypeFormatFlags.NoTruncation
-              );
-              const positions = providesNode.map((_) => {
-                const nodePosition = _.node.getStart(sourceFile, false);
-                const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
-                const nodeText = _.node.getText().trim().replace(/\n/g, " ").substr(0, 50);
-                return "ln " + (line + 1) + " col " + character + " by `" + nodeText + "`";
-              });
-              lines.push("- " + typeString + " " + kindText + " at " + positions.join(", "));
-            };
-            for (const providesKey of rootNode.rout) {
-              const providesNode = findInnermostGraphEdge(rootNode, "rout", providesKey);
-              appendInfo(providesNode, graphCtx.services.get(providesKey), "provided");
-            }
-            if (lines.length > 0) lines.push("");
-            for (const requiresKey of rootNode.rin) {
-              const requiresNode = findInnermostGraphEdge(rootNode, "rin", requiresKey);
-              appendInfo(requiresNode, graphCtx.services.get(requiresKey), "required");
-            }
-            const mermaidUri = yield* option(generateMarmaidUri(rootNode, graphCtx));
+          ({ mermaidCode, textualExplanation }) => gen(function* () {
             const linkParts = [];
-            if (isSome2(mermaidUri)) {
+            if (!options.noExternal) {
+              const mermaidUri = yield* generateMarmaidUri(mermaidCode);
               linkParts.push({ kind: "space", text: "\n" });
               linkParts.push({ kind: "link", text: "{@link " });
-              linkParts.push({ kind: "linkText", text: mermaidUri.value + " Show full Layer graph" });
+              linkParts.push({ kind: "linkText", text: mermaidUri + " Show full Layer graph" });
               linkParts.push({ kind: "link", text: "}" });
               linkParts.push({ kind: "space", text: "\n" });
             }
-            if (lines.length === 0) return linkParts;
+            if (textualExplanation.length === 0) return linkParts;
             return [
               {
                 kind: "text",
-                text: "```\n/**\n" + lines.map((l) => " * " + l).join("\n") + "\n */\n```\n"
+                text: "```\n/**\n" + textualExplanation.map((l) => " * " + l).join("\n") + "\n */\n```\n"
               },
               ...linkParts
             ];
@@ -13570,6 +13697,56 @@ var init = (modules) => {
       }
       return applicableRenameInfo;
     };
+    const additionalProtocolHandlers = {
+      "_effectGetLayerMermaid": (arg) => {
+        const { character, line, path } = arg.arguments;
+        const normalizedPath = modules.typescript.server.toNormalizedPath(path);
+        const projectService = info.project.projectService;
+        const scriptInfo = projectService.getScriptInfoForNormalizedPath(normalizedPath);
+        if (scriptInfo) {
+          const targetProject = scriptInfo.getDefaultProject();
+          if (targetProject) {
+            const program = targetProject.getLanguageService().getProgram();
+            if (program) {
+              const sourceFile = targetProject.getSourceFile(scriptInfo.path);
+              if (sourceFile) {
+                return pipe(
+                  effectApiGetLayerGraph(sourceFile, line, character),
+                  map3((response) => ({
+                    response: {
+                      success: true,
+                      ...response
+                    }
+                  })),
+                  runNano(program),
+                  getOrElse((e) => ({
+                    response: {
+                      success: false,
+                      error: e.message
+                    }
+                  }))
+                );
+              }
+            }
+          }
+        }
+        return {
+          response: {
+            success: false,
+            error: "No source file found"
+          }
+        };
+      }
+    };
+    if (info.session) {
+      for (const [key, value] of Object.entries(additionalProtocolHandlers)) {
+        try {
+          info.session.addProtocolHandler(key, value);
+        } catch (e) {
+          info.project.log("[@effect/language-service] Skipped adding " + key + " protocol handler due to error: " + e);
+        }
+      }
+    }
     return proxy;
   }
   return { create, onConfigurationChanged };