@effect/language-service 0.38.4 → 0.40.0

package/README.md

@@ -55,6 +55,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn on subsequent `Effect.provide` anti-pattern
 - Detect wrong `Self` type parameter for APIs like `Effect.Service` or `Schema.TaggedError` and similar 
 - Unnecessary usages of `Effect.gen` or `pipe()`
+- Warn when using `Effect.gen` with the old generator adapter pattern
 - Warn when importing from a barrel file instead of from the module directly
 - Warn on usage of try/catch inside `Effect.gen` and family
 - Detect unnecessary pipe chains like `X.pipe(Y).pipe(Z)`
@@ -116,7 +117,8 @@ Few options can be provided alongside the initialization of the Language Service
         "barrelImportPackages": [], // package names that should be preferred as imported from the top level barrel file (default: [])
         "namespaceImportPackages": [], // package names that should be preferred as imported with namespace imports e.g. ["effect", "@effect/*"] (default: [])
         "topLevelNamedReexports": "ignore", // for namespaceImportPackages, how should top level named re-exports (e.g. {pipe} from "effect") be treated? "ignore" will leave them as is, "follow" will rewrite them to the re-exported module (e.g. {pipe} from "effect/Function")
-        "importAliases": { "Array": "Arr" } // allows to chose some different names for import name aliases (only when not chosing to import the whole module) (default: {})
+        "importAliases": { "Array": "Arr" }, // allows to chose some different names for import name aliases (only when not chosing to import the whole module) (default: {})
+        "noExternal": false // disables features that provides links to external websites (such as links to mermaidchart.com) (default: false)
       }
     ]
   }

package/effect-lsp-patch-utils.js

@@ -1182,7 +1182,8 @@ var defaults = {
   topLevelNamedReexports: "ignore",
   barrelImportPackages: [],
   importAliases: {},
-  renames: true
+  renames: true,
+  noExternal: false
 };
 function parse(config) {
   return {
@@ -1199,7 +1200,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) ? map2(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
   };
 }
 
@@ -2462,13 +2464,28 @@ function make2(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;
     }),
@@ -2482,8 +2499,23 @@ function make2(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;
     }),
@@ -2514,9 +2546,24 @@ function make2(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",
@@ -2879,8 +2926,10 @@ function make2(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),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -2920,8 +2969,10 @@ function make2(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),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -2963,8 +3014,10 @@ function make2(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),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3082,8 +3135,10 @@ function make2(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),
+                    flatMap2(() => importedSchemaModule(schemaIdentifier.expression)),
                     option
                   );
                   if (isSome2(parsedSchemaModule)) {
@@ -3317,6 +3372,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)),
@@ -3409,6 +3465,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),
+          map4(({ 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",
@@ -5217,6 +5310,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 var diagnostics = [
   classSelfMismatch,
   duplicatePackage,
+  effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
   missingEffectServiceDependency,