@effect/language-service 0.39.0 → 0.40.1

package/package.json

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

package/transform.js

@@ -1187,7 +1187,8 @@ var defaults = {
   topLevelNamedReexports: "ignore",
   barrelImportPackages: [],
   importAliases: {},
-  renames: true
+  renames: true,
+  noExternal: false
 };
 function parse(config) {
   return {
@@ -1204,7 +1205,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)),
@@ -3325,7 +3381,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);
@@ -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",
@@ -4375,7 +4468,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,
@@ -5217,6 +5313,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 var diagnostics = [
   classSelfMismatch,
   duplicatePackage,
+  effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
   missingEffectServiceDependency,