@effect/language-service 0.58.4 → 0.59.0

package/package.json

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

package/transform.js

@@ -2840,67 +2840,69 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.effectSubtype",
     (type) => type
   );
-  const importedContextModule = cachedBy(
-    fn("TypeParser.importedContextModule")(function* (node) {
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an identifier", void 0, node);
-      }
-      const type = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type, "Tag");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'Tag' property", 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;
+  const isEffectContextSourceFile = cachedBy(
+    fn("TypeParser.isEffectContextSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const contextSymbol = typeChecker.tryGetMemberInModuleExports("Context", moduleSymbol);
+      if (!contextSymbol) return yield* typeParserIssue("Context not found", void 0, sourceFile);
+      const tagSymbol = typeChecker.tryGetMemberInModuleExports("Tag", moduleSymbol);
+      if (!tagSymbol) return yield* typeParserIssue("Tag not found", void 0, sourceFile);
+      const tagType = typeChecker.getDeclaredTypeOfSymbol(tagSymbol);
+      yield* contextTag(tagType, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectContextSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectContextModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectContextModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectContextSourceFile, memberName);
     }),
+    `TypeParser.isNodeReferenceToEffectContextModuleApi(${memberName})`,
+    (node) => node
+  );
+  const importedContextModule = cachedBy(
+    (node) => pipe(
+      isNodeReferenceToPackageModule(node, "effect", isEffectContextSourceFile),
+      map4(() => node)
+    ),
     "TypeParser.importedContextModule",
     (node) => node
   );
-  const importedEffectModule = (node) => pipe(
-    isNodeReferenceToPackageModule(node, "effect", isEffectTypeSourceFile),
-    map4(() => node)
+  const importedEffectModule = cachedBy(
+    (node) => pipe(
+      isNodeReferenceToPackageModule(node, "effect", isEffectTypeSourceFile),
+      map4(() => node)
+    ),
+    "TypeParser.importedEffectModule",
+    (node) => node
+  );
+  const isEffectDataSourceFile = cachedBy(
+    fn("TypeParser.isEffectDataSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const taggedEnumSymbol = typeChecker.tryGetMemberInModuleExports("TaggedEnum", moduleSymbol);
+      if (!taggedEnumSymbol) return yield* typeParserIssue("TaggedEnum not found", void 0, sourceFile);
+      const taggedErrorSymbol = typeChecker.tryGetMemberInModuleExports("TaggedError", moduleSymbol);
+      if (!taggedErrorSymbol) return yield* typeParserIssue("TaggedError not found", void 0, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectDataSourceFile",
+    (sourceFile) => sourceFile
   );
-  const importedDataModule = cachedBy(
-    fn("TypeParser.importedDataModule")(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, "TaggedError");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'TaggedError' property", 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;
+  const isNodeReferenceToEffectDataModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectDataModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectDataSourceFile, memberName);
     }),
+    `TypeParser.isNodeReferenceToEffectDataModuleApi(${memberName})`,
+    (node) => node
+  );
+  const importedDataModule = cachedBy(
+    (node) => pipe(
+      isNodeReferenceToPackageModule(node, "effect", isEffectDataSourceFile),
+      map4(() => node)
+    ),
     "TypeParser.importedDataModule",
     (node) => node
   );
@@ -3639,6 +3641,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
+    isNodeReferenceToEffectDataModuleApi,
+    isNodeReferenceToEffectContextModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -6042,6 +6046,85 @@ Consider extracting the Runtime by using for example Effect.runtime and then use
   })
 });
 
+// src/diagnostics/schemaStructWithTag.ts
+var schemaStructWithTag = createDiagnostic({
+  name: "schemaStructWithTag",
+  code: 34,
+  severity: "suggestion",
+  apply: fn("schemaStructWithTag.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();
+      if (ts.isCallExpression(node)) {
+        const isSchemaStructCall = yield* pipe(
+          typeParser.isNodeReferenceToEffectSchemaModuleApi("Struct")(node.expression),
+          orElse2(() => void_)
+        );
+        if (isSchemaStructCall && node.arguments.length === 1) {
+          const arg = node.arguments[0];
+          if (ts.isObjectLiteralExpression(arg)) {
+            const tagProperty = arg.properties.find(
+              (prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && ts.idText(prop.name) === "_tag"
+            );
+            if (tagProperty && ts.isCallExpression(tagProperty.initializer)) {
+              const isSchemaLiteralCall = yield* pipe(
+                typeParser.isNodeReferenceToEffectSchemaModuleApi("Literal")(
+                  tagProperty.initializer.expression
+                ),
+                option
+              );
+              if (isSchemaLiteralCall._tag === "Some") {
+                const literalCall = tagProperty.initializer;
+                const literalArgs = fromIterable(literalCall.arguments);
+                if (literalArgs.length === 1 && ts.isStringLiteral(literalArgs[0])) {
+                  const tagValue = literalArgs[0].text;
+                  const otherProperties = arg.properties.filter((prop) => prop !== tagProperty);
+                  report({
+                    location: node,
+                    messageText: "Schema.Struct with a _tag field can be simplified to Schema.TaggedStruct to make the tag optional in the constructor.",
+                    fixes: [{
+                      fixName: "schemaStructWithTag_fix",
+                      description: "Replace with Schema.TaggedStruct",
+                      apply: gen(function* () {
+                        const changeTracker = yield* service(ChangeTracker);
+                        const newObjectLiteral = ts.factory.createObjectLiteralExpression(
+                          otherProperties,
+                          true
+                        );
+                        const newNode = ts.factory.createCallExpression(
+                          ts.factory.createPropertyAccessExpression(
+                            // Reuse the Schema identifier from the original expression
+                            ts.isPropertyAccessExpression(node.expression) ? node.expression.expression : ts.factory.createIdentifier("Schema"),
+                            "TaggedStruct"
+                          ),
+                          void 0,
+                          [
+                            ts.factory.createStringLiteral(tagValue),
+                            newObjectLiteral
+                          ]
+                        );
+                        changeTracker.replaceNode(sourceFile, node, newNode);
+                      })
+                    }]
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/schemaUnionOfLiterals.ts
 var schemaUnionOfLiterals = createDiagnostic({
   name: "schemaUnionOfLiterals",
@@ -6733,7 +6816,8 @@ var diagnostics = [
   strictEffectProvide,
   unknownInEffectCatch,
   runEffectInsideEffect,
-  schemaUnionOfLiterals
+  schemaUnionOfLiterals,
+  schemaStructWithTag
 ];
 
 // src/transform.ts